Context Navigation

sptest.adb @ d5154d0f

Last change on this file since d5154d0f was d5154d0f, checked in by Aun-Ali Zaidi <admin@…>, on 12/23/15 at 20:44:02

api: Remove deprecated Notepads

Notepads where a feature of RTEMS' tasks that simply functioned in
the same way as POSIX keys or threaded local storage (TLS). They were
introduced well before per task variables, which are also deprecated,
and were barely used in favor of their POSIX alternatives.

In addition to their scarce usage, Notepads took up unnecessary memory.
For each task:

16 32-bit integers were allocated.
A total of 64 bytes per task per thread.

This is especially critical in low memory and safety-critical applications.

They are also defined as uint32_t, and therefore are not guaranteed to
hold a pointer.

Lastly, they are not portable solutions for SMP and uniprocessor systems,
like POSIX keys and TLS.

updates #2493.

Property mode set to 100644

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

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

Context Navigation

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

Download in other formats: