trunk/testsuite/Test17.pas

(*
 *  IBX Test suite. This program is used to test the IBX non-visual
 *  components and provides a semi-automated pass/fail check for each test.
 *
 *  The contents of this file are subject to the Initial Developer's
 *  Public License Version 1.0 (the "License"); you may not use this
 *  file except in compliance with the License. You may obtain a copy
 *  of the License here:
 *
 *    http://www.firebirdsql.org/index.php?op=doc&id=idpl
 *
 *  Software distributed under the License is distributed on an "AS
 *  IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
 *  implied. See the License for the specific language governing rights
 *  and limitations under the License.
 *
 *  The Initial Developer of the Original Code is Tony Whyman.
 *
 *  The Original Code is (C) 2021 Tony Whyman, MWA Software
 *  (http://www.mwasoftware.co.uk).
 *
 *  All Rights Reserved.
 *
 *  Contributor(s): ______________________________________.
 *
*)      
unit Test17;

{$mode objfpc}{$H+}

{Test 17: TIBDataSet Tests}

{ Description

  TIBDataset Insert/Update/Delete tests.
}

interface

uses
  Classes, SysUtils,   TestApplication, IBXTestBase, DB, IB, IBCustomDataSet;

const
  aTestID    = '17';
  aTestTitle = 'TIBDataset Tests';

type

{ TTest1 }

  { TTest17 }

  TTest17 = class(TIBXTestBase)
  private
    FIBDataSet1: TIBDataSet;
    FIBDataSet2: TIBDataSet;
    F2KeyDataset: TIBDataset;
    procedure HandleDeleteReturning(Sender: TObject; QryResults: IResults);
    procedure HandleBeforeOpen(DataSet: TDataSet);
    procedure HandleAfterOpen(DataSet: TDataSet);
    procedure HandleBeforeClose(DataSet: TDataSet);
    procedure HandleAfterClose(DataSet: TDataSet);
    procedure HandleBeforeInsert(DataSet: TDataSet);
    procedure HandleAfterInsert(DataSet: TDataSet);
    procedure HandleBeforeEdit(DataSet: TDataSet);
    procedure HandleAfterEdit(DataSet: TDataSet);
    procedure HandleBeforePost(DataSet: TDataSet);
    procedure HandleAfterPost(DataSet: TDataSet);
    procedure HandleBeforeCancel(DataSet: TDataSet);
    procedure HandleAfterCancel(DataSet: TDataSet);
    procedure HandleBeforeDelete(DataSet: TDataSet);
    procedure HandleAfterDelete(DataSet: TDataSet);
    procedure HandleBeforeScroll(DataSet: TDataSet);
    procedure HandleAfterScroll(DataSet: TDataSet);
    procedure HandleBeforeRefresh(DataSet: TDataSet);
    procedure HandleAfterRefresh(DataSet: TDataSet);
    procedure ValidatePostOK(Sender: TObject; var CancelPost: boolean);
    procedure ValidatePostCancel(Sender: TObject; var CancelPost: boolean);
    procedure HandlePostError(DataSet: TDataSet; E: EDatabaseError;
                     var DataAction: TDataAction);
  protected
    procedure CreateObjects(Application: TTestApplication); override;
    function GetTestID: AnsiString; override;
    function GetTestTitle: AnsiString; override;
    procedure InitTest; override;
  public
    procedure RunTest(CharSet: AnsiString; SQLDialect: integer); override;
  end;


implementation

{ TTest17 }

procedure TTest17.HandleDeleteReturning(Sender: TObject; QryResults: IResults);
begin
  writeln(OutFile,'Delete Returning');
  ReportResult(QryResults);
  writeln(OutFile);
end;

procedure TTest17.HandleBeforeOpen(DataSet: TDataSet);
Begin
  writeln(Outfile,'Dataset Event BeforeOpen: State = ',DataSet.State);
end;
procedure TTest17.HandleAfterOpen(DataSet: TDataSet);
Begin
  writeln(Outfile,'Dataset Event AfterOpen: State = ',DataSet.State);
end;
procedure TTest17.HandleBeforeClose(DataSet: TDataSet);
Begin
  writeln(Outfile,'Dataset Event BeforeClose: State = ',DataSet.State);
end;
procedure TTest17.HandleAfterClose(DataSet: TDataSet);
Begin
  writeln(Outfile,'Dataset Event AfterClose: State = ',DataSet.State);
end;
procedure TTest17.HandleBeforeInsert(DataSet: TDataSet);
Begin
  writeln(Outfile,'Dataset Event BeforeInsert: State = ',DataSet.State);
end;
procedure TTest17.HandleAfterInsert(DataSet: TDataSet);
Begin
  writeln(Outfile,'Dataset Event AfterInsert: State = ',DataSet.State);
end;
procedure TTest17.HandleBeforeEdit(DataSet: TDataSet);
Begin
  writeln(Outfile,'Dataset Event BeforeEdit: State = ',DataSet.State);
end;
procedure TTest17.HandleAfterEdit(DataSet: TDataSet);
Begin
  writeln(Outfile,'Dataset Event AfterEdit: State = ',DataSet.State);
end;
procedure TTest17.HandleBeforePost(DataSet: TDataSet);
Begin
  writeln(Outfile,'Dataset Event BeforePost: State = ',DataSet.State);
end;
procedure TTest17.HandleAfterPost(DataSet: TDataSet);
Begin
  writeln(Outfile,'Dataset Event AfterPost: State = ',DataSet.State);
end;
procedure TTest17.HandleBeforeCancel(DataSet: TDataSet);
Begin
  writeln(Outfile,'Dataset Event BeforeCancel: State = ',DataSet.State);
end;
procedure TTest17.HandleAfterCancel(DataSet: TDataSet);
Begin
  writeln(Outfile,'Dataset Event AfterCancel: State = ',DataSet.State);
end;
procedure TTest17.HandleBeforeDelete(DataSet: TDataSet);
Begin
  writeln(Outfile,'Dataset Event BeforeDelete: State = ',DataSet.State);
end;
procedure TTest17.HandleAfterDelete(DataSet: TDataSet);
Begin
  writeln(Outfile,'Dataset Event AfterDelete: State = ',DataSet.State);
end;
procedure TTest17.HandleBeforeScroll(DataSet: TDataSet);
Begin
  writeln(Outfile,'Dataset Event BeforeScroll: State = ',DataSet.State);
end;
procedure TTest17.HandleAfterScroll(DataSet: TDataSet);
Begin
  writeln(Outfile,'Dataset Event AfterScroll: State = ',DataSet.State);
end;
procedure TTest17.HandleBeforeRefresh(DataSet: TDataSet);
Begin
  writeln(Outfile,'Dataset Event BeforeRefresh: State = ',DataSet.State);
end;
procedure TTest17.HandleAfterRefresh(DataSet: TDataSet);
Begin
  writeln(Outfile,'Dataset Event AfterRefresh: State = ',DataSet.State);
end;

procedure TTest17.ValidatePostOK(Sender: TObject; var CancelPost: boolean);
begin
  writeln(Outfile,'Validate Post OK called');
  CancelPost := false;
end;

procedure TTest17.ValidatePostCancel(Sender: TObject; var CancelPost: boolean);
begin
  writeln(Outfile,'Validate Post Cancel called');
  CancelPost := true;
end;

procedure TTest17.HandlePostError(DataSet: TDataSet; E: EDatabaseError;
  var DataAction: TDataAction);
begin
  writeln(Outfile,'Post Error Called: ',E.Message);
  DataAction := daFail;
end;

procedure TTest17.CreateObjects(Application: TTestApplication);
begin
  inherited CreateObjects(Application);
  FIBDataSet1 := TIBDataSet.Create(Application);
  with FIBDataSet1 do
  begin
    Database := IBDatabase;
    Transaction := IBTransaction;
    Unidirectional := false;
    SelectSQL.Add('Select * From IBDataSetTest');
    InsertSQL.Add('Insert into IBDataSetTest(KeyField,PlainText) Values (:KeyField,:PlainText)');
    ModifySQL.Add('Update IBDataSetTest Set KeyField = :KeyField, PlainText = :PlainText Where KeyField = :Old_KeyField');
    DeleteSQL.Add('Delete from IBDataSetTest Where KeyField = :old_KeyField');
    RefreshSQL.Add('Select * from IBDataSetTest Where KeyField = :KeyField');
    GeneratorField.Field := 'KeyField';
    GeneratorField.Generator := 'AGENERATOR';
    GeneratorField.Increment := 1;
    OnPostError := @HandlePostError;
  end;
  FIBDataSet2 := TIBDataSet.Create(Application);
  with FIBDataSet2 do
  begin
    Database := IBDatabase;
    Transaction := IBTransaction;
    Unidirectional := false;
    SelectSQL.Add('Select * From IBDataSetTest');
    InsertSQL.Add('Insert into IBDataSetTest(KeyField,PlainText) Values (Gen_ID(AGenerator,1),:PlainText) Returning KeyField, TextAndKey');
    ModifySQL.Add('Update IBDataSetTest Set KeyField = :KeyField, PlainText = :PlainText Where KeyField = :Old_KeyField Returning TextAndKey,ServerSideText');
    DeleteSQL.Add('Delete from IBDataSetTest Where KeyField = :old_KeyField Returning KeyField');
    RefreshSQL.Add('Select * from IBDataSetTest Where KeyField = :KeyField');
    OnDeleteReturning := @HandleDeleteReturning;
    BeforeOpen := @HandleBeforeOpen;
    AfterOpen := @HandleAfterOpen;
    BeforeClose := @HandleBeforeClose;
    AfterClose := @HandleAfterClose;
    BeforeInsert := @HandleBeforeInsert;
    AfterInsert := @HandleAfterInsert;
    BeforeEdit := @HandleBeforeEdit;
    AfterEdit := @HandleAfterEdit;
    BeforePost := @HandleBeforePost;
    AfterPost := @HandleAfterPost;
    BeforeCancel := @HandleBeforeCancel;
    AfterCancel := @HandleAfterCancel;
    BeforeDelete := @HandleBeforeDelete;
    AfterDelete := @HandleAfterDelete;
    BeforeScroll := @HandleBeforeScroll;
    AfterScroll := @HandleAfterScroll;
    BeforeRefresh := @HandleBeforeRefresh;
    AfterRefresh := @HandleAfterRefresh;
  end;
  F2KeyDataset := TIBDataSet.Create(Application);
  with F2KeyDataset do
  begin
    Database := IBDatabase;
    Transaction := IBTransaction;
    SelectSQL.Text := 'Select Key1, Key2 From IBXTest2';
    InsertSQL.Text := 'Insert into IBXTest2(Key1,Key2) Values(:Key1,:Key2)';
    RefreshSQL.Text := 'Select Key1, Key2 From IBXTest2 where Key1 = :Key1 and Key2 = :Key2';
 end;
end;

function TTest17.GetTestID: AnsiString;
begin
  Result := aTestID;
end;

function TTest17.GetTestTitle: AnsiString;
begin
  Result := aTestTitle;
end;

procedure TTest17.InitTest;
begin
  IBDatabase.DatabaseName := Owner.GetNewDatabaseName;
  IBDatabase.CreateIfNotExists := true;
  ReadWriteTransaction;
end;

procedure TTest17.RunTest(CharSet: AnsiString; SQLDialect: integer);
var lastKey: integer;
    i: integer;
    B: TBookmark;
begin
  IBDatabase.CreateDatabase;
  try
    IBTransaction.Active := true;
    with FIBDataSet1 do
    begin
      Active := true;
      writeln(OutFile,'FIBDataSet1: Simple Append');
      Append;
//      writeln(outfile,'BOF = ',BOF,', EOF = ',EOF);
      FieldByName('PlainText').AsString := 'This is a test';
      Post;
      PrintDataSetRow(FIBDataSet1);
      Refresh;
      writeln(OutFile,'After Refresh');
      PrintDataSetRow(FIBDataSet1);
      writeln(OutFile,'Append and Update');
      Append;
      FieldByName('PlainText').AsString := 'This is another test';
      Post;
      PrintDataSetRow(FIBDataSet1);
      Edit;
      FieldByName('PlainText').AsString := 'This is the update test';
      Post;
      PrintDataSetRow(FIBDataSet1);
      writeln(Outfile,'Show whole Dataset');
      PrintDataSet(FIBDataSet1);
      writeln(OutFile,'Now delete the first row');
      First;
      Delete;
      PrintDataSet(FIBDataSet1);
      writeln(Outfile,'On Post KeyField Assignment');
      FIBDataSet1.GeneratorField.ApplyOnEvent := gaeOnPostRecord;
      Append;
      FieldByName('PlainText').AsString := 'On Post KeyField test';
      PrintDataSetRow(FIBDataSet1);
      Post;
      writeln(Outfile,'Row data after post');
      PrintDataSetRow(FIBDataSet1);
      FIBDataSet1.GeneratorField.ApplyOnEvent := gaeOnNewRecord; {restore}

      writeln(Outfile,'Catch a Post Error - duplicate key');
      lastkey := FieldByName('KeyField').AsInteger;
      Append;
      FieldByName('KeyField').AsInteger := lastkey;
      FieldByName('PlainText').AsString := 'On Post Error test';
      try
        Post;
      except on E: Exception do
        writeln(Outfile,'Exception handled: ',E.Message);
      end;

      IBTransaction.Rollback;
      IBTransaction.Active := true;
      DataSetCloseAction := dcSaveChanges;
      Active := true;
      writeln(OutFile,'FIBDataSet1: Simple Append with automatic posting on close');
      Append;
      FieldByName('PlainText').AsString := 'This is a test';
      Active := false;
      Active := true;
      PrintDataSet(FIBDataSet1);

      IBTransaction.Rollback;
      IBTransaction.Active := true;
      DataSetCloseAction := dcDiscardChanges;
      Active := true;
      writeln(OutFile,'FIBDataSet1: Simple Append with discard on close');
      Append;
      FieldByName('PlainText').AsString := 'This is a test';
      Active := false;
      Active := true;
      PrintDataSet(FIBDataSet1);

      IBTransaction.Rollback;
      IBTransaction.Active := true;
      writeln(Outfile);
      writeln(Outfile,'Unidirectional editing');
      Unidirectional := true;
      Active := true;
      writeln(OutFile,'FIBDataSet1: Simple Append - unidirectional');
      Insert;
      writeln(outfile,'BOF = ',BOF,', EOF = ',EOF);
      FieldByName('PlainText').AsString := 'This is a test - unidirectional';
      PrintDataSetRow(FIBDataSet1);
      Post;
      writeln(outfile,'BOF = ',BOF,', EOF = ',EOF);
      PrintDataSetRow(FIBDataSet1);
      Refresh;
      writeln(OutFile,'After Refresh - unidirectional');
      PrintDataSetRow(FIBDataSet1);
      writeln(OutFile,' Record Count = ',FIBDataSet1.RecordCount);
      writeln(OutFile,'Insert and Update');
      Insert;
      FieldByName('PlainText').AsString := 'This is another test - unidirectional';
      Post;
      PrintDataSetRow(FIBDataSet1);
      Edit;
      FieldByName('PlainText').AsString := 'This is the update test - unidirectional';
      Post;
      PrintDataSetRow(FIBDataSet1);
      writeln(OutFile,'Now delete the first row - unidirectional with Record Count = ',FIBDataSet1.RecordCount);
      Active := false;
      Active := true;
      Delete;
      writeln(OutFile,'Show Current Row');
      PrintDataSetRow(FIBDataSet1);
      writeln(OutFile,' Record Count = ',FIBDataSet1.RecordCount);
      writeln(Outfile,'Ensure dataset saved to database');
      Active := false;
      Active := true;
      PrintDataSet(FIBDataSet1);

    end;
    writeln(Outfile,'==================================');
    IBTransaction.Rollback;
    IBTransaction.Active := true;
    with FIBDataSet2 do
    try
      Active := true;
      writeln(OutFile,'FIBDataSet2: Simple Append');
      Append;
      FieldByName('PlainText').AsString := 'This is a test';
      Post;
      PrintDataSetRow(FIBDataSet2);
      Refresh;
      writeln(OutFile,'After Refresh');
      PrintDataSetRow(FIBDataSet2);
      writeln(OutFile,'Append and Update');
      Append;
      FieldByName('PlainText').AsString := 'This is another test';
      Post;
      PrintDataSetRow(FIBDataSet2);
      Edit;
      FieldByName('PlainText').AsString := 'This is the update test';
      Post;
      PrintDataSetRow(FIBDataSet2);
      writeln(OutFile,'Now delete the first row');
      PrintDataSet(FIBDataSet2);
      First;
      Delete;
      PrintDataSet(FIBDataSet2);
      OnValidatePost := @ValidatePostOK;
      writeln(Outfile,'Validate Post OK');
      Append;
      FieldByName('PlainText').AsString := 'This is a validated Post';
      Post;
      PrintDataSetRow(FIBDataSet2);
      OnValidatePost := @ValidatePostCancel;
      writeln(Outfile,'Validate Post Cancel');
      Append;
      FieldByName('PlainText').AsString := 'This is a validated Post which should have been cancelled';
      Post;
      PrintDataSetRow(FIBDataSet2);
      OnValidatePost := nil;
      writeln(OutFile,'FIBDataSet2: Simple Append with Forced Refresh');
      ForcedRefresh := true;
      Append;
      FieldByName('PlainText').AsString := 'This is a test';
      Post;
      PrintDataSetRow(FIBDataSet2);
    except on E: Exception do
     writeln(Outfile,E.Message);
    end;
    IBTransaction.Rollback;
    IBTransaction.Active := true;
    with FIBDataSet1 do
    try
      Unidirectional := false;
      Active := true;
      writeln(outfile,'----------------------------------------------');
      writeln(OutFile,'FIBDataSet1: Insert at start');
      for i := 1 to 2 do
      begin
        Append;
        FieldByName('PlainText').AsString := 'Row ' + IntToStr(i);
        Post;
      end;
      First;
      Insert;
      FieldByName('PlainText').AsString := 'This is an insert test';
      Post;
      B := Bookmark;
      PrintDataSet(FIBDataSet1);
      writeln(outfile,'Delete inserted row');
      Bookmark := B;
      Delete;
      PrintDataSet(FIBDataSet1);
      writeln(outfile,'Repeat');
      First;
      Insert;
      FieldByName('PlainText').AsString := 'This is an insert test #1';
      Post;
      B := Bookmark;
      PrintDataSet(FIBDataSet1);
      writeln(outfile,'Delete inserted row');
      Bookmark := B;
      Delete;
      PrintDataSet(FIBDataSet1);
      writeln(outfile,'Insert/Delete after first row');
      Next;
      Insert;
      FieldByName('PlainText').AsString := 'This is an insert test #2';
      Post;
      B := Bookmark;
      PrintDataSet(FIBDataSet1);
      writeln(outfile,'Delete inserted row');
      Bookmark := B;
      Delete;
      PrintDataSet(FIBDataSet1);
      writeln(outfile,'Insert/Delete at last row');
      Last;
      Insert;
      FieldByName('PlainText').AsString := 'This is an insert test #3';
      Post;
      B := Bookmark;
      PrintDataSet(FIBDataSet1);
      writeln(outfile,'Delete inserted row');
      Bookmark := B;
      Delete;
      PrintDataSet(FIBDataSet1);
    except on E: Exception do
       writeln(Outfile,E.Message);
    end;

    writeln(outfile,'Refresh Dataset wit two primary keys');
    with F2KeyDataset do
    try
      Transaction.Active := true;
      Active := true;
      Append;
      FieldByName('Key1').AsInteger := 1;
      FieldByName('Key2').AsInteger := 1;
      Post;
      Append;
      FieldByName('Key1').AsInteger := 1;
      FieldByName('Key2').AsInteger := 2;
      Post;
      Refresh;
      PrintDataset(F2KeyDataset);
    except on E: Exception do
        writeln(Outfile,E.Message);
     end;

  finally
    IBDatabase.DropDatabase;
  end;
end;

initialization
  RegisterTest(TTest17);

end.

Revision:	429
Committed:	Sat Dec 30 16:07:08 2023 UTC (10 months, 2 weeks ago) by tony
Content type:	text/x-pascal
File size:	17343 byte(s)
Log Message:	TIBCustomDataset.PrimaryKeys when used in InternalRefresh. when more than one primary key is used by the dataset then the list of primary keys is now properly separated by a ';'.
#	User	Rev	Content
1	tony	323	(*
2			* IBX Test suite. This program is used to test the IBX non-visual
3			* components and provides a semi-automated pass/fail check for each test.
4			*
5			* The contents of this file are subject to the Initial Developer's
6			* Public License Version 1.0 (the "License"); you may not use this
7			* file except in compliance with the License. You may obtain a copy
8			* of the License here:
9			*
10			* http://www.firebirdsql.org/index.php?op=doc&id=idpl
11			*
12			* Software distributed under the License is distributed on an "AS
13			* IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
14			* implied. See the License for the specific language governing rights
15			* and limitations under the License.
16			*
17			* The Initial Developer of the Original Code is Tony Whyman.
18			*
19			* The Original Code is (C) 2021 Tony Whyman, MWA Software
20			* (http://www.mwasoftware.co.uk).
21			*
22			* All Rights Reserved.
23			*
24			* Contributor(s): ______________________________________.
25			*
26			*)
27	tony	315	unit Test17;
28
29			{$mode objfpc}{$H+}
30
31			{Test 17: TIBDataSet Tests}
32
33			{ Description
34
35			TIBDataset Insert/Update/Delete tests.
36			}
37
38			interface
39
40			uses
41			Classes, SysUtils, TestApplication, IBXTestBase, DB, IB, IBCustomDataSet;
42
43			const
44			aTestID = '17';
45			aTestTitle = 'TIBDataset Tests';
46
47			type
48
49			{ TTest1 }
50
51			{ TTest17 }
52
53			TTest17 = class(TIBXTestBase)
54			private
55			FIBDataSet1: TIBDataSet;
56			FIBDataSet2: TIBDataSet;
57	tony	429	F2KeyDataset: TIBDataset;
58	tony	315	procedure HandleDeleteReturning(Sender: TObject; QryResults: IResults);
59			procedure HandleBeforeOpen(DataSet: TDataSet);
60			procedure HandleAfterOpen(DataSet: TDataSet);
61			procedure HandleBeforeClose(DataSet: TDataSet);
62			procedure HandleAfterClose(DataSet: TDataSet);
63			procedure HandleBeforeInsert(DataSet: TDataSet);
64			procedure HandleAfterInsert(DataSet: TDataSet);
65			procedure HandleBeforeEdit(DataSet: TDataSet);
66			procedure HandleAfterEdit(DataSet: TDataSet);
67			procedure HandleBeforePost(DataSet: TDataSet);
68			procedure HandleAfterPost(DataSet: TDataSet);
69			procedure HandleBeforeCancel(DataSet: TDataSet);
70			procedure HandleAfterCancel(DataSet: TDataSet);
71			procedure HandleBeforeDelete(DataSet: TDataSet);
72			procedure HandleAfterDelete(DataSet: TDataSet);
73			procedure HandleBeforeScroll(DataSet: TDataSet);
74			procedure HandleAfterScroll(DataSet: TDataSet);
75			procedure HandleBeforeRefresh(DataSet: TDataSet);
76			procedure HandleAfterRefresh(DataSet: TDataSet);
77			procedure ValidatePostOK(Sender: TObject; var CancelPost: boolean);
78			procedure ValidatePostCancel(Sender: TObject; var CancelPost: boolean);
79			procedure HandlePostError(DataSet: TDataSet; E: EDatabaseError;
80			var DataAction: TDataAction);
81			protected
82			procedure CreateObjects(Application: TTestApplication); override;
83			function GetTestID: AnsiString; override;
84			function GetTestTitle: AnsiString; override;
85			procedure InitTest; override;
86			public
87			procedure RunTest(CharSet: AnsiString; SQLDialect: integer); override;
88			end;
89
90
91			implementation
92
93			{ TTest17 }
94
95			procedure TTest17.HandleDeleteReturning(Sender: TObject; QryResults: IResults);
96			begin
97			writeln(OutFile,'Delete Returning');
98			ReportResult(QryResults);
99			writeln(OutFile);
100			end;
101
102			procedure TTest17.HandleBeforeOpen(DataSet: TDataSet);
103			Begin
104			writeln(Outfile,'Dataset Event BeforeOpen: State = ',DataSet.State);
105			end;
106			procedure TTest17.HandleAfterOpen(DataSet: TDataSet);
107			Begin
108			writeln(Outfile,'Dataset Event AfterOpen: State = ',DataSet.State);
109			end;
110			procedure TTest17.HandleBeforeClose(DataSet: TDataSet);
111			Begin
112			writeln(Outfile,'Dataset Event BeforeClose: State = ',DataSet.State);
113			end;
114			procedure TTest17.HandleAfterClose(DataSet: TDataSet);
115			Begin
116			writeln(Outfile,'Dataset Event AfterClose: State = ',DataSet.State);
117			end;
118			procedure TTest17.HandleBeforeInsert(DataSet: TDataSet);
119			Begin
120			writeln(Outfile,'Dataset Event BeforeInsert: State = ',DataSet.State);
121			end;
122			procedure TTest17.HandleAfterInsert(DataSet: TDataSet);
123			Begin
124			writeln(Outfile,'Dataset Event AfterInsert: State = ',DataSet.State);
125			end;
126			procedure TTest17.HandleBeforeEdit(DataSet: TDataSet);
127			Begin
128			writeln(Outfile,'Dataset Event BeforeEdit: State = ',DataSet.State);
129			end;
130			procedure TTest17.HandleAfterEdit(DataSet: TDataSet);
131			Begin
132			writeln(Outfile,'Dataset Event AfterEdit: State = ',DataSet.State);
133			end;
134			procedure TTest17.HandleBeforePost(DataSet: TDataSet);
135			Begin
136			writeln(Outfile,'Dataset Event BeforePost: State = ',DataSet.State);
137			end;
138			procedure TTest17.HandleAfterPost(DataSet: TDataSet);
139			Begin
140			writeln(Outfile,'Dataset Event AfterPost: State = ',DataSet.State);
141			end;
142			procedure TTest17.HandleBeforeCancel(DataSet: TDataSet);
143			Begin
144			writeln(Outfile,'Dataset Event BeforeCancel: State = ',DataSet.State);
145			end;
146			procedure TTest17.HandleAfterCancel(DataSet: TDataSet);
147			Begin
148			writeln(Outfile,'Dataset Event AfterCancel: State = ',DataSet.State);
149			end;
150			procedure TTest17.HandleBeforeDelete(DataSet: TDataSet);
151			Begin
152			writeln(Outfile,'Dataset Event BeforeDelete: State = ',DataSet.State);
153			end;
154			procedure TTest17.HandleAfterDelete(DataSet: TDataSet);
155			Begin
156			writeln(Outfile,'Dataset Event AfterDelete: State = ',DataSet.State);
157			end;
158			procedure TTest17.HandleBeforeScroll(DataSet: TDataSet);
159			Begin
160			writeln(Outfile,'Dataset Event BeforeScroll: State = ',DataSet.State);
161			end;
162			procedure TTest17.HandleAfterScroll(DataSet: TDataSet);
163			Begin
164			writeln(Outfile,'Dataset Event AfterScroll: State = ',DataSet.State);
165			end;
166			procedure TTest17.HandleBeforeRefresh(DataSet: TDataSet);
167			Begin
168			writeln(Outfile,'Dataset Event BeforeRefresh: State = ',DataSet.State);
169			end;
170			procedure TTest17.HandleAfterRefresh(DataSet: TDataSet);
171			Begin
172			writeln(Outfile,'Dataset Event AfterRefresh: State = ',DataSet.State);
173			end;
174
175			procedure TTest17.ValidatePostOK(Sender: TObject; var CancelPost: boolean);
176			begin
177			writeln(Outfile,'Validate Post OK called');
178			CancelPost := false;
179			end;
180
181			procedure TTest17.ValidatePostCancel(Sender: TObject; var CancelPost: boolean);
182			begin
183			writeln(Outfile,'Validate Post Cancel called');
184			CancelPost := true;
185			end;
186
187			procedure TTest17.HandlePostError(DataSet: TDataSet; E: EDatabaseError;
188			var DataAction: TDataAction);
189			begin
190			writeln(Outfile,'Post Error Called: ',E.Message);
191			DataAction := daFail;
192			end;
193
194			procedure TTest17.CreateObjects(Application: TTestApplication);
195			begin
196			inherited CreateObjects(Application);
197			FIBDataSet1 := TIBDataSet.Create(Application);
198			with FIBDataSet1 do
199			begin
200			Database := IBDatabase;
201			Transaction := IBTransaction;
202			Unidirectional := false;
203			SelectSQL.Add('Select * From IBDataSetTest');
204			InsertSQL.Add('Insert into IBDataSetTest(KeyField,PlainText) Values (:KeyField,:PlainText)');
205			ModifySQL.Add('Update IBDataSetTest Set KeyField = :KeyField, PlainText = :PlainText Where KeyField = :Old_KeyField');
206			DeleteSQL.Add('Delete from IBDataSetTest Where KeyField = :old_KeyField');
207			RefreshSQL.Add('Select * from IBDataSetTest Where KeyField = :KeyField');
208			GeneratorField.Field := 'KeyField';
209			GeneratorField.Generator := 'AGENERATOR';
210			GeneratorField.Increment := 1;
211			OnPostError := @HandlePostError;
212			end;
213			FIBDataSet2 := TIBDataSet.Create(Application);
214			with FIBDataSet2 do
215			begin
216			Database := IBDatabase;
217			Transaction := IBTransaction;
218			Unidirectional := false;
219			SelectSQL.Add('Select * From IBDataSetTest');
220			InsertSQL.Add('Insert into IBDataSetTest(KeyField,PlainText) Values (Gen_ID(AGenerator,1),:PlainText) Returning KeyField, TextAndKey');
221			ModifySQL.Add('Update IBDataSetTest Set KeyField = :KeyField, PlainText = :PlainText Where KeyField = :Old_KeyField Returning TextAndKey,ServerSideText');
222			DeleteSQL.Add('Delete from IBDataSetTest Where KeyField = :old_KeyField Returning KeyField');
223			RefreshSQL.Add('Select * from IBDataSetTest Where KeyField = :KeyField');
224			OnDeleteReturning := @HandleDeleteReturning;
225			BeforeOpen := @HandleBeforeOpen;
226			AfterOpen := @HandleAfterOpen;
227			BeforeClose := @HandleBeforeClose;
228			AfterClose := @HandleAfterClose;
229			BeforeInsert := @HandleBeforeInsert;
230			AfterInsert := @HandleAfterInsert;
231			BeforeEdit := @HandleBeforeEdit;
232			AfterEdit := @HandleAfterEdit;
233			BeforePost := @HandleBeforePost;
234			AfterPost := @HandleAfterPost;
235			BeforeCancel := @HandleBeforeCancel;
236			AfterCancel := @HandleAfterCancel;
237			BeforeDelete := @HandleBeforeDelete;
238			AfterDelete := @HandleAfterDelete;
239			BeforeScroll := @HandleBeforeScroll;
240			AfterScroll := @HandleAfterScroll;
241			BeforeRefresh := @HandleBeforeRefresh;
242			AfterRefresh := @HandleAfterRefresh;
243			end;
244	tony	429	F2KeyDataset := TIBDataSet.Create(Application);
245			with F2KeyDataset do
246			begin
247			Database := IBDatabase;
248			Transaction := IBTransaction;
249			SelectSQL.Text := 'Select Key1, Key2 From IBXTest2';
250			InsertSQL.Text := 'Insert into IBXTest2(Key1,Key2) Values(:Key1,:Key2)';
251			RefreshSQL.Text := 'Select Key1, Key2 From IBXTest2 where Key1 = :Key1 and Key2 = :Key2';
252			end;
253	tony	315	end;
254
255			function TTest17.GetTestID: AnsiString;
256			begin
257			Result := aTestID;
258			end;
259
260			function TTest17.GetTestTitle: AnsiString;
261			begin
262			Result := aTestTitle;
263			end;
264
265			procedure TTest17.InitTest;
266			begin
267			IBDatabase.DatabaseName := Owner.GetNewDatabaseName;
268			IBDatabase.CreateIfNotExists := true;
269			ReadWriteTransaction;
270			end;
271
272			procedure TTest17.RunTest(CharSet: AnsiString; SQLDialect: integer);
273			var lastKey: integer;
274	tony	410	i: integer;
275			B: TBookmark;
276	tony	315	begin
277			IBDatabase.CreateDatabase;
278			try
279			IBTransaction.Active := true;
280			with FIBDataSet1 do
281			begin
282			Active := true;
283			writeln(OutFile,'FIBDataSet1: Simple Append');
284			Append;
285			// writeln(outfile,'BOF = ',BOF,', EOF = ',EOF);
286			FieldByName('PlainText').AsString := 'This is a test';
287			Post;
288			PrintDataSetRow(FIBDataSet1);
289			Refresh;
290			writeln(OutFile,'After Refresh');
291			PrintDataSetRow(FIBDataSet1);
292			writeln(OutFile,'Append and Update');
293			Append;
294			FieldByName('PlainText').AsString := 'This is another test';
295			Post;
296			PrintDataSetRow(FIBDataSet1);
297			Edit;
298			FieldByName('PlainText').AsString := 'This is the update test';
299			Post;
300			PrintDataSetRow(FIBDataSet1);
301	tony	410	writeln(Outfile,'Show whole Dataset');
302			PrintDataSet(FIBDataSet1);
303	tony	315	writeln(OutFile,'Now delete the first row');
304			First;
305			Delete;
306			PrintDataSet(FIBDataSet1);
307			writeln(Outfile,'On Post KeyField Assignment');
308			FIBDataSet1.GeneratorField.ApplyOnEvent := gaeOnPostRecord;
309			Append;
310			FieldByName('PlainText').AsString := 'On Post KeyField test';
311			PrintDataSetRow(FIBDataSet1);
312			Post;
313			writeln(Outfile,'Row data after post');
314			PrintDataSetRow(FIBDataSet1);
315			FIBDataSet1.GeneratorField.ApplyOnEvent := gaeOnNewRecord; {restore}
316
317			writeln(Outfile,'Catch a Post Error - duplicate key');
318			lastkey := FieldByName('KeyField').AsInteger;
319			Append;
320			FieldByName('KeyField').AsInteger := lastkey;
321			FieldByName('PlainText').AsString := 'On Post Error test';
322			try
323			Post;
324			except on E: Exception do
325			writeln(Outfile,'Exception handled: ',E.Message);
326			end;
327
328			IBTransaction.Rollback;
329			IBTransaction.Active := true;
330			DataSetCloseAction := dcSaveChanges;
331			Active := true;
332			writeln(OutFile,'FIBDataSet1: Simple Append with automatic posting on close');
333			Append;
334			FieldByName('PlainText').AsString := 'This is a test';
335			Active := false;
336			Active := true;
337			PrintDataSet(FIBDataSet1);
338
339			IBTransaction.Rollback;
340			IBTransaction.Active := true;
341			DataSetCloseAction := dcDiscardChanges;
342			Active := true;
343			writeln(OutFile,'FIBDataSet1: Simple Append with discard on close');
344			Append;
345			FieldByName('PlainText').AsString := 'This is a test';
346			Active := false;
347			Active := true;
348			PrintDataSet(FIBDataSet1);
349
350	tony	410	IBTransaction.Rollback;
351	tony	315	IBTransaction.Active := true;
352			writeln(Outfile);
353			writeln(Outfile,'Unidirectional editing');
354			Unidirectional := true;
355			Active := true;
356			writeln(OutFile,'FIBDataSet1: Simple Append - unidirectional');
357			Insert;
358			writeln(outfile,'BOF = ',BOF,', EOF = ',EOF);
359			FieldByName('PlainText').AsString := 'This is a test - unidirectional';
360			PrintDataSetRow(FIBDataSet1);
361			Post;
362			writeln(outfile,'BOF = ',BOF,', EOF = ',EOF);
363			PrintDataSetRow(FIBDataSet1);
364			Refresh;
365			writeln(OutFile,'After Refresh - unidirectional');
366			PrintDataSetRow(FIBDataSet1);
367	tony	410	writeln(OutFile,' Record Count = ',FIBDataSet1.RecordCount);
368			writeln(OutFile,'Insert and Update');
369	tony	315	Insert;
370			FieldByName('PlainText').AsString := 'This is another test - unidirectional';
371			Post;
372			PrintDataSetRow(FIBDataSet1);
373			Edit;
374			FieldByName('PlainText').AsString := 'This is the update test - unidirectional';
375			Post;
376			PrintDataSetRow(FIBDataSet1);
377	tony	410	writeln(OutFile,'Now delete the first row - unidirectional with Record Count = ',FIBDataSet1.RecordCount);
378			Active := false;
379			Active := true;
380	tony	315	Delete;
381	tony	410	writeln(OutFile,'Show Current Row');
382			PrintDataSetRow(FIBDataSet1);
383			writeln(OutFile,' Record Count = ',FIBDataSet1.RecordCount);
384	tony	315	writeln(Outfile,'Ensure dataset saved to database');
385			Active := false;
386			Active := true;
387	tony	410	PrintDataSet(FIBDataSet1);
388	tony	315
389			end;
390			writeln(Outfile,'==================================');
391			IBTransaction.Rollback;
392			IBTransaction.Active := true;
393			with FIBDataSet2 do
394	tony	410	try
395	tony	315	Active := true;
396			writeln(OutFile,'FIBDataSet2: Simple Append');
397			Append;
398			FieldByName('PlainText').AsString := 'This is a test';
399			Post;
400			PrintDataSetRow(FIBDataSet2);
401			Refresh;
402			writeln(OutFile,'After Refresh');
403			PrintDataSetRow(FIBDataSet2);
404			writeln(OutFile,'Append and Update');
405			Append;
406			FieldByName('PlainText').AsString := 'This is another test';
407			Post;
408			PrintDataSetRow(FIBDataSet2);
409			Edit;
410			FieldByName('PlainText').AsString := 'This is the update test';
411			Post;
412			PrintDataSetRow(FIBDataSet2);
413			writeln(OutFile,'Now delete the first row');
414			PrintDataSet(FIBDataSet2);
415			First;
416			Delete;
417			PrintDataSet(FIBDataSet2);
418			OnValidatePost := @ValidatePostOK;
419			writeln(Outfile,'Validate Post OK');
420			Append;
421			FieldByName('PlainText').AsString := 'This is a validated Post';
422			Post;
423			PrintDataSetRow(FIBDataSet2);
424			OnValidatePost := @ValidatePostCancel;
425			writeln(Outfile,'Validate Post Cancel');
426			Append;
427			FieldByName('PlainText').AsString := 'This is a validated Post which should have been cancelled';
428			Post;
429			PrintDataSetRow(FIBDataSet2);
430			OnValidatePost := nil;
431			writeln(OutFile,'FIBDataSet2: Simple Append with Forced Refresh');
432			ForcedRefresh := true;
433			Append;
434			FieldByName('PlainText').AsString := 'This is a test';
435			Post;
436			PrintDataSetRow(FIBDataSet2);
437	tony	410	except on E: Exception do
438			writeln(Outfile,E.Message);
439			end;
440			IBTransaction.Rollback;
441			IBTransaction.Active := true;
442			with FIBDataSet1 do
443			try
444			Unidirectional := false;
445			Active := true;
446			writeln(outfile,'----------------------------------------------');
447			writeln(OutFile,'FIBDataSet1: Insert at start');
448			for i := 1 to 2 do
449			begin
450			Append;
451			FieldByName('PlainText').AsString := 'Row ' + IntToStr(i);
452			Post;
453			end;
454			First;
455			Insert;
456			FieldByName('PlainText').AsString := 'This is an insert test';
457			Post;
458			B := Bookmark;
459			PrintDataSet(FIBDataSet1);
460			writeln(outfile,'Delete inserted row');
461			Bookmark := B;
462			Delete;
463			PrintDataSet(FIBDataSet1);
464			writeln(outfile,'Repeat');
465			First;
466			Insert;
467			FieldByName('PlainText').AsString := 'This is an insert test #1';
468			Post;
469			B := Bookmark;
470			PrintDataSet(FIBDataSet1);
471			writeln(outfile,'Delete inserted row');
472			Bookmark := B;
473			Delete;
474			PrintDataSet(FIBDataSet1);
475	tony	419	writeln(outfile,'Insert/Delete after first row');
476	tony	410	Next;
477			Insert;
478			FieldByName('PlainText').AsString := 'This is an insert test #2';
479			Post;
480			B := Bookmark;
481			PrintDataSet(FIBDataSet1);
482			writeln(outfile,'Delete inserted row');
483			Bookmark := B;
484			Delete;
485			PrintDataSet(FIBDataSet1);
486	tony	419	writeln(outfile,'Insert/Delete at last row');
487	tony	410	Last;
488			Insert;
489			FieldByName('PlainText').AsString := 'This is an insert test #3';
490			Post;
491			B := Bookmark;
492			PrintDataSet(FIBDataSet1);
493			writeln(outfile,'Delete inserted row');
494			Bookmark := B;
495			Delete;
496			PrintDataSet(FIBDataSet1);
497			except on E: Exception do
498			writeln(Outfile,E.Message);
499			end;
500	tony	315
501	tony	429	writeln(outfile,'Refresh Dataset wit two primary keys');
502			with F2KeyDataset do
503			try
504			Transaction.Active := true;
505			Active := true;
506			Append;
507			FieldByName('Key1').AsInteger := 1;
508			FieldByName('Key2').AsInteger := 1;
509			Post;
510			Append;
511			FieldByName('Key1').AsInteger := 1;
512			FieldByName('Key2').AsInteger := 2;
513			Post;
514			Refresh;
515			PrintDataset(F2KeyDataset);
516			except on E: Exception do
517			writeln(Outfile,E.Message);
518			end;
519
520	tony	315	finally
521			IBDatabase.DropDatabase;
522			end;
523			end;
524
525			initialization
526			RegisterTest(TTest17);
527
528			end.
529