Context Navigation

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

5

Last change on this file since 783fbce was 783fbce, checked in by Sebastian Huber <sebastian.huber@…>, on 05/23/17 at 09:33:29

ada: Update due to Clock Manager API changes

Update #2676.

Property mode set to 100644

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

Note: See TracBrowser for help on using the repository browser.

Download in other formats: