1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
|
-- C954026.A
--
-- Grant of Unlimited Rights
--
-- Under contracts F33600-87-D-0337, F33600-84-D-0280, MDA903-79-C-0687,
-- F08630-91-C-0015, and DCA100-97-D-0025, the U.S. Government obtained
-- unlimited rights in the software and documentation contained herein.
-- Unlimited rights are defined in DFAR 252.227-7013(a)(19). By making
-- this public release, the Government intends to confer upon all
-- recipients unlimited rights equal to those held by the Government.
-- These rights include rights to use, duplicate, release or disclose the
-- released technical data and computer software in whole or in part, in
-- any manner and for any purpose whatsoever, and to have or permit others
-- to do so.
--
-- DISCLAIMER
--
-- ALL MATERIALS OR INFORMATION HEREIN RELEASED, MADE AVAILABLE OR
-- DISCLOSED ARE AS IS. THE GOVERNMENT MAKES NO EXPRESS OR IMPLIED
-- WARRANTY AS TO ANY MATTER WHATSOEVER, INCLUDING THE CONDITIONS OF THE
-- SOFTWARE, DOCUMENTATION OR OTHER INFORMATION RELEASED, MADE AVAILABLE
-- OR DISCLOSED, OR THE OWNERSHIP, MERCHANTABILITY, OR FITNESS FOR A
-- PARTICULAR PURPOSE OF SAID MATERIAL.
--*
--
-- OBJECTIVE:
-- Check that if the original protected entry call was a conditional
-- entry call, the call is cancelled if a requeue-with-abort of the
-- call is not selected immediately.
-- Check that if the original protected entry call was a timed entry
-- call, the expiration time for a requeue-with-abort is the original
-- expiration time.
--
-- TEST DESCRIPTION:
-- In this test the main task makes a variety of calls to the protected
-- object Initial_PO. These calls include a simple call, a conditional
-- call, and a timed call. The timed calls include calls with enough
-- time and those with less than the needed amount of time to get through
-- the requeue performed by Initial_PO.
-- Initial_PO requeues its entry call to Final_PO.
-- Final_PO does not accept the requeued call until the protected
-- procedure Ok_To_Take_Requeue is called.
-- A separate task, Delayed_Opener, is used to call Ok_To_Take_Requeue
-- after a delay amount specified by the main task has expired.
--
--
-- CHANGE HISTORY:
-- 15 DEC 95 SAIC ACVC 2.1
-- 10 JUL 96 SAIC Incorporated reviewer comments.
-- 10 OCT 96 SAIC Incorporated fix provided by vendor.
--
--!
with Calendar;
use type Calendar.Time;
with Report;
with Impdef;
procedure C954026 is
Verbose : constant Boolean := False;
Final_Po_Reached : Boolean := False;
Allowed_Time : constant Duration := 2.0 * Impdef.One_Long_Second;
Plenty_Of_Time : constant Duration :=
Allowed_Time + Impdef.Clear_Ready_Queue + 1.0 * Impdef.One_Long_Second;
Not_Enough_Time : constant Duration := Allowed_Time - 0.5 * Impdef.One_Long_Second;
begin
Report.Test ("C954026",
"Check that if the original entry" &
" call was a conditional or timed entry call," &
" the expiration time for a requeue with" &
" abort to a protected" &
" entry is the original expiration time");
declare
protected Initial_Po is
entry Start_Here;
end Initial_Po;
protected Final_Po is
entry Requeue_Target;
procedure Ok_To_Take_Requeue;
procedure Close_Requeue;
private
Open : Boolean := False;
end Final_Po;
-- the Delayed_Opener task is used to notify Final_PO that it can
-- accept the Requeue_Target entry.
task Delayed_Opener is
entry Start_Timer (Amt : Duration);
entry Cancel_Timer;
end Delayed_Opener;
task body Delayed_Opener is
Wait_Amt : Duration;
begin
loop
accept Start_Timer (Amt : Duration) do
Wait_Amt := Amt;
end Start_Timer;
exit when Wait_Amt < 0.0;
if Verbose then
Report.Comment ("Timer started");
end if;
select
accept Cancel_Timer do
Final_Po.Close_Requeue;
end Cancel_Timer;
or
delay Wait_Amt;
Final_Po.Ok_To_Take_Requeue;
accept Cancel_Timer do
Final_Po.Close_Requeue;
end Cancel_Timer;
end select;
end loop;
exception
when others =>
Report.Failed ("exception in Delayed_Opener");
end Delayed_Opener;
protected body Initial_Po is
entry Start_Here when True is
begin
Final_Po_Reached := False;
requeue Final_Po.Requeue_Target with abort;
end Start_Here;
end Initial_Po;
protected body Final_Po is
entry Requeue_Target when Open is
begin
Open := False;
Final_Po_Reached := True;
end Requeue_Target;
procedure Ok_To_Take_Requeue is
begin
Open := True;
end Ok_To_Take_Requeue;
procedure Close_Requeue is
begin
Open := False;
end Close_Requeue;
end Final_Po;
begin -- test encapsulation
-- unconditional entry call to check the simple case
Delayed_Opener.Start_Timer (0.0);
Initial_Po.Start_Here;
if Final_Po_Reached then
if Verbose then
Report.Comment ("simple case passed");
end if;
else
Report.Failed ("simple case");
end if;
Delayed_Opener.Cancel_Timer;
-- timed but with plenty of time - delay relative
Delayed_Opener.Start_Timer (Allowed_Time);
select
Initial_Po.Start_Here;
or
delay Plenty_Of_Time;
Report.Failed ("plenty of time timed out (1)");
if Final_Po_Reached then
Report.Failed (
"plenty of time timed out after accept (1)");
end if;
end select;
if Final_Po_Reached then
if Verbose then
Report.Comment ("plenty of time case passed (1)");
end if;
else
Report.Failed ("plenty of time (1)");
end if;
Delayed_Opener.Cancel_Timer;
-- timed but with plenty of time -- delay until
Delayed_Opener.Start_Timer (Allowed_Time);
select
Initial_Po.Start_Here;
or
delay until Calendar.Clock + Plenty_Of_Time;
Report.Failed ("plenty of time timed out (2)");
if Final_Po_Reached then
Report.Failed (
"plenty of time timed out after accept(2)");
end if;
end select;
if Final_Po_Reached then
if Verbose then
Report.Comment ("plenty of time case passed (2)");
end if;
else
Report.Failed ("plenty of time (2)");
end if;
Delayed_Opener.Cancel_Timer;
-- timed without enough time - delay relative
Delayed_Opener.Start_Timer (Allowed_Time);
select
Initial_Po.Start_Here;
Report.Failed ("not enough time completed accept (1)");
or
delay Not_Enough_Time;
end select;
if Final_Po_Reached then
Report.Failed ("not enough time (1)");
else
if Verbose then
Report.Comment ("not enough time case passed (1)");
end if;
end if;
Delayed_Opener.Cancel_Timer;
-- timed without enough time - delay until
Delayed_Opener.Start_Timer (Allowed_Time);
select
Initial_Po.Start_Here;
Report.Failed ("not enough time completed accept (2)");
or
delay until Calendar.Clock + Not_Enough_Time;
end select;
if Final_Po_Reached then
Report.Failed ("not enough time (2)");
else
if Verbose then
Report.Comment ("not enough time case passed (2)");
end if;
end if;
Delayed_Opener.Cancel_Timer;
-- conditional case
Delayed_Opener.Start_Timer (Allowed_Time);
select
Initial_Po.Start_Here;
Report.Failed ("no time completed accept");
else
if Verbose then
Report.Comment ("conditional case - else taken");
end if;
end select;
if Final_Po_Reached then
Report.Failed ("no time");
else
if Verbose then
Report.Comment ("no time case passed");
end if;
end if;
Delayed_Opener.Cancel_Timer;
-- kill off the Delayed_Opener task
Delayed_Opener.Start_Timer (-10.0);
exception
when others =>
Report.Failed ("exception in main");
end;
Report.Result;
end C954026;
|
