source: rtems/c/src/ada-tests/sptests/sp12/sptest.adb @ cf1ced66

4.104.114.84.95
Last change on this file since cf1ced66 was bf9ae83, checked in by Joel Sherrill <joel.sherrill@…>, on Jun 2, 1997 at 8:32:11 PM

modified copyright notice to be the same as RTEMS 4.0.0.

changed the CVS ID string to be a "development" version.

  • Property mode set to 100644
File size: 23.1 KB
Line 
1--
2--  SPTEST / BODY
3--
4--  DESCRIPTION:
5--
6--  This package is the implementation of Test 12 of the RTEMS
7--  Single Processor Test Suite.
8--
9--  DEPENDENCIES:
10--
11-- 
12--
13--  COPYRIGHT (c) 1989-1997.
14--  On-Line Applications Research Corporation (OAR).
15--  Copyright assigned to U.S. Government, 1994.
16--
17--  The license and distribution terms for this file may in
18--  the file LICENSE in this distribution or at
19--  http://www.OARcorp.com/rtems/license.html.
20--
21--  $Id$
22--
23
24with INTERFACES; use INTERFACES;
25with RTEMS;
26with TEST_SUPPORT;
27with TEXT_IO;
28with UNSIGNED32_IO;
29
30package body SPTEST is
31
32--PAGE
33--
34--  INIT
35--
36
37   procedure INIT (
38      ARGUMENT : in     RTEMS.TASK_ARGUMENT
39   ) is
40      STATUS : RTEMS.STATUS_CODES;
41   begin
42
43      TEXT_IO.NEW_LINE( 2 );
44      TEXT_IO.PUT_LINE( "*** TEST 12 ***" );
45
46      SPTEST.TASK_NAME( 1 ) := RTEMS.BUILD_NAME(  'T', 'A', '1', ' ' );
47      SPTEST.TASK_NAME( 2 ) := RTEMS.BUILD_NAME(  'T', 'A', '2', ' ' );
48      SPTEST.TASK_NAME( 3 ) := RTEMS.BUILD_NAME(  'T', 'A', '3', ' ' );
49      SPTEST.TASK_NAME( 4 ) := RTEMS.BUILD_NAME(  'T', 'A', '4', ' ' );
50      SPTEST.TASK_NAME( 5 ) := RTEMS.BUILD_NAME(  'T', 'A', '5', ' ' );
51
52      SPTEST.PRIORITY_TASK_NAME( 1 ) := 
53         RTEMS.BUILD_NAME(  'P', 'R', 'I', '1' );
54      SPTEST.PRIORITY_TASK_NAME( 2 ) := 
55         RTEMS.BUILD_NAME(  'P', 'R', 'I', '2' );
56      SPTEST.PRIORITY_TASK_NAME( 3 ) := 
57         RTEMS.BUILD_NAME(  'P', 'R', 'I', '3' );
58      SPTEST.PRIORITY_TASK_NAME( 4 ) := 
59         RTEMS.BUILD_NAME(  'P', 'R', 'I', '4' );
60      SPTEST.PRIORITY_TASK_NAME( 5 ) := 
61         RTEMS.BUILD_NAME(  'P', 'R', 'I', '5' );
62
63      SPTEST.SEMAPHORE_NAME( 1 ) := RTEMS.BUILD_NAME(  'S', 'M', '1', ' ' );
64      SPTEST.SEMAPHORE_NAME( 2 ) := RTEMS.BUILD_NAME(  'S', 'M', '2', ' ' );
65      SPTEST.SEMAPHORE_NAME( 3 ) := RTEMS.BUILD_NAME(  'S', 'M', '3', ' ' );
66
67      RTEMS.SEMAPHORE_CREATE( 
68         SPTEST.SEMAPHORE_NAME( 1 ), 
69         1,
70         RTEMS.DEFAULT_ATTRIBUTES,
71         SPTEST.SEMAPHORE_ID( 1 ),
72         STATUS
73      );
74      TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "SEMAPHORE_CREATE OF SM1" );
75
76      RTEMS.SEMAPHORE_CREATE( 
77         SPTEST.SEMAPHORE_NAME( 2 ), 
78         0,
79         RTEMS.PRIORITY,
80         SPTEST.SEMAPHORE_ID( 2 ),
81         STATUS
82      );
83      TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "SEMAPHORE_CREATE OF SM2" );
84
85      RTEMS.SEMAPHORE_CREATE( 
86         SPTEST.SEMAPHORE_NAME( 3 ), 
87         1,
88         RTEMS.DEFAULT_ATTRIBUTES,
89         SPTEST.SEMAPHORE_ID( 3 ),
90         STATUS
91      );
92      TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "SEMAPHORE_CREATE OF SM3" );
93
94      TEXT_IO.PUT_LINE( "INIT - Forward priority queue test" );
95      SPTEST.PRIORITY_TEST_DRIVER( 0 );
96
97      TEXT_IO.PUT_LINE( "INIT - Backward priority queue test" );
98      SPTEST.PRIORITY_TEST_DRIVER( 32 );
99
100TEST_SUPPORT.PAUSE;
101
102      TEXT_IO.PUT_LINE( 
103        "INIT - Binary Semaphore and Priority Inheritance Test" 
104      );
105
106      RTEMS.SEMAPHORE_DELETE( SPTEST.SEMAPHORE_ID( 2 ), STATUS );
107      TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "SEMAPHORE_DELETE OF SM2" );
108
109      TEXT_IO.PUT_LINE( 
110        "INIT - semaphore_create - allocated binary semaphore"
111      );
112      RTEMS.SEMAPHORE_CREATE( 
113         SPTEST.SEMAPHORE_NAME( 2 ), 
114         0,
115         RTEMS.BINARY_SEMAPHORE + RTEMS.PRIORITY + RTEMS.INHERIT_PRIORITY,
116         SPTEST.SEMAPHORE_ID( 2 ),
117         STATUS
118      );
119      TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "SEMAPHORE_CREATE OF SM2" );
120
121      TEXT_IO.PUT_LINE( 
122        "INIT - semaphore_release - allocated binary semaphore"
123      );
124      RTEMS.SEMAPHORE_RELEASE( SPTEST.SEMAPHORE_ID( 2 ), STATUS );
125      TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "SEMAPHORE_RELEASE OF SM2" );
126
127      TEXT_IO.PUT_LINE( 
128        "INIT - semaphore_delete - allocated binary semaphore"
129      );
130      RTEMS.SEMAPHORE_DELETE( SPTEST.SEMAPHORE_ID( 2 ), STATUS );
131      TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "SEMAPHORE_DELETE OF SM2" );
132
133      RTEMS.SEMAPHORE_CREATE( 
134         SPTEST.SEMAPHORE_NAME( 2 ), 
135         1,
136         RTEMS.BINARY_SEMAPHORE + RTEMS.PRIORITY + RTEMS.INHERIT_PRIORITY,
137         SPTEST.SEMAPHORE_ID( 2 ),
138         STATUS
139      );
140      TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "SEMAPHORE_CREATE OF SM2" );
141
142      SPTEST.PRIORITY_TEST_DRIVER( 64 );
143
144TEST_SUPPORT.PAUSE;
145
146      RTEMS.SEMAPHORE_DELETE( SPTEST.SEMAPHORE_ID( 2 ), STATUS );
147      TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "SEMAPHORE_DELETE OF SM2" );
148
149      RTEMS.SEMAPHORE_CREATE( 
150         SPTEST.SEMAPHORE_NAME( 2 ), 
151         0,
152         RTEMS.PRIORITY,
153         SPTEST.SEMAPHORE_ID( 2 ),
154         STATUS
155      );
156      TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "SEMAPHORE_CREATE OF SM2" );
157
158      RTEMS.SEMAPHORE_RELEASE( SPTEST.SEMAPHORE_ID( 2 ), STATUS );
159      TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "SEMAPHORE_RELEASE OF SM2" );
160
161      RTEMS.TASK_CREATE( 
162         SPTEST.TASK_NAME( 1 ), 
163         4, 
164         2048, 
165         RTEMS.DEFAULT_MODES,
166         RTEMS.DEFAULT_ATTRIBUTES,
167         SPTEST.TASK_ID( 1 ),
168         STATUS
169      );
170      TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "TASK_CREATE OF TA1" );
171
172      RTEMS.TASK_CREATE( 
173         SPTEST.TASK_NAME( 2 ), 
174         4, 
175         2048, 
176         RTEMS.DEFAULT_MODES,
177         RTEMS.DEFAULT_ATTRIBUTES,
178         SPTEST.TASK_ID( 2 ),
179         STATUS
180      );
181      TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "TASK_CREATE OF TA2" );
182
183      RTEMS.TASK_CREATE( 
184         SPTEST.TASK_NAME( 3 ), 
185         4, 
186         2048, 
187         RTEMS.DEFAULT_MODES,
188         RTEMS.DEFAULT_ATTRIBUTES,
189         SPTEST.TASK_ID( 3 ),
190         STATUS
191      );
192      TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "TASK_CREATE OF TA3" );
193
194      RTEMS.TASK_START(
195         SPTEST.TASK_ID( 1 ),
196         SPTEST.TASK_1'ACCESS,
197         0,
198         STATUS
199      );
200      TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "TASK_START OF TA1" );
201
202      RTEMS.TASK_START(
203         SPTEST.TASK_ID( 2 ),
204         SPTEST.TASK_2'ACCESS,
205         0,
206         STATUS
207      );
208      TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "TASK_START OF TA2" );
209
210      RTEMS.TASK_START(
211         SPTEST.TASK_ID( 3 ),
212         SPTEST.TASK_3'ACCESS,
213         0,
214         STATUS
215      );
216      TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "TASK_START OF TA3" );
217
218      RTEMS.TASK_DELETE( RTEMS.SELF, STATUS );
219      TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "TASK_DELETE OF SELF" );
220
221   end INIT;
222
223--PAGE
224--
225--  PRIORITY_TEST_DRIVER
226--
227
228   procedure PRIORITY_TEST_DRIVER (
229      PRIORITY_BASE : in     RTEMS.UNSIGNED32
230   ) is 
231      PREVIOUS_PRIORITY : RTEMS.TASK_PRIORITY;
232      STATUS            : RTEMS.STATUS_CODES;
233   begin
234
235      for INDEX in 1 .. 5
236      loop
237
238         case INDEX is
239            when 1 | 2 | 3 => 
240               SPTEST.TASK_PRIORITY( INDEX )  := 
241                  PRIORITY_BASE + RTEMS.TASK_PRIORITY( INDEX );
242            when others    => 
243               SPTEST.TASK_PRIORITY( INDEX )  := PRIORITY_BASE + 3;
244         end case;
245
246         RTEMS.TASK_CREATE( 
247            SPTEST.PRIORITY_TASK_NAME( INDEX ), 
248            SPTEST.TASK_PRIORITY( INDEX ), 
249            2048, 
250            RTEMS.DEFAULT_MODES,
251            RTEMS.DEFAULT_ATTRIBUTES,
252            SPTEST.PRIORITY_TASK_ID( INDEX ),
253            STATUS
254         );
255         TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "TASK_CREATE LOOP" );
256
257      end loop;
258
259      if PRIORITY_BASE = 0 then
260
261         for INDEX in 1 .. 5
262         loop
263
264            RTEMS.TASK_START( 
265               SPTEST.PRIORITY_TASK_ID( INDEX ),
266               SPTEST.PRIORITY_TASK'ACCESS,
267               RTEMS.TASK_ARGUMENT( INDEX ), 
268               STATUS
269            );
270            TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "TASK_START LOOP" );
271     
272         end loop;
273
274      else
275
276         for INDEX in reverse 1 .. 5
277         loop
278
279            RTEMS.TASK_START( 
280               SPTEST.PRIORITY_TASK_ID( INDEX ),
281               SPTEST.PRIORITY_TASK'ACCESS,
282               RTEMS.TASK_ARGUMENT( INDEX ), 
283               STATUS
284            );
285            TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "TASK_START LOOP" );
286     
287            RTEMS.TASK_WAKE_AFTER( TEST_SUPPORT.TICKS_PER_SECOND, STATUS );
288            TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "TASK_WAKE_AFTER LOOP" );
289
290            if PRIORITY_BASE = 64 then
291               if INDEX = 4 then
292                  RTEMS.TASK_SET_PRIORITY( 
293                     SPTEST.PRIORITY_TASK_ID( 5 ),
294                     PRIORITY_BASE + 4,
295                     PREVIOUS_PRIORITY,
296                     STATUS
297                  );
298                  TEXT_IO.PUT( "PDRV - change priority of PRI5 from " );
299                  UNSIGNED32_IO.PUT( PREVIOUS_PRIORITY );
300                  TEXT_IO.PUT( " to " );
301                  UNSIGNED32_IO.PUT( PRIORITY_BASE + 4 );
302                  TEXT_IO.NEW_LINE;
303                  TEST_SUPPORT.DIRECTIVE_FAILED( 
304                     STATUS, 
305                     "PDRV TASK_SET_PRIORITY" 
306                  );
307               end if;
308
309               RTEMS.TASK_SET_PRIORITY( 
310                  SPTEST.PRIORITY_TASK_ID( 5 ),
311                  RTEMS.CURRENT_PRIORITY,
312                  PREVIOUS_PRIORITY,
313                  STATUS
314               );
315               TEXT_IO.PUT( "PDRV - priority of PRI5 is " );
316               UNSIGNED32_IO.PUT( PREVIOUS_PRIORITY );
317               TEXT_IO.NEW_LINE;
318               TEST_SUPPORT.DIRECTIVE_FAILED( 
319                  STATUS, 
320                  "PDRV TASK_SET_PRIORITY" 
321               );
322            end if;
323
324         end loop;
325
326      end if;
327
328      RTEMS.TASK_WAKE_AFTER( TEST_SUPPORT.TICKS_PER_SECOND, STATUS );
329      TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "TASK_WAKE_AFTER AFTER LOOP" );
330
331      if PRIORITY_BASE = 0 then
332         for INDEX in 1 .. 5
333         loop
334
335            RTEMS.SEMAPHORE_RELEASE( 
336               SPTEST.SEMAPHORE_ID( 2 ),
337               STATUS
338            );
339            TEST_SUPPORT.DIRECTIVE_FAILED( 
340               STATUS,
341               "SEMAPHORE_RELEASE LOOP"
342            );
343
344         end loop;
345      end if;
346
347      if PRIORITY_BASE = 64 then
348
349         TEXT_IO.PUT_LINE( "PDRV - task_resume - PRI5" );
350         RTEMS.TASK_RESUME( SPTEST.PRIORITY_TASK_ID( 5 ), STATUS );
351         TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "TASK_RESUME" );
352
353         RTEMS.TASK_WAKE_AFTER( TEST_SUPPORT.TICKS_PER_SECOND, STATUS );
354         TEST_SUPPORT.DIRECTIVE_FAILED( 
355           STATUS, 
356           "TASK_WAKE_AFTER SO PRI5 can run" 
357         );
358
359         RTEMS.TASK_DELETE( SPTEST.PRIORITY_TASK_ID( 5 ), STATUS );
360         TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "TASK_DELETE OF PRI5" );
361      else
362
363         for INDEX in 1 .. 5
364         loop
365
366            RTEMS.TASK_DELETE( 
367               SPTEST.PRIORITY_TASK_ID( INDEX ),
368               STATUS
369            );
370            TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "TASK_DELETE LOOP" );
371
372         end loop;
373      end if;
374
375
376   end PRIORITY_TEST_DRIVER;
377
378--PAGE
379--
380--  PRIORITY_TASK
381--
382
383   procedure PRIORITY_TASK (
384      ITS_INDEX : in     RTEMS.TASK_ARGUMENT
385   ) is 
386      TIMEOUT          : RTEMS.INTERVAL;
387      ITS_PRIORITY     : RTEMS.TASK_PRIORITY;
388      CURRENT_PRIORITY : RTEMS.TASK_PRIORITY;
389      STATUS           : RTEMS.STATUS_CODES;
390   begin
391
392      ITS_PRIORITY := SPTEST.TASK_PRIORITY( INTEGER( ITS_INDEX ) );
393
394      if ITS_PRIORITY < 3 then
395         TIMEOUT := 5 * TEST_SUPPORT.TICKS_PER_SECOND;
396      else
397         TIMEOUT := RTEMS.NO_TIMEOUT;
398      end if;
399
400      TEST_SUPPORT.PUT_NAME( PRIORITY_TASK_NAME( INTEGER(ITS_INDEX) ), FALSE );
401      TEXT_IO.PUT_LINE( " - semaphore_obtain - wait forever on SM2" );
402   
403      RTEMS.SEMAPHORE_OBTAIN( 
404         SPTEST.SEMAPHORE_ID( 2 ), 
405         RTEMS.DEFAULT_OPTIONS, 
406         TIMEOUT, 
407         STATUS
408      );
409      TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "SEMAPHORE_OBTAIN OF SM2" );
410
411      if ITS_PRIORITY < 64 then
412         TEXT_IO.PUT( "PRI" );
413         UNSIGNED32_IO.PUT( ITS_INDEX );
414         TEXT_IO.PUT( " - WHY AM I HERE? (priority = " );
415         UNSIGNED32_IO.PUT( ITS_PRIORITY );
416         TEXT_IO.PUT_LINE( " )" );
417         RTEMS.SHUTDOWN_EXECUTIVE( 0 );
418      end if;
419
420      if ITS_INDEX = 5 then
421         TEXT_IO.PUT_LINE(
422            "PRI5 - task_suspend - until all priority tasks blocked" 
423         );
424      end if;
425
426      RTEMS.TASK_SUSPEND( RTEMS.SELF, STATUS );
427      TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "TASK_SUSPEND" );
428
429      TEXT_IO.PUT_LINE( "PRI5 - task_delete - all tasks waiting on SM2" );
430      for INDEX in 1 .. 4 
431      loop
432
433         RTEMS.TASK_DELETE(  SPTEST.PRIORITY_TASK_ID( INDEX ), STATUS );
434         TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "TASK_DELETE LOOP" );
435
436      end loop;
437
438      TEXT_IO.PUT_LINE( "PRI5 - semaphore_obtain - nested" );
439      RTEMS.SEMAPHORE_OBTAIN( 
440         SPTEST.SEMAPHORE_ID( 2 ), 
441         RTEMS.DEFAULT_OPTIONS, 
442         TIMEOUT, 
443         STATUS
444      );
445      TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "SEMAPHORE_OBTAIN NESTED" );
446
447      TEXT_IO.PUT_LINE( "PRI5 - semaphore_release - nested" );
448      RTEMS.SEMAPHORE_RELEASE( SPTEST.SEMAPHORE_ID( 2 ), STATUS );
449      TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "SEMAPHORE_RELEASE NESTED" );
450
451      TEXT_IO.PUT_LINE( "PRI5 - semaphore_release - restore priority" );
452      RTEMS.SEMAPHORE_RELEASE( SPTEST.SEMAPHORE_ID( 2 ), STATUS );
453      TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "SEMAPHORE_RELEASE" );
454
455      RTEMS.TASK_SET_PRIORITY( 
456         SPTEST.PRIORITY_TASK_ID( 5 ),
457         RTEMS.CURRENT_PRIORITY,
458         CURRENT_PRIORITY,
459         STATUS
460      );
461      TEXT_IO.PUT( "PRI5 - priority of PRI5 is " );
462      UNSIGNED32_IO.PUT( CURRENT_PRIORITY );
463      TEXT_IO.NEW_LINE;
464      TEST_SUPPORT.DIRECTIVE_FAILED( 
465         STATUS, 
466         "PRI5 TASK_SET_PRIORITY CURRENT" 
467      );
468      RTEMS.TASK_SUSPEND( RTEMS.SELF, STATUS );
469
470   end PRIORITY_TASK;
471   
472--PAGE
473--
474--  TASK_1
475--
476
477   procedure TASK_1 (
478      ARGUMENT : in     RTEMS.TASK_ARGUMENT
479   ) is
480      SMID   : RTEMS.ID;
481      STATUS : RTEMS.STATUS_CODES;
482   begin
483
484      RTEMS.SEMAPHORE_IDENT( 
485         SPTEST.SEMAPHORE_NAME( 1 ), 
486         RTEMS.SEARCH_ALL_NODES, 
487         SMID, 
488         STATUS
489      );
490      TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "SEMAPHORE_IDENT OF SM1" );
491      TEXT_IO.PUT( "TA1 - semaphore_ident - smid => " );
492      UNSIGNED32_IO.PUT( SMID, WIDTH => 8, BASE => 16 );
493      TEXT_IO.NEW_LINE;
494
495      TEXT_IO.PUT_LINE( "TA1 - semaphore_obtain - wait forever on SM2" );
496      RTEMS.SEMAPHORE_OBTAIN( 
497         SPTEST.SEMAPHORE_ID( 2 ),
498         RTEMS.DEFAULT_MODES, 
499         RTEMS.NO_TIMEOUT,
500         STATUS
501      );
502      TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "SEMAPHORE_OBTAIN ON SM2" );
503     
504      TEXT_IO.PUT_LINE( "TA1 - got SM2" );
505
506      TEXT_IO.PUT_LINE( "TA1 - semaphore_obtain - wait forever on SM3" );
507      RTEMS.SEMAPHORE_OBTAIN( 
508         SPTEST.SEMAPHORE_ID( 3 ),
509         RTEMS.DEFAULT_MODES, 
510         RTEMS.NO_TIMEOUT,
511         STATUS
512      );
513      TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "SEMAPHORE_OBTAIN ON SM3" );
514     
515      TEXT_IO.PUT_LINE( "TA1 - got SM3" );
516   
517      TEXT_IO.PUT_LINE( "TA1 - semaphore_obtain - get SM1 - NO_WAIT" );
518      RTEMS.SEMAPHORE_OBTAIN( 
519         SPTEST.SEMAPHORE_ID( 1 ),
520         RTEMS.NO_WAIT, 
521         RTEMS.NO_TIMEOUT,
522         STATUS
523      );
524      TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "SEMAPHORE_OBTAIN ON SM1" );
525     
526      TEXT_IO.PUT_LINE( "TA1 - got SM1" );
527
528      TEXT_IO.PUT_LINE( "TA1 - task_wake_after - sleep 5 seconds" );
529      RTEMS.TASK_WAKE_AFTER( 5 * TEST_SUPPORT.TICKS_PER_SECOND, STATUS );
530      TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "TASK_WAKE_AFTER" );
531
532TEST_SUPPORT.PAUSE;
533
534      TEXT_IO.PUT_LINE( "TA1 - semaphore_release - release SM1" );
535      RTEMS.SEMAPHORE_RELEASE( SPTEST.SEMAPHORE_ID( 1 ), STATUS );
536      TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "SEMAPHORE_RELEASE ON SM1" );
537     
538      TEXT_IO.PUT_LINE( 
539         "TA1 - semaphore_obtain - waiting for SM1 with 10 second timeout"
540      );
541      RTEMS.SEMAPHORE_OBTAIN( 
542         SPTEST.SEMAPHORE_ID( 1 ),
543         RTEMS.DEFAULT_MODES, 
544         10 * TEST_SUPPORT.TICKS_PER_SECOND,
545         STATUS
546      );
547      TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "SEMAPHORE_OBTAIN ON SM3" );
548     
549      TEXT_IO.PUT_LINE( "TA1 - got SM1" );
550   
551      TEXT_IO.PUT_LINE( "TA1 - semaphore_release - release SM2" );
552      RTEMS.SEMAPHORE_RELEASE( 
553         SPTEST.SEMAPHORE_ID( 2 ),
554         STATUS
555      );
556      TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "SEMAPHORE_RELEASE ON SM2" );
557
558      TEXT_IO.PUT_LINE( "TA1 - task_wake_after - sleep 5 seconds" );
559      RTEMS.TASK_WAKE_AFTER( 5 * TEST_SUPPORT.TICKS_PER_SECOND, STATUS );
560      TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "TASK_WAKE_AFTER" );
561
562TEST_SUPPORT.PAUSE;
563
564      TEXT_IO.PUT_LINE( "TA1 - task_delete - delete TA3" );
565      RTEMS.TASK_DELETE( SPTEST.TASK_ID( 3 ), STATUS );
566      TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "TASK_DELETE OF TA3" );
567
568      RTEMS.TASK_CREATE( 
569         SPTEST.TASK_NAME( 4 ), 
570         4, 
571         2048, 
572         RTEMS.DEFAULT_MODES,
573         RTEMS.DEFAULT_ATTRIBUTES,
574         SPTEST.TASK_ID( 4 ),
575         STATUS
576      );
577      TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "TASK_CREATE OF TA4" );
578
579      RTEMS.TASK_CREATE( 
580         SPTEST.TASK_NAME( 5 ), 
581         4, 
582         2048, 
583         RTEMS.DEFAULT_MODES,
584         RTEMS.DEFAULT_ATTRIBUTES,
585         SPTEST.TASK_ID( 5 ),
586         STATUS
587      );
588      TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "TASK_CREATE OF TA5" );
589
590      RTEMS.TASK_START(
591         SPTEST.TASK_ID( 4 ),
592         SPTEST.TASK_4'ACCESS,
593         0,
594         STATUS
595      );
596      TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "TASK_START OF TA4" );
597
598      RTEMS.TASK_START(
599         SPTEST.TASK_ID( 5 ),
600         SPTEST.TASK_5'ACCESS,
601         0,
602         STATUS
603      );
604      TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "TASK_START OF TA5" );
605
606      TEXT_IO.PUT_LINE( "TA1 - task_wake_after - sleep 5 seconds" );
607      RTEMS.TASK_WAKE_AFTER( 5 * TEST_SUPPORT.TICKS_PER_SECOND, STATUS );
608      TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "TASK_WAKE_AFTER" );
609
610      TEXT_IO.PUT_LINE( "TA1 - task_delete - delete TA4" );
611      RTEMS.TASK_DELETE( SPTEST.TASK_ID( 4 ), STATUS );
612      TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "TASK_DELETE OF TA4" );
613
614      TEXT_IO.PUT_LINE( "TA1 - semaphore_release - release SM1" );
615      RTEMS.SEMAPHORE_RELEASE( 
616         SPTEST.SEMAPHORE_ID( 1 ),
617         STATUS
618      );
619      TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "SEMAPHORE_RELEASE ON SM1" );
620
621      TEXT_IO.PUT_LINE( "TA1 - task_wake_after - sleep 5 seconds" );
622      RTEMS.TASK_WAKE_AFTER( 5 * TEST_SUPPORT.TICKS_PER_SECOND, STATUS );
623      TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "TASK_WAKE_AFTER" );
624
625      TEXT_IO.PUT_LINE( "TA1 - semaphore_delete - delete SM1" );
626      RTEMS.SEMAPHORE_DELETE( SPTEST.SEMAPHORE_ID( 1 ), STATUS );
627      TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "SEMAPHORE_DELETE OF SM1" );
628
629      TEXT_IO.PUT_LINE( "TA1 - semaphore_delete - delete SM3" );
630      RTEMS.SEMAPHORE_DELETE( SPTEST.SEMAPHORE_ID( 3 ), STATUS );
631      TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "SEMAPHORE_DELETE OF SM3" );
632
633      TEXT_IO.PUT_LINE( "TA1 - task_delete - delete self" );
634      RTEMS.TASK_DELETE( RTEMS.SELF, STATUS );
635      TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "TASK_DELETE OF TA1" );
636
637   end TASK_1;
638
639--PAGE
640--
641--  TASK_2
642--
643
644   procedure TASK_2 (
645      ARGUMENT : in    RTEMS.TASK_ARGUMENT
646   ) is
647      STATUS            : RTEMS.STATUS_CODES;
648      PREVIOUS_PRIORITY : RTEMS.TASK_PRIORITY;
649   begin
650 
651      TEXT_IO.PUT_LINE( "TA2 - semaphore_obtain - wait forever on SM1" );
652      RTEMS.SEMAPHORE_OBTAIN( 
653         SPTEST.SEMAPHORE_ID( 1 ),
654         RTEMS.DEFAULT_MODES, 
655         RTEMS.NO_TIMEOUT,
656         STATUS
657      );
658      TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "SEMAPHORE_OBTAIN ON SM1" );
659     
660      TEXT_IO.PUT_LINE( "TA2 - got SM1" );
661   
662      TEXT_IO.PUT_LINE( "TA2 - semaphore_release - release SM1" );
663      RTEMS.SEMAPHORE_RELEASE( 
664         SPTEST.SEMAPHORE_ID( 1 ),
665         STATUS
666      );
667      TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "SEMAPHORE_RELEASE ON SM1" );
668
669      TEXT_IO.PUT_LINE( 
670         "TA2 - task_set_priority - make self highest priority task" 
671      );
672      RTEMS.TASK_SET_PRIORITY(
673         RTEMS.SELF,
674         3,
675         PREVIOUS_PRIORITY,
676         STATUS
677      );
678      TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "TASK_SET_PRIORITY ON TA2" );
679     
680      TEXT_IO.PUT_LINE( "TA2 - semaphore_obtain - wait forever on SM2" );
681      RTEMS.SEMAPHORE_OBTAIN( 
682         SPTEST.SEMAPHORE_ID( 2 ),
683         RTEMS.DEFAULT_MODES, 
684         RTEMS.NO_TIMEOUT,
685         STATUS
686      );
687      TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "SEMAPHORE_OBTAIN ON SM2" );
688     
689      TEXT_IO.PUT_LINE( "TA2 - got SM2" );
690   
691      TEXT_IO.PUT_LINE( "TA2 - semaphore_release - release SM2" );
692      RTEMS.SEMAPHORE_RELEASE( 
693         SPTEST.SEMAPHORE_ID( 2 ),
694         STATUS
695      );
696      TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "SEMAPHORE_RELEASE ON SM2" );
697   
698      TEXT_IO.PUT_LINE( "TA2 - task_delete - delete self" );
699      RTEMS.TASK_DELETE( RTEMS.SELF, STATUS );
700      TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "TASK_DELETE OF TA2" );
701
702   end TASK_2;
703
704--PAGE
705--
706--  TASK_3
707--
708
709   procedure TASK_3 (
710      ARGUMENT : in    RTEMS.TASK_ARGUMENT
711   ) is
712      STATUS : RTEMS.STATUS_CODES;
713   begin
714 
715      TEXT_IO.PUT_LINE( "TA3 - semaphore_obtain - wait forever on SM2" );
716      RTEMS.SEMAPHORE_OBTAIN( 
717         SPTEST.SEMAPHORE_ID( 2 ),
718         RTEMS.DEFAULT_MODES, 
719         RTEMS.NO_TIMEOUT,
720         STATUS
721      );
722      TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "SEMAPHORE_OBTAIN ON SM2" );
723      TEXT_IO.PUT_LINE( "TA3 - got SM2" );
724   
725      TEXT_IO.PUT_LINE( "TA3 - semaphore_release - release SM2" );
726      RTEMS.SEMAPHORE_RELEASE( 
727         SPTEST.SEMAPHORE_ID( 2 ),
728         STATUS
729      );
730      TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "SEMAPHORE_RELEASE ON SM2" );
731   
732      TEXT_IO.PUT_LINE( "TA3 - semaphore_obtain - wait forever on SM3" );
733      RTEMS.SEMAPHORE_OBTAIN( 
734         SPTEST.SEMAPHORE_ID( 3 ),
735         RTEMS.DEFAULT_MODES, 
736         RTEMS.NO_TIMEOUT,
737         STATUS
738      );
739      TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "SEMAPHORE_OBTAIN ON SM3" );
740     
741   end TASK_3;
742
743--PAGE
744--
745--  TASK_4
746--
747
748   procedure TASK_4 (
749      ARGUMENT : in    RTEMS.TASK_ARGUMENT
750   ) is
751      STATUS : RTEMS.STATUS_CODES;
752   begin
753 
754      TEXT_IO.PUT_LINE( "TA4 - semaphore_obtain - wait forever on SM1" );
755      RTEMS.SEMAPHORE_OBTAIN( 
756         SPTEST.SEMAPHORE_ID( 1 ),
757         RTEMS.DEFAULT_MODES, 
758         RTEMS.NO_TIMEOUT,
759         STATUS
760      );
761      TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "SEMAPHORE_OBTAIN ON SM1" );
762     
763   end TASK_4;
764
765--PAGE
766--
767--  TASK_5
768--
769
770   procedure TASK_5 (
771      ARGUMENT : in    RTEMS.TASK_ARGUMENT
772   ) is
773      STATUS : RTEMS.STATUS_CODES;
774   begin
775 
776      TEXT_IO.PUT_LINE( "TA5 - semaphore_obtain - wait forever on SM1" );
777      RTEMS.SEMAPHORE_OBTAIN( 
778         SPTEST.SEMAPHORE_ID( 1 ),
779         RTEMS.DEFAULT_MODES, 
780         RTEMS.NO_TIMEOUT,
781         STATUS
782      );
783      TEST_SUPPORT.DIRECTIVE_FAILED( STATUS, "SEMAPHORE_OBTAIN ON SM1" );
784     
785      TEXT_IO.PUT_LINE( "TA5 - got SM1" );
786   
787      TEXT_IO.PUT_LINE( "TA5 - semaphore_obtain - wait forever on SM1" );
788      RTEMS.SEMAPHORE_OBTAIN( 
789         SPTEST.SEMAPHORE_ID( 1 ),
790         RTEMS.DEFAULT_MODES, 
791         RTEMS.NO_TIMEOUT,
792         STATUS
793      );
794      TEST_SUPPORT.FATAL_DIRECTIVE_STATUS( 
795         STATUS, 
796         RTEMS.OBJECT_WAS_DELETED, 
797         "SEMAPHORE_OBTAIN ON SM1" 
798      );
799      TEXT_IO.PUT_LINE( "TA5 - SM1 deleted by TA1" );
800   
801      TEXT_IO.PUT_LINE( "*** END OF TEST 12 ***" );
802      RTEMS.SHUTDOWN_EXECUTIVE( 0 );
803   
804   end TASK_5;
805
806end SPTEST;
Note: See TracBrowser for help on using the repository browser.