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

Last change on this file since 3d7d2a37 was 3d7d2a37, checked in by Sebastian Huber <sebastian.huber@…>, on Dec 4, 2017 at 9:52:01 AM

ada/sp09: Fix timer server test case

A priority of zero is valid for the timer server.

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