source: rtems/testsuites/ada/sptests/sp09/sptest.adb @ bc96f3b4

Last change on this file since bc96f3b4 was bc96f3b4, checked in by Sebastian Huber <sebastian.huber@…>, on Jan 23, 2018 at 8:53:06 AM

ada: Introduce RTEMS.Size type

Some time ago the Classic API object size related parameters were
changed to use size_t. Reflect this in the Ada bindings.

Update #3082.

  • Property mode set to 100644
File size: 84.6 KB
Line 
1--
2--  SPTEST / BODY
3--
4--  DESCRIPTION:
5--
6--  This package is the implementation of Test 9 of the RTEMS
7--  Single Processor Test Suite.
8--
9--  DEPENDENCIES:
10--
11-- 
12--
13--  COPYRIGHT (c) 1989-2011.
14--  On-Line Applications Research Corporation (OAR).
15--
16--  The license and distribution terms for this file may in
17--  the file LICENSE in this distribution or at
18--  http://www.rtems.org/license/LICENSE.
19--
20
21with INTERFACES; use INTERFACES;
22with TEST_SUPPORT;
23with TEXT_IO;
24with RTEMS.CLOCK;
25with RTEMS.EVENT;
26with RTEMS.MESSAGE_QUEUE;
27with RTEMS.PARTITION;
28with RTEMS.PORT;
29with RTEMS.RATE_MONOTONIC;
30with RTEMS.REGION;
31with RTEMS.SEMAPHORE;
32with RTEMS.TIMER;
33with Interfaces.C;
34use Interfaces.C;
35
36package body SPTEST is
37
38--
39--  INIT
40--
41
42   procedure INIT (
43      ARGUMENT : in     RTEMS.TASKS.ARGUMENT
44   ) is
45      pragma Unreferenced(ARGUMENT);
46      STATUS : RTEMS.STATUS_CODES;
47   begin
48
49      TEXT_IO.NEW_LINE( 2 );
50      TEST_SUPPORT.ADA_TEST_BEGIN;
51
52      SPTEST.TASK_NAME( 1 )   := RTEMS.BUILD_NAME(  'T', 'A', '1', ' ' );
53      SPTEST.TASK_NAME( 2 )   := RTEMS.BUILD_NAME(  'T', 'A', '2', ' ' );
54      SPTEST.TASK_NAME( 3 )   := RTEMS.BUILD_NAME(  'T', 'A', '3', ' ' );
55      SPTEST.TASK_NAME( 4 )   := RTEMS.BUILD_NAME(  'T', 'A', '4', ' ' );
56      SPTEST.TASK_NAME( 5 )   := RTEMS.BUILD_NAME(  'T', 'A', '5', ' ' );
57      SPTEST.TASK_NAME( 6 )   := RTEMS.BUILD_NAME(  'T', 'A', '6', ' ' );
58      SPTEST.TASK_NAME( 7 )   := RTEMS.BUILD_NAME(  'T', 'A', '7', ' ' );
59      SPTEST.TASK_NAME( 8 )   := RTEMS.BUILD_NAME(  'T', 'A', '8', ' ' );
60      SPTEST.TASK_NAME( 9 )   := RTEMS.BUILD_NAME(  'T', 'A', '9', ' ' );
61      SPTEST.TASK_NAME( 10 )  := RTEMS.BUILD_NAME(  'T', 'A', 'A', ' ' );
62
63      SPTEST.TIMER_NAME( 1 )   := RTEMS.BUILD_NAME(  'T', 'M', '1', ' ' );
64
65      SPTEST.SEMAPHORE_NAME( 1 ) := RTEMS.BUILD_NAME( 'S', 'M', '1', ' ' );
66      SPTEST.SEMAPHORE_NAME( 2 ) := RTEMS.BUILD_NAME( 'S', 'M', '2', ' ' );
67      SPTEST.SEMAPHORE_NAME( 3 ) := RTEMS.BUILD_NAME( 'S', 'M', '3', ' ' );
68
69      SPTEST.QUEUE_NAME( 1 )     := RTEMS.BUILD_NAME( 'M', 'Q', '1', ' ' );
70      SPTEST.QUEUE_NAME( 2 )     := RTEMS.BUILD_NAME( 'M', 'Q', '2', ' ' );
71
72      SPTEST.PARTITION_NAME( 1 ) := RTEMS.BUILD_NAME( 'P', 'T', '1', ' ' );
73
74      SPTEST.REGION_NAME( 1 )    := RTEMS.BUILD_NAME( 'R', 'N', '1', ' ' );
75
76      SPTEST.PORT_NAME( 1 )      := RTEMS.BUILD_NAME( 'D', 'P', '1', ' ' );
77
78      SPTEST.PERIOD_NAME( 1 )    := RTEMS.BUILD_NAME( 'T', 'M', '1', ' ' );
79
80      RTEMS.TASKS.CREATE(
81         SPTEST.TASK_NAME( 1 ),
82         0,
83         2048,
84         RTEMS.DEFAULT_MODES,
85         RTEMS.DEFAULT_ATTRIBUTES,
86         SPTEST.TASK_ID( 1 ),
87         STATUS
88      );
89      TEST_SUPPORT.FATAL_DIRECTIVE_STATUS(
90         STATUS,
91         RTEMS.INVALID_PRIORITY,
92         "TASK_CREATE WITH ILLEGAL PRIORITY"
93      );
94      TEXT_IO.PUT_LINE( "INIT - task_create - INVALID_PRIORITY" );
95
96      RTEMS.TASKS.CREATE(
97         SPTEST.TASK_NAME( 1 ),
98         4,
99         2048,
100         RTEMS.DEFAULT_MODES,
101         RTEMS.DEFAULT_ATTRIBUTES,
102         SPTEST.TASK_ID( 1 ),
103         STATUS
104      );
105      TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "TASK_CREATE OF TA1" );
106
107      RTEMS.TASKS.RESTART(
108         SPTEST.TASK_ID( 1 ),
109         0,
110         STATUS
111      );
112      TEST_SUPPORT.FATAL_DIRECTIVE_STATUS(
113         STATUS,
114         RTEMS.INCORRECT_STATE,
115         "TASK_RESTART OF DORMANT TASK"
116      );
117      TEXT_IO.PUT_LINE( "INIT - task_restart - INCORRECT_STATE" );
118
119      RTEMS.TASKS.START(
120         SPTEST.TASK_ID( 1 ),
121         SPTEST.TASK_1'ACCESS,
122         0,
123         STATUS
124      );
125      TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "TASK_START OF TA1" );
126
127      RTEMS.TASKS.DELETE( RTEMS.SELF, STATUS );
128      TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "TASK_DELETE OF SELF" );
129
130   end INIT;
131
132--
133--  DELAYED_SUBPROGRAM
134--
135
136   procedure DELAYED_SUBPROGRAM (
137      IGNORED_ID      : in     RTEMS.ID;
138      IGNORED_ADDRESS : in     RTEMS.ADDRESS
139   ) is
140   begin
141
142      NULL;
143
144   end DELAYED_SUBPROGRAM;
145
146--
147--  SCREEN_1
148--
149
150   procedure SCREEN_1
151   is
152      SELF_ID           : RTEMS.ID;
153      PREVIOUS_PRIORITY : RTEMS.TASKS.PRIORITY;
154      STATUS            : RTEMS.STATUS_CODES;
155   begin
156
157      RTEMS.TASKS.DELETE( 100, STATUS );
158      TEST_SUPPORT.FATAL_DIRECTIVE_STATUS(
159         STATUS,
160         RTEMS.INVALID_ID,
161         "TASK_DELETE WITH ILLEGAL ID"
162      );
163      TEXT_IO.PUT_LINE( "TA1 - task_delete - INVALID_ID" );
164
165      RTEMS.TASKS.IDENT(
166         RTEMS.SELF,
167         RTEMS.SEARCH_ALL_NODES, 
168         SELF_ID,
169         STATUS
170      );
171      TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "TASK_IDENT OF SELF" );
172      if SELF_ID /= SPTEST.TASK_ID( 1 ) then
173         TEXT_IO.PUT_LINE( "ERROR - task_ident - incorrect ID returned!" );
174         RTEMS.SHUTDOWN_EXECUTIVE( 0 );
175      end if;
176      TEXT_IO.PUT_LINE(
177         "TA1 - task_ident - current task SUCCESSFUL"
178      );
179
180      RTEMS.TASKS.IDENT(
181         100,
182         RTEMS.SEARCH_ALL_NODES,
183         SPTEST.JUNK_ID,
184         STATUS
185      );
186      TEST_SUPPORT.FATAL_DIRECTIVE_STATUS(
187         STATUS,
188         RTEMS.INVALID_NAME,
189         "TASK_IDENT WITH ILLEGAL NAME (local)"
190      );
191      TEXT_IO.PUT_LINE( "TA1 - task_ident - global INVALID_NAME" );
192
193      RTEMS.TASKS.IDENT( 100, 1, SPTEST.JUNK_ID, STATUS );
194      TEST_SUPPORT.FATAL_DIRECTIVE_STATUS(
195         STATUS,
196         RTEMS.INVALID_NAME,
197         "TASK_IDENT WITH ILLEGAL NAME (global)"
198      );
199      TEXT_IO.PUT_LINE( "TA1 - task_ident - local INVALID_NAME" );
200
201      RTEMS.TASKS.IDENT( 100, 2, SPTEST.JUNK_ID, STATUS );
202      if TEST_SUPPORT.Is_Configured_Multiprocessing then
203         TEST_SUPPORT.FATAL_DIRECTIVE_STATUS(
204            STATUS,
205            RTEMS.INVALID_NODE,
206            "TASK_IDENT WITH ILLEGAL NODE"
207         );
208      else
209         TEST_SUPPORT.FATAL_DIRECTIVE_STATUS(
210            STATUS,
211            RTEMS.INVALID_NAME,
212            "TASK_IDENT WITH ILLEGAL NODE"
213         );
214      end if;
215      TEXT_IO.PUT_LINE( "TA1 - task_ident - INVALID_NODE" );
216
217      RTEMS.TASKS.RESTART( 100, 0, STATUS );
218      TEST_SUPPORT.FATAL_DIRECTIVE_STATUS(
219         STATUS,
220         RTEMS.INVALID_ID,
221         "TASK_RESTART WITH ILLEGAL ID"
222      );
223      TEXT_IO.PUT_LINE( "TA1 - task_restart - INVALID_ID" );
224
225      RTEMS.TASKS.RESUME( 100, STATUS );
226      TEST_SUPPORT.FATAL_DIRECTIVE_STATUS(
227         STATUS,
228         RTEMS.INVALID_ID,
229         "TASK_RESUME WITH ILLEGAL ID"
230      );
231      TEXT_IO.PUT_LINE( "TA1 - task_resume - INVALID_ID" );
232
233      RTEMS.TASKS.RESUME( RTEMS.SELF, STATUS );
234      TEST_SUPPORT.FATAL_DIRECTIVE_STATUS(
235         STATUS,
236         RTEMS.INCORRECT_STATE,
237         "TASK_RESUME OF READY TASK"
238      );
239      TEXT_IO.PUT_LINE( "TA1 - task_resume - INCORRECT_STATE" );
240
241      begin
242        RTEMS.TASKS.SET_PRIORITY( RTEMS.SELF, 512, PREVIOUS_PRIORITY, STATUS );
243        TEST_SUPPORT.FATAL_DIRECTIVE_STATUS(
244           STATUS,
245           RTEMS.INVALID_PRIORITY,
246           "TASK_SET_PRIORITY WITH ILLEGAL PRIORITY"
247        );
248        TEXT_IO.PUT_LINE(
249           "TA1 - task_set_priority - INVALID_PRIORITY"
250        );
251      exception
252         when others =>
253            TEXT_IO.PUT_LINE(
254               "TA1 - task_set_priority - INVALID_PRIORITY -- constraint error"
255            );
256      end;
257
258      RTEMS.TASKS.SET_PRIORITY( 100, 8, PREVIOUS_PRIORITY, STATUS );
259      TEST_SUPPORT.FATAL_DIRECTIVE_STATUS(
260         STATUS,
261         RTEMS.INVALID_ID,
262         "TASK_SET_PRIORITY WITH ILLEGAL ID"
263      );
264      TEXT_IO.PUT_LINE( "TA1 - task_set_priority - INVALID_ID" );
265
266      RTEMS.TASKS.START( 100, SPTEST.TASK_1'ACCESS, 0, STATUS );
267      TEST_SUPPORT.FATAL_DIRECTIVE_STATUS(
268         STATUS,
269         RTEMS.INVALID_ID,
270         "TASK_START WITH ILLEGAL ID"
271      );
272      TEXT_IO.PUT_LINE( "TA1 - task_start - INVALID_ID" );
273
274      RTEMS.TASKS.START( RTEMS.SELF, SPTEST.TASK_1'ACCESS, 0, STATUS );
275      TEST_SUPPORT.FATAL_DIRECTIVE_STATUS(
276         STATUS,
277         RTEMS.INCORRECT_STATE,
278         "TASK_START OF READY TASK"
279      );
280      TEXT_IO.PUT_LINE( "TA1 - task_start - INCORRECT_STATE" );
281
282      RTEMS.TASKS.SUSPEND( 100, STATUS );
283      TEST_SUPPORT.FATAL_DIRECTIVE_STATUS(
284         STATUS,
285         RTEMS.INVALID_ID,
286         "TASK_SUSPEND WITH INVALID ID"
287      );
288      TEXT_IO.PUT_LINE( "TA1 - task_suspend - INVALID_ID" );
289
290   end SCREEN_1;
291
292--
293--  SCREEN_2
294--
295
296   procedure SCREEN_2
297   is
298      TIME   : RTEMS.TIME_OF_DAY;
299      STATUS : RTEMS.STATUS_CODES;
300   begin
301
302-- errors before clock is set
303
304      RTEMS.CLOCK.GET_TOD( TIME, STATUS );
305      if RTEMS.IS_STATUS_SUCCESSFUL( STATUS ) then
306         TEXT_IO.PUT_LINE(
307            "TA1 - clock_get - NOT_DEFINED -- DID THE BSP SET THE TIME OF DAY?"
308         );
309      else
310         TEST_SUPPORT.FATAL_DIRECTIVE_STATUS(
311            STATUS,
312            RTEMS.NOT_DEFINED,
313            "CLOCK_GET BEFORE CLOCK IS SET"
314         );
315         TEXT_IO.PUT_LINE( "TA1 - clock_get - NOT_DEFINED" );
316      end if;
317
318      RTEMS.TASKS.WAKE_WHEN( TIME, STATUS );
319      if RTEMS.IS_STATUS_SUCCESSFUL( STATUS ) then
320         TEXT_IO.PUT( "TA1 - task_wake_when - NOT_DEFINED -- " );
321         TEXT_IO.PUT_LINE( "DID THE BSP SET THE TIME OF DAY?" );
322      else
323         TEST_SUPPORT.FATAL_DIRECTIVE_STATUS(
324            STATUS,
325            RTEMS.NOT_DEFINED,
326            "TASK_WAKE_WHEN BEFORE CLOCK IS SET"
327         );
328         TEXT_IO.PUT_LINE( "TA1 - task_wake_when - NOT_DEFINED" );
329      end if;
330
331      RTEMS.TIMER.FIRE_WHEN(
332         0,
333         TIME,
334         SPTEST.DELAYED_SUBPROGRAM'ACCESS,
335         RTEMS.NULL_ADDRESS,
336         STATUS
337      );
338
339      if RTEMS.IS_STATUS_SUCCESSFUL( STATUS ) then
340         TEXT_IO.PUT( "TA1 - task_fire_when - NOT_DEFINED -- " );
341         TEXT_IO.PUT_LINE( "DID THE BSP SET THE TIME OF DAY?" );
342      else
343
344         TEST_SUPPORT.FATAL_DIRECTIVE_STATUS(
345            STATUS,
346            RTEMS.NOT_DEFINED,
347            "TIMER_FIRE_WHEN BEFORE CLOCK IS SET"
348         );
349         TEXT_IO.PUT_LINE( "TA1 - timer_fire_when - NOT_DEFINED" );
350
351      end if;
352
353-- invalid time of day field
354
355      TIME := ( 1987, 2, 5, 8, 30, 45, 0 );
356      TEST_SUPPORT.PRINT_TIME( "TA1 - clock_set - ", TIME, "" );
357      RTEMS.CLOCK.SET( TIME, STATUS );
358      TEST_SUPPORT.FATAL_DIRECTIVE_STATUS(
359         STATUS,
360         RTEMS.INVALID_CLOCK,
361         "CLOCK_SET WITH INVALID YEAR"
362      );
363      TEXT_IO.PUT_LINE( " - INVALID_CLOCK" );
364
365      TIME := ( 1988, 15, 5, 8, 30, 45, 0 );
366      TEST_SUPPORT.PRINT_TIME( "TA1 - clock_set - ", TIME, "" );
367      RTEMS.CLOCK.SET( TIME, STATUS );
368      TEST_SUPPORT.FATAL_DIRECTIVE_STATUS(
369         STATUS,
370         RTEMS.INVALID_CLOCK,
371         "CLOCK_SET WITH INVALID MONTH"
372      );
373      TEXT_IO.PUT_LINE( " - INVALID_CLOCK" );
374
375      TIME := ( 1988, 2, 32, 8, 30, 45, 0 );
376      TEST_SUPPORT.PRINT_TIME( "TA1 - clock_set - ", TIME, "" );
377      RTEMS.CLOCK.SET( TIME, STATUS );
378      TEST_SUPPORT.FATAL_DIRECTIVE_STATUS(
379         STATUS,
380         RTEMS.INVALID_CLOCK,
381         "CLOCK_SET WITH INVALID DAY"
382      );
383      TEXT_IO.PUT_LINE( " - INVALID_CLOCK" );
384
385      TIME := ( 1988, 2, 5, 25, 30, 45, 0 );
386      TEST_SUPPORT.PRINT_TIME( "TA1 - clock_set - ", TIME, "" );
387      RTEMS.CLOCK.SET( TIME, STATUS );
388      TEST_SUPPORT.FATAL_DIRECTIVE_STATUS(
389         STATUS,
390         RTEMS.INVALID_CLOCK,
391         "CLOCK_SET WITH INVALID HOUR"
392      );
393      TEXT_IO.PUT_LINE( " - INVALID_CLOCK" );
394
395      TIME := ( 1988, 2, 5, 8, 61, 45, 0 );
396      TEST_SUPPORT.PRINT_TIME( "TA1 - clock_set - ", TIME, "" );
397      RTEMS.CLOCK.SET( TIME, STATUS );
398      TEST_SUPPORT.FATAL_DIRECTIVE_STATUS(
399         STATUS,
400         RTEMS.INVALID_CLOCK,
401         "CLOCK_SET WITH INVALID MINUTE"
402      );
403      TEXT_IO.PUT_LINE( " - INVALID_CLOCK" );
404
405      TIME := ( 1988, 2, 5, 8, 30, 61, 0 );
406      TEST_SUPPORT.PRINT_TIME( "TA1 - clock_set - ", TIME, "" );
407      RTEMS.CLOCK.SET( TIME, STATUS );
408      TEST_SUPPORT.FATAL_DIRECTIVE_STATUS(
409         STATUS,
410         RTEMS.INVALID_CLOCK,
411         "CLOCK_SET WITH INVALID SECOND"
412      );
413      TEXT_IO.PUT_LINE( " - INVALID_CLOCK" );
414
415      TIME := ( 1988, 2, 5, 8, 30, 45, TEST_SUPPORT.TICKS_PER_SECOND + 1 );
416      TEST_SUPPORT.PRINT_TIME( "TA1 - clock_set - ", TIME, "" );
417      RTEMS.CLOCK.SET( TIME, STATUS );
418      TEST_SUPPORT.FATAL_DIRECTIVE_STATUS(
419         STATUS,
420         RTEMS.INVALID_CLOCK,
421         "CLOCK_SET WITH INVALID TICKS PER SECOND"
422      );
423      TEXT_IO.PUT_LINE( " - INVALID_CLOCK" );
424
425      TIME := ( 1988, 2, 5, 8, 30, 45, 0 );
426      TEST_SUPPORT.PRINT_TIME( "TA1 - clock_set - ", TIME, "" );
427      RTEMS.CLOCK.SET( TIME, STATUS );
428      TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "CLOCK_SET SUCCESSFUL" );
429      TEXT_IO.PUT_LINE( " - SUCCESSFUL" );
430
431-- task_wake_when
432
433      TIME := ( 1988, 2, 5, 8, 30, 48, TEST_SUPPORT.TICKS_PER_SECOND + 1 );
434      TEXT_IO.PUT( "TA1 - task_wake_when - TICK INVALID - " );
435      TEXT_IO.PUT_LINE( "sleep about 3 seconds" );
436      RTEMS.TASKS.WAKE_WHEN( TIME, STATUS );
437      TEST_SUPPORT.DIRECTIVE_FAILED(
438         STATUS,
439         "TASK_WAKE_WHEN WITH INVALID TICKS PER SECOND"
440      );
441      TEXT_IO.PUT( "TA1 - task_wake_when - TICK INVALID - " );
442      TEXT_IO.PUT_LINE( "woke up SUCCESSFUL" );
443
444      TIME := ( 1961, 2, 5, 8, 30, 48, 0 );
445      TEST_SUPPORT.PRINT_TIME( "TA1 - task_wake_when - ", TIME, "" );
446      RTEMS.TASKS.WAKE_WHEN( TIME, STATUS );
447      TEST_SUPPORT.FATAL_DIRECTIVE_STATUS(
448         STATUS,
449         RTEMS.INVALID_CLOCK,
450         "TASK_WAKE_WHEN WITH INVALID YEAR"
451      );
452      TEXT_IO.PUT_LINE( " - INVALID_CLOCK" );
453
454      TIME := ( 1988, 2, 5, 25, 30, 48, 0 );
455      TEST_SUPPORT.PRINT_TIME( "TA1 - task_wake_when - ", TIME, "" );
456      RTEMS.TASKS.WAKE_WHEN( TIME, STATUS );
457      TEST_SUPPORT.FATAL_DIRECTIVE_STATUS(
458         STATUS,
459         RTEMS.INVALID_CLOCK,
460         "TASK_WAKE_WHEN WITH INVALID HOUR"
461      );
462      TEXT_IO.PUT_LINE( " - INVALID_CLOCK" );
463
464      RTEMS.CLOCK.GET_TOD( TIME, STATUS );
465      TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "CLOCK_GET_TOD" );
466      TEST_SUPPORT.PRINT_TIME( "TA1 - current time - ", TIME, "" );
467      TEXT_IO.NEW_LINE;
468
469      TIME.MONTH := 1;
470      TEST_SUPPORT.PRINT_TIME( "TA1 - task_wake_when - ", TIME, "" );
471      RTEMS.TASKS.WAKE_WHEN( TIME, STATUS );
472      TEST_SUPPORT.FATAL_DIRECTIVE_STATUS(
473         STATUS,
474         RTEMS.INVALID_CLOCK,
475         "TASK_WAKE_WHEN BEFORE CURRENT TIME"
476      );
477      TEXT_IO.PUT_LINE( " - INVALID_CLOCK" );
478
479   end SCREEN_2;
480
481--
482--  SCREEN_3
483--
484
485   procedure SCREEN_3
486   is
487      TASK_NAME : RTEMS.NAME;
488      STATUS    : RTEMS.STATUS_CODES;
489   begin
490
491      TASK_NAME := 1;
492
493      RTEMS.TASKS.CREATE(
494         0,
495         1,
496         2048,
497         RTEMS.DEFAULT_MODES,
498         RTEMS.DEFAULT_ATTRIBUTES,
499         SPTEST.JUNK_ID,
500         STATUS
501      );
502      TEST_SUPPORT.FATAL_DIRECTIVE_STATUS(
503         STATUS,
504         RTEMS.INVALID_NAME,
505         "TASK_CREATE WITH ILLEGAL NAME"
506      );
507      TEXT_IO.PUT_LINE( 
508         "TA1 - task_create - INVALID_NAME"
509      );
510
511      RTEMS.TASKS.CREATE(
512         TASK_NAME,
513         1,
514         TEST_SUPPORT.WORK_SPACE_SIZE,
515         RTEMS.DEFAULT_MODES,
516         RTEMS.DEFAULT_ATTRIBUTES,
517         SPTEST.JUNK_ID,
518         STATUS
519      );
520      TEST_SUPPORT.FATAL_DIRECTIVE_STATUS(
521         STATUS,
522         RTEMS.UNSATISFIED,
523         "TASK_CREATE WITH A STACK SIZE LARGER THAN THE WORKSPACE"
524      );
525      TEXT_IO.PUT_LINE(
526         "TA1 - task_create - stack size - UNSATISFIED"
527      );
528
529      RTEMS.TASKS.CREATE(
530         SPTEST.TASK_NAME( 2 ),
531         4,
532         2048,
533         RTEMS.DEFAULT_MODES,
534         RTEMS.DEFAULT_ATTRIBUTES,
535         SPTEST.TASK_ID( 2 ),
536         STATUS
537      );
538      TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "TASK_CREATE OF TA2" );
539      TEXT_IO.PUT_LINE(
540         "TA1 - task_create - TA2 created - SUCCESSFUL"
541      );
542
543      RTEMS.TASKS.SUSPEND( SPTEST.TASK_ID( 2 ), STATUS );
544      TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "TASK_SUSPEND OF TA2" );
545      TEXT_IO.PUT_LINE(
546         "TA1 - task_suspend - suspend TA2 - SUCCESSFUL"
547      );
548
549      RTEMS.TASKS.SUSPEND( SPTEST.TASK_ID( 2 ), STATUS );
550      TEST_SUPPORT.FATAL_DIRECTIVE_STATUS(
551         STATUS,
552         RTEMS.ALREADY_SUSPENDED,
553         "TASK_SUSPEND ON SUSPENDED TA2"
554      );
555      TEXT_IO.PUT_LINE(
556         "TA1 - task_suspend - suspend TA2 - ALREADY_SUSPENDED"
557      );
558
559      RTEMS.TASKS.RESUME( SPTEST.TASK_ID( 2 ), STATUS );
560      TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "TASK_RESUME OF TA2" );
561      TEXT_IO.PUT_LINE(
562         "TA1 - task_resume - TA2 resumed - SUCCESSFUL"
563      );
564
565      RTEMS.TASKS.CREATE(
566         SPTEST.TASK_NAME( 3 ),
567         4,
568         2048,
569         RTEMS.DEFAULT_MODES,
570         RTEMS.DEFAULT_ATTRIBUTES,
571         SPTEST.TASK_ID( 3 ),
572         STATUS
573      );
574      TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "TASK_CREATE OF TA3" );
575      TEXT_IO.PUT_LINE(
576         "TA1 - task_create - TA3 created - SUCCESSFUL"
577      );
578
579      RTEMS.TASKS.CREATE(
580         SPTEST.TASK_NAME( 4 ),
581         4,
582         2048,
583         RTEMS.DEFAULT_MODES,
584         RTEMS.DEFAULT_ATTRIBUTES,
585         SPTEST.TASK_ID( 4 ),
586         STATUS
587      );
588      TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "TASK_CREATE OF TA4" );
589      TEXT_IO.PUT_LINE(
590         "TA1 - task_create - 4 created - SUCCESSFUL"
591      );
592
593      RTEMS.TASKS.CREATE(
594         SPTEST.TASK_NAME( 5 ),
595         4,
596         2048,
597         RTEMS.DEFAULT_MODES,
598         RTEMS.DEFAULT_ATTRIBUTES,
599         SPTEST.TASK_ID( 5 ),
600         STATUS
601      );
602      TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "TASK_CREATE OF TA5" );
603      TEXT_IO.PUT_LINE(
604         "TA1 - task_create - 5 created - SUCCESSFUL"
605      );
606
607      RTEMS.TASKS.CREATE(
608         SPTEST.TASK_NAME( 6 ),
609         4,
610         2048,
611         RTEMS.DEFAULT_MODES,
612         RTEMS.DEFAULT_ATTRIBUTES,
613         SPTEST.TASK_ID( 6 ),
614         STATUS
615      );
616      TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "TASK_CREATE OF TA6" );
617      TEXT_IO.PUT_LINE(
618         "TA1 - task_create - 6 created - SUCCESSFUL"
619      );
620
621      RTEMS.TASKS.CREATE(
622         SPTEST.TASK_NAME( 7 ),
623         4,
624         2048,
625         RTEMS.DEFAULT_MODES,
626         RTEMS.DEFAULT_ATTRIBUTES,
627         SPTEST.TASK_ID( 7 ),
628         STATUS
629      );
630      TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "TASK_CREATE OF TA7" );
631      TEXT_IO.PUT_LINE(
632         "TA1 - task_create - 7 created - SUCCESSFUL"
633      );
634
635      RTEMS.TASKS.CREATE(
636         SPTEST.TASK_NAME( 8 ),
637         4,
638         2048,
639         RTEMS.DEFAULT_MODES,
640         RTEMS.DEFAULT_ATTRIBUTES,
641         SPTEST.TASK_ID( 8 ),
642         STATUS
643      );
644      TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "TASK_CREATE OF TA8" );
645      TEXT_IO.PUT_LINE(
646         "TA1 - task_create - 8 created - SUCCESSFUL"
647      );
648
649      RTEMS.TASKS.CREATE(
650         SPTEST.TASK_NAME( 9 ),
651         4,
652         2048,
653         RTEMS.DEFAULT_MODES,
654         RTEMS.DEFAULT_ATTRIBUTES,
655         SPTEST.TASK_ID( 9 ),
656         STATUS
657      );
658      TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "TASK_CREATE OF TA9" );
659      TEXT_IO.PUT_LINE(
660         "TA1 - task_create - 9 created - SUCCESSFUL"
661      );
662
663      RTEMS.TASKS.CREATE(
664         SPTEST.TASK_NAME( 10 ),
665         4,
666         2048,
667         RTEMS.DEFAULT_MODES,
668         RTEMS.DEFAULT_ATTRIBUTES,
669         SPTEST.TASK_ID( 10 ),
670         STATUS
671      );
672      TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "TASK_CREATE OF TA10" );
673      TEXT_IO.PUT_LINE(
674         "TA1 - task_create - 10 created - SUCCESSFUL"
675      );
676
677      RTEMS.TASKS.CREATE(
678         TASK_NAME,
679         4,
680         2048,
681         RTEMS.DEFAULT_MODES,
682         RTEMS.DEFAULT_ATTRIBUTES,
683         SPTEST.JUNK_ID,
684         STATUS
685      );
686      TEST_SUPPORT.FATAL_DIRECTIVE_STATUS(
687         STATUS,
688         RTEMS.TOO_MANY,
689         "TASK_CREATE FOR TOO MANY TASKS"
690      );
691      TEXT_IO.PUT_LINE( "TA1 - task_create - 11 - TOO_MANY" );
692
693      if TEST_SUPPORT.Is_Configured_Multiprocessing then
694         RTEMS.TASKS.CREATE(
695            TASK_NAME,
696            4,
697            2048,
698            RTEMS.DEFAULT_MODES,
699            RTEMS.GLOBAL,
700            SPTEST.JUNK_ID,
701            STATUS
702         );
703         TEST_SUPPORT.FATAL_DIRECTIVE_STATUS(
704            STATUS,
705            RTEMS.MP_NOT_CONFIGURED,
706            "TASK_CREATE OF GLOBAL TASK IN SINGLE CPU SYSTEM"
707         );
708      end if;
709      TEXT_IO.PUT_LINE( "TA1 - task_create - MP_NOT_CONFIGURED" );
710
711   end SCREEN_3;
712
713--
714--  SCREEN_4
715--
716
717   procedure SCREEN_4
718   is
719      EVENT_OUT : RTEMS.EVENT_SET;
720      TIME      : RTEMS.TIME_OF_DAY;
721      STATUS    : RTEMS.STATUS_CODES;
722   begin
723
724      RTEMS.EVENT.RECEIVE(
725         RTEMS.EVENT_16,
726         RTEMS.NO_WAIT,
727         RTEMS.NO_TIMEOUT,
728         EVENT_OUT,
729         STATUS
730      );
731      TEST_SUPPORT.FATAL_DIRECTIVE_STATUS(
732         STATUS,
733         RTEMS.UNSATISFIED,
734         "EVENT_RECEIVE UNSATISFIED (ALL)"
735      );
736      TEXT_IO.PUT_LINE(
737         "TA1 - event_receive - UNSATISFIED ( all conditions )"
738      );
739
740      RTEMS.EVENT.RECEIVE(
741         RTEMS.EVENT_16,
742         RTEMS.NO_WAIT + RTEMS.EVENT_ANY,
743         RTEMS.NO_TIMEOUT,
744         EVENT_OUT,
745         STATUS
746      );
747      TEST_SUPPORT.FATAL_DIRECTIVE_STATUS(
748         STATUS,
749         RTEMS.UNSATISFIED,
750         "EVENT_RECEIVE UNSATISFIED (ANY)"
751      );
752      TEXT_IO.PUT_LINE(
753         "TA1 - event_receive - UNSATISFIED ( any conditions )"
754      );
755
756      TEXT_IO.PUT_LINE( "TA1 - event_receive - timeout in 3 seconds" );
757      RTEMS.EVENT.RECEIVE(
758         RTEMS.EVENT_16,
759         RTEMS.DEFAULT_OPTIONS,
760         3 * TEST_SUPPORT.TICKS_PER_SECOND,
761         EVENT_OUT,
762         STATUS
763      );
764      TEST_SUPPORT.FATAL_DIRECTIVE_STATUS(
765         STATUS,
766         RTEMS.TIMEOUT,
767         "EVENT_RECEIVE AFTER 3 SECOND TIMEOUT"
768      );
769      TEXT_IO.PUT_LINE(
770         "TA1 - event_receive - woke with TIMEOUT"
771      );
772
773      RTEMS.EVENT.SEND(
774         100,
775         RTEMS.EVENT_16,
776         STATUS
777      );
778      TEST_SUPPORT.FATAL_DIRECTIVE_STATUS(
779         STATUS,
780         RTEMS.INVALID_ID,
781         "EVENT_SEND WITH ILLEGAL ID"
782      );
783      TEXT_IO.PUT_LINE(
784         "TA1 - event_send - INVALID_ID"
785      );
786
787      TEXT_IO.PUT_LINE( 
788         "TA1 - task_wake_after - sleep 1 second - SUCCESSFUL" 
789      );
790      RTEMS.TASKS.WAKE_AFTER( TEST_SUPPORT.TICKS_PER_SECOND, STATUS );
791      TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "TASK_WAKE_AFTER (1 SECOND)" );
792
793      TIME := ( 1988, 2, 5, 8, 30, 45, 0 );
794      TEST_SUPPORT.PRINT_TIME( "TA1 - clock_set - ", TIME, "" );
795      RTEMS.CLOCK.SET( TIME, STATUS );
796      TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "CLOCK_SET SUCCESSFUL" );
797      TEXT_IO.PUT_LINE( " - SUCCESSFUL" );
798
799   end SCREEN_4;
800
801--
802--  SCREEN_5
803--
804
805   procedure SCREEN_5
806   is
807      STATUS         : RTEMS.STATUS_CODES;
808   begin
809
810      RTEMS.SEMAPHORE.CREATE(
811         0,
812         1,
813         RTEMS.DEFAULT_ATTRIBUTES,
814         RTEMS.TASKS.NO_PRIORITY,
815         SPTEST.JUNK_ID,
816         STATUS
817      );
818      TEST_SUPPORT.FATAL_DIRECTIVE_STATUS(
819         STATUS,
820         RTEMS.INVALID_NAME,
821         "SEMAPHORE_CREATE WITH ILLEGAL NAME"
822      );
823      TEXT_IO.PUT_LINE( "TA1 - semaphore_create - INVALID_NAME" );
824
825      RTEMS.SEMAPHORE.CREATE(
826         SPTEST.SEMAPHORE_NAME( 1 ),
827         1,
828         RTEMS.DEFAULT_ATTRIBUTES,
829         RTEMS.TASKS.NO_PRIORITY,
830         SPTEST.SEMAPHORE_ID( 1 ),
831         STATUS
832      );
833      TEST_SUPPORT.DIRECTIVE_FAILED(
834         STATUS,
835         "SEMAPHORE_CREATE SUCCESSFUL"
836      );
837      TEXT_IO.PUT_LINE( "TA1 - semaphore_create - 1 - SUCCESSFUL" );
838
839      RTEMS.SEMAPHORE.CREATE(
840         SPTEST.SEMAPHORE_NAME( 2 ),
841         1,
842         (RTEMS.BINARY_SEMAPHORE or RTEMS.PRIORITY or RTEMS.INHERIT_PRIORITY),
843         RTEMS.TASKS.NO_PRIORITY,
844         SPTEST.SEMAPHORE_ID( 2 ),
845         STATUS
846      );
847      TEST_SUPPORT.DIRECTIVE_FAILED(
848         STATUS,
849         "SEMAPHORE_CREATE SUCCESSFUL"
850      );
851      TEXT_IO.PUT_LINE( "TA1 - semaphore_create - 2 - SUCCESSFUL" );
852
853      loop
854         RTEMS.SEMAPHORE.CREATE(
855            SPTEST.SEMAPHORE_NAME( 3 ),
856            1,
857            RTEMS.DEFAULT_ATTRIBUTES,
858            RTEMS.TASKS.NO_PRIORITY,
859            SPTEST.JUNK_ID,
860            STATUS
861         );
862
863         exit when not RTEMS.ARE_STATUSES_EQUAL( STATUS, RTEMS.SUCCESSFUL );
864      end loop;
865
866      TEST_SUPPORT.FATAL_DIRECTIVE_STATUS(
867         STATUS,
868         RTEMS.TOO_MANY,
869         "SEMAPHORE_CREATE OF TOO MANY"
870      );
871      TEXT_IO.PUT_LINE( "TA1 - semaphore_create - 3 - TOO_MANY" );
872
873      RTEMS.SEMAPHORE.CREATE(
874         SPTEST.SEMAPHORE_NAME( 1 ),
875         1,
876         RTEMS.INHERIT_PRIORITY + RTEMS.BINARY_SEMAPHORE + RTEMS.FIFO,
877         RTEMS.TASKS.NO_PRIORITY,
878         SPTEST.JUNK_ID,
879         STATUS
880      );
881      TEST_SUPPORT.FATAL_DIRECTIVE_STATUS(
882         STATUS,
883         RTEMS.NOT_DEFINED,
884         "SEMAPHORE_CREATE OF FIFO INHERIT PRIORITY"
885      );
886      TEXT_IO.PUT_LINE("TA1 - semaphore_create - NOT_DEFINED");
887
888      RTEMS.SEMAPHORE.CREATE(
889         SPTEST.SEMAPHORE_NAME( 1 ),
890         1,
891         RTEMS.INHERIT_PRIORITY + RTEMS.COUNTING_SEMAPHORE + RTEMS.PRIORITY,
892         RTEMS.TASKS.NO_PRIORITY,
893         SPTEST.JUNK_ID,
894         STATUS
895      );
896      TEST_SUPPORT.FATAL_DIRECTIVE_STATUS(
897         STATUS,
898         RTEMS.NOT_DEFINED,
899         "SEMAPHORE_CREATE OF COUNTING_SEMAPHORE INHERIT PRIORITY"
900      );
901      TEXT_IO.PUT_LINE("TA1 - semaphore_create - NOT_DEFINED");
902
903      RTEMS.SEMAPHORE.CREATE(
904         SPTEST.SEMAPHORE_NAME( 1 ),
905         2,
906         RTEMS.BINARY_SEMAPHORE,
907         RTEMS.TASKS.NO_PRIORITY,
908         SPTEST.JUNK_ID,
909         STATUS
910      );
911      TEST_SUPPORT.FATAL_DIRECTIVE_STATUS(
912         STATUS,
913         RTEMS.INVALID_NUMBER,
914         "SEMAPHORE_CREATE OF BINARY_SEMAPHORE with COUNT > 1"
915      );
916      TEXT_IO.PUT_LINE("TA1 - semaphore_create - INVALID_NUMBER");
917
918      if TEST_SUPPORT.Is_Configured_Multiprocessing then
919         RTEMS.SEMAPHORE.CREATE(
920            SPTEST.SEMAPHORE_NAME( 3 ),
921            1,
922            RTEMS.GLOBAL,
923            RTEMS.TASKS.NO_PRIORITY,
924            SPTEST.JUNK_ID,
925            STATUS
926         );
927         TEST_SUPPORT.FATAL_DIRECTIVE_STATUS(
928            STATUS,
929            RTEMS.MP_NOT_CONFIGURED,
930            "SEMAPHORE_CREATE OF MP_NOT_CONFIGURED"
931         );
932      end if;
933      TEXT_IO.PUT_LINE("TA1 - semaphore_create - MP_NOT_CONFIGURED");
934
935      RTEMS.SEMAPHORE.DELETE( 100, STATUS );
936      TEST_SUPPORT.FATAL_DIRECTIVE_STATUS(
937         STATUS,
938         RTEMS.INVALID_ID,
939         "SEMAPHORE_DELETE WITH ILLEGAL ID"
940      );
941      TEXT_IO.PUT_LINE(
942         "TA1 - semaphore_delete - unknown INVALID_ID"
943      );
944
945      RTEMS.SEMAPHORE.DELETE( 16#10100#, STATUS );
946      TEST_SUPPORT.FATAL_DIRECTIVE_STATUS(
947         STATUS,
948         RTEMS.INVALID_ID,
949         "SEMAPHORE_DELETE WITH LOCAL ILLEGAL ID"
950      );
951      TEXT_IO.PUT_LINE(
952         "TA1 - semaphore_delete - local INVALID_ID"
953      );
954
955      RTEMS.SEMAPHORE.IDENT(
956         100,
957         RTEMS.SEARCH_ALL_NODES,
958         SPTEST.JUNK_ID,
959         STATUS
960      );
961      TEST_SUPPORT.FATAL_DIRECTIVE_STATUS(
962         STATUS,
963         RTEMS.INVALID_NAME,
964         "SEMAPHORE_IDENT WITH ILLEGAL NAME (local)"
965      );
966      TEXT_IO.PUT_LINE(
967         "TA1 - semaphore_ident - global INVALID_NAME"
968      );
969
970      RTEMS.SEMAPHORE.IDENT( 100, 1, SPTEST.JUNK_ID, STATUS );
971      TEST_SUPPORT.FATAL_DIRECTIVE_STATUS(
972         STATUS,
973         RTEMS.INVALID_NAME,
974         "SEMAPHORE_IDENT WITH ILLEGAL NAME (global)"
975      );
976      TEXT_IO.PUT_LINE(
977         "TA1 - semaphore_ident - local INVALID_NAME"
978      );
979
980  end SCREEN_5;
981
982--
983--  SCREEN_6
984--
985
986   procedure SCREEN_6
987   is
988      STATUS         : RTEMS.STATUS_CODES;
989   begin
990
991      RTEMS.SEMAPHORE.OBTAIN(
992         100,
993         RTEMS.DEFAULT_OPTIONS,
994         RTEMS.NO_TIMEOUT,
995         STATUS
996      );
997      TEST_SUPPORT.FATAL_DIRECTIVE_STATUS(
998         STATUS,
999         RTEMS.INVALID_ID,
1000         "SEMAPHORE_OBTAIN WITH ILLEGAL ID"
1001      );
1002      TEXT_IO.PUT_LINE( "TA1 - semaphore_obtain - INVALID_ID" );
1003
1004      RTEMS.SEMAPHORE.OBTAIN(
1005         SPTEST.SEMAPHORE_ID( 1 ),
1006         RTEMS.DEFAULT_OPTIONS,
1007         RTEMS.NO_TIMEOUT,
1008         STATUS
1009      );
1010      TEST_SUPPORT.DIRECTIVE_FAILED(STATUS, "SEMAPHORE_OBTAIN SUCCESSFUL");
1011      TEXT_IO.PUT_LINE( 
1012         "TA1 - semaphore_obtain - got sem 1 - SUCCESSFUL"
1013      );
1014
1015      RTEMS.SEMAPHORE.OBTAIN(
1016         SPTEST.SEMAPHORE_ID( 1 ),
1017         RTEMS.NO_WAIT,
1018         RTEMS.NO_TIMEOUT,
1019         STATUS
1020      );
1021      TEST_SUPPORT.FATAL_DIRECTIVE_STATUS(
1022         STATUS,
1023         RTEMS.UNSATISFIED,
1024         "SEMAPHORE_OBTAIN NOT AVAILABLE"
1025      );
1026      TEXT_IO.PUT_LINE( "TA1 - semaphore_obtain - UNSATISFIED" );
1027
1028      TEXT_IO.PUT_LINE( "TA1 - semaphore_obtain - timeout in 3 seconds" );
1029      RTEMS.SEMAPHORE.OBTAIN(
1030         SPTEST.SEMAPHORE_ID( 1 ),
1031         RTEMS.DEFAULT_OPTIONS,
1032         3 * TEST_SUPPORT.TICKS_PER_SECOND,
1033         STATUS
1034      );
1035      TEST_SUPPORT.FATAL_DIRECTIVE_STATUS(
1036         STATUS,
1037         RTEMS.TIMEOUT,
1038         "SEMAPHORE_OBTAIN NOT AVAILABLE"
1039      );
1040      TEXT_IO.PUT_LINE(
1041         "TA1 - semaphore_obtain - woke with TIMEOUT"
1042      );
1043
1044      RTEMS.SEMAPHORE.RELEASE( SPTEST.SEMAPHORE_ID( 2 ), STATUS );
1045      TEST_SUPPORT.FATAL_DIRECTIVE_STATUS(
1046         STATUS,
1047         RTEMS.NOT_OWNER_OF_RESOURCE,
1048         "SEMAPHORE_RELEASE AND NOT OWNER"
1049      );
1050      TEXT_IO.PUT_LINE( 
1051         "TA1 - semaphore_release - NOT_OWNER_OF_RESOURCE"
1052      );
1053
1054      RTEMS.SEMAPHORE.RELEASE( 100, STATUS );
1055      TEST_SUPPORT.FATAL_DIRECTIVE_STATUS(
1056         STATUS,
1057         RTEMS.INVALID_ID,
1058         "SEMAPHORE_RELEASE WITH ILLEGAL ID"
1059      );
1060      TEXT_IO.PUT_LINE( "TA1 - semaphore_release - INVALID_ID" );
1061
1062      TEXT_IO.PUT_LINE(
1063         "TA1 - task_start - start TA2 - SUCCESSFUL"
1064     );
1065      RTEMS.TASKS.START(
1066         SPTEST.TASK_ID( 2 ),
1067         SPTEST.TASK_2'ACCESS,
1068         0,
1069         STATUS
1070      );
1071      TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "TASK_START OF TA2" );
1072
1073      TEXT_IO.PUT_LINE( 
1074         "TA1 - task_wake_after - yield processor - SUCCESSFUL"
1075      );
1076      RTEMS.TASKS.WAKE_AFTER( RTEMS.YIELD_PROCESSOR, STATUS );
1077      TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "TASK_WAKE_AFTER (yield)" );
1078
1079      TEXT_IO.PUT_LINE( 
1080         "TA1 - semaphore_delete - delete sem 1 - SUCCESSFUL"
1081      );
1082      RTEMS.SEMAPHORE.DELETE( SPTEST.SEMAPHORE_ID( 1 ), STATUS );
1083      TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "SEMAPHORE_DELETE OF SM1" );
1084
1085      TEXT_IO.PUT_LINE( "TA1 - semaphore_obtain - binary semaphore" );
1086      RTEMS.SEMAPHORE.OBTAIN(
1087         SPTEST.SEMAPHORE_ID( 2 ),
1088         RTEMS.NO_WAIT,
1089         RTEMS.NO_TIMEOUT,
1090         STATUS
1091      );
1092      TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "SEMAPHORE_OBTAIN" );
1093
1094      TEXT_IO.PUT_LINE( 
1095         "TA1 - semaphore_delete - delete sem 2 - RESOURCE_IN_USE"
1096      );
1097      RTEMS.SEMAPHORE.DELETE( SPTEST.SEMAPHORE_ID( 2 ), STATUS );
1098      TEST_SUPPORT.FATAL_DIRECTIVE_STATUS( 
1099         STATUS, 
1100         RTEMS.RESOURCE_IN_USE,
1101         "SEMAPHORE_DELETE OF SM2" 
1102      );
1103
1104      TEXT_IO.PUT_LINE( 
1105         "TA1 - task_wake_after - yield processor - SUCCESSFUL"
1106      );
1107      RTEMS.TASKS.WAKE_AFTER( RTEMS.YIELD_PROCESSOR, STATUS );
1108      TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "TASK_WAKE_AFTER (yield)" );
1109
1110      RTEMS.TASKS.DELETE( SPTEST.TASK_ID( 2 ), STATUS );
1111      TEST_SUPPORT.FATAL_DIRECTIVE_STATUS(
1112         STATUS,
1113         RTEMS.INVALID_ID,
1114         "TASK_DELETE AFTER THE TASK HAS BEEN DELETED"
1115      );
1116      TEXT_IO.PUT_LINE( 
1117         "TA1 - task_delete TA2 - already deleted INVALID_ID"
1118      );
1119
1120   end SCREEN_6;
1121
1122--
1123--  SCREEN_7
1124--
1125
1126   procedure SCREEN_7
1127   is
1128      BUFFER         : SPTEST.BUFFER;
1129      BUFFER_POINTER : RTEMS.ADDRESS;
1130      COUNT          : RTEMS.UNSIGNED32;
1131      MESSAGE_SIZE   : RTEMS.Size := 0;
1132      STATUS         : RTEMS.STATUS_CODES;
1133   begin
1134
1135      BUFFER_POINTER := BUFFER'ADDRESS;
1136
1137      RTEMS.MESSAGE_QUEUE.BROADCAST(
1138         100,
1139         BUFFER_POINTER,
1140         16,
1141         COUNT,
1142         STATUS
1143      );
1144      TEST_SUPPORT.FATAL_DIRECTIVE_STATUS(
1145         STATUS,
1146         RTEMS.INVALID_ID,
1147         "MESSAGE_QUEUE_BROADCAST WITH ILLEGAL ID"
1148      );
1149      TEXT_IO.PUT_LINE(
1150         "TA1 - message_queue_broadcast - INVALID_ID"
1151      );
1152
1153      RTEMS.MESSAGE_QUEUE.CREATE(
1154         0,
1155         3,
1156         16,
1157         RTEMS.DEFAULT_ATTRIBUTES,
1158         SPTEST.JUNK_ID,
1159         STATUS
1160      );
1161      TEST_SUPPORT.FATAL_DIRECTIVE_STATUS(
1162         STATUS,
1163         RTEMS.INVALID_NAME,
1164         "MESSAGE_QUEUE_CREATE WITH ILLEGAL NAME"
1165      );
1166      TEXT_IO.PUT_LINE(
1167         "TA1 - message_queue_create - Q 1 - INVALID_NAME"
1168      );
1169
1170      if TEST_SUPPORT.Is_Configured_Multiprocessing then
1171         RTEMS.MESSAGE_QUEUE.CREATE(
1172            SPTEST.QUEUE_NAME( 1 ),
1173            1,
1174            16,
1175            RTEMS.GLOBAL,
1176            SPTEST.JUNK_ID,
1177            STATUS
1178         );
1179         TEST_SUPPORT.FATAL_DIRECTIVE_STATUS(
1180            STATUS,
1181            RTEMS.MP_NOT_CONFIGURED,
1182            "MESSAGE_QUEUE_CREATE OF MP NOT CONFIGURED"
1183         );
1184      end if;
1185      TEXT_IO.PUT_LINE(
1186             "TA1 - message_queue_create - Q 1 - MP_NOT_CONFIGURED");
1187
1188      RTEMS.MESSAGE_QUEUE.CREATE(
1189         SPTEST.QUEUE_NAME( 1 ),
1190         2,
1191         16,
1192         RTEMS.DEFAULT_ATTRIBUTES,
1193         SPTEST.QUEUE_ID( 1 ),
1194         STATUS
1195      );
1196      TEST_SUPPORT.DIRECTIVE_FAILED(
1197         STATUS,
1198         "MESSAGE_QUEUE_CREATE SUCCESSFUL"
1199      );
1200      TEXT_IO.PUT_LINE(
1201         "TA1 - message_queue_create - Q 1 - 2 DEEP - SUCCESSFUL"
1202      );
1203
1204      RTEMS.MESSAGE_QUEUE.CREATE(
1205         SPTEST.QUEUE_NAME( 2 ),
1206         1,
1207         16,
1208         RTEMS.DEFAULT_ATTRIBUTES,
1209         SPTEST.JUNK_ID,
1210         STATUS
1211      );
1212      TEST_SUPPORT.FATAL_DIRECTIVE_STATUS(
1213         STATUS,
1214         RTEMS.TOO_MANY,
1215         "MESSAGE_QUEUE_CREATE OF TOO MANY"
1216      );
1217      TEXT_IO.PUT_LINE(
1218         "TA1 - message_queue_create - Q 2 - TOO_MANY"
1219      );
1220
1221      RTEMS.MESSAGE_QUEUE.DELETE( 100, STATUS );
1222      TEST_SUPPORT.FATAL_DIRECTIVE_STATUS(
1223         STATUS,
1224         RTEMS.INVALID_ID,
1225         "MESSAGE_QUEUE_DELETE WITH ILLEGAL ID"
1226      );
1227      TEXT_IO.PUT_LINE(
1228         "TA1 - message_queue_delete - unknown INVALID_ID"
1229      );
1230
1231      RTEMS.MESSAGE_QUEUE.DELETE( 16#10100#, STATUS );
1232      TEST_SUPPORT.FATAL_DIRECTIVE_STATUS(
1233         STATUS,
1234         RTEMS.INVALID_ID,
1235         "MESSAGE_QUEUE_DELETE WITH LOCAL ILLEGAL ID"
1236      );
1237      TEXT_IO.PUT_LINE(
1238         "TA1 - message_queue_delete - local INVALID_ID"
1239      );
1240
1241      RTEMS.MESSAGE_QUEUE.IDENT(
1242         100,
1243         RTEMS.SEARCH_ALL_NODES,
1244         SPTEST.JUNK_ID,
1245         STATUS
1246      );
1247      TEST_SUPPORT.FATAL_DIRECTIVE_STATUS(
1248         STATUS,
1249         RTEMS.INVALID_NAME,
1250         "MESSAGE_QUEUE_IDENT WITH ILLEGAL NAME"
1251      );
1252      TEXT_IO.PUT_LINE( "TA1 - message_queue_ident - INVALID_NAME" );
1253
1254      RTEMS.MESSAGE_QUEUE.GET_NUMBER_PENDING( 100, COUNT, STATUS );
1255      TEST_SUPPORT.FATAL_DIRECTIVE_STATUS(
1256        STATUS,
1257        RTEMS.INVALID_ID,
1258        "MESSAGE_QUEUE_GET_NUMBER_PENDING WITH ILLEGAL ID"
1259      );
1260      TEXT_IO.PUT_LINE("TA1 - message_queue_get_number_pending - INVALID_ID");
1261
1262      RTEMS.MESSAGE_QUEUE.FLUSH( 100, COUNT, STATUS );
1263      TEST_SUPPORT.FATAL_DIRECTIVE_STATUS(
1264         STATUS,
1265         RTEMS.INVALID_ID,
1266         "MESSAGE_QUEUE_FLUSH WITH ILLEGAL ID"
1267      );
1268      TEXT_IO.PUT_LINE( "TA1 - message_queue_flush - INVALID_ID" );
1269
1270      RTEMS.MESSAGE_QUEUE.RECEIVE(
1271         100,
1272         BUFFER_POINTER,
1273         RTEMS.DEFAULT_OPTIONS,
1274         RTEMS.NO_TIMEOUT,
1275         MESSAGE_SIZE,
1276         STATUS
1277      );
1278      TEST_SUPPORT.FATAL_DIRECTIVE_STATUS(
1279         STATUS,
1280         RTEMS.INVALID_ID,
1281         "MESSAGE_QUEUE_RECEIVE WITH ILLEGAL ID"
1282      );
1283      TEXT_IO.PUT_LINE( "TA1 - message_queue_receive - INVALID_ID" );
1284
1285      RTEMS.MESSAGE_QUEUE.RECEIVE(
1286         SPTEST.QUEUE_ID( 1 ),
1287         BUFFER_POINTER,
1288         RTEMS.NO_WAIT,
1289         RTEMS.NO_TIMEOUT,
1290         MESSAGE_SIZE,
1291         STATUS
1292      );
1293      TEST_SUPPORT.FATAL_DIRECTIVE_STATUS(
1294         STATUS,
1295         RTEMS.UNSATISFIED,
1296         "MESSAGE_QUEUE_RECEIVE UNSATISFIED"
1297      );
1298      TEXT_IO.PUT_LINE(
1299         "TA1 - message_queue_receive - Q 1 - UNSATISFIED"
1300      );
1301
1302      TEXT_IO.PUT_LINE(
1303         "TA1 - message_queue_receive - Q 1 - timeout in 3 seconds"
1304      );
1305      RTEMS.MESSAGE_QUEUE.RECEIVE(
1306         SPTEST.QUEUE_ID( 1 ),
1307         BUFFER_POINTER,
1308         RTEMS.DEFAULT_OPTIONS,
1309         3 * TEST_SUPPORT.TICKS_PER_SECOND,
1310         MESSAGE_SIZE,
1311         STATUS
1312      );
1313      TEST_SUPPORT.FATAL_DIRECTIVE_STATUS(
1314         STATUS,
1315         RTEMS.TIMEOUT,
1316         "MESSAGE_QUEUE_RECEIVE 3 SECOND TIMEOUT"
1317      );
1318      TEXT_IO.PUT_LINE(
1319         "TA1 - message_queue_receive - Q 1 - woke up with TIMEOUT"
1320      );
1321
1322      RTEMS.MESSAGE_QUEUE.SEND( 100, BUFFER_POINTER, 16, STATUS );
1323      TEST_SUPPORT.FATAL_DIRECTIVE_STATUS(
1324         STATUS,
1325         RTEMS.INVALID_ID,
1326         "MESSAGE_QUEUE_SEND WITH ILLEGAL ID"
1327      );
1328      TEXT_IO.PUT_LINE( "TA1 - message_queue_send - INVALID_ID" );
1329
1330      RTEMS.MESSAGE_QUEUE.SEND(
1331         SPTEST.QUEUE_ID( 1 ),
1332         BUFFER_POINTER,
1333         16,
1334         STATUS
1335      );
1336      TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "MESSAGE_QUEUE_SEND" );
1337      TEXT_IO.PUT_LINE(
1338         "TA1 - message_queue_send - BUFFER 1 TO Q 1 - SUCCESSFUL"
1339      );
1340
1341      RTEMS.MESSAGE_QUEUE.SEND(
1342         SPTEST.QUEUE_ID( 1 ),
1343         BUFFER_POINTER,
1344         16,
1345         STATUS
1346      );
1347      TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "MESSAGE_QUEUE_SEND" );
1348      TEXT_IO.PUT_LINE(
1349         "TA1 - message_queue_send - BUFFER 2 TO Q 1 - SUCCESSFUL"
1350      );
1351
1352      RTEMS.MESSAGE_QUEUE.SEND(
1353         SPTEST.QUEUE_ID( 1 ),
1354         BUFFER_POINTER,
1355         16,
1356         STATUS
1357      );
1358      TEST_SUPPORT.FATAL_DIRECTIVE_STATUS(
1359         STATUS,
1360         RTEMS.TOO_MANY,
1361         "MESSAGE_QUEUE_SEND TOO MANY TO LIMITED QUEUE"
1362      );
1363      TEXT_IO.PUT_LINE(
1364         "TA1 - message_queue_send - BUFFER 3 TO Q 1 - TOO_MANY"
1365      );
1366
1367   end SCREEN_7;
1368
1369--
1370--  SCREEN_8
1371--
1372
1373   procedure SCREEN_8
1374   is
1375      BUFFER         : SPTEST.BUFFER;
1376      BUFFER_POINTER : RTEMS.ADDRESS;
1377      STATUS         : RTEMS.STATUS_CODES;
1378   begin
1379
1380      BUFFER_POINTER := BUFFER'ADDRESS;
1381
1382      RTEMS.MESSAGE_QUEUE.DELETE( SPTEST.QUEUE_ID( 1 ), STATUS );
1383      TEST_SUPPORT.DIRECTIVE_FAILED(
1384         STATUS,
1385         "MESSAGE_QUEUE_DELETE SUCCESSFUL"
1386      );
1387      TEXT_IO.PUT_LINE(
1388         "TA1 - message_queue_delete - Q 1 - SUCCESSFUL"
1389      );
1390
1391      RTEMS.MESSAGE_QUEUE.CREATE(
1392         SPTEST.QUEUE_NAME( 1 ),
1393         2,
1394         16,
1395         RTEMS.DEFAULT_ATTRIBUTES,
1396         SPTEST.QUEUE_ID( 1 ),
1397         STATUS
1398      );
1399      TEST_SUPPORT.DIRECTIVE_FAILED(
1400         STATUS,
1401         "MESSAGE_QUEUE_CREATE SUCCESSFUL"
1402      );
1403      TEXT_IO.PUT_LINE(
1404         "TA1 - message_queue_create - Q 1 - 2 DEEP - SUCCESSFUL"
1405      );
1406
1407      RTEMS.MESSAGE_QUEUE.SEND(
1408         SPTEST.QUEUE_ID( 1 ),
1409         BUFFER_POINTER,
1410         16,
1411         STATUS
1412      );
1413      TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "MESSAGE_QUEUE_SEND" );
1414      TEXT_IO.PUT_LINE(
1415         "TA1 - message_queue_send - BUFFER 1 TO Q 1 - SUCCESSFUL"
1416      );
1417
1418      RTEMS.MESSAGE_QUEUE.SEND(
1419         SPTEST.QUEUE_ID( 1 ),
1420         BUFFER_POINTER,
1421         16,
1422         STATUS
1423      );
1424      TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "MESSAGE_QUEUE_SEND" );
1425      TEXT_IO.PUT_LINE(
1426         "TA1 - message_queue_send - BUFFER 2 TO Q 1 - SUCCESSFUL"
1427      );
1428
1429      RTEMS.MESSAGE_QUEUE.SEND(
1430         SPTEST.QUEUE_ID( 1 ),
1431         BUFFER_POINTER,
1432         16,
1433         STATUS
1434      );
1435      TEST_SUPPORT.FATAL_DIRECTIVE_STATUS(
1436         STATUS,
1437         RTEMS.TOO_MANY,
1438         "MESSAGE_QUEUE_SEND TOO MANY TO LIMITED QUEUE"
1439      );
1440      TEXT_IO.PUT_LINE(
1441         "TA1 - message_queue_send - BUFFER 3 TO Q 1 - TOO_MANY"
1442      );
1443
1444      RTEMS.MESSAGE_QUEUE.DELETE( SPTEST.QUEUE_ID( 1 ), STATUS );
1445      TEST_SUPPORT.DIRECTIVE_FAILED(
1446         STATUS,
1447         "MESSAGE_QUEUE_DELETE SUCCESSFUL"
1448      );
1449      TEXT_IO.PUT_LINE(
1450         "TA1 - message_queue_delete - Q 1 - SUCCESSFUL"
1451      );
1452
1453      RTEMS.MESSAGE_QUEUE.CREATE(
1454         SPTEST.QUEUE_NAME( 1 ),
1455         3,
1456         16,
1457         RTEMS.DEFAULT_ATTRIBUTES,
1458         SPTEST.QUEUE_ID( 1 ),
1459         STATUS
1460      );
1461      TEST_SUPPORT.DIRECTIVE_FAILED(
1462         STATUS,
1463         "MESSAGE_QUEUE_CREATE SUCCESSFUL"
1464      );
1465      TEXT_IO.PUT_LINE(
1466         "TA1 - message_queue_create - Q 1 - 3 DEEP - SUCCESSFUL"
1467      );
1468
1469      RTEMS.MESSAGE_QUEUE.SEND(
1470         SPTEST.QUEUE_ID( 1 ),
1471         BUFFER_POINTER,
1472         16,
1473         STATUS
1474      );
1475      TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "MESSAGE_QUEUE_SEND" );
1476      TEXT_IO.PUT_LINE(
1477         "TA1 - message_queue_send - BUFFER 1 TO Q 1 - SUCCESSFUL"
1478      );
1479
1480      RTEMS.MESSAGE_QUEUE.SEND(
1481         SPTEST.QUEUE_ID( 1 ),
1482         BUFFER_POINTER,
1483         16,
1484         STATUS
1485      );
1486      TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "MESSAGE_QUEUE_SEND" );
1487      TEXT_IO.PUT_LINE(
1488         "TA1 - message_queue_send - BUFFER 2 TO Q 1 - SUCCESSFUL"
1489      );
1490
1491      RTEMS.MESSAGE_QUEUE.SEND(
1492         SPTEST.QUEUE_ID( 1 ),
1493         BUFFER_POINTER,
1494         16,
1495         STATUS
1496      );
1497      TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "MESSAGE_QUEUE_SEND" );
1498      TEXT_IO.PUT_LINE(
1499         "TA1 - message_queue_send - BUFFER 3 TO Q 1 - SUCCESSFUL"
1500      );
1501
1502      RTEMS.MESSAGE_QUEUE.SEND(
1503         SPTEST.QUEUE_ID( 1 ),
1504         BUFFER_POINTER,
1505         16,
1506         STATUS
1507      );
1508      TEST_SUPPORT.FATAL_DIRECTIVE_STATUS(
1509         STATUS,
1510         RTEMS.TOO_MANY,
1511         "MESSAGE_QUEUE_SEND TOO MANY TO LIMITED QUEUE"
1512      );
1513      TEXT_IO.PUT_LINE(
1514         "TA1 - message_queue_send - BUFFER 4 TO Q 1 - TOO_MANY"
1515      );
1516
1517      RTEMS.MESSAGE_QUEUE.DELETE( SPTEST.QUEUE_ID( 1 ), STATUS );
1518      TEST_SUPPORT.DIRECTIVE_FAILED(
1519         STATUS,
1520         "MESSAGE_QUEUE_DELETE SUCCESSFUL"
1521      );
1522      TEXT_IO.PUT_LINE(
1523         "TA1 - message_queue_delete - Q 1 - SUCCESSFUL"
1524      );
1525
1526      RTEMS.MESSAGE_QUEUE.CREATE(
1527         SPTEST.QUEUE_NAME( 1 ),
1528         2,
1529         16,
1530         RTEMS.DEFAULT_ATTRIBUTES,
1531         SPTEST.QUEUE_ID( 1 ),
1532         STATUS
1533      );
1534      TEST_SUPPORT.DIRECTIVE_FAILED(
1535         STATUS,
1536         "MESSAGE_QUEUE_CREATE SUCCESSFUL"
1537      );
1538      TEXT_IO.PUT_LINE(
1539         "TA1 - message_queue_create - Q 1 - 3 DEEP - SUCCESSFUL"
1540      );
1541
1542      TEXT_IO.PUT_LINE( 
1543         "TA1 - task_start - start TA3 - SUCCESSFUL"
1544      );
1545      RTEMS.TASKS.START(
1546         SPTEST.TASK_ID( 3 ),
1547         SPTEST.TASK_3'ACCESS,
1548         0,
1549         STATUS
1550      );
1551      TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "TASK_START OF TA3" );
1552
1553      TEXT_IO.PUT_LINE( 
1554         "TA1 - task_wake_after - yield processor - SUCCESSFUL"
1555      );
1556      RTEMS.TASKS.WAKE_AFTER( RTEMS.YIELD_PROCESSOR, STATUS );
1557      TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "TASK_WAKE_AFTER (yield)" );
1558
1559      RTEMS.MESSAGE_QUEUE.DELETE( SPTEST.QUEUE_ID( 1 ), STATUS );
1560      TEST_SUPPORT.DIRECTIVE_FAILED(
1561         STATUS,
1562         "MESSAGE_QUEUE_DELETE SUCCESSFUL"
1563      );
1564      TEXT_IO.PUT_LINE(
1565         "TA1 - message_queue_delete - delete Q 1 - SUCCESSFUL"
1566      );
1567
1568      TEXT_IO.PUT_LINE( 
1569         "TA1 - task_wake_after - yield processor - SUCCESSFUL"
1570      );
1571      RTEMS.TASKS.WAKE_AFTER( RTEMS.YIELD_PROCESSOR, STATUS );
1572      TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "TASK_WAKE_AFTER (yield)" );
1573
1574   end SCREEN_8;
1575
1576--
1577--  SCREEN_9
1578--
1579
1580   procedure SCREEN_9
1581   is
1582      CONVERTED : RTEMS.ADDRESS;
1583      STATUS    : RTEMS.STATUS_CODES;
1584   begin
1585
1586      RTEMS.PORT.CREATE(
1587         0,
1588         SPTEST.INTERNAL_PORT_AREA'ADDRESS,
1589         SPTEST.EXTERNAL_PORT_AREA'ADDRESS,
1590         SPTEST.INTERNAL_PORT_AREA'LENGTH,
1591         SPTEST.JUNK_ID,
1592         STATUS
1593      );
1594      TEST_SUPPORT.FATAL_DIRECTIVE_STATUS(
1595         STATUS,
1596         RTEMS.INVALID_NAME,
1597         "PORT_CREATE WITH ILLEGAL NAME"
1598      );
1599      TEXT_IO.PUT_LINE( "TA1 - port_create - INVALID_NAME" );
1600
1601      RTEMS.PORT.CREATE(
1602         SPTEST.PORT_NAME( 1 ),
1603         SPTEST.INTERNAL_PORT_AREA( 1 )'ADDRESS,
1604         SPTEST.EXTERNAL_PORT_AREA'ADDRESS,
1605         SPTEST.INTERNAL_PORT_AREA'LENGTH,
1606         SPTEST.JUNK_ID,
1607         STATUS
1608      );
1609      TEST_SUPPORT.FATAL_DIRECTIVE_STATUS(
1610         STATUS,
1611         RTEMS.INVALID_ADDRESS,
1612         "PORT_CREATE WITH ILLEGAL ADDRESS"
1613      );
1614      TEXT_IO.PUT_LINE( "TA1 - port_create - INVALID_ADDRESS" );
1615
1616      RTEMS.PORT.CREATE(
1617         SPTEST.PORT_NAME( 1 ),
1618         SPTEST.INTERNAL_PORT_AREA'ADDRESS,
1619         SPTEST.EXTERNAL_PORT_AREA'ADDRESS,
1620         SPTEST.INTERNAL_PORT_AREA'LENGTH,
1621         SPTEST.JUNK_ID,
1622         STATUS
1623      );
1624      TEST_SUPPORT.FATAL_DIRECTIVE_STATUS(
1625         STATUS,
1626         RTEMS.TOO_MANY,
1627         "PORT_CREATE OF TOO MANY"
1628      );
1629      TEXT_IO.PUT_LINE( "TA1 - port_create - TOO_MANY" );
1630
1631      RTEMS.PORT.DELETE( 0, STATUS );
1632      TEST_SUPPORT.FATAL_DIRECTIVE_STATUS(
1633         STATUS,
1634         RTEMS.INVALID_ID,
1635         "PORT_DELETE WITH ILLEGAL ID"
1636      );
1637      TEXT_IO.PUT_LINE( "TA1 - port_delete - INVALID_ID" );
1638
1639      RTEMS.PORT.IDENT( 0, SPTEST.JUNK_ID, STATUS );
1640      TEST_SUPPORT.FATAL_DIRECTIVE_STATUS(
1641         STATUS,
1642         RTEMS.INVALID_NAME,
1643         "PORT_IDENT WITH ILLEGAL NAME"
1644      );
1645      TEXT_IO.PUT_LINE( "TA1 - port_ident - INVALID_NAME" );
1646
1647      RTEMS.PORT.INTERNAL_TO_EXTERNAL(
1648         100,
1649         SPTEST.INTERNAL_PORT_AREA'ADDRESS,
1650         CONVERTED,
1651         STATUS
1652      );
1653      TEST_SUPPORT.FATAL_DIRECTIVE_STATUS(
1654         STATUS,
1655         RTEMS.INVALID_ID,
1656         "PORT_INTERNAL_TO_EXTERNAL WITH ILLEGAL ID"
1657      );
1658      TEXT_IO.PUT_LINE(
1659         "TA1 - port_internal_to_external - INVALID_ID"
1660      );
1661
1662      RTEMS.PORT.EXTERNAL_TO_INTERNAL(
1663         100,
1664         SPTEST.EXTERNAL_PORT_AREA'ADDRESS,
1665         CONVERTED,
1666         STATUS
1667      );
1668      TEST_SUPPORT.FATAL_DIRECTIVE_STATUS(
1669         STATUS,
1670         RTEMS.INVALID_ID,
1671         "PORT_EXTERNAL_TO_INTERNAL WITH ILLEGAL ID"
1672      );
1673      TEXT_IO.PUT_LINE(
1674         "TA1 - port_external_to_internal - INVALID_ID"
1675      );
1676
1677   end SCREEN_9;
1678
1679--
1680--  SCREEN_10
1681--
1682
1683   procedure SCREEN_10
1684   is
1685      STATUS : RTEMS.STATUS_CODES;
1686   begin
1687
1688      RTEMS.RATE_MONOTONIC.CREATE( 0, SPTEST.JUNK_ID, STATUS );
1689      TEST_SUPPORT.FATAL_DIRECTIVE_STATUS(
1690         STATUS,
1691         RTEMS.INVALID_NAME,
1692         "RATE_MONOTONIC_CREATE WITH ILLEGAL NAME"
1693      );
1694      TEXT_IO.PUT_LINE(
1695         "TA1 - rate_monotonic_create - INVALID_NAME"
1696      );
1697
1698      RTEMS.RATE_MONOTONIC.CREATE(
1699         SPTEST.PERIOD_NAME( 1 ),
1700         SPTEST.PERIOD_ID( 1 ),
1701         STATUS
1702      );
1703      TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "RATE_MONOTONIC_CREATE" );
1704      TEXT_IO.PUT_LINE(
1705         "TA1 - rate_monotonic_create - SUCCESSFUL"
1706      );
1707
1708      RTEMS.RATE_MONOTONIC.CREATE(
1709         SPTEST.PERIOD_NAME( 1 ),
1710         SPTEST.JUNK_ID,
1711         STATUS
1712      );
1713      TEST_SUPPORT.FATAL_DIRECTIVE_STATUS(
1714         STATUS,
1715         RTEMS.TOO_MANY,
1716         "RATE_MONOTONIC_CREATE FOR TOO MANY"
1717      );
1718      TEXT_IO.PUT_LINE( "TA1 - rate_monotonic_create - TOO_MANY" );
1719
1720      RTEMS.RATE_MONOTONIC.IDENT( 0, SPTEST.JUNK_ID, STATUS );
1721      TEST_SUPPORT.FATAL_DIRECTIVE_STATUS(
1722         STATUS,
1723         RTEMS.INVALID_NAME,
1724         "RATE_MONOTONIC_IDENT WITH ILLEGAL NAME"
1725      );
1726      TEXT_IO.PUT_LINE(
1727         "TA1 - rate_monotonic_ident - INVALID_NAME"
1728      );
1729
1730      RTEMS.RATE_MONOTONIC.PERIOD( 100, 5, STATUS );
1731      TEST_SUPPORT.FATAL_DIRECTIVE_STATUS(
1732         STATUS,
1733         RTEMS.INVALID_ID,
1734         "RATE_MONOTONIC_PERIOD WITH ILLEGAL ID"
1735      );
1736      TEXT_IO.PUT_LINE(
1737         "TA1 - rate_monotonic_period - unknown INVALID_ID"
1738      );
1739
1740      RTEMS.RATE_MONOTONIC.PERIOD( 16#10100#, 5, STATUS );
1741      TEST_SUPPORT.FATAL_DIRECTIVE_STATUS(
1742         STATUS,
1743         RTEMS.INVALID_ID,
1744         "RATE_MONOTONIC_PERIOD WITH ILLEGAL ID"
1745      );
1746      TEXT_IO.PUT_LINE(
1747         "TA1 - rate_monotonic_period - local INVALID_ID"
1748      );
1749
1750      RTEMS.RATE_MONOTONIC.PERIOD(
1751         SPTEST.PERIOD_ID( 1 ),
1752         RTEMS.RATE_MONOTONIC_PERIOD_STATUS,
1753         STATUS
1754      );
1755      TEST_SUPPORT.FATAL_DIRECTIVE_STATUS(
1756         STATUS,
1757         RTEMS.NOT_DEFINED,
1758         "RATE_MONOTONIC_PERIOD STATUS NOT DEFINED"
1759      );
1760      TEXT_IO.PUT_LINE( 
1761         "TA1 - rate_monotonic_period( STATUS ) - NOT_DEFINED"
1762      );
1763
1764      RTEMS.RATE_MONOTONIC.PERIOD( SPTEST.PERIOD_ID( 1 ), 100, STATUS );
1765      TEST_SUPPORT.DIRECTIVE_FAILED(
1766         STATUS,
1767         "RATE_MONOTONIC_PERIOD 100 TICKS"
1768      );
1769      TEXT_IO.PUT( "TA1 - rate_monotonic_period - 100 ticks - " );
1770      TEXT_IO.PUT_LINE( "SUCCESSFUL" );
1771
1772      RTEMS.RATE_MONOTONIC.PERIOD(
1773         SPTEST.PERIOD_ID( 1 ),
1774         RTEMS.RATE_MONOTONIC_PERIOD_STATUS,
1775         STATUS
1776      );
1777      TEST_SUPPORT.DIRECTIVE_FAILED(
1778         STATUS,
1779         "RATE_MONOTONIC_PERIOD STATUS"
1780      );
1781      TEXT_IO.PUT( "TA1 - rate_monotonic_period( STATUS ) - " );
1782      TEXT_IO.PUT_LINE( "SUCCESSFUL" );
1783
1784      loop
1785
1786         RTEMS.RATE_MONOTONIC.PERIOD(
1787            SPTEST.PERIOD_ID( 1 ),
1788            RTEMS.RATE_MONOTONIC_PERIOD_STATUS,
1789            STATUS
1790         );
1791
1792         exit when RTEMS.ARE_STATUSES_EQUAL( STATUS, RTEMS.TIMEOUT );
1793
1794         TEST_SUPPORT.DIRECTIVE_FAILED(
1795            STATUS,
1796            "RATE_MONOTONIC_PERIOD STATUS WAITING FOR TIMEOUT"
1797         );
1798 
1799      end loop;
1800      TEXT_IO.PUT( "TA1 - rate_monotonic_period( STATUS ) - " );
1801      TEXT_IO.PUT_LINE( "TIMEOUT" );
1802
1803      RTEMS.RATE_MONOTONIC.CANCEL( 100, STATUS );
1804      TEST_SUPPORT.FATAL_DIRECTIVE_STATUS(
1805         STATUS,
1806         RTEMS.INVALID_ID,
1807         "RATE_MONOTONIC_CANCEL WITH ILLEGAL ID"
1808      );
1809      TEXT_IO.PUT_LINE(
1810         "TA1 - rate_monotonic_cancel - unknown INVALID_ID"
1811      );
1812
1813      RTEMS.RATE_MONOTONIC.CANCEL( 16#10100#, STATUS );
1814      TEST_SUPPORT.FATAL_DIRECTIVE_STATUS(
1815         STATUS,
1816         RTEMS.INVALID_ID,
1817         "RATE_MONOTONIC_CANCEL WITH ILLEGAL ID"
1818      );
1819      TEXT_IO.PUT_LINE(
1820         "TA1 - rate_monotonic_cancel - local INVALID_ID"
1821      );
1822
1823      RTEMS.RATE_MONOTONIC.CANCEL( SPTEST.PERIOD_ID( 1 ), STATUS );
1824      TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "RATE_MONOTONIC_CANCEL" );
1825      TEXT_IO.PUT_LINE( "TA1 - rate_monotonic_cancel - SUCCESSFUL" );
1826
1827      RTEMS.RATE_MONOTONIC.PERIOD( SPTEST.PERIOD_ID( 1 ), 5, STATUS );
1828      TEST_SUPPORT.DIRECTIVE_FAILED(
1829         STATUS,
1830         "RATE_MONOTONIC_PERIOD RESTART"
1831      );
1832
1833      RTEMS.TASKS.WAKE_AFTER( TEST_SUPPORT.TICKS_PER_SECOND, STATUS );
1834      TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "TASK_WAKE_AFTER" );
1835
1836      RTEMS.RATE_MONOTONIC.PERIOD( SPTEST.PERIOD_ID( 1 ), 5, STATUS );
1837      TEST_SUPPORT.FATAL_DIRECTIVE_STATUS(
1838         STATUS,
1839         RTEMS.TIMEOUT,
1840         "RATE_MONOTONIC_PERIOD TIMED OUT"
1841      );
1842      TEXT_IO.PUT_LINE( 
1843         "TA1 - rate_monotonic_period - 5 ticks - TIMEOUT" 
1844      );
1845
1846      RTEMS.TASKS.START(
1847         SPTEST.TASK_ID( 4 ),
1848         SPTEST.TASK_4'ACCESS,
1849         0,
1850         STATUS
1851      );
1852      TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "TASK_START OF TA4" );
1853
1854      TEXT_IO.PUT_LINE( "TA1 - task_wake_after - yielding to TA4" );
1855      RTEMS.TASKS.WAKE_AFTER( RTEMS.YIELD_PROCESSOR, STATUS );
1856      TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "TASK_WAKE_AFTER (yield)" );
1857
1858      RTEMS.RATE_MONOTONIC.DELETE( 100, STATUS );
1859      TEST_SUPPORT.FATAL_DIRECTIVE_STATUS(
1860         STATUS,
1861         RTEMS.INVALID_ID,
1862         "RATE_MONOTONIC_DELETE WITH ILLEGAL ID"
1863      );
1864      TEXT_IO.PUT_LINE(
1865         "TA1 - rate_monotonic_delete - unknown INVALID_ID"
1866      );
1867
1868      RTEMS.RATE_MONOTONIC.DELETE( 16#10100#, STATUS );
1869      TEST_SUPPORT.FATAL_DIRECTIVE_STATUS(
1870         STATUS,
1871         RTEMS.INVALID_ID,
1872         "RATE_MONOTONIC_DELETE WITH ILLEGAL ID"
1873      );
1874      TEXT_IO.PUT_LINE(
1875         "TA1 - rate_monotonic_delete - local INVALID_ID"
1876      );
1877
1878      RTEMS.RATE_MONOTONIC.DELETE( SPTEST.PERIOD_ID( 1 ), STATUS );
1879      TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "RATE_MONOTONIC_DELETE" );
1880      TEXT_IO.PUT_LINE(
1881         "TA1 - rate_monotonic_delete - SUCCESSFUL"
1882      );
1883
1884   end SCREEN_10;
1885
1886--
1887--  SCREEN_11
1888--
1889
1890   procedure SCREEN_11
1891   is
1892      BUFFER_ADDRESS_1 : RTEMS.ADDRESS;
1893      BUFFER_ADDRESS_2 : RTEMS.ADDRESS;
1894      BUFFER_ADDRESS_3 : RTEMS.ADDRESS;
1895      STATUS           : RTEMS.STATUS_CODES;
1896   begin
1897
1898      RTEMS.PARTITION.CREATE(
1899         0,
1900         SPTEST.PARTITION_GOOD_AREA'ADDRESS,
1901         128,
1902         40,
1903         RTEMS.DEFAULT_ATTRIBUTES,
1904         SPTEST.JUNK_ID,
1905         STATUS
1906      );
1907      TEST_SUPPORT.FATAL_DIRECTIVE_STATUS(
1908         STATUS,
1909         RTEMS.INVALID_NAME,
1910         "PARTITION_CREATE WITH ILLEGAL NAME"
1911      );
1912      TEXT_IO.PUT_LINE( "TA1 - partition_create - INVALID_NAME" );
1913
1914      RTEMS.PARTITION.CREATE(
1915         SPTEST.PARTITION_NAME( 1 ),
1916         SPTEST.PARTITION_GOOD_AREA'ADDRESS,
1917         0,
1918         80,
1919         RTEMS.DEFAULT_ATTRIBUTES,
1920         SPTEST.JUNK_ID,
1921         STATUS
1922      );
1923      TEST_SUPPORT.FATAL_DIRECTIVE_STATUS(
1924         STATUS,
1925         RTEMS.INVALID_SIZE,
1926         "PARTITION_CREATE WITH ILLEGAL LENGTH"
1927      );
1928      TEXT_IO.PUT_LINE(
1929         "TA1 - partition_create - length - INVALID_SIZE"
1930      );
1931
1932      RTEMS.PARTITION.CREATE(
1933         SPTEST.PARTITION_NAME( 1 ),
1934         SPTEST.PARTITION_GOOD_AREA'ADDRESS,
1935         128,
1936         0,
1937         RTEMS.DEFAULT_ATTRIBUTES,
1938         SPTEST.JUNK_ID,
1939         STATUS
1940      );
1941      TEST_SUPPORT.FATAL_DIRECTIVE_STATUS(
1942         STATUS,
1943         RTEMS.INVALID_SIZE,
1944         "PARTITION_CREATE WITH ILLEGAL BUFFER_SIZE"
1945      );
1946      TEXT_IO.PUT_LINE( 
1947         "TA1 - partition_create - buffer size - INVALID_SIZE" 
1948      );
1949
1950      RTEMS.PARTITION.CREATE(
1951         SPTEST.PARTITION_NAME( 1 ),
1952         SPTEST.PARTITION_GOOD_AREA'ADDRESS,
1953         128,
1954         256,
1955         RTEMS.DEFAULT_ATTRIBUTES,
1956         SPTEST.JUNK_ID,
1957         STATUS
1958      );
1959      TEST_SUPPORT.FATAL_DIRECTIVE_STATUS(
1960         STATUS,
1961         RTEMS.INVALID_SIZE,
1962         "PARTITION_CREATE WITH BUFFER_SIZE > LENGTH"
1963      );
1964      TEXT_IO.PUT_LINE( 
1965       "TA1 - partition_create - length < buffer size - INVALID_SIZE"
1966      );
1967
1968      if TEST_SUPPORT.Is_Configured_Multiprocessing then
1969         RTEMS.PARTITION.CREATE(
1970            SPTEST.PARTITION_NAME( 1 ),
1971            SPTEST.PARTITION_GOOD_AREA'ADDRESS,
1972            128,
1973            64,
1974            RTEMS.GLOBAL,
1975            SPTEST.JUNK_ID,
1976            STATUS
1977         );
1978         TEST_SUPPORT.FATAL_DIRECTIVE_STATUS(
1979            STATUS,
1980            RTEMS.MP_NOT_CONFIGURED,
1981            "PARTITION_CREATE OF GLOBAL"
1982         );
1983      end if;
1984      TEXT_IO.PUT_LINE("TA1 - partition_create - MP_NOT_CONFIGURED");
1985
1986      RTEMS.PARTITION.CREATE(
1987         SPTEST.PARTITION_NAME( 1 ),
1988         SPTEST.PARTITION_BAD_AREA'ADDRESS,
1989         128,
1990         64,
1991         RTEMS.DEFAULT_ATTRIBUTES,
1992         SPTEST.JUNK_ID,
1993         STATUS
1994      );
1995      TEST_SUPPORT.FATAL_DIRECTIVE_STATUS(
1996         STATUS,
1997         RTEMS.INVALID_ADDRESS,
1998         "PARTITION_CREATE WITH BAD ADDRESS"
1999      );
2000      TEXT_IO.PUT_LINE( "TA1 - partition_create - INVALID_ADDRESS" );
2001
2002      RTEMS.PARTITION.CREATE(
2003         SPTEST.PARTITION_NAME( 1 ),
2004         SPTEST.PARTITION_GOOD_AREA'ADDRESS,
2005         128,
2006         34,
2007         RTEMS.DEFAULT_ATTRIBUTES,
2008         SPTEST.JUNK_ID,
2009         STATUS
2010      );
2011      TEST_SUPPORT.FATAL_DIRECTIVE_STATUS(
2012         STATUS,
2013         RTEMS.INVALID_SIZE,
2014         "PARTITION_CREATE WITH UNALIGNED BUFFER_SIZE"
2015      );
2016      TEXT_IO.PUT_LINE( "TA1 - partition_create - INVALID_SIZE" );
2017
2018      RTEMS.PARTITION.DELETE( 100, STATUS );
2019      TEST_SUPPORT.FATAL_DIRECTIVE_STATUS(
2020         STATUS,
2021         RTEMS.INVALID_ID,
2022         "PARTITION_DELETE WITH ILLEGAL ID"
2023      );
2024      TEXT_IO.PUT_LINE(
2025         "TA1 - partition_delete - unknown INVALID_ID"
2026      );
2027
2028      RTEMS.PARTITION.DELETE( 16#10100#, STATUS );
2029      TEST_SUPPORT.FATAL_DIRECTIVE_STATUS(
2030         STATUS,
2031         RTEMS.INVALID_ID,
2032         "PARTITION_DELETE WITH ILLEGAL ID"
2033      );
2034      TEXT_IO.PUT_LINE(
2035         "TA1 - partition_delete - local INVALID_ID"
2036      );
2037
2038      RTEMS.PARTITION.GET_BUFFER( 100, BUFFER_ADDRESS_1, STATUS );
2039      TEST_SUPPORT.FATAL_DIRECTIVE_STATUS(
2040         STATUS,
2041         RTEMS.INVALID_ID,
2042         "PARTITION_GET_BUFFER WITH ILLEGAL ID"
2043      );
2044      TEXT_IO.PUT_LINE( "TA1 - partition_get_buffer - INVALID_ID" );
2045
2046      RTEMS.PARTITION.IDENT(
2047         0,
2048         RTEMS.SEARCH_ALL_NODES,
2049         SPTEST.JUNK_ID,
2050         STATUS
2051      );
2052      TEST_SUPPORT.FATAL_DIRECTIVE_STATUS(
2053         STATUS,
2054         RTEMS.INVALID_NAME,
2055         "PARTITION_IDENT WITH ILLEGAL NAME"
2056      );
2057      TEXT_IO.PUT_LINE( "TA1 - partition_ident - INVALID_NAME" );
2058
2059      RTEMS.PARTITION.RETURN_BUFFER( 100, BUFFER_ADDRESS_1, STATUS );
2060      TEST_SUPPORT.FATAL_DIRECTIVE_STATUS(
2061         STATUS,
2062         RTEMS.INVALID_ID,
2063         "PARTITION_RETURN WITH ILLEGAL ID"
2064      );
2065      TEXT_IO.PUT_LINE(
2066         "TA1 - partition_return_buffer - INVALID_ID"
2067      );
2068
2069      RTEMS.PARTITION.CREATE(
2070         SPTEST.PARTITION_NAME( 1 ),
2071         SPTEST.PARTITION_GOOD_AREA'ADDRESS,
2072         128,
2073         64,
2074         RTEMS.DEFAULT_ATTRIBUTES,
2075         SPTEST.PARTITION_ID( 1 ),
2076         STATUS
2077      );
2078      TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "PARTITION_CREATE" );
2079      TEXT_IO.PUT_LINE( "TA1 - partition_create - SUCCESSFUL" );
2080
2081      RTEMS.PARTITION.CREATE(
2082         SPTEST.PARTITION_NAME( 1 ),
2083         SPTEST.PARTITION_GOOD_AREA'ADDRESS,
2084         128,
2085         64,
2086         RTEMS.DEFAULT_ATTRIBUTES,
2087         SPTEST.JUNK_ID,
2088         STATUS
2089      );
2090      TEST_SUPPORT.FATAL_DIRECTIVE_STATUS(
2091         STATUS,
2092         RTEMS.TOO_MANY,
2093         "PARTITION_CREATE OF TOO MANY"
2094      );
2095      TEXT_IO.PUT_LINE( "TA1 - partition_create - TOO_MANY" );
2096
2097      RTEMS.PARTITION.GET_BUFFER(
2098         SPTEST.PARTITION_ID( 1 ),
2099         BUFFER_ADDRESS_1,
2100         STATUS
2101      );
2102      TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "PARTITION_GET_BUFFER" );
2103      TEXT_IO.PUT_LINE( "TA1 - partition_get_buffer - SUCCESSFUL" );
2104
2105      RTEMS.PARTITION.GET_BUFFER(
2106         SPTEST.PARTITION_ID( 1 ),
2107         BUFFER_ADDRESS_2,
2108         STATUS
2109      );
2110      TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "PARTITION_GET_BUFFER" );
2111      TEXT_IO.PUT_LINE( "TA1 - partition_get_buffer - SUCCESSFUL" );
2112
2113      RTEMS.PARTITION.GET_BUFFER(
2114         SPTEST.PARTITION_ID( 1 ),
2115         BUFFER_ADDRESS_3,
2116         STATUS
2117      );
2118      TEST_SUPPORT.FATAL_DIRECTIVE_STATUS(
2119         STATUS,
2120         RTEMS.UNSATISFIED,
2121         "PARTITION_GET_BUFFER UNSATISFIED"
2122      );
2123      TEXT_IO.PUT_LINE( "TA1 - partition_get_buffer - UNSATISFIED" );
2124
2125      RTEMS.PARTITION.DELETE(
2126         SPTEST.PARTITION_ID( 1 ),
2127         STATUS
2128      );
2129      TEST_SUPPORT.FATAL_DIRECTIVE_STATUS(
2130         STATUS,
2131         RTEMS.RESOURCE_IN_USE,
2132         "PARTITION_DELETE WITH BUFFERS IN USE"
2133      );
2134      TEXT_IO.PUT_LINE( "TA1 - partition_delete - RESOURCE_IN_USE" );
2135
2136      RTEMS.PARTITION.RETURN_BUFFER(
2137         SPTEST.PARTITION_ID( 1 ),
2138         SPTEST.REGION_GOOD_AREA( 0 )'ADDRESS,  -- NOTE: REGION
2139         STATUS
2140      );
2141      TEST_SUPPORT.FATAL_DIRECTIVE_STATUS(
2142         STATUS,
2143         RTEMS.INVALID_ADDRESS,
2144         "PARTITION_RETURN WITH BUFFER ADDRESS OUT OF PARTITION"
2145      );
2146      TEXT_IO.PUT( "TA1 - partition_return_buffer - " );
2147      TEXT_IO.PUT_LINE( "INVALID_ADDRESS - out of range" );
2148
2149      RTEMS.PARTITION.RETURN_BUFFER(
2150         SPTEST.PARTITION_ID( 1 ),
2151         SPTEST.PARTITION_GOOD_AREA( 7 )'ADDRESS,
2152         STATUS
2153      );
2154      TEST_SUPPORT.FATAL_DIRECTIVE_STATUS(
2155         STATUS,
2156         RTEMS.INVALID_ADDRESS,
2157         "PARTITION_RETURN WITH BUFFER ADDRESS NOT ON BOUNDARY"
2158      );
2159      TEXT_IO.PUT( "TA1 - partition_return_buffer - " );
2160      TEXT_IO.PUT_LINE( "INVALID_ADDRESS - not on boundary" );
2161
2162
2163   end SCREEN_11;
2164
2165--
2166--  SCREEN_12
2167--
2168
2169   procedure SCREEN_12
2170   is
2171      SEGMENT_ADDRESS_1 : RTEMS.ADDRESS;
2172      SEGMENT_ADDRESS_2 : RTEMS.ADDRESS;
2173      SEGMENT_ADDRESS_3 : RTEMS.ADDRESS;
2174--    OFFSET            : RTEMS.UNSIGNED32;
2175--    GOOD_FRONT_FLAG   : RTEMS.UNSIGNED32;
2176--    GOOD_BACK_FLAG    : RTEMS.UNSIGNED32;
2177      STATUS            : RTEMS.STATUS_CODES;
2178   begin
2179
2180      RTEMS.REGION.CREATE(
2181         0,
2182         SPTEST.REGION_GOOD_AREA'ADDRESS,
2183         16#40#,
2184         32,
2185         RTEMS.DEFAULT_ATTRIBUTES,
2186         SPTEST.JUNK_ID,
2187         STATUS
2188      );
2189      TEST_SUPPORT.FATAL_DIRECTIVE_STATUS(
2190         STATUS,
2191         RTEMS.INVALID_NAME,
2192         "REGION_CREATE WITH ILLEGAL NAME"
2193      );
2194      TEXT_IO.PUT_LINE( "TA1 - region_create - INVALID_NAME" );
2195
2196      RTEMS.REGION.CREATE(
2197         SPTEST.REGION_NAME( 1 ),
2198         SPTEST.REGION_BAD_AREA'ADDRESS,
2199         16#40#,
2200         32,
2201         RTEMS.DEFAULT_ATTRIBUTES,
2202         SPTEST.JUNK_ID,
2203         STATUS
2204      );
2205      TEST_SUPPORT.FATAL_DIRECTIVE_STATUS(
2206         STATUS,
2207         RTEMS.INVALID_ADDRESS,
2208         "REGION_CREATE WITH ILLEGAL ADDRESS"
2209      );
2210      TEXT_IO.PUT_LINE( "TA1 - region_create - INVALID_ADDRESS" );
2211
2212      RTEMS.REGION.CREATE(
2213         SPTEST.REGION_NAME( 1 ),
2214         SPTEST.REGION_GOOD_AREA'ADDRESS,
2215         34,
2216         34,
2217         RTEMS.DEFAULT_ATTRIBUTES,
2218         SPTEST.JUNK_ID,
2219         STATUS
2220      );
2221      TEST_SUPPORT.FATAL_DIRECTIVE_STATUS(
2222         STATUS,
2223         RTEMS.INVALID_SIZE,
2224         "REGION_CREATE WITH ILLEGAL SIZE"
2225      );
2226      TEXT_IO.PUT_LINE( "TA1 - region_create - INVALID_SIZE" );
2227
2228      RTEMS.REGION.CREATE(
2229         SPTEST.REGION_NAME( 1 ),
2230         SPTEST.REGION_GOOD_AREA( SPTEST.REGION_START_OFFSET )'ADDRESS,
2231         SPTEST.REGION_LENGTH,
2232         16#40#,
2233         RTEMS.DEFAULT_ATTRIBUTES,
2234         SPTEST.REGION_ID( 1 ),
2235         STATUS
2236      );
2237      TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "REGION_CREATE" );
2238      TEXT_IO.PUT_LINE( "TA1 - region_create - SUCCESSFUL" );
2239
2240      RTEMS.REGION.CREATE(
2241         SPTEST.REGION_NAME( 1 ),
2242         SPTEST.REGION_GOOD_AREA'ADDRESS,
2243         SPTEST.REGION_LENGTH,
2244         16#40#,
2245         RTEMS.DEFAULT_ATTRIBUTES,
2246         SPTEST.JUNK_ID,
2247         STATUS
2248      );
2249      TEST_SUPPORT.FATAL_DIRECTIVE_STATUS(
2250         STATUS,
2251         RTEMS.TOO_MANY,
2252         "REGION_CREATE FOR TOO MANY"
2253      );
2254      TEXT_IO.PUT_LINE( "TA1 - region_create - TOO_MANY" );
2255
2256      RTEMS.REGION.DELETE( 100, STATUS );
2257      TEST_SUPPORT.FATAL_DIRECTIVE_STATUS(
2258         STATUS,
2259         RTEMS.INVALID_ID,
2260         "REGION_DELETE WITH ILLEGAL ID"
2261      );
2262      TEXT_IO.PUT_LINE( "TA1 - region_delete - unknown INVALID_ID" );
2263
2264      RTEMS.REGION.DELETE( 16#10100#, STATUS );
2265      TEST_SUPPORT.FATAL_DIRECTIVE_STATUS(
2266         STATUS,
2267         RTEMS.INVALID_ID,
2268         "REGION_DELETE WITH ILLEGAL ID"
2269      );
2270      TEXT_IO.PUT_LINE( "TA1 - region_delete - local INVALID_ID" );
2271
2272      RTEMS.REGION.IDENT( 0, SPTEST.JUNK_ID, STATUS );
2273      TEST_SUPPORT.FATAL_DIRECTIVE_STATUS(
2274         STATUS,
2275         RTEMS.INVALID_NAME,
2276         "REGION_IDENT WITH ILLEGAL NAME"
2277      );
2278      TEXT_IO.PUT_LINE( "TA1 - region_ident - INVALID_NAME" );
2279
2280      RTEMS.REGION.GET_SEGMENT(
2281         100,
2282         16#40#,
2283         RTEMS.DEFAULT_OPTIONS,
2284         RTEMS.NO_TIMEOUT,
2285         SEGMENT_ADDRESS_1,
2286         STATUS
2287      );
2288      TEST_SUPPORT.FATAL_DIRECTIVE_STATUS(
2289         STATUS,
2290         RTEMS.INVALID_ID,
2291         "REGION_GET_SEGMENT WITH ILLEGAL ID"
2292      );
2293      TEXT_IO.PUT_LINE( "TA1 - region_get_segment - INVALID_ID" );
2294
2295      RTEMS.REGION.GET_SEGMENT(
2296         SPTEST.REGION_ID( 1 ),
2297         (SPTEST.REGION_GOOD_AREA'SIZE / 8) * 2,
2298         RTEMS.DEFAULT_OPTIONS,
2299         RTEMS.NO_TIMEOUT,
2300         SEGMENT_ADDRESS_1,
2301         STATUS
2302      );
2303      TEST_SUPPORT.FATAL_DIRECTIVE_STATUS(
2304         STATUS,
2305         RTEMS.INVALID_SIZE,
2306         "REGION_GET_SEGMENT WITH ILLEGAL SIZE"
2307      );
2308      TEXT_IO.PUT_LINE( "TA1 - region_get_segment - INVALID_SIZE" );
2309
2310      RTEMS.REGION.GET_SEGMENT(
2311         SPTEST.REGION_ID( 1 ),
2312         384,
2313         RTEMS.DEFAULT_OPTIONS,
2314         RTEMS.NO_TIMEOUT,
2315         SEGMENT_ADDRESS_1,
2316         STATUS
2317      );
2318      TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "REGION_GET_SEGMENT" );
2319      TEXT_IO.PUT_LINE( "TA1 - region_get_segment - SUCCESSFUL" );
2320
2321      RTEMS.REGION.GET_SEGMENT(
2322         SPTEST.REGION_ID( 1 ),
2323         SPTEST.REGION_LENGTH / 2,
2324         RTEMS.NO_WAIT,
2325         RTEMS.NO_TIMEOUT,
2326         SEGMENT_ADDRESS_2,
2327         STATUS
2328      );
2329      TEST_SUPPORT.FATAL_DIRECTIVE_STATUS(
2330         STATUS,
2331         RTEMS.UNSATISFIED,
2332         "REGION_GET_SEGMENT UNSATISFIED"
2333      );
2334      TEXT_IO.PUT_LINE( "TA1 - region_get_segment - UNSATISFIED" );
2335
2336      TEXT_IO.PUT_LINE( "TA1 - region_get_segment - timeout in 3 seconds" );
2337      RTEMS.REGION.GET_SEGMENT(
2338         SPTEST.REGION_ID( 1 ),
2339         128,
2340         RTEMS.DEFAULT_OPTIONS,
2341         3 * TEST_SUPPORT.TICKS_PER_SECOND,
2342         SEGMENT_ADDRESS_3,
2343         STATUS
2344      );
2345      TEST_SUPPORT.FATAL_DIRECTIVE_STATUS(
2346         STATUS,
2347         RTEMS.TIMEOUT,
2348         "REGION_GET_SEGMENT TIMEOUT"
2349      );
2350      TEXT_IO.PUT_LINE( 
2351         "TA1 - region_get_segment - woke up with TIMEOUT" 
2352      );
2353
2354      RTEMS.REGION.DELETE( SPTEST.REGION_ID( 1 ), STATUS );
2355      TEST_SUPPORT.FATAL_DIRECTIVE_STATUS(
2356         STATUS,
2357         RTEMS.RESOURCE_IN_USE,
2358         "REGION_DELETE WITH BUFFERS IN USE"
2359      );
2360      TEXT_IO.PUT_LINE( "TA1 - region_delete - RESOURCE_IN_USE" );
2361
2362      RTEMS.REGION.RETURN_SEGMENT(
2363         100,
2364         SEGMENT_ADDRESS_1,
2365         STATUS
2366      );
2367      TEST_SUPPORT.FATAL_DIRECTIVE_STATUS(
2368         STATUS,
2369         RTEMS.INVALID_ID,
2370         "REGION_RETURN_SEGMENT WITH ILLEGAL ID"
2371      );
2372      TEXT_IO.PUT_LINE( "TA1 - region_return_segment - INVALID_ID" );
2373
2374      RTEMS.REGION.RETURN_SEGMENT(
2375         SPTEST.REGION_ID( 1 ),
2376         SPTEST.REGION_GOOD_AREA'ADDRESS,
2377         STATUS
2378      );
2379      TEST_SUPPORT.FATAL_DIRECTIVE_STATUS(
2380         STATUS,
2381         RTEMS.INVALID_ADDRESS,
2382         "REGION_RETURN_SEGMENT WITH ILLEGAL SEGMENT"
2383      );
2384      TEXT_IO.PUT_LINE(
2385         "TA1 - region_return_segment - INVALID_ADDRESS"
2386      );
2387
2388--    OFFSET := 0;
2389--    GOOD_BACK_FLAG := 0;
2390--    GOOD_FRONT_FLAG := 0;
2391
2392      TEXT_IO.PUT_LINE(
2393         "TA1 - region_return_segment - INVALID_ADDRESS - SKIPPED"
2394      );
2395      TEXT_IO.PUT_LINE(
2396         "TA1 - region_return_segment - INVALID_ADDRESS - SKIPPED"
2397      );
2398
2399
2400--      OFFSET := RTEMS.SUBTRACT(
2401--                   SEGMENT_ADDRESS_1,
2402--                   SPTEST.REGION_GOOD_AREA'ADDRESS
2403--                ) / 4;
2404--
2405--     
2406--      -- bad FRONT_FLAG error
2407--
2408--      GOOD_FRONT_FLAG := SPTEST.REGION_GOOD_AREA( OFFSET - 1 );
2409--      SPTEST.REGION_GOOD_AREA( OFFSET - 1 ) := GOOD_FRONT_FLAG + 2;
2410--
2411--      RTEMS.REGION.RETURN_SEGMENT(
2412--         SPTEST.REGION_ID( 1 ),
2413--         SEGMENT_ADDRESS_1,
2414--         STATUS
2415--      );
2416--      TEST_SUPPORT.FATAL_DIRECTIVE_STATUS(
2417--         STATUS,
2418--         RTEMS.INVALID_ADDRESS,
2419--         "REGION_RETURN_SEGMENT WITH BACK_FLAG /= FRONT_FLAG"
2420--      );
2421--      TEXT_IO.PUT_LINE(
2422--         "TA1 - region_return_segment - INVALID_ADDRESS"
2423--      );
2424--
2425--      SPTEST.REGION_GOOD_AREA( OFFSET - 1 ) := GOOD_FRONT_FLAG;
2426--
2427--      -- bad BACK_FLAG error
2428--
2429--      GOOD_BACK_FLAG := SPTEST.REGION_GOOD_AREA( OFFSET - 2 );
2430--      SPTEST.REGION_GOOD_AREA( OFFSET - 2 ) := 1024;
2431--
2432--      RTEMS.REGION.RETURN_SEGMENT(
2433--         SPTEST.REGION_ID( 1 ),
2434--         SEGMENT_ADDRESS_1,
2435--         STATUS
2436--      );
2437--      TEST_SUPPORT.FATAL_DIRECTIVE_STATUS(
2438--         STATUS,
2439--         RTEMS.INVALID_ADDRESS,
2440--         "REGION_RETURN_SEGMENT WITH BACK_FLAG /= FRONT_FLAG"
2441--      );
2442--      TEXT_IO.PUT_LINE(
2443--         "TA1 - region_return_segment - INVALID_ADDRESS"
2444--      );
2445--
2446--      SPTEST.REGION_GOOD_AREA( OFFSET - 2 ) := GOOD_BACK_FLAG;
2447
2448      RTEMS.REGION.EXTEND(
2449         100,
2450         SPTEST.REGION_GOOD_AREA'ADDRESS,
2451         128,
2452         STATUS
2453      );
2454      TEST_SUPPORT.FATAL_DIRECTIVE_STATUS(
2455         STATUS,
2456         RTEMS.INVALID_ID,
2457         "REGION_EXTEND WITH INVALID_ID"
2458      );
2459      TEXT_IO.PUT_LINE(
2460         "TA1 - region_extend - INVALID_ID"
2461      );
2462
2463      RTEMS.REGION.EXTEND(
2464         SPTEST.REGION_ID( 1 ),
2465         SPTEST.REGION_GOOD_AREA( SPTEST.REGION_START_OFFSET + 16 )'ADDRESS,
2466         128,
2467         STATUS
2468      );
2469      TEST_SUPPORT.FATAL_DIRECTIVE_STATUS(
2470         STATUS,
2471         RTEMS.INVALID_ADDRESS,
2472         "REGION_EXTEND WITH INVALID_ADDRESS"
2473      );
2474      TEXT_IO.PUT_LINE(
2475         "TA1 - region_extend - within heap - INVALID_ADDRESS"
2476      );
2477
2478      RTEMS.REGION.EXTEND(
2479         SPTEST.REGION_ID( 1 ),
2480         SPTEST.REGION_GOOD_AREA(
2481            SPTEST.REGION_START_OFFSET - 2 * SPTEST.REGION_LENGTH )'ADDRESS,
2482         SPTEST.REGION_LENGTH,
2483         STATUS
2484      );
2485      TEST_SUPPORT.FATAL_DIRECTIVE_STATUS(
2486         STATUS,
2487         RTEMS.SUCCESSFUL,
2488         "REGION_EXTEND"
2489      );
2490      TEXT_IO.PUT_LINE(
2491         "TA1 - region_extend - non-contiguous lower - SUCCESSFUL"
2492      );
2493
2494      RTEMS.REGION.EXTEND(
2495         SPTEST.REGION_ID( 1 ),
2496         SPTEST.REGION_GOOD_AREA( 
2497            SPTEST.REGION_START_OFFSET - SPTEST.REGION_LENGTH )'ADDRESS,
2498         SPTEST.REGION_LENGTH,
2499         STATUS
2500      );
2501      TEST_SUPPORT.FATAL_DIRECTIVE_STATUS(
2502         STATUS,
2503         RTEMS.SUCCESSFUL,
2504         "REGION_EXTEND"
2505      );
2506      TEXT_IO.PUT_LINE(
2507         "TA1 - region_extend - contiguous lower - SUCCESSFUL"
2508      );
2509
2510      RTEMS.REGION.EXTEND(
2511         SPTEST.REGION_ID( 1 ),
2512         SPTEST.REGION_GOOD_AREA( 
2513            SPTEST.REGION_START_OFFSET + 2 * SPTEST.REGION_LENGTH )'ADDRESS,
2514         SPTEST.REGION_LENGTH,
2515         STATUS
2516      );
2517      TEST_SUPPORT.FATAL_DIRECTIVE_STATUS(
2518         STATUS,
2519         RTEMS.SUCCESSFUL,
2520         "REGION_EXTEND"
2521      );
2522      TEXT_IO.PUT_LINE(
2523         "TA1 - region_extend - non-contiguous higher - SUCCESSFUL"
2524      );
2525
2526   end SCREEN_12;
2527
2528--
2529--  SCREEN_13
2530--
2531
2532   procedure SCREEN_13
2533   is
2534      TIME   : RTEMS.TIME_OF_DAY;
2535      STATUS : RTEMS.STATUS_CODES;
2536   begin
2537      TIME := ( 2000, 12, 31, 23, 59, 59, 0 );
2538      RTEMS.CLOCK.SET( TIME, STATUS );
2539      TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "CLOCK_SET SUCCESSFUL" );
2540      TEST_SUPPORT.PRINT_TIME(
2541         "TA1 - clock_set - ",
2542         TIME,
2543         " - SUCCESSFUL"
2544      );
2545      TEXT_IO.NEW_LINE;
2546      RTEMS.TASKS.WAKE_AFTER( TEST_SUPPORT.TICKS_PER_SECOND, STATUS );
2547      TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "TASK_WAKE_AFTER" );
2548      RTEMS.CLOCK.GET_TOD( TIME, STATUS );
2549      TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "CLOCK_GET_TOD" );
2550      TEST_SUPPORT.PRINT_TIME(
2551         "TA1 - clock_get - ",
2552         TIME,
2553         " - SUCCESSFUL"
2554      );
2555      TEXT_IO.NEW_LINE;
2556
2557      TIME := ( 1999, 12, 31, 23, 59, 59, 0 );
2558      RTEMS.CLOCK.SET( TIME, STATUS );
2559      TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "CLOCK_SET SUCCESSFUL" );
2560      TEST_SUPPORT.PRINT_TIME(
2561         "TA1 - clock_set - ",
2562         TIME,
2563         " - SUCCESSFUL"
2564      );
2565      TEXT_IO.NEW_LINE;
2566      RTEMS.TASKS.WAKE_AFTER( TEST_SUPPORT.TICKS_PER_SECOND, STATUS );
2567      TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "TASK_WAKE_AFTER" );
2568      RTEMS.CLOCK.GET_TOD( TIME, STATUS );
2569      TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "CLOCK_GET_TOD" );
2570      TEST_SUPPORT.PRINT_TIME(
2571         "TA1 - clock_get - ",
2572         TIME,
2573         " - SUCCESSFUL"
2574      );
2575      TEXT_IO.NEW_LINE;
2576
2577      TIME := ( 2100, 12, 31, 23, 59, 59, 0 );
2578      RTEMS.CLOCK.SET( TIME, STATUS );
2579      TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "CLOCK_SET SUCCESSFUL" );
2580      TEST_SUPPORT.PRINT_TIME(
2581         "TA1 - clock_set - ",
2582         TIME,
2583         " - SUCCESSFUL"
2584      );
2585      TEXT_IO.NEW_LINE;
2586      RTEMS.TASKS.WAKE_AFTER( TEST_SUPPORT.TICKS_PER_SECOND, STATUS );
2587      TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "TASK_WAKE_AFTER" );
2588      RTEMS.CLOCK.GET_TOD( TIME, STATUS );
2589      TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "CLOCK_GET_TOD" );
2590      TEST_SUPPORT.PRINT_TIME(
2591         "TA1 - clock_get - ",
2592         TIME,
2593         " - SUCCESSFUL"
2594      );
2595      TEXT_IO.NEW_LINE;
2596
2597      TIME := ( 2099, 12, 31, 23, 59, 59, 0 );
2598      RTEMS.CLOCK.SET( TIME, STATUS );
2599      TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "CLOCK_SET SUCCESSFUL" );
2600      TEST_SUPPORT.PRINT_TIME(
2601         "TA1 - clock_set - ",
2602         TIME,
2603         " - SUCCESSFUL"
2604      );
2605      TEXT_IO.NEW_LINE;
2606      RTEMS.TASKS.WAKE_AFTER( TEST_SUPPORT.TICKS_PER_SECOND, STATUS );
2607      TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "TASK_WAKE_AFTER" );
2608      RTEMS.CLOCK.GET_TOD( TIME, STATUS );
2609      TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "CLOCK_GET_TOD" );
2610      TEST_SUPPORT.PRINT_TIME(
2611         "TA1 - clock_get - ",
2612         TIME,
2613         " - SUCCESSFUL"
2614      );
2615      TEXT_IO.NEW_LINE;
2616
2617      TIME := ( 1991, 12, 31, 23, 59, 59, 0 );
2618      RTEMS.CLOCK.SET( TIME, STATUS );
2619      TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "CLOCK_SET SUCCESSFUL" );
2620      TEST_SUPPORT.PRINT_TIME(
2621         "TA1 - clock_set - ",
2622         TIME,
2623         " - SUCCESSFUL"
2624      );
2625      TEXT_IO.NEW_LINE;
2626      RTEMS.TASKS.WAKE_AFTER( TEST_SUPPORT.TICKS_PER_SECOND, STATUS );
2627      TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "TASK_WAKE_AFTER" );
2628      RTEMS.CLOCK.GET_TOD( TIME, STATUS );
2629      TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "CLOCK_GET_TOD" );
2630      TEST_SUPPORT.PRINT_TIME(
2631         "TA1 - clock_get - ",
2632         TIME,
2633         " - SUCCESSFUL"
2634      );
2635      TEXT_IO.NEW_LINE;
2636
2637   end SCREEN_13;
2638
2639--
2640--  SCREEN_14
2641--
2642
2643   procedure SCREEN_14
2644   is
2645      TIME   : RTEMS.TIME_OF_DAY;
2646      STATUS : RTEMS.STATUS_CODES;
2647   begin
2648
2649      RTEMS.TIMER.CREATE( 0, SPTEST.JUNK_ID, STATUS );
2650      TEST_SUPPORT.FATAL_DIRECTIVE_STATUS(
2651         STATUS,
2652         RTEMS.INVALID_NAME,
2653         "TIMER_CREATE WITH ILLEGAL NAME"
2654      );
2655      TEXT_IO.PUT_LINE( "TA1 - timer_create - INVALID_NAME" );
2656
2657      RTEMS.TIMER.CREATE(
2658         SPTEST.TIMER_NAME( 1 ),
2659         SPTEST.TIMER_ID( 1 ),
2660         STATUS
2661      );
2662      TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "TIMER_CREATE" );
2663      TEXT_IO.PUT_LINE( "TA1 - timer_create - 1 - SUCCESSFUL" );
2664
2665      RTEMS.TIMER.CREATE(
2666         SPTEST.TIMER_NAME( 1 ),
2667         SPTEST.JUNK_ID,
2668         STATUS
2669      );
2670      TEST_SUPPORT.FATAL_DIRECTIVE_STATUS(
2671         STATUS,
2672         RTEMS.TOO_MANY,
2673         "TIMER_CREATE FOR TOO MANY"
2674      );
2675      TEXT_IO.PUT_LINE( "TA1 - timer_create - 2 - TOO_MANY" );
2676
2677      RTEMS.TIMER.DELETE( 100, STATUS );
2678      TEST_SUPPORT.FATAL_DIRECTIVE_STATUS(
2679         STATUS,
2680         RTEMS.INVALID_ID,
2681         "TIMER_DELETE WITH ILLEGAL ID"
2682      );
2683      TEXT_IO.PUT_LINE( "TA1 - timer_delete - local INVALID_ID" );
2684
2685      RTEMS.TIMER.DELETE( 16#10100#, STATUS );
2686      TEST_SUPPORT.FATAL_DIRECTIVE_STATUS(
2687         STATUS,
2688         RTEMS.INVALID_ID,
2689         "TIMER_DELETE WITH ILLEGAL ID"
2690      );
2691      TEXT_IO.PUT_LINE( "TA1 - timer_delete - global INVALID_ID" );
2692
2693      RTEMS.TIMER.IDENT( 0, SPTEST.JUNK_ID, STATUS );
2694      TEST_SUPPORT.FATAL_DIRECTIVE_STATUS(
2695         STATUS,
2696         RTEMS.INVALID_NAME,
2697         "TIMER_IDENT WITH ILLEGAL NAME"
2698      );
2699      TEXT_IO.PUT_LINE( "TA1 - timer_ident - INVALID_NAME" );
2700
2701      RTEMS.TIMER.CANCEL( 16#10100#, STATUS );
2702      TEST_SUPPORT.FATAL_DIRECTIVE_STATUS(
2703         STATUS,
2704         RTEMS.INVALID_ID,
2705         "TIMER_CANCEL WITH ILLEGAL ID"
2706      );
2707      TEXT_IO.PUT_LINE( "TA1 - timer_cancel - INVALID_ID" );
2708
2709      RTEMS.TIMER.RESET( 16#10100#, STATUS );
2710      TEST_SUPPORT.FATAL_DIRECTIVE_STATUS(
2711         STATUS,
2712         RTEMS.INVALID_ID,
2713         "TIMER_RESET WITH ILLEGAL ID"
2714      );
2715      TEXT_IO.PUT_LINE( "TA1 - timer_reset - INVALID_ID" );
2716
2717      RTEMS.TIMER.RESET( SPTEST.TIMER_ID( 1 ), STATUS );
2718      TEST_SUPPORT.FATAL_DIRECTIVE_STATUS(
2719         STATUS,
2720         RTEMS.NOT_DEFINED,
2721         "TIMER_RESET BEFORE INITIATED"
2722      );
2723      TEXT_IO.PUT_LINE( "TA1 - timer_reset - NOT_DEFINED" );
2724
2725      RTEMS.TIMER.FIRE_AFTER(
2726         16#10100#,
2727         5 * TEST_SUPPORT.TICKS_PER_SECOND,
2728         SPTEST.DELAYED_SUBPROGRAM'ACCESS,
2729         RTEMS.NULL_ADDRESS,
2730         STATUS
2731      );
2732      TEST_SUPPORT.FATAL_DIRECTIVE_STATUS(
2733         STATUS,
2734         RTEMS.INVALID_ID,
2735         "TIMER_FIRE_AFTER WITH ILLEGAL ID"
2736      );
2737      TEXT_IO.PUT_LINE( "TA1 - timer_fire_after - INVALID_ID" );
2738
2739      TIME := ( 1994, 12, 31, 1, 0, 0, 0 );
2740      RTEMS.TIMER.FIRE_WHEN(
2741         16#10100#,
2742         TIME,
2743         SPTEST.DELAYED_SUBPROGRAM'ACCESS,
2744         RTEMS.NULL_ADDRESS,
2745         STATUS
2746      );
2747      TEST_SUPPORT.FATAL_DIRECTIVE_STATUS(
2748         STATUS,
2749         RTEMS.INVALID_ID,
2750         "TIMER_FIRE_WHEN WITH ILLEGAL ID"
2751      );
2752      TEXT_IO.PUT_LINE( "TA1 - timer_fire_when - INVALID_ID" );
2753
2754      RTEMS.TIMER.FIRE_AFTER(
2755         SPTEST.TIMER_ID( 1 ),
2756         0,
2757         SPTEST.DELAYED_SUBPROGRAM'ACCESS,
2758         RTEMS.NULL_ADDRESS,
2759         STATUS
2760      );
2761      TEST_SUPPORT.FATAL_DIRECTIVE_STATUS(
2762         STATUS,
2763         RTEMS.INVALID_NUMBER,
2764         "TIMER_FIRE_AFTER WITH 0 TICKS"
2765      );
2766      TEXT_IO.PUT_LINE( "TA1 - timer_fire_after - INVALID_NUMBER" );
2767
2768      TIME := ( 1987, 2, 5, 8, 30, 45, 0 );
2769      RTEMS.TIMER.FIRE_WHEN(
2770         SPTEST.TIMER_ID( 1 ),
2771         TIME,
2772         SPTEST.DELAYED_SUBPROGRAM'ACCESS,
2773         RTEMS.NULL_ADDRESS,
2774         STATUS
2775      );
2776      TEST_SUPPORT.FATAL_DIRECTIVE_STATUS(
2777         STATUS,
2778         RTEMS.INVALID_CLOCK,
2779         "TIMER_FIRE_WHEN WITH ILLEGAL TIME"
2780      );
2781      TEST_SUPPORT.PRINT_TIME(
2782         "TA1 - timer_fire_when - ",
2783         TIME,
2784         " - INVALID_CLOCK"
2785      );
2786      TEXT_IO.NEW_LINE;
2787
2788      RTEMS.CLOCK.GET_TOD( TIME, STATUS );
2789      TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "CLOCK_GET SUCCESSFUL" );
2790      TEST_SUPPORT.PRINT_TIME( "TA1 - clock_get       - ", TIME, "" );
2791      TEXT_IO.NEW_LINE;
2792
2793      TIME := ( 1990, 2, 5, 8, 30, 45, 0 );
2794      RTEMS.TIMER.FIRE_WHEN(
2795         SPTEST.TIMER_ID( 1 ),
2796         TIME,
2797         SPTEST.DELAYED_SUBPROGRAM'ACCESS,
2798         RTEMS.NULL_ADDRESS,
2799         STATUS
2800      );
2801      TEST_SUPPORT.FATAL_DIRECTIVE_STATUS(
2802         STATUS,
2803         RTEMS.INVALID_CLOCK,
2804         "TIMER_FIRE_WHEN BEFORE CURRENT TIME"
2805      );
2806      TEST_SUPPORT.PRINT_TIME(
2807         "TA1 - timer_fire_when - ",
2808         TIME,
2809         " - before INVALID_CLOCK"
2810      );
2811      TEXT_IO.NEW_LINE;
2812
2813      RTEMS.TIMER.SERVER_FIRE_AFTER(
2814         0, 5, SPTEST.DELAYED_SUBPROGRAM'ACCESS, RTEMS.NULL_ADDRESS, STATUS
2815      );
2816      TEST_SUPPORT.FATAL_DIRECTIVE_STATUS(
2817        STATUS,
2818        RTEMS.INCORRECT_STATE,
2819        "TIMER_SERVER_FIRE_AFTER INCORRECT STATE"
2820      );
2821      TEXT_IO.PUT_LINE( "TA1 - timer_server_fire_after - INCORRECT_STATE" );
2822
2823      RTEMS.TIMER.SERVER_FIRE_WHEN(
2824         0, TIME, SPTEST.DELAYED_SUBPROGRAM'ACCESS, RTEMS.NULL_ADDRESS, STATUS
2825      );
2826      TEST_SUPPORT.FATAL_DIRECTIVE_STATUS(
2827        STATUS,
2828        RTEMS.INCORRECT_STATE,
2829        "TIMER_SERVER_FIRE_WHEN INCORRECT STATE"
2830      );
2831      TEXT_IO.PUT_LINE( "TA1 - timer_server_fire_when - INCORRECT_STATE" );
2832
2833      RTEMS.TIMER.INITIATE_SERVER( 16#80000000#, 0, 0, STATUS );
2834      TEST_SUPPORT.FATAL_DIRECTIVE_STATUS(
2835        STATUS,
2836        RTEMS.INVALID_PRIORITY,
2837        "timer_initiate_server invalid priority"
2838      );
2839      TEXT_IO.PUT_LINE( "TA1 - timer_initiate_server - INVALID_PRIORITY" );
2840
2841      RTEMS.TIMER.INITIATE_SERVER(
2842-- XXX ask Joel
2843--         RTEMS.TIMER.SERVER_DEFAULT_PRIORITY, 0, 0, STATUS
2844         -1, 0, 0, STATUS
2845      );
2846      TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "timer_initiate_server" );
2847      TEXT_IO.PUT_LINE( "TA1 - timer_initiate_server" );
2848
2849      RTEMS.TIMER.SERVER_FIRE_AFTER(
2850        16#010100#,
2851        5 * TEST_SUPPORT.TICKS_PER_SECOND,
2852        SPTEST.DELAYED_SUBPROGRAM'ACCESS,
2853        RTEMS.NULL_ADDRESS,
2854        STATUS
2855      );
2856      TEST_SUPPORT.FATAL_DIRECTIVE_STATUS(
2857        STATUS,
2858        RTEMS.INVALID_ID,
2859        "TIMER_SERVER_FIRE_AFTER ILLEGAL ID"
2860      );
2861      TEXT_IO.PUT_LINE( "TA1 - timer_server_fire_after - INVALID_ID" );
2862
2863      TIME := ( 1994, 12, 31, 9, 0, 0, 0 );
2864      RTEMS.TIMER.SERVER_FIRE_WHEN(
2865         16#010100#,
2866         TIME,
2867         SPTEST.DELAYED_SUBPROGRAM'ACCESS,
2868         RTEMS.NULL_ADDRESS,
2869         STATUS
2870      );
2871      TEST_SUPPORT.FATAL_DIRECTIVE_STATUS(
2872        STATUS,
2873        RTEMS.INVALID_ID,
2874        "TIMER_SERVER_FIRE_WHEN WITH ILLEGAL ID"
2875      );
2876      TEXT_IO.PUT_LINE( "TA1 - timer_server_fire_when - INVALID_ID" );
2877
2878      RTEMS.TIMER.SERVER_FIRE_AFTER(
2879         SPTEST.TIMER_ID( 1 ),
2880         0,
2881         SPTEST.DELAYED_SUBPROGRAM'ACCESS,
2882         RTEMS.NULL_ADDRESS,
2883         STATUS
2884      );
2885      TEST_SUPPORT.FATAL_DIRECTIVE_STATUS(
2886        STATUS,
2887        RTEMS.INVALID_NUMBER,
2888        "TIMER_SERVER_FIRE_AFTER WITH 0 TICKS"
2889      );
2890      TEXT_IO.PUT_LINE( "TA1 - timer_server_fire_after - INVALID_NUMBER" );
2891
2892      TIME := ( 1987, 2, 5, 8, 30, 45, 0 );
2893      RTEMS.TIMER.SERVER_FIRE_WHEN(
2894         SPTEST.TIMER_ID( 1 ),
2895         TIME,
2896         SPTEST.DELAYED_SUBPROGRAM'ACCESS,
2897         RTEMS.NULL_ADDRESS,
2898         STATUS
2899      );
2900      TEST_SUPPORT.FATAL_DIRECTIVE_STATUS(
2901        STATUS,
2902        RTEMS.INVALID_CLOCK,
2903        "TIMER_SERVER_FIRE_WHEN WITH ILLEGAL TIME"
2904      );
2905      TEST_SUPPORT.PRINT_TIME(
2906        "TA1 - timer_server_fire_when - ",
2907        TIME,
2908        " - INVALID_CLOCK"
2909      );
2910      TEXT_IO.NEW_LINE;
2911
2912      RTEMS.CLOCK.GET_TOD( TIME, STATUS );
2913      TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "clock_set" );
2914      TEST_SUPPORT.PRINT_TIME( "TA1 - clock_get       - ", TIME, "" );
2915      TEXT_IO.NEW_LINE;
2916
2917      TIME := ( 1990, 2, 5, 8, 30, 45, 0 );
2918      RTEMS.TIMER.SERVER_FIRE_WHEN(
2919         SPTEST.TIMER_ID( 1 ),
2920         TIME,
2921         SPTEST.DELAYED_SUBPROGRAM'ACCESS,
2922         RTEMS.NULL_ADDRESS,
2923         STATUS
2924      );
2925      TEST_SUPPORT.FATAL_DIRECTIVE_STATUS(
2926        STATUS,
2927        RTEMS.INVALID_CLOCK,
2928        "TIMER_SERVER_FIRE_WHEN BEFORE CURRENT TIME"
2929      );
2930      TEST_SUPPORT.PRINT_TIME(
2931        "TA1 - timer_server_fire_when - ",
2932        TIME,
2933        " - before INVALID_CLOCK"
2934      );
2935      TEXT_IO.NEW_LINE;
2936
2937   end SCREEN_14;
2938
2939--
2940--  TASK_1
2941--
2942
2943   procedure TASK_1 (
2944      ARGUMENT : in     RTEMS.TASKS.ARGUMENT
2945   ) is
2946      pragma Unreferenced(ARGUMENT);
2947   begin
2948
2949      SPTEST.SCREEN_1;
2950      TEST_SUPPORT.PAUSE_AND_SCREEN_NUMBER( 2 );
2951
2952      SPTEST.SCREEN_2;
2953      TEST_SUPPORT.PAUSE_AND_SCREEN_NUMBER( 3 );
2954
2955      SPTEST.SCREEN_3;
2956      TEST_SUPPORT.PAUSE_AND_SCREEN_NUMBER( 4 );
2957
2958      SPTEST.SCREEN_4;
2959      TEST_SUPPORT.PAUSE_AND_SCREEN_NUMBER( 5 );
2960
2961      SPTEST.SCREEN_5;
2962      TEST_SUPPORT.PAUSE_AND_SCREEN_NUMBER( 6 );
2963
2964      SPTEST.SCREEN_6;
2965      TEST_SUPPORT.PAUSE_AND_SCREEN_NUMBER( 7 );
2966
2967      SPTEST.SCREEN_7;
2968      TEST_SUPPORT.PAUSE_AND_SCREEN_NUMBER( 8 );
2969
2970      SPTEST.SCREEN_8;
2971      TEST_SUPPORT.PAUSE_AND_SCREEN_NUMBER( 9 );
2972
2973      SPTEST.SCREEN_9;
2974      TEST_SUPPORT.PAUSE_AND_SCREEN_NUMBER( 10 );
2975
2976      SPTEST.SCREEN_10;
2977      TEST_SUPPORT.PAUSE_AND_SCREEN_NUMBER( 11 );
2978
2979      SPTEST.SCREEN_11;
2980      TEST_SUPPORT.PAUSE_AND_SCREEN_NUMBER( 12 );
2981
2982      SPTEST.SCREEN_12;
2983      TEST_SUPPORT.PAUSE_AND_SCREEN_NUMBER( 13 );
2984
2985      SPTEST.SCREEN_13;
2986      TEST_SUPPORT.PAUSE_AND_SCREEN_NUMBER( 14 );
2987
2988      SPTEST.SCREEN_14;
2989
2990      TEST_SUPPORT.ADA_TEST_END;
2991      RTEMS.SHUTDOWN_EXECUTIVE( 0 );
2992
2993   end TASK_1;
2994
2995--
2996--  TASK_2
2997--
2998
2999   procedure TASK_2 (
3000      ARGUMENT : in     RTEMS.TASKS.ARGUMENT
3001   ) is
3002      pragma Unreferenced(ARGUMENT);
3003      STATUS : RTEMS.STATUS_CODES;
3004   begin
3005
3006      TEXT_IO.PUT_LINE( "TA2 - semaphore_obtain - sem 1 - WAIT FOREVER" );
3007      RTEMS.SEMAPHORE.OBTAIN(
3008         SPTEST.SEMAPHORE_ID( 1 ),
3009         RTEMS.DEFAULT_OPTIONS,
3010         RTEMS.NO_TIMEOUT,
3011         STATUS
3012      );
3013      TEST_SUPPORT.FATAL_DIRECTIVE_STATUS(
3014         STATUS,
3015         RTEMS.OBJECT_WAS_DELETED,
3016         "SEMAPHORE_OBTAIN WAITING TO BE DELETED"
3017      );
3018      TEXT_IO.PUT_LINE(
3019         "TA2 - semaphore_obtain - woke up with OBJECT_WAS_DELETED"
3020      );
3021
3022      TEXT_IO.PUT_LINE( 
3023         "TA2 - task_delete - delete self - SUCCESSFUL" 
3024      );
3025      RTEMS.TASKS.DELETE( RTEMS.SELF, STATUS );
3026      TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "TASK_DELETE OF TA2" );
3027
3028   end TASK_2;
3029
3030--
3031--  TASK_3
3032--
3033
3034   procedure TASK_3 (
3035      ARGUMENT : in     RTEMS.TASKS.ARGUMENT
3036   ) is
3037      pragma Unreferenced(ARGUMENT);
3038      BUFFER         : SPTEST.BUFFER;
3039      BUFFER_POINTER : RTEMS.ADDRESS;
3040      MESSAGE_SIZE   : RTEMS.Size := 0;
3041      STATUS         : RTEMS.STATUS_CODES;
3042   begin
3043
3044      BUFFER_POINTER := BUFFER'ADDRESS;
3045
3046      TEXT_IO.PUT_LINE(
3047         "TA3 - message_queue_receive - Q 1 - WAIT FOREVER"
3048      );
3049      RTEMS.MESSAGE_QUEUE.RECEIVE(
3050         SPTEST.QUEUE_ID( 1 ),
3051         BUFFER_POINTER,
3052         RTEMS.DEFAULT_OPTIONS,
3053         RTEMS.NO_TIMEOUT,
3054         MESSAGE_SIZE,
3055         STATUS
3056      );
3057      TEST_SUPPORT.FATAL_DIRECTIVE_STATUS(
3058         STATUS,
3059         RTEMS.OBJECT_WAS_DELETED,
3060         "MESSAGE_QUEUE_RECEIVE WAITING TO BE DELETED"
3061      );
3062      TEXT_IO.PUT( "TA3 - message_queue_receive - woke up " );
3063      TEXT_IO.PUT_LINE( "with OBJECT_WAS_DELETED" );
3064
3065      TEXT_IO.PUT_LINE( 
3066         "TA3 - task_delete - delete self - SUCCESSFUL" 
3067      );
3068      RTEMS.TASKS.DELETE( RTEMS.SELF, STATUS );
3069      TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "TASK_DELETE OF TA3" );
3070
3071   end TASK_3;
3072
3073--
3074--  TASK_4
3075--
3076
3077   procedure TASK_4 (
3078      ARGUMENT : in     RTEMS.TASKS.ARGUMENT
3079   ) is
3080      pragma Unreferenced(ARGUMENT);
3081      STATUS : RTEMS.STATUS_CODES;
3082   begin
3083
3084      RTEMS.RATE_MONOTONIC.CANCEL(
3085         SPTEST.PERIOD_ID( 1 ),
3086         STATUS
3087      );
3088      TEST_SUPPORT.FATAL_DIRECTIVE_STATUS(
3089         STATUS,
3090         RTEMS.NOT_OWNER_OF_RESOURCE,
3091         "RATE_MONOTONIC_CANCEL NOT THE OWNER"
3092      );
3093      TEXT_IO.PUT_LINE(
3094         "TA4 - rate_monotonic_cancel - NOT_OWNER_OF_RESOURCE"
3095       );
3096
3097      RTEMS.RATE_MONOTONIC.PERIOD(
3098         SPTEST.PERIOD_ID( 1 ),
3099         5,
3100         STATUS
3101      );
3102      TEST_SUPPORT.FATAL_DIRECTIVE_STATUS(
3103         STATUS,
3104         RTEMS.NOT_OWNER_OF_RESOURCE,
3105         "RATE_MONOTONIC_PERIOD NOT THE OWNER"
3106      );
3107      TEXT_IO.PUT_LINE(
3108         "TA4 - rate_monotonic_period - NOT_OWNER_OF_RESOURCE"
3109      );
3110
3111      TEXT_IO.PUT_LINE(
3112         "TA4 - task_delete - delete self - SUCCESSFUL" 
3113      );
3114      RTEMS.TASKS.DELETE( RTEMS.SELF, STATUS );
3115      TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "TASK_DELETE OF TA4" );
3116
3117
3118   end TASK_4;
3119
3120end SPTEST;
Note: See TracBrowser for help on using the repository browser.