Context Navigation

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

Last change on this file was d4c21e5, checked in by Sebastian Huber <sebastian.huber@…>, on 07/20/22 at 07:42:17

ada/sp09: The year 2100 cannot be set

Update #4338.

Property mode set to 100644

File size: 85.5 KB

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

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

Download in other formats: