ViewVC Help
View File | Revision Log | Show Annotations | Download File | View Changeset | Root Listing
root/public/ibx/branches/udr/testsuite/Test10.pas
(Generate patch)

Comparing:
ibx/trunk/fbintf/testsuite/Test10.pas (file contents), Revision 45 by tony, Tue Dec 6 10:33:46 2016 UTC vs.
ibx/branches/journaling/fbintf/testsuite/Test10.pas (file contents), Revision 362 by tony, Tue Dec 7 13:27:39 2021 UTC

# Line 1 | Line 1
1 + (*
2 + *  Firebird Interface (fbintf) Test suite. This program is used to
3 + *  test the Firebird Pascal Interface and provide a semi-automated
4 + *  pass/fail check for each test.
5 + *
6 + *  The contents of this file are subject to the Initial Developer's
7 + *  Public License Version 1.0 (the "License"); you may not use this
8 + *  file except in compliance with the License. You may obtain a copy
9 + *  of the License here:
10 + *
11 + *    http://www.firebirdsql.org/index.php?op=doc&id=idpl
12 + *
13 + *  Software distributed under the License is distributed on an "AS
14 + *  IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
15 + *  implied. See the License for the specific language governing rights
16 + *  and limitations under the License.
17 + *
18 + *  The Initial Developer of the Original Code is Tony Whyman.
19 + *
20 + *  The Original Code is (C) 2016 Tony Whyman, MWA Software
21 + *  (http://www.mwasoftware.co.uk).
22 + *
23 + *  All Rights Reserved.
24 + *
25 + *  Contributor(s): ______________________________________.
26 + *
27 + *)
28 +
29   unit Test10;
30 + {$IFDEF MSWINDOWS}
31 + {$DEFINE WINDOWS}
32 + {$ENDIF}
33  
34 < {$mode objfpc}{$H+}
34 > {$IFDEF FPC}
35 > {$mode delphi}
36   {$codepage utf8}
37 + {$ENDIF}
38  
39   {Test 10: Event Handling}
40  
# Line 25 | Line 58 | unit Test10;
58   interface
59  
60   uses
61 <  Classes, SysUtils, TestManager, IB;
61 >  Classes, SysUtils, TestApplication, FBTestApp, IB;
62  
63   type
64  
65   { TTest10 }
66  
67 <  TTest10 = class(TTestBase)
67 >  TTest10 = class(TFBTestBase)
68    private
69      FEventSignalled: boolean;
70      procedure EventsTest(Attachment: IAttachment);
71      procedure EventReport(Sender: IEvents);
72 +    procedure ShowEventReport;
73 +    procedure ShowEventCounts(Intf: IEvents);
74    public
75 <    function TestTitle: string; override;
76 <    procedure RunTest(CharSet: string; SQLDialect: integer); override;
75 >    function TestTitle: AnsiString; override;
76 >    procedure RunTest(CharSet: AnsiString; SQLDialect: integer); override;
77    end;
78  
79  
# Line 51 | Line 86 | const
86  
87   procedure TTest10.EventsTest(Attachment: IAttachment);
88   var EventHandler: IEvents;
54 –    EventCounts: TEventCounts;
55 –    i: integer;
89      WaitCount: integer;
90   begin
91 +  FEventSignalled := false;
92    EventHandler := Attachment.GetEventHandler('TESTEVENT');
93    writeln(OutFile,'Call Async Wait');
94 <  EventHandler.AsyncWaitForEvent(@EventReport);
94 >  EventHandler.AsyncWaitForEvent(EventReport);
95    writeln(OutFile,'Async Wait Called');
96 <
96 >  sleep(500);
97 >  CheckSynchronize;
98 >  if FEventSignalled then
99 >  begin
100 >    writeln(OutFile,'First Event - usually ignored');
101 >    FEventSignalled := false;
102 >    EventHandler.AsyncWaitForEvent(EventReport);
103 >    sleep(100);
104 >    CheckSynchronize;
105 >    if FEventSignalled then
106 >    begin
107 >      writeln(OutFile,'Unexpected Event 1');
108 >      Exit;
109 >    end;
110 >  end;
111    writeln(OutFile,'Signal Event');
112    Attachment.ExecImmediate([isc_tpb_write,isc_tpb_nowait,isc_tpb_concurrency],sqlEvent);
113 <  while not FEventSignalled do;
114 <  writeln(OutFile,'Event Signalled');
67 <  EventCounts := EventHandler.ExtractEventCounts;
68 <  for i := 0 to length(EventCounts) - 1 do
69 <    writeln(OutFile,'Event: ',EventCounts[i].EventName,', Count = ',EventCounts[i].Count);
113 >  while not FEventSignalled do Sleep(50);
114 >  ShowEventCounts(EventHandler);
115    FEventSignalled := false;
116  
117    writeln(OutFile,'Two more events');
118    Attachment.ExecImmediate([isc_tpb_write,isc_tpb_nowait,isc_tpb_concurrency],sqlEvent);
119    Attachment.ExecImmediate([isc_tpb_write,isc_tpb_nowait,isc_tpb_concurrency],sqlEvent);
120 +  if FEventSignalled then
121 +  begin
122 +    writeln(OutFile,'Unexpected Event 2');
123 +    FEventSignalled := false
124 +  end;
125    writeln(OutFile,'Call Async Wait');
126 <  EventHandler.AsyncWaitForEvent(@EventReport);
126 >  EventHandler.AsyncWaitForEvent(EventReport);
127    writeln(OutFile,'Async Wait Called');
128 +  sleep(500);
129 +  CheckSynchronize;
130 +  if FEventSignalled then
131 +  begin
132 +    writeln(OutFile,'Deferred Events Caught');
133 +    ShowEventCounts(EventHandler);
134 +    FEventSignalled := false;
135 +    EventHandler.AsyncWaitForEvent(EventReport);
136 +    CheckSynchronize;
137 +    sleep(100);
138 +    if FEventSignalled then
139 +      writeln(OutFile,'Unexpected Event 3');
140 +  end;
141    writeln(OutFile,'Signal Event');
142    Attachment.ExecImmediate([isc_tpb_write,isc_tpb_nowait,isc_tpb_concurrency],sqlEvent);
143    while not FEventSignalled do;
144 <  writeln(OutFile,'Event Signalled');
82 <  EventCounts := EventHandler.ExtractEventCounts;
83 <  for i := 0 to length(EventCounts) - 1 do
84 <    writeln(OutFile,'Event: ',EventCounts[i].EventName,', Count = ',EventCounts[i].Count);
144 >  ShowEventCounts(EventHandler);
145  
146    FEventSignalled := false;
147    writeln(OutFile,'Async Wait: Test Cancel');
148 <  EventHandler.AsyncWaitForEvent(@EventReport);
148 >  EventHandler.AsyncWaitForEvent(EventReport);
149 >  CheckSynchronize;
150    writeln(OutFile,'Async Wait Called');
151    EventHandler.Cancel;
152 +  writeln(OutFile,'Event Cancelled');
153 +  FEventSignalled := false;
154    Attachment.ExecImmediate([isc_tpb_write,isc_tpb_nowait,isc_tpb_concurrency],sqlEvent);
155    WaitCount := 100000000;
156    while not FEventSignalled and (WaitCount > 0) do Dec(WaitCount);
# Line 96 | Line 159 | begin
159      writeln(OutFile,'Event called - so Cancel failed');
160  
161    writeln(OutFile,'Sync wait');
162 +  CheckSynchronize;
163    Attachment.ExecImmediate([isc_tpb_write,isc_tpb_nowait,isc_tpb_concurrency],sqlEvent);
164    EventHandler.WaitForEvent;
165    writeln(OutFile,'Event Signalled');
166 <  EventCounts := EventHandler.ExtractEventCounts;
167 <  for i := 0 to length(EventCounts) - 1 do
168 <    writeln(OutFile,'Event: ',EventCounts[i].EventName,', Count = ',EventCounts[i].Count);
166 >  ShowEventCounts(EventHandler);
167 >  EventHandler := nil;
168 >  CheckSynchronize;
169   end;
170  
171   procedure TTest10.EventReport(Sender: IEvents);
172   begin
173    FEventSignalled := true;
174 +  TThread.Synchronize(nil,ShowEventReport);
175 + end;
176 +
177 + procedure TTest10.ShowEventReport;
178 + begin
179 +  writeln(OutFile,'Event Signalled');
180 + end;
181 +
182 + procedure TTest10.ShowEventCounts(Intf: IEvents);
183 + var
184 +  i: integer;
185 +  EventCounts: TEventCounts;
186 + begin
187 +  EventCounts := Intf.ExtractEventCounts;
188 +  for i := 0 to length(EventCounts) - 1 do
189 +    writeln(OutFile,'Event Counts: ',EventCounts[i].EventName,', Count = ',EventCounts[i].Count);
190   end;
191  
192 < function TTest10.TestTitle: string;
192 > function TTest10.TestTitle: AnsiString;
193   begin
194    Result := 'Test 10: Event Handling';
195   end;
196  
197 < procedure TTest10.RunTest(CharSet: string; SQLDialect: integer);
197 > procedure TTest10.RunTest(CharSet: AnsiString; SQLDialect: integer);
198   var Attachment: IAttachment;
199      DPB: IDPB;
200   begin

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines