trunk/testsuite/Test17.pas

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;
    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;
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;
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,'Now delete the first row');
      PrintDataSet(FIBDataSet1);
      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);

      {See https://bugs.freepascal.org/view.php?id=37900}

(*      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,'Append 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');
      PrintDataSet(FIBDataSet1);
      First;
      Delete;
      PrintDataSet(FIBDataSet1);
      writeln(Outfile,'Ensure dataset saved to database');
      Active := false;
      Active := true;
      PrintDataSet(FIBDataSet1);  *)

    end;
    writeln(Outfile,'==================================');
    IBTransaction.Rollback;
    IBTransaction.Active := true;
    with FIBDataSet2 do
    begin
      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);

    end;
  finally
    IBDatabase.DropDatabase;
  end;
end;

initialization
  RegisterTest(TTest17);

end.

Revision:	315
Committed:	Thu Feb 25 11:56:36 2021 UTC (3 years, 9 months ago) by tony
Content type:	text/x-pascal
File size:	13438 byte(s)
Log Message:	Updated for IBX 4 release
#	User	Rev	Content
1	tony	315	unit Test17;
2
3			{$mode objfpc}{$H+}
4
5			{Test 17: TIBDataSet Tests}
6
7			{ Description
8
9			TIBDataset Insert/Update/Delete tests.
10			}
11
12			interface
13
14			uses
15			Classes, SysUtils, TestApplication, IBXTestBase, DB, IB, IBCustomDataSet;
16
17			const
18			aTestID = '17';
19			aTestTitle = 'TIBDataset Tests';
20
21			type
22
23			{ TTest1 }
24
25			{ TTest17 }
26
27			TTest17 = class(TIBXTestBase)
28			private
29			FIBDataSet1: TIBDataSet;
30			FIBDataSet2: TIBDataSet;
31			procedure HandleDeleteReturning(Sender: TObject; QryResults: IResults);
32			procedure HandleBeforeOpen(DataSet: TDataSet);
33			procedure HandleAfterOpen(DataSet: TDataSet);
34			procedure HandleBeforeClose(DataSet: TDataSet);
35			procedure HandleAfterClose(DataSet: TDataSet);
36			procedure HandleBeforeInsert(DataSet: TDataSet);
37			procedure HandleAfterInsert(DataSet: TDataSet);
38			procedure HandleBeforeEdit(DataSet: TDataSet);
39			procedure HandleAfterEdit(DataSet: TDataSet);
40			procedure HandleBeforePost(DataSet: TDataSet);
41			procedure HandleAfterPost(DataSet: TDataSet);
42			procedure HandleBeforeCancel(DataSet: TDataSet);
43			procedure HandleAfterCancel(DataSet: TDataSet);
44			procedure HandleBeforeDelete(DataSet: TDataSet);
45			procedure HandleAfterDelete(DataSet: TDataSet);
46			procedure HandleBeforeScroll(DataSet: TDataSet);
47			procedure HandleAfterScroll(DataSet: TDataSet);
48			procedure HandleBeforeRefresh(DataSet: TDataSet);
49			procedure HandleAfterRefresh(DataSet: TDataSet);
50			procedure ValidatePostOK(Sender: TObject; var CancelPost: boolean);
51			procedure ValidatePostCancel(Sender: TObject; var CancelPost: boolean);
52			procedure HandlePostError(DataSet: TDataSet; E: EDatabaseError;
53			var DataAction: TDataAction);
54			protected
55			procedure CreateObjects(Application: TTestApplication); override;
56			function GetTestID: AnsiString; override;
57			function GetTestTitle: AnsiString; override;
58			procedure InitTest; override;
59			public
60			procedure RunTest(CharSet: AnsiString; SQLDialect: integer); override;
61			end;
62
63
64			implementation
65
66			{ TTest17 }
67
68			procedure TTest17.HandleDeleteReturning(Sender: TObject; QryResults: IResults);
69			begin
70			writeln(OutFile,'Delete Returning');
71			ReportResult(QryResults);
72			writeln(OutFile);
73			end;
74
75			procedure TTest17.HandleBeforeOpen(DataSet: TDataSet);
76			Begin
77			writeln(Outfile,'Dataset Event BeforeOpen: State = ',DataSet.State);
78			end;
79			procedure TTest17.HandleAfterOpen(DataSet: TDataSet);
80			Begin
81			writeln(Outfile,'Dataset Event AfterOpen: State = ',DataSet.State);
82			end;
83			procedure TTest17.HandleBeforeClose(DataSet: TDataSet);
84			Begin
85			writeln(Outfile,'Dataset Event BeforeClose: State = ',DataSet.State);
86			end;
87			procedure TTest17.HandleAfterClose(DataSet: TDataSet);
88			Begin
89			writeln(Outfile,'Dataset Event AfterClose: State = ',DataSet.State);
90			end;
91			procedure TTest17.HandleBeforeInsert(DataSet: TDataSet);
92			Begin
93			writeln(Outfile,'Dataset Event BeforeInsert: State = ',DataSet.State);
94			end;
95			procedure TTest17.HandleAfterInsert(DataSet: TDataSet);
96			Begin
97			writeln(Outfile,'Dataset Event AfterInsert: State = ',DataSet.State);
98			end;
99			procedure TTest17.HandleBeforeEdit(DataSet: TDataSet);
100			Begin
101			writeln(Outfile,'Dataset Event BeforeEdit: State = ',DataSet.State);
102			end;
103			procedure TTest17.HandleAfterEdit(DataSet: TDataSet);
104			Begin
105			writeln(Outfile,'Dataset Event AfterEdit: State = ',DataSet.State);
106			end;
107			procedure TTest17.HandleBeforePost(DataSet: TDataSet);
108			Begin
109			writeln(Outfile,'Dataset Event BeforePost: State = ',DataSet.State);
110			end;
111			procedure TTest17.HandleAfterPost(DataSet: TDataSet);
112			Begin
113			writeln(Outfile,'Dataset Event AfterPost: State = ',DataSet.State);
114			end;
115			procedure TTest17.HandleBeforeCancel(DataSet: TDataSet);
116			Begin
117			writeln(Outfile,'Dataset Event BeforeCancel: State = ',DataSet.State);
118			end;
119			procedure TTest17.HandleAfterCancel(DataSet: TDataSet);
120			Begin
121			writeln(Outfile,'Dataset Event AfterCancel: State = ',DataSet.State);
122			end;
123			procedure TTest17.HandleBeforeDelete(DataSet: TDataSet);
124			Begin
125			writeln(Outfile,'Dataset Event BeforeDelete: State = ',DataSet.State);
126			end;
127			procedure TTest17.HandleAfterDelete(DataSet: TDataSet);
128			Begin
129			writeln(Outfile,'Dataset Event AfterDelete: State = ',DataSet.State);
130			end;
131			procedure TTest17.HandleBeforeScroll(DataSet: TDataSet);
132			Begin
133			writeln(Outfile,'Dataset Event BeforeScroll: State = ',DataSet.State);
134			end;
135			procedure TTest17.HandleAfterScroll(DataSet: TDataSet);
136			Begin
137			writeln(Outfile,'Dataset Event AfterScroll: State = ',DataSet.State);
138			end;
139			procedure TTest17.HandleBeforeRefresh(DataSet: TDataSet);
140			Begin
141			writeln(Outfile,'Dataset Event BeforeRefresh: State = ',DataSet.State);
142			end;
143			procedure TTest17.HandleAfterRefresh(DataSet: TDataSet);
144			Begin
145			writeln(Outfile,'Dataset Event AfterRefresh: State = ',DataSet.State);
146			end;
147
148			procedure TTest17.ValidatePostOK(Sender: TObject; var CancelPost: boolean);
149			begin
150			writeln(Outfile,'Validate Post OK called');
151			CancelPost := false;
152			end;
153
154			procedure TTest17.ValidatePostCancel(Sender: TObject; var CancelPost: boolean);
155			begin
156			writeln(Outfile,'Validate Post Cancel called');
157			CancelPost := true;
158			end;
159
160			procedure TTest17.HandlePostError(DataSet: TDataSet; E: EDatabaseError;
161			var DataAction: TDataAction);
162			begin
163			writeln(Outfile,'Post Error Called: ',E.Message);
164			DataAction := daFail;
165			end;
166
167			procedure TTest17.CreateObjects(Application: TTestApplication);
168			begin
169			inherited CreateObjects(Application);
170			FIBDataSet1 := TIBDataSet.Create(Application);
171			with FIBDataSet1 do
172			begin
173			Database := IBDatabase;
174			Transaction := IBTransaction;
175			Unidirectional := false;
176			SelectSQL.Add('Select * From IBDataSetTest');
177			InsertSQL.Add('Insert into IBDataSetTest(KeyField,PlainText) Values (:KeyField,:PlainText)');
178			ModifySQL.Add('Update IBDataSetTest Set KeyField = :KeyField, PlainText = :PlainText Where KeyField = :Old_KeyField');
179			DeleteSQL.Add('Delete from IBDataSetTest Where KeyField = :old_KeyField');
180			RefreshSQL.Add('Select * from IBDataSetTest Where KeyField = :KeyField');
181			GeneratorField.Field := 'KeyField';
182			GeneratorField.Generator := 'AGENERATOR';
183			GeneratorField.Increment := 1;
184			OnPostError := @HandlePostError;
185			end;
186			FIBDataSet2 := TIBDataSet.Create(Application);
187			with FIBDataSet2 do
188			begin
189			Database := IBDatabase;
190			Transaction := IBTransaction;
191			Unidirectional := false;
192			SelectSQL.Add('Select * From IBDataSetTest');
193			InsertSQL.Add('Insert into IBDataSetTest(KeyField,PlainText) Values (Gen_ID(AGenerator,1),:PlainText) Returning KeyField, TextAndKey');
194			ModifySQL.Add('Update IBDataSetTest Set KeyField = :KeyField, PlainText = :PlainText Where KeyField = :Old_KeyField Returning TextAndKey,ServerSideText');
195			DeleteSQL.Add('Delete from IBDataSetTest Where KeyField = :old_KeyField Returning KeyField');
196			RefreshSQL.Add('Select * from IBDataSetTest Where KeyField = :KeyField');
197			OnDeleteReturning := @HandleDeleteReturning;
198			BeforeOpen := @HandleBeforeOpen;
199			AfterOpen := @HandleAfterOpen;
200			BeforeClose := @HandleBeforeClose;
201			AfterClose := @HandleAfterClose;
202			BeforeInsert := @HandleBeforeInsert;
203			AfterInsert := @HandleAfterInsert;
204			BeforeEdit := @HandleBeforeEdit;
205			AfterEdit := @HandleAfterEdit;
206			BeforePost := @HandleBeforePost;
207			AfterPost := @HandleAfterPost;
208			BeforeCancel := @HandleBeforeCancel;
209			AfterCancel := @HandleAfterCancel;
210			BeforeDelete := @HandleBeforeDelete;
211			AfterDelete := @HandleAfterDelete;
212			BeforeScroll := @HandleBeforeScroll;
213			AfterScroll := @HandleAfterScroll;
214			BeforeRefresh := @HandleBeforeRefresh;
215			AfterRefresh := @HandleAfterRefresh;
216			end;
217			end;
218
219			function TTest17.GetTestID: AnsiString;
220			begin
221			Result := aTestID;
222			end;
223
224			function TTest17.GetTestTitle: AnsiString;
225			begin
226			Result := aTestTitle;
227			end;
228
229			procedure TTest17.InitTest;
230			begin
231			IBDatabase.DatabaseName := Owner.GetNewDatabaseName;
232			IBDatabase.CreateIfNotExists := true;
233			ReadWriteTransaction;
234			end;
235
236			procedure TTest17.RunTest(CharSet: AnsiString; SQLDialect: integer);
237			var lastKey: integer;
238			begin
239			IBDatabase.CreateDatabase;
240			try
241			IBTransaction.Active := true;
242			with FIBDataSet1 do
243			begin
244			Active := true;
245			writeln(OutFile,'FIBDataSet1: Simple Append');
246			Append;
247			// writeln(outfile,'BOF = ',BOF,', EOF = ',EOF);
248			FieldByName('PlainText').AsString := 'This is a test';
249			Post;
250			PrintDataSetRow(FIBDataSet1);
251			Refresh;
252			writeln(OutFile,'After Refresh');
253			PrintDataSetRow(FIBDataSet1);
254			writeln(OutFile,'Append and Update');
255			Append;
256			FieldByName('PlainText').AsString := 'This is another test';
257			Post;
258			PrintDataSetRow(FIBDataSet1);
259			Edit;
260			FieldByName('PlainText').AsString := 'This is the update test';
261			Post;
262			PrintDataSetRow(FIBDataSet1);
263			writeln(OutFile,'Now delete the first row');
264			PrintDataSet(FIBDataSet1);
265			First;
266			Delete;
267			PrintDataSet(FIBDataSet1);
268			writeln(Outfile,'On Post KeyField Assignment');
269			FIBDataSet1.GeneratorField.ApplyOnEvent := gaeOnPostRecord;
270			Append;
271			FieldByName('PlainText').AsString := 'On Post KeyField test';
272			PrintDataSetRow(FIBDataSet1);
273			Post;
274			writeln(Outfile,'Row data after post');
275			PrintDataSetRow(FIBDataSet1);
276			FIBDataSet1.GeneratorField.ApplyOnEvent := gaeOnNewRecord; {restore}
277
278			writeln(Outfile,'Catch a Post Error - duplicate key');
279			lastkey := FieldByName('KeyField').AsInteger;
280			Append;
281			FieldByName('KeyField').AsInteger := lastkey;
282			FieldByName('PlainText').AsString := 'On Post Error test';
283			try
284			Post;
285			except on E: Exception do
286			writeln(Outfile,'Exception handled: ',E.Message);
287			end;
288
289			IBTransaction.Rollback;
290			IBTransaction.Active := true;
291			DataSetCloseAction := dcSaveChanges;
292			Active := true;
293			writeln(OutFile,'FIBDataSet1: Simple Append with automatic posting on close');
294			Append;
295			FieldByName('PlainText').AsString := 'This is a test';
296			Active := false;
297			Active := true;
298			PrintDataSet(FIBDataSet1);
299
300			IBTransaction.Rollback;
301			IBTransaction.Active := true;
302			DataSetCloseAction := dcDiscardChanges;
303			Active := true;
304			writeln(OutFile,'FIBDataSet1: Simple Append with discard on close');
305			Append;
306			FieldByName('PlainText').AsString := 'This is a test';
307			Active := false;
308			Active := true;
309			PrintDataSet(FIBDataSet1);
310
311			{See https://bugs.freepascal.org/view.php?id=37900}
312
313			(* IBTransaction.Rollback;
314			IBTransaction.Active := true;
315			writeln(Outfile);
316			writeln(Outfile,'Unidirectional editing');
317			Unidirectional := true;
318			Active := true;
319			writeln(OutFile,'FIBDataSet1: Simple Append - unidirectional');
320			Insert;
321			writeln(outfile,'BOF = ',BOF,', EOF = ',EOF);
322			FieldByName('PlainText').AsString := 'This is a test - unidirectional';
323			PrintDataSetRow(FIBDataSet1);
324			Post;
325			writeln(outfile,'BOF = ',BOF,', EOF = ',EOF);
326			PrintDataSetRow(FIBDataSet1);
327			Refresh;
328			writeln(OutFile,'After Refresh - unidirectional');
329			PrintDataSetRow(FIBDataSet1);
330			writeln(OutFile,'Append and Update');
331			Insert;
332			FieldByName('PlainText').AsString := 'This is another test - unidirectional';
333			Post;
334			PrintDataSetRow(FIBDataSet1);
335			Edit;
336			FieldByName('PlainText').AsString := 'This is the update test - unidirectional';
337			Post;
338			PrintDataSetRow(FIBDataSet1);
339			writeln(OutFile,'Now delete the first row - unidirectional');
340			PrintDataSet(FIBDataSet1);
341			First;
342			Delete;
343			PrintDataSet(FIBDataSet1);
344			writeln(Outfile,'Ensure dataset saved to database');
345			Active := false;
346			Active := true;
347			PrintDataSet(FIBDataSet1); *)
348
349			end;
350			writeln(Outfile,'==================================');
351			IBTransaction.Rollback;
352			IBTransaction.Active := true;
353			with FIBDataSet2 do
354			begin
355			Active := true;
356			writeln(OutFile,'FIBDataSet2: Simple Append');
357			Append;
358			FieldByName('PlainText').AsString := 'This is a test';
359			Post;
360			PrintDataSetRow(FIBDataSet2);
361			Refresh;
362			writeln(OutFile,'After Refresh');
363			PrintDataSetRow(FIBDataSet2);
364			writeln(OutFile,'Append and Update');
365			Append;
366			FieldByName('PlainText').AsString := 'This is another test';
367			Post;
368			PrintDataSetRow(FIBDataSet2);
369			Edit;
370			FieldByName('PlainText').AsString := 'This is the update test';
371			Post;
372			PrintDataSetRow(FIBDataSet2);
373			writeln(OutFile,'Now delete the first row');
374			PrintDataSet(FIBDataSet2);
375			First;
376			Delete;
377			PrintDataSet(FIBDataSet2);
378			OnValidatePost := @ValidatePostOK;
379			writeln(Outfile,'Validate Post OK');
380			Append;
381			FieldByName('PlainText').AsString := 'This is a validated Post';
382			Post;
383			PrintDataSetRow(FIBDataSet2);
384			OnValidatePost := @ValidatePostCancel;
385			writeln(Outfile,'Validate Post Cancel');
386			Append;
387			FieldByName('PlainText').AsString := 'This is a validated Post which should have been cancelled';
388			Post;
389			PrintDataSetRow(FIBDataSet2);
390			OnValidatePost := nil;
391			writeln(OutFile,'FIBDataSet2: Simple Append with Forced Refresh');
392			ForcedRefresh := true;
393			Append;
394			FieldByName('PlainText').AsString := 'This is a test';
395			Post;
396			PrintDataSetRow(FIBDataSet2);
397
398			end;
399			finally
400			IBDatabase.DropDatabase;
401			end;
402			end;
403
404			initialization
405			RegisterTest(TTest17);
406
407			end.
408