source: rtems/c/src/ada-tests/sptests/sp09/sptest.adb @ c499856

4.115
Last change on this file since c499856 was c499856, checked in by Chris Johns <chrisj@…>, on 03/20/14 at 21:10:47

Change all references of rtems.com to rtems.org.

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