|
0
|
1 //=========================================================================== |
|
|
2 // |
|
2
|
3 // test1.c |
|
0
|
4 // |
|
2
|
5 // uITRON "C" test program one |
|
0
|
6 // |
|
|
7 //=========================================================================== |
|
|
8 //####COPYRIGHTBEGIN#### |
|
|
9 // |
|
|
10 // ------------------------------------------- |
|
|
11 // The contents of this file are subject to the Cygnus eCos Public License |
|
|
12 // Version 1.0 (the "License"); you may not use this file except in |
|
|
13 // compliance with the License. You may obtain a copy of the License at |
|
|
14 // http://sourceware.cygnus.com/ecos |
|
|
15 // |
|
|
16 // Software distributed under the License is distributed on an "AS IS" |
|
|
17 // basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See the |
|
|
18 // License for the specific language governing rights and limitations under |
|
|
19 // the License. |
|
|
20 // |
|
|
21 // The Original Code is eCos - Embedded Cygnus Operating System, released |
|
|
22 // September 30, 1998. |
|
|
23 // |
|
|
24 // The Initial Developer of the Original Code is Cygnus. Portions created |
|
2
|
25 // by Cygnus are Copyright (C) 1998,1999 Cygnus Solutions. All Rights Reserved. |
|
0
|
26 // ------------------------------------------- |
|
|
27 // |
|
|
28 //####COPYRIGHTEND#### |
|
|
29 //=========================================================================== |
|
|
30 //#####DESCRIPTIONBEGIN#### |
|
|
31 // |
|
2
|
32 // Author(s): hmt |
|
|
33 // Contributors: hmt |
|
|
34 // Date: 1998-03-13 |
|
|
35 // Purpose: uITRON API testing |
|
|
36 // Description: |
|
0
|
37 // |
|
|
38 //####DESCRIPTIONEND#### |
|
|
39 // |
|
|
40 //=========================================================================== |
|
|
41 |
|
|
42 #include <pkgconf/uitron.h> // uITRON setup CYGNUM_UITRON_SEMAS |
|
|
43 // CYGPKG_UITRON et al |
|
|
44 #include <cyg/infra/testcase.h> // testing infrastructure |
|
|
45 |
|
|
46 #ifdef CYGPKG_UITRON // we DO want the uITRON package |
|
|
47 |
|
|
48 #ifdef CYGSEM_KERNEL_SCHED_MLQUEUE // we DO want prioritized threads |
|
|
49 |
|
|
50 #ifdef CYGFUN_KERNEL_THREADS_TIMER // we DO want timout-able calls |
|
|
51 |
|
|
52 #ifdef CYGVAR_KERNEL_COUNTERS_CLOCK // we DO want the realtime clock |
|
|
53 |
|
|
54 // we're OK if it's C++ or neither of those two is defined: |
|
|
55 #if defined( __cplusplus ) || \ |
|
|
56 (!defined( CYGIMP_UITRON_INLINE_FUNCS ) && \ |
|
|
57 !defined( CYGIMP_UITRON_CPP_OUTLINE_FUNCS) ) |
|
|
58 |
|
|
59 // =================== TEST CONFIGURATION =================== |
|
|
60 #if \ |
|
|
61 /* test configuration for enough tasks */ \ |
|
|
62 (CYGNUM_UITRON_TASKS >= 4) && \ |
|
|
63 (CYGNUM_UITRON_TASKS < 90) && \ |
|
|
64 (CYGNUM_UITRON_START_TASKS == 1) && \ |
|
|
65 ( !defined(CYGPKG_UITRON_TASKS_CREATE_DELETE) || \ |
|
|
66 CYGNUM_UITRON_TASKS_INITIALLY >= 4 ) && \ |
|
|
67 \ |
|
|
68 /* the end of the large #if statement */ \ |
|
|
69 1 |
|
|
70 |
|
|
71 // ============================ END ============================ |
|
|
72 |
|
|
73 |
|
|
74 |
|
|
75 #include <cyg/compat/uitron/uit_func.h> // uITRON |
|
|
76 |
|
|
77 externC void |
|
|
78 cyg_package_start( void ) |
|
|
79 { |
|
|
80 CYG_TEST_INIT(); |
|
|
81 CYG_TEST_INFO( "Calling cyg_uitron_start()" ); |
|
|
82 cyg_uitron_start(); |
|
|
83 } |
|
|
84 |
|
|
85 volatile int intercom = 0; |
|
|
86 volatile int intercount = 0; |
|
|
87 INT scratch = 0; |
|
|
88 |
|
|
89 #ifndef CYGSEM_KERNEL_SCHED_TIMESLICE |
|
|
90 #define TIMESLICEMSG "Assuming no kernel timeslicing" |
|
2
|
91 #define TSGO() (1) |
|
|
92 #define TSRELEASE() CYG_EMPTY_STATEMENT |
|
|
93 #define TSSTOP() CYG_EMPTY_STATEMENT |
|
|
94 #define TSLOCK() CYG_EMPTY_STATEMENT |
|
|
95 #define TSUNLOCK() CYG_EMPTY_STATEMENT |
|
|
96 #define ICWAIT( _i_ ) CYG_EMPTY_STATEMENT |
|
0
|
97 |
|
|
98 #else |
|
|
99 // Now follow some nasty bodges to control the scheduling when basically it |
|
|
100 // isn't controlled ie. timeslicing is on. It's bodgy because we're |
|
|
101 // testing normal synchronization methods, so we shouldn't rely on them for |
|
|
102 // comms between threads here. Instead there's a mixture of communicating |
|
|
103 // via a flag (ts_interlock) which stops the "controlled" thread running |
|
|
104 // away, and waiting for the controlled thread to run enough for us. |
|
|
105 // |
|
|
106 // Tasks 3 and 4 are waited for by the control task: task 3 locks the |
|
|
107 // scheduler so is immediately descheduled when it unlocks it, task 4 does |
|
|
108 // waiting-type operations, so we must give it chance to run by yielding a |
|
|
109 // few times ourselves. Note the plain constant in ICWAIT() below. |
|
|
110 |
|
|
111 #define TIMESLICEMSG "Assuming kernel timeslicing ENABLED" |
|
|
112 volatile int ts_interlock = 0; |
|
2
|
113 #define TSGO() (ts_interlock) |
|
|
114 #define TSRELEASE() ts_interlock = 1 |
|
|
115 #define TSSTOP() ts_interlock = 0 |
|
0
|
116 |
|
2
|
117 #define TSLOCK() CYG_MACRO_START \ |
|
|
118 ER ercd2 = dis_dsp(); \ |
|
|
119 CYG_TEST_CHECK( E_OK == ercd2, "dis_dsp (TSLOCK) bad ercd2" ); \ |
|
0
|
120 CYG_MACRO_END |
|
|
121 |
|
2
|
122 #define TSUNLOCK() CYG_MACRO_START \ |
|
|
123 ER ercd3 = ena_dsp(); \ |
|
|
124 CYG_TEST_CHECK( E_OK == ercd3, "ena_dsp (TSUNLOCK) bad ercd3" ); \ |
|
0
|
125 CYG_MACRO_END |
|
|
126 |
|
2
|
127 #define ICWAIT( _i_ ) CYG_MACRO_START \ |
|
|
128 int loops; \ |
|
|
129 for ( loops = 3; (0 < loops) || ((_i_) > intercount); loops-- ) { \ |
|
|
130 ER ercd4 = rot_rdq( 0 ); /* yield */ \ |
|
|
131 CYG_TEST_CHECK( E_OK == ercd4, "rot_rdq (ICWAIT) bad ercd4" ); \ |
|
|
132 } \ |
|
0
|
133 CYG_MACRO_END |
|
|
134 #endif // CYGSEM_KERNEL_SCHED_TIMESLICE |
|
|
135 |
|
|
136 /* |
|
|
137 #define IC() \ |
|
|
138 CYG_MACRO_START \ |
|
|
139 static char *msgs[] = { "ZERO", "ONE", "TWO", "THREE", "FOUR", "LOTS" }; \ |
|
|
140 CYG_TEST_INFO( msgs[ intercount > 5 ? 5 : intercount ] ); \ |
|
|
141 CYG_MACRO_END |
|
|
142 */ |
|
|
143 |
|
|
144 // #define CYG_TEST_UITRON_TEST1_LOOPING 1 |
|
|
145 |
|
|
146 void task1( unsigned int arg ) |
|
|
147 { |
|
|
148 ER ercd; |
|
|
149 T_RTSK ref_tskd; |
|
|
150 |
|
|
151 #ifdef CYG_TEST_UITRON_TEST1_LOOPING |
|
|
152 while ( 1 ) { |
|
|
153 #endif // CYG_TEST_UITRON_TEST1_LOOPING |
|
|
154 |
|
|
155 CYG_TEST_INFO( "Task 1 running" ); |
|
|
156 CYG_TEST_INFO( TIMESLICEMSG ); |
|
|
157 |
|
|
158 intercom = 0; |
|
|
159 intercount = 0; |
|
|
160 |
|
|
161 CYG_TEST_INFO( "Testing get_tid and ref_tsk" ); |
|
|
162 ercd = get_tid( &scratch ); |
|
|
163 CYG_TEST_CHECK( E_OK == ercd, "get_tid bad ercd" ); |
|
|
164 CYG_TEST_CHECK( 1 == scratch, "tid not 1" ); |
|
|
165 #ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS |
|
|
166 #ifndef CYGSEM_UITRON_PARAMS_NULL_IS_GOOD_PTR |
|
|
167 ercd = get_tid( NULL ); |
|
|
168 CYG_TEST_CHECK( E_PAR == ercd, "get_tid bad ercd !E_PAR" ); |
|
|
169 #endif |
|
|
170 ercd = get_tid( NADR ); |
|
|
171 CYG_TEST_CHECK( E_PAR == ercd, "get_tid bad ercd !E_PAR" ); |
|
|
172 ercd = ref_tsk( &ref_tskd, -6 ); |
|
|
173 CYG_TEST_CHECK( E_ID == ercd, "ref_tsk bad ercd !E_ID" ); |
|
|
174 ercd = ref_tsk( &ref_tskd, 99 ); |
|
|
175 CYG_TEST_CHECK( E_ID == ercd, "ref_tsk bad ercd !E_ID" ); |
|
|
176 #ifndef CYGSEM_UITRON_PARAMS_NULL_IS_GOOD_PTR |
|
|
177 ercd = ref_tsk( NULL, 1 ); |
|
|
178 CYG_TEST_CHECK( E_PAR == ercd, "ref_tsk bad ercd !E_PAR" ); |
|
|
179 #endif |
|
|
180 ercd = ref_tsk( NADR, 1 ); |
|
|
181 CYG_TEST_CHECK( E_PAR == ercd, "ref_tsk bad ercd !E_PAR" ); |
|
|
182 #endif // we can test bad param error returns |
|
|
183 ercd = ref_tsk( &ref_tskd, 1 ); |
|
|
184 CYG_TEST_CHECK( E_OK == ercd, "ref_tsk bad ercd" ); |
|
|
185 CYG_TEST_CHECK( TTS_RUN == ref_tskd.tskstat, "Bad task status 1" ); |
|
|
186 ercd = ref_tsk( &ref_tskd, 0 ); |
|
|
187 CYG_TEST_CHECK( E_OK == ercd, "ref_tsk bad ercd" ); |
|
|
188 CYG_TEST_CHECK( TTS_RUN == ref_tskd.tskstat, "Bad task status 0" ); |
|
|
189 ercd = ref_tsk( &ref_tskd, 2 ); |
|
|
190 CYG_TEST_CHECK( E_OK == ercd, "ref_tsk bad ercd" ); |
|
|
191 CYG_TEST_CHECK( TTS_DMT == ref_tskd.tskstat, "Bad task status 2" ); |
|
|
192 CYG_TEST_CHECK( 2 == ref_tskd.tskpri, "Bad task prio 2" ); |
|
|
193 |
|
|
194 ercd = rsm_tsk( 2 ); |
|
|
195 CYG_TEST_CHECK( E_OBJ == ercd, "rsm_tsk DMT bad ercd !E_OBJ" ); |
|
|
196 ercd = frsm_tsk( 2 ); |
|
|
197 CYG_TEST_CHECK( E_OBJ == ercd, "frsm_tsk DMT bad ercd !E_OBJ" ); |
|
|
198 ercd = rel_wai( 2 ); |
|
|
199 CYG_TEST_CHECK( E_OBJ == ercd, "rel_wai DMT bad ercd !E_OBJ" ); |
|
|
200 ercd = sus_tsk( 2 ); |
|
|
201 CYG_TEST_CHECK( E_OBJ == ercd, "sus_tsk DMT bad ercd !E_OBJ" ); |
|
|
202 ercd = wup_tsk( 2 ); |
|
|
203 CYG_TEST_CHECK( E_OBJ == ercd, "wup_tsk DMT bad ercd !E_OBJ" ); |
|
|
204 ercd = can_wup( &scratch, 2 ); |
|
|
205 CYG_TEST_CHECK( E_OBJ == ercd, "can_wup DMT bad ercd !E_OBJ" ); |
|
|
206 |
|
|
207 CYG_TEST_PASS( "get_tid, ref_tsk" ); |
|
|
208 |
|
|
209 CYG_TEST_INFO( "Testing prio change and start task" ); |
|
|
210 ercd = sta_tsk( 2, 99 ); |
|
|
211 CYG_TEST_CHECK( E_OK == ercd, "sta_tsk bad ercd" ); |
|
|
212 |
|
|
213 // drop pri of task 2 |
|
|
214 ercd = chg_pri( 2, 4 ); |
|
|
215 CYG_TEST_CHECK( E_OK == ercd, "chg_pri bad ercd" ); |
|
|
216 ercd = ref_tsk( &ref_tskd, 2 ); |
|
|
217 CYG_TEST_CHECK( E_OK == ercd, "ref_tsk bad ercd" ); |
|
|
218 CYG_TEST_CHECK( TTS_RDY == ref_tskd.tskstat, "Bad task status 2" ); |
|
|
219 CYG_TEST_CHECK( 4 == ref_tskd.tskpri, "Bad task prio 2" ); |
|
|
220 |
|
|
221 // drop our pri below task 2 |
|
|
222 ercd = chg_pri( 0, 5 ); |
|
|
223 CYG_TEST_CHECK( E_OK == ercd, "chg_pri bad ercd" ); |
|
|
224 |
|
|
225 ercd = ref_tsk( &ref_tskd, 1 ); |
|
|
226 CYG_TEST_CHECK( E_OK == ercd, "ref_tsk bad ercd" ); |
|
|
227 CYG_TEST_CHECK( 5 == ref_tskd.tskpri, "Bad task prio 1" ); |
|
|
228 ercd = ref_tsk( &ref_tskd, 0 ); |
|
|
229 CYG_TEST_CHECK( E_OK == ercd, "ref_tsk bad ercd" ); |
|
|
230 CYG_TEST_CHECK( 5 == ref_tskd.tskpri, "Bad task prio 0" ); |
|
|
231 ercd = ref_tsk( &ref_tskd, 2 ); |
|
|
232 CYG_TEST_CHECK( E_OK == ercd, "ref_tsk bad ercd" ); |
|
|
233 // it will have run to completion and regained its original prio |
|
|
234 CYG_TEST_CHECK( 2 == ref_tskd.tskpri, "Bad task prio 2" ); |
|
|
235 CYG_TEST_CHECK( TTS_DMT == ref_tskd.tskstat, "Bad task status 2" ); |
|
|
236 |
|
|
237 // retest these now that the task has executed once |
|
|
238 ercd = rsm_tsk( 2 ); |
|
|
239 CYG_TEST_CHECK( E_OBJ == ercd, "rsm_tsk DMT bad ercd !E_OBJ" ); |
|
|
240 ercd = frsm_tsk( 2 ); |
|
|
241 CYG_TEST_CHECK( E_OBJ == ercd, "frsm_tsk DMT bad ercd !E_OBJ" ); |
|
|
242 ercd = rel_wai( 2 ); |
|
|
243 CYG_TEST_CHECK( E_OBJ == ercd, "rel_wai DMT bad ercd !E_OBJ" ); |
|
|
244 ercd = sus_tsk( 2 ); |
|
|
245 CYG_TEST_CHECK( E_OBJ == ercd, "sus_tsk DMT bad ercd !E_OBJ" ); |
|
|
246 ercd = wup_tsk( 2 ); |
|
|
247 CYG_TEST_CHECK( E_OBJ == ercd, "wup_tsk DMT bad ercd !E_OBJ" ); |
|
|
248 ercd = can_wup( &scratch, 2 ); |
|
|
249 CYG_TEST_CHECK( E_OBJ == ercd, "can_wup DMT bad ercd !E_OBJ" ); |
|
|
250 |
|
|
251 #ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS |
|
|
252 ercd = chg_pri( -6, 9 ); |
|
|
253 CYG_TEST_CHECK( E_ID == ercd, "chg_pri bad ercd !E_ID" ); |
|
|
254 ercd = chg_pri( 99, 9 ); |
|
|
255 CYG_TEST_CHECK( E_ID == ercd, "chg_pri bad ercd !E_ID" ); |
|
|
256 ercd = sta_tsk( -6, 99 ); |
|
|
257 CYG_TEST_CHECK( E_ID == ercd, "sta_tsk bad ercd !E_ID" ); |
|
|
258 ercd = sta_tsk( 99, 99 ); |
|
|
259 CYG_TEST_CHECK( E_ID == ercd, "sta_tsk bad ercd !E_ID" ); |
|
|
260 #endif // we can test bad param error returns |
|
|
261 |
|
|
262 CYG_TEST_PASS( "sta_tsk, chg_pri" ); |
|
|
263 |
|
|
264 CYG_TEST_INFO( "Testing delay and dispatch disabling" ); |
|
|
265 ercd = dly_tsk( 10 ); |
|
|
266 CYG_TEST_CHECK( E_OK == ercd, "dly_tsk bad ercd" ); |
|
|
267 ercd = ena_dsp(); |
|
|
268 CYG_TEST_CHECK( E_OK == ercd, "ena_dsp bad ercd" ); |
|
|
269 ercd = dly_tsk( 10 ); |
|
|
270 CYG_TEST_CHECK( E_OK == ercd, "dly_tsk bad ercd" ); |
|
|
271 ercd = dis_dsp(); |
|
|
272 CYG_TEST_CHECK( E_OK == ercd, "dis_dsp bad ercd" ); |
|
|
273 #ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS |
|
|
274 ercd = dly_tsk( 10 ); |
|
|
275 CYG_TEST_CHECK( E_CTX == ercd, "dly_tsk bad ercd !E_CTX" ); |
|
|
276 ercd = dis_dsp(); |
|
|
277 CYG_TEST_CHECK( E_OK == ercd, "dis_dsp bad ercd" ); |
|
|
278 ercd = dly_tsk( 10 ); |
|
|
279 CYG_TEST_CHECK( E_CTX == ercd, "dly_tsk bad ercd !E_CTX" ); |
|
|
280 #endif // we can test bad param error returns |
|
|
281 ercd = ena_dsp(); |
|
|
282 CYG_TEST_CHECK( E_OK == ercd, "ena_dsp bad ercd" ); |
|
|
283 ercd = dly_tsk( 10 ); |
|
|
284 CYG_TEST_CHECK( E_OK == ercd, "dly_tsk bad ercd" ); |
|
|
285 ercd = ena_dsp(); |
|
|
286 CYG_TEST_CHECK( E_OK == ercd, "ena_dsp bad ercd" ); |
|
|
287 ercd = dly_tsk( 10 ); |
|
|
288 CYG_TEST_CHECK( E_OK == ercd, "dly_tsk bad ercd" ); |
|
|
289 |
|
|
290 CYG_TEST_PASS( "dly_tsk, ena_dsp, dis_dsp" ); |
|
|
291 |
|
|
292 CYG_TEST_INFO( "Testing ready queue manipulation" ); |
|
|
293 ercd = rot_rdq( 0 ); |
|
|
294 CYG_TEST_CHECK( E_OK == ercd, "rot_rdq bad ercd" ); |
|
|
295 ercd = rot_rdq( 4 ); |
|
|
296 CYG_TEST_CHECK( E_OK == ercd, "rot_rdq bad ercd" ); |
|
|
297 ercd = rot_rdq( 5 ); |
|
|
298 CYG_TEST_CHECK( E_OK == ercd, "rot_rdq bad ercd" ); |
|
|
299 #ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS |
|
|
300 ercd = rot_rdq( -6 ); |
|
|
301 CYG_TEST_CHECK( E_PAR == ercd, "rot_rdq bad ercd !E_PAR" ); |
|
|
302 ercd = rot_rdq( 99 ); |
|
|
303 CYG_TEST_CHECK( E_PAR == ercd, "rot_rdq bad ercd !E_PAR" ); |
|
|
304 #endif // we can test bad param error returns |
|
|
305 |
|
|
306 CYG_TEST_PASS( "rot_rdq" ); |
|
|
307 |
|
|
308 CYG_TEST_INFO( "Testing suspend/resume" ); |
|
|
309 #ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS |
|
|
310 ercd = sus_tsk( -6 ); |
|
|
311 CYG_TEST_CHECK( E_ID == ercd, "sus_tsk bad ercd !E_ID" ); |
|
|
312 ercd = sus_tsk( 99 ); |
|
|
313 CYG_TEST_CHECK( E_ID == ercd, "sus_tsk bad ercd !E_ID" ); |
|
|
314 ercd = rsm_tsk( -6 ); |
|
|
315 CYG_TEST_CHECK( E_ID == ercd, "rsm_tsk bad ercd !E_ID" ); |
|
|
316 ercd = rsm_tsk( 99 ); |
|
|
317 CYG_TEST_CHECK( E_ID == ercd, "rsm_tsk bad ercd !E_ID" ); |
|
|
318 ercd = frsm_tsk( -6 ); |
|
|
319 CYG_TEST_CHECK( E_ID == ercd, "frsm_tsk bad ercd !E_ID" ); |
|
|
320 ercd = frsm_tsk( 99 ); |
|
|
321 CYG_TEST_CHECK( E_ID == ercd, "frsm_tsk bad ercd !E_ID" ); |
|
|
322 #endif // we can test bad param error returns |
|
|
323 // drop task 3 pri to same as us |
|
|
324 CYG_TEST_CHECK( 0 == intercount, "intercount != 0" ); |
|
|
325 |
|
|
326 intercom = 3; // tell T3 to loop |
|
|
327 TSRELEASE(); |
|
|
328 ercd = dis_dsp(); |
|
|
329 CYG_TEST_CHECK( E_OK == ercd, "dis_dsp bad ercd" ); |
|
|
330 ercd = sta_tsk( 3, 66 ); |
|
|
331 CYG_TEST_CHECK( E_OK == ercd, "sta_tsk bad ercd" ); |
|
|
332 ercd = chg_pri( 3, 5 ); |
|
|
333 CYG_TEST_CHECK( E_OK == ercd, "chg_pri bad ercd" ); |
|
|
334 ercd = ena_dsp(); |
|
|
335 CYG_TEST_CHECK( E_OK == ercd, "ena_dsp bad ercd" ); |
|
|
336 |
|
|
337 ercd = rot_rdq( 0 ); |
|
|
338 CYG_TEST_CHECK( E_OK == ercd, "rot_rdq bad ercd" ); |
|
|
339 ICWAIT( 1 ); |
|
|
340 CYG_TEST_CHECK( 1 == intercount, "intercount != 1" ); |
|
|
341 ercd = sus_tsk( 3 ); |
|
|
342 TSRELEASE(); |
|
|
343 CYG_TEST_CHECK( E_OK == ercd, "sus_tsk bad ercd" ); |
|
|
344 intercom = 0; // bad data to T3 |
|
|
345 ercd = rot_rdq( 0 ); |
|
|
346 CYG_TEST_CHECK( E_OK == ercd, "rot_rdq bad ercd" ); |
|
|
347 CYG_TEST_CHECK( 1 == intercount, "intercount != 1" ); |
|
|
348 intercom = 3; // tell T3 to loop |
|
|
349 TSRELEASE(); |
|
|
350 ercd = rsm_tsk( 3 ); |
|
|
351 CYG_TEST_CHECK( E_OK == ercd, "rsm_tsk bad ercd" ); |
|
|
352 ercd = rot_rdq( 0 ); |
|
|
353 CYG_TEST_CHECK( E_OK == ercd, "rot_rdq bad ercd" ); |
|
|
354 ICWAIT( 2 ); |
|
|
355 CYG_TEST_CHECK( 2 == intercount, "intercount != 2" ); |
|
|
356 |
|
|
357 CYG_TEST_INFO( "Command task 3 inner loop stop" ); |
|
|
358 intercom = 2 + 4; |
|
|
359 TSRELEASE(); |
|
|
360 ercd = rot_rdq( 0 ); |
|
|
361 CYG_TEST_CHECK( E_OK == ercd, "rot_rdq bad ercd" ); |
|
|
362 CYG_TEST_CHECK( 2 == intercount, "intercount != 2" ); |
|
|
363 |
|
|
364 ercd = sus_tsk( 3 ); |
|
|
365 CYG_TEST_CHECK( E_OK == ercd, "sus_tsk bad ercd" ); |
|
|
366 intercom = 0; // bad data to T3 |
|
|
367 TSRELEASE(); |
|
|
368 ercd = rot_rdq( 0 ); |
|
|
369 CYG_TEST_CHECK( E_OK == ercd, "rot_rdq bad ercd" ); |
|
|
370 ercd = sus_tsk( 3 ); // suspend AGAIN |
|
|
371 CYG_TEST_CHECK( E_OK == ercd, "sus_tsk bad ercd" ); |
|
|
372 ercd = sus_tsk( 3 ); // AND AGAIN |
|
|
373 CYG_TEST_CHECK( E_OK == ercd, "sus_tsk bad ercd" ); |
|
|
374 TSRELEASE(); |
|
|
375 ercd = rot_rdq( 0 ); |
|
|
376 CYG_TEST_CHECK( E_OK == ercd, "rot_rdq bad ercd" ); |
|
|
377 CYG_TEST_CHECK( 2 == intercount, "intercount != 2" ); |
|
|
378 ercd = rsm_tsk( 3 ); |
|
|
379 CYG_TEST_CHECK( E_OK == ercd, "rsm_tsk bad ercd" ); |
|
|
380 ercd = rsm_tsk( 3 ); |
|
|
381 CYG_TEST_CHECK( E_OK == ercd, "rsm_tsk bad ercd" ); |
|
|
382 TSRELEASE(); |
|
|
383 ercd = rot_rdq( 0 ); |
|
|
384 CYG_TEST_CHECK( E_OK == ercd, "rot_rdq bad ercd" ); |
|
|
385 CYG_TEST_CHECK( 2 == intercount, "intercount != 2" ); |
|
|
386 intercom = 3; // tell T3 to loop |
|
|
387 TSRELEASE(); |
|
|
388 ercd = rsm_tsk( 3 ); // expect restart this time |
|
|
389 CYG_TEST_CHECK( E_OK == ercd, "rsm_tsk bad ercd" ); |
|
|
390 ercd = rot_rdq( 0 ); |
|
|
391 CYG_TEST_CHECK( E_OK == ercd, "rot_rdq bad ercd" ); |
|
|
392 ICWAIT( 3 ); |
|
|
393 CYG_TEST_CHECK( 3 == intercount, "intercount != 3" ); |
|
|
394 |
|
|
395 CYG_TEST_INFO( "Command task 3 inner loop stop 2" ); |
|
|
396 intercom = 2 + 4; |
|
|
397 TSRELEASE(); |
|
|
398 ercd = rot_rdq( 0 ); |
|
|
399 CYG_TEST_CHECK( E_OK == ercd, "rot_rdq bad ercd" ); |
|
|
400 CYG_TEST_CHECK( 3 == intercount, "intercount != 3" ); |
|
|
401 |
|
|
402 ercd = sus_tsk( 3 ); |
|
|
403 CYG_TEST_CHECK( E_OK == ercd, "sus_tsk bad ercd" ); |
|
|
404 intercom = 0; // bad data to T3 |
|
|
405 TSRELEASE(); |
|
|
406 ercd = rot_rdq( 0 ); |
|
|
407 CYG_TEST_CHECK( E_OK == ercd, "rot_rdq bad ercd" ); |
|
|
408 CYG_TEST_CHECK( 3 == intercount, "intercount != 3" ); |
|
|
409 ercd = sus_tsk( 3 ); // suspend AGAIN |
|
|
410 CYG_TEST_CHECK( E_OK == ercd, "sus_tsk bad ercd" ); |
|
|
411 ercd = sus_tsk( 3 ); // AND AGAIN |
|
|
412 CYG_TEST_CHECK( E_OK == ercd, "sus_tsk bad ercd" ); |
|
|
413 TSRELEASE(); |
|
|
414 ercd = rot_rdq( 0 ); |
|
|
415 CYG_TEST_CHECK( E_OK == ercd, "rot_rdq bad ercd" ); |
|
|
416 CYG_TEST_CHECK( 3 == intercount, "intercount != 3" ); |
|
|
417 intercom = 3; // tell T3 to loop |
|
|
418 TSRELEASE(); |
|
|
419 ercd = frsm_tsk( 3 ); // expect restart this time |
|
|
420 CYG_TEST_CHECK( E_OK == ercd, "frsm_tsk bad ercd" ); |
|
|
421 ercd = rot_rdq( 0 ); |
|
|
422 CYG_TEST_CHECK( E_OK == ercd, "rot_rdq bad ercd" ); |
|
|
423 ICWAIT( 4 ); |
|
|
424 CYG_TEST_CHECK( 4 == intercount, "intercount != 4" ); |
|
|
425 |
|
|
426 TSRELEASE(); |
|
|
427 ercd = rsm_tsk( 3 ); // try it again |
|
|
428 CYG_TEST_CHECK( E_OBJ == ercd, "rsm_tsk bad ercd !E_OBJ" ); |
|
|
429 ercd = rot_rdq( 0 ); |
|
|
430 CYG_TEST_CHECK( E_OK == ercd, "rot_rdq bad ercd" ); |
|
|
431 ICWAIT( 5 ); |
|
|
432 CYG_TEST_CHECK( 5 == intercount, "intercount != 5" ); |
|
|
433 |
|
|
434 TSRELEASE(); |
|
|
435 ercd = frsm_tsk( 3 ); // try it again |
|
|
436 CYG_TEST_CHECK( E_OBJ == ercd, "frsm_tsk bad ercd !E_OBJ" ); |
|
|
437 ercd = rot_rdq( 0 ); |
|
|
438 CYG_TEST_CHECK( E_OK == ercd, "rot_rdq bad ercd" ); |
|
|
439 ICWAIT( 6 ); |
|
|
440 CYG_TEST_CHECK( 6 == intercount, "intercount != 6" ); |
|
|
441 |
|
|
442 CYG_TEST_INFO( "Command task 3 all loops stop" ); |
|
|
443 intercom = 4 + 8; |
|
|
444 TSRELEASE(); |
|
|
445 ercd = rot_rdq( 0 ); |
|
|
446 CYG_TEST_CHECK( E_OK == ercd, "rot_rdq bad ercd" ); |
|
|
447 TSRELEASE(); |
|
|
448 ercd = rot_rdq( 0 ); |
|
|
449 CYG_TEST_CHECK( E_OK == ercd, "rot_rdq bad ercd" ); |
|
|
450 CYG_TEST_CHECK( 6 == intercount, "intercount != 6" ); |
|
|
451 |
|
|
452 intercom = intercount = 0; |
|
|
453 |
|
|
454 CYG_TEST_PASS( "sus_tsk, rsm_tsk, frsm_tsk" ); |
|
|
455 |
|
|
456 CYG_TEST_INFO( "Testing sleep/wakeup stuff" ); |
|
|
457 #ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS |
|
|
458 ercd = wup_tsk( -6 ); |
|
|
459 CYG_TEST_CHECK( E_ID == ercd, "wup_tsk bad ercd !E_ID" ); |
|
|
460 ercd = wup_tsk( 99 ); |
|
|
461 CYG_TEST_CHECK( E_ID == ercd, "wup_tsk bad ercd !E_ID" ); |
|
|
462 ercd = can_wup( &scratch, -6 ); |
|
|
463 CYG_TEST_CHECK( E_ID == ercd, "can_wup bad ercd !E_ID" ); |
|
|
464 ercd = can_wup( &scratch, 99 ); |
|
|
465 CYG_TEST_CHECK( E_ID == ercd, "can_wup bad ercd !E_ID" ); |
|
|
466 #ifndef CYGSEM_UITRON_PARAMS_NULL_IS_GOOD_PTR |
|
|
467 ercd = can_wup( NULL, 2 ); |
|
|
468 CYG_TEST_CHECK( E_PAR == ercd, "can_wup bad ercd !E_PAR" ); |
|
|
469 #endif |
|
|
470 ercd = can_wup( NADR, 2 ); |
|
|
471 CYG_TEST_CHECK( E_PAR == ercd, "can_wup bad ercd !E_PAR" ); |
|
|
472 |
|
|
473 ercd = wup_tsk( 0 ); // not ourself |
|
|
474 CYG_TEST_CHECK( E_ID == ercd, "wup_tsk bad ercd !E_ID" ); |
|
|
475 ercd = wup_tsk( 1 ); // ourself |
|
|
476 CYG_TEST_CHECK( E_OBJ == ercd, "wup_tsk bad ercd !E_OBJ" ); |
|
|
477 #endif // we can test bad param error returns |
|
|
478 |
|
|
479 #ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS |
|
|
480 ercd = tslp_tsk( -6 ); |
|
|
481 CYG_TEST_CHECK( E_PAR == ercd, "tslp_tsk bad ercd !E_PAR" ); |
|
|
482 #endif // we can test bad param error returns |
|
|
483 ercd = tslp_tsk( TMO_POL ); |
|
|
484 CYG_TEST_CHECK( E_TMOUT == ercd, "tslp_tsk bad ercd !E_TMOUT" ); |
|
|
485 ercd = tslp_tsk( 5 ); |
|
|
486 CYG_TEST_CHECK( E_TMOUT == ercd, "tslp_tsk bad ercd !E_TMOUT" ); |
|
|
487 #ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS |
|
|
488 ercd = dis_dsp(); |
|
|
489 CYG_TEST_CHECK( E_OK == ercd, "dis_dsp bad ercd" ); |
|
|
490 ercd = tslp_tsk( TMO_FEVR ); |
|
|
491 CYG_TEST_CHECK( E_CTX == ercd, "tslp_tsk bad ercd !E_CTX" ); |
|
|
492 ercd = tslp_tsk( TMO_POL ); |
|
|
493 CYG_TEST_CHECK( E_CTX == ercd, "tslp_tsk bad ercd !E_CTX" ); |
|
|
494 ercd = tslp_tsk( 5 ); |
|
|
495 CYG_TEST_CHECK( E_CTX == ercd, "tslp_tsk bad ercd !E_CTX" ); |
|
|
496 ercd = ena_dsp(); |
|
|
497 CYG_TEST_CHECK( E_OK == ercd, "ena_dsp bad ercd" ); |
|
|
498 ercd = tslp_tsk( -6 ); |
|
|
499 CYG_TEST_CHECK( E_PAR == ercd, "tslp_tsk bad ercd !E_PAR" ); |
|
|
500 #endif // we can test bad param error returns |
|
|
501 ercd = tslp_tsk( TMO_POL ); |
|
|
502 CYG_TEST_CHECK( E_TMOUT == ercd, "tslp_tsk bad ercd !E_TMOUT" ); |
|
|
503 ercd = tslp_tsk( 5 ); |
|
|
504 CYG_TEST_CHECK( E_TMOUT == ercd, "tslp_tsk bad ercd !E_TMOUT" ); |
|
|
505 |
|
|
506 // drop task 4 pri to same as us |
|
|
507 intercount = 0; |
|
|
508 intercom = 1; // test plain slp_tsk |
|
|
509 TSRELEASE(); |
|
|
510 ercd = chg_pri( 4, 5 ); |
|
|
511 CYG_TEST_CHECK( E_OBJ == ercd, "chg_pri bad ercd" ); |
|
|
512 |
|
|
513 ercd = dis_dsp(); |
|
|
514 CYG_TEST_CHECK( E_OK == ercd, "dis_dsp bad ercd" ); |
|
|
515 ercd = sta_tsk( 4, 77 ); |
|
|
516 CYG_TEST_CHECK( E_OK == ercd, "sta_tsk bad ercd" ); |
|
|
517 ercd = chg_pri( 4, 5 ); |
|
|
518 CYG_TEST_CHECK( E_OK == ercd, "chg_pri bad ercd" ); |
|
|
519 ercd = ena_dsp(); |
|
|
520 CYG_TEST_CHECK( E_OK == ercd, "ena_dsp bad ercd" ); |
|
|
521 |
|
|
522 ercd = wup_tsk( 4 ); |
|
|
523 CYG_TEST_CHECK( E_OK == ercd, "wup_tsk bad ercd" ); |
|
|
524 ercd = rot_rdq( 0 ); |
|
|
525 CYG_TEST_CHECK( E_OK == ercd, "rot_rdq bad ercd" ); |
|
|
526 ICWAIT( 1 ); |
|
|
527 CYG_TEST_CHECK( 1 == intercount, "intercount != 1" ); |
|
|
528 intercom = 2; // test tslp_tsk |
|
|
529 TSRELEASE(); |
|
|
530 ercd = wup_tsk( 4 ); |
|
|
531 CYG_TEST_CHECK( E_OK == ercd, "wup_tsk bad ercd" ); |
|
|
532 ercd = rot_rdq( 0 ); |
|
|
533 CYG_TEST_CHECK( E_OK == ercd, "rot_rdq bad ercd" ); |
|
|
534 ICWAIT( 2 ); |
|
|
535 CYG_TEST_CHECK( 2 == intercount, "intercount != 2" ); |
|
|
536 intercom = 3; // test tslp_tsk |
|
|
537 TSRELEASE(); |
|
|
538 ercd = rot_rdq( 0 ); |
|
|
539 CYG_TEST_CHECK( E_OK == ercd, "rot_rdq bad ercd" ); |
|
|
540 CYG_TEST_CHECK( 2 == intercount, "intercount != 2" ); |
|
|
541 intercom = 1; // test slp_tsk next... |
|
|
542 ercd = dly_tsk( 20 ); // without a wup |
|
|
543 CYG_TEST_CHECK( E_OK == ercd, "dly_tsk bad ercd" ); |
|
|
544 ICWAIT( 3 ); |
|
|
545 CYG_TEST_CHECK( 3 == intercount, "intercount != 3" ); |
|
|
546 |
|
|
547 intercom = 1; // ...test slp_tsk |
|
|
548 TSRELEASE(); |
|
|
549 ercd = dly_tsk( 20 ); // without a wup (yet) |
|
|
550 CYG_TEST_CHECK( E_OK == ercd, "dly_tsk bad ercd" ); |
|
|
551 CYG_TEST_CHECK( 3 == intercount, "intercount != 3" ); |
|
|
552 TSRELEASE(); |
|
|
553 ercd = tslp_tsk( 20 ); // yield again |
|
|
554 CYG_TEST_CHECK( E_TMOUT == ercd, "tslp_tsk bad ercd !E_TMOUT" ); |
|
|
555 CYG_TEST_CHECK( 3 == intercount, "intercount != 3" ); |
|
|
556 TSRELEASE(); |
|
|
557 ercd = rot_rdq( 0 ); // and again |
|
|
558 CYG_TEST_CHECK( E_OK == ercd, "rot_rdq bad ercd" ); |
|
|
559 CYG_TEST_CHECK( 3 == intercount, "intercount != 3" ); |
|
|
560 TSRELEASE(); |
|
|
561 ercd = wup_tsk( 4 ); // now issue a wup |
|
|
562 CYG_TEST_CHECK( E_OK == ercd, "wup_tsk bad ercd" ); |
|
|
563 ercd = rot_rdq( 0 ); // and yield |
|
|
564 CYG_TEST_CHECK( E_OK == ercd, "rot_rdq bad ercd" ); |
|
|
565 ICWAIT( 4 ); |
|
|
566 CYG_TEST_CHECK( 4 == intercount, "intercount != 4" ); |
|
|
567 |
|
|
568 intercom = 1; // test slp_tsk |
|
|
569 TSRELEASE(); |
|
|
570 ercd = dly_tsk( 20 ); // without a wup (yet) |
|
|
571 CYG_TEST_CHECK( E_OK == ercd, "dly_tsk bad ercd" ); |
|
|
572 CYG_TEST_CHECK( 4 == intercount, "intercount != 4" ); |
|
|
573 |
|
|
574 // this wup will restart it when we yield: |
|
|
575 TSLOCK(); |
|
|
576 ercd = wup_tsk( 4 ); // now issue a wup |
|
|
577 CYG_TEST_CHECK( E_OK == ercd, "wup_tsk bad ercd" ); |
|
|
578 // these will count up: |
|
|
579 ercd = wup_tsk( 4 ); // now issue a wup |
|
|
580 CYG_TEST_CHECK( E_OK == ercd, "wup_tsk bad ercd" ); |
|
|
581 ercd = wup_tsk( 4 ); // now issue a wup |
|
|
582 CYG_TEST_CHECK( E_OK == ercd, "wup_tsk bad ercd" ); |
|
|
583 scratch = -1; |
|
|
584 ercd = can_wup( &scratch, 4 ); |
|
|
585 CYG_TEST_CHECK( E_OK == ercd, "can_wup bad ercd" ); |
|
|
586 CYG_TEST_CHECK( 2 == scratch, "Cancelled wups not 2" ); |
|
|
587 CYG_TEST_CHECK( 4 == intercount, "intercount != 4" ); |
|
|
588 TSUNLOCK(); |
|
|
589 |
|
|
590 intercom = 4; // do nothing |
|
|
591 TSRELEASE(); |
|
|
592 ercd = rot_rdq( 0 ); // and yield |
|
|
593 CYG_TEST_CHECK( E_OK == ercd, "rot_rdq bad ercd" ); |
|
|
594 ICWAIT( 5 ); |
|
|
595 CYG_TEST_CHECK( 5 == intercount, "intercount != 5" ); |
|
|
596 TSRELEASE(); |
|
|
597 ercd = dly_tsk( 20 ); // let it do nothing |
|
|
598 CYG_TEST_CHECK( E_OK == ercd, "dly_tsk bad ercd" ); |
|
|
599 |
|
|
600 TSRELEASE(); |
|
|
601 ercd = wup_tsk( 4 ); // now issue a wup |
|
|
602 CYG_TEST_CHECK( E_OK == ercd, "wup_tsk bad ercd" ); |
|
|
603 TSRELEASE(); |
|
|
604 ercd = wup_tsk( 4 ); // now issue a wup |
|
|
605 CYG_TEST_CHECK( E_OK == ercd, "wup_tsk bad ercd" ); |
|
|
606 TSRELEASE(); |
|
|
607 ercd = wup_tsk( 4 ); // now issue a wup |
|
|
608 CYG_TEST_CHECK( E_OK == ercd, "wup_tsk bad ercd" ); |
|
|
609 TSRELEASE(); |
|
|
610 ercd = dly_tsk( 20 ); // lots of wups but no sleep |
|
|
611 CYG_TEST_CHECK( E_OK == ercd, "dly_tsk bad ercd" ); |
|
|
612 CYG_TEST_CHECK( 5 == intercount, "intercount != 5" ); |
|
|
613 scratch = -1; |
|
|
614 ercd = can_wup( &scratch, 4 ); |
|
|
615 CYG_TEST_CHECK( E_OK == ercd, "can_wup bad ercd" ); |
|
|
616 CYG_TEST_CHECK( 3 == scratch, "Cancelled wups not 3" ); |
|
|
617 // now check that they are cancelled by doing a wait again |
|
|
618 intercom = 1; // test slp_tsk |
|
|
619 TSRELEASE(); |
|
|
620 ercd = rot_rdq( 0 ); // still without a wup |
|
|
621 CYG_TEST_CHECK( E_OK == ercd, "rot_rdq bad ercd" ); |
|
|
622 TSRELEASE(); |
|
|
623 ercd = rot_rdq( 0 ); // still without a wup |
|
|
624 CYG_TEST_CHECK( E_OK == ercd, "rot_rdq bad ercd" ); |
|
|
625 intercom = 4; // do nothing next |
|
|
626 TSRELEASE(); |
|
|
627 ICWAIT( 6 ); |
|
|
628 CYG_TEST_CHECK( 6 == intercount, "intercount != 6" ); |
|
|
629 ercd = rot_rdq( 0 ); // still without a wup |
|
|
630 CYG_TEST_CHECK( E_OK == ercd, "rot_rdq bad ercd" ); |
|
|
631 CYG_TEST_CHECK( 6 == intercount, "intercount != 6" ); |
|
|
632 TSRELEASE(); |
|
|
633 ercd = wup_tsk( 4 ); // now issue a wup |
|
|
634 CYG_TEST_CHECK( E_OK == ercd, "wup_tsk bad ercd" ); |
|
|
635 ercd = rot_rdq( 0 ); // it will run now |
|
|
636 CYG_TEST_CHECK( E_OK == ercd, "wup_tsk bad ercd" ); |
|
|
637 TSRELEASE(); |
|
|
638 ercd = rot_rdq( 0 ); // it will run now |
|
|
639 CYG_TEST_CHECK( E_OK == ercd, "rot_rdq bad ercd" ); |
|
|
640 ICWAIT( 7 ); |
|
|
641 CYG_TEST_CHECK( 7 == intercount, "intercount != 7" ); |
|
|
642 |
|
|
643 TSRELEASE(); |
|
|
644 intercom = 99; // exit, all done |
|
|
645 ercd = rot_rdq( 0 ); // let it run |
|
|
646 CYG_TEST_CHECK( E_OK == ercd, "rot_rdq bad ercd" ); |
|
|
647 ICWAIT( 8 ); |
|
|
648 CYG_TEST_CHECK( 8 == intercount, "intercount != 8" ); |
|
|
649 |
|
|
650 TSRELEASE(); |
|
|
651 ercd = rot_rdq( 0 ); // let it run |
|
|
652 CYG_TEST_CHECK( E_OK == ercd, "rot_rdq bad ercd" ); |
|
|
653 CYG_TEST_CHECK( 8 == intercount, "intercount != 8" ); |
|
|
654 |
|
|
655 CYG_TEST_PASS( "wup_tsk, can_wup, slp_tsk, tslp_tsk" ); |
|
|
656 |
|
|
657 #ifdef CYG_TEST_UITRON_TEST1_LOOPING |
|
|
658 chg_pri( 1, 1 ); |
|
|
659 rot_rdq( 0 ); |
|
|
660 ter_tsk( 2 ); |
|
|
661 rot_rdq( 0 ); |
|
|
662 ter_tsk( 3 ); |
|
|
663 rot_rdq( 0 ); |
|
|
664 ter_tsk( 4 ); |
|
|
665 rot_rdq( 0 ); |
|
|
666 } |
|
|
667 #endif // CYG_TEST_UITRON_TEST1_LOOPING |
|
|
668 |
|
|
669 CYG_TEST_EXIT( "All done" ); |
|
|
670 ext_tsk(); |
|
|
671 } |
|
|
672 |
|
|
673 |
|
|
674 |
|
|
675 void task2( unsigned int arg ) |
|
|
676 { |
|
|
677 ER ercd; |
|
|
678 CYG_TEST_PASS( "Task 2 running" ); |
|
|
679 ercd = get_tid( &scratch ); |
|
|
680 CYG_TEST_CHECK( E_OK == ercd, "get_tid bad ercd" ); |
|
|
681 CYG_TEST_CHECK( 2 == scratch, "tid not 2" ); |
|
|
682 if ( 99 != arg ) |
|
|
683 CYG_TEST_FAIL( "Task 2 arg not 99" ); |
|
|
684 ext_tsk(); |
|
|
685 CYG_TEST_FAIL( "Task 2 failed to exit" ); |
|
|
686 } |
|
|
687 |
|
|
688 void task3( unsigned int arg ) |
|
|
689 { |
|
|
690 ER ercd; |
|
|
691 TSLOCK(); |
|
|
692 CYG_TEST_PASS("Task3 running"); |
|
|
693 ercd = get_tid( &scratch ); |
|
|
694 CYG_TEST_CHECK( E_OK == ercd, "get_tid bad ercd" ); |
|
|
695 CYG_TEST_CHECK( 3 == scratch, "tid not 3" ); |
|
|
696 if ( 66 != arg ) |
|
|
697 CYG_TEST_FAIL( "Task 3 arg not 66" ); |
|
|
698 |
|
|
699 while ( 2 & intercom ) { |
|
|
700 while ( 1 & intercom ) { |
|
|
701 intercount++; |
|
|
702 TSSTOP(); |
|
|
703 do { |
|
|
704 TSUNLOCK(); |
|
|
705 ercd = rot_rdq( 0 ); // yield() |
|
|
706 TSLOCK(); |
|
|
707 CYG_TEST_CHECK( E_OK == ercd, "rot_rdq 1 (task3) bad ercd" ); |
|
|
708 } while ( !TSGO() ); |
|
|
709 } |
|
|
710 CYG_TEST_CHECK( 4 & intercom, "should not have got here yet 1" ); |
|
|
711 TSSTOP(); |
|
|
712 do { |
|
|
713 TSUNLOCK(); |
|
|
714 ercd = rot_rdq( 0 ); // yield() |
|
|
715 TSLOCK(); |
|
|
716 CYG_TEST_CHECK( E_OK == ercd, "rot_rdq 2 (task3) bad ercd" ); |
|
|
717 } while ( !TSGO() ); |
|
|
718 } |
|
|
719 CYG_TEST_CHECK( 8 & intercom, "should not have got here yet 2" ); |
|
|
720 |
|
|
721 TSUNLOCK(); |
|
|
722 ext_tsk(); |
|
|
723 CYG_TEST_FAIL( "Task 3 failed to exit" ); |
|
|
724 } |
|
|
725 |
|
|
726 void task4( unsigned int arg ) |
|
|
727 { |
|
|
728 ER ercd; |
|
|
729 CYG_TEST_PASS("Task4 running"); |
|
|
730 ercd = get_tid( &scratch ); |
|
|
731 CYG_TEST_CHECK( E_OK == ercd, "get_tid bad ercd" ); |
|
|
732 CYG_TEST_CHECK( 4 == scratch, "tid not 4" ); |
|
|
733 if ( 77 != arg ) |
|
|
734 CYG_TEST_FAIL( "Task 4 arg not 77" ); |
|
|
735 while ( 1 ) { |
|
|
736 switch ( intercom ) { |
|
|
737 case 1: |
|
|
738 ercd = slp_tsk(); |
|
|
739 CYG_TEST_CHECK( E_OK == ercd, "slp_tsk (task4) bad ercd" ); |
|
|
740 break; |
|
|
741 case 2: |
|
|
742 ercd = tslp_tsk( 10 ); |
|
|
743 CYG_TEST_CHECK( E_OK == ercd, "slp_tsk (task4) bad ercd" ); |
|
|
744 break; |
|
|
745 case 3: |
|
|
746 ercd = tslp_tsk( 10 ); |
|
|
747 CYG_TEST_CHECK( E_TMOUT == ercd, |
|
|
748 "slp_tsk (task4) bad ercd !E_TMOUT" ); |
|
|
749 break; |
|
|
750 case 4: |
|
|
751 // busily do nothing |
|
|
752 while ( 4 == intercom ) { |
|
|
753 ercd = rot_rdq( 0 ); |
|
|
754 CYG_TEST_CHECK( E_OK == ercd, |
|
|
755 "rot_rdq (task4 idle) bad ercd" ); |
|
|
756 } |
|
|
757 break; |
|
|
758 case 99: |
|
|
759 goto out; |
|
|
760 default: |
|
|
761 CYG_TEST_FAIL( "Task 4 bad intercom" ); |
|
|
762 goto out; |
|
|
763 } |
|
|
764 intercount++; |
|
|
765 TSSTOP(); |
|
|
766 do { |
|
|
767 ercd = rot_rdq( 0 ); // yield() |
|
|
768 CYG_TEST_CHECK( E_OK == ercd, "rot_rdq (task4) bad ercd" ); |
|
|
769 } while ( !TSGO() ); |
|
|
770 } |
|
|
771 out: |
|
|
772 ext_tsk(); |
|
|
773 CYG_TEST_FAIL( "Task 4 failed to exit" ); |
|
|
774 } |
|
|
775 |
|
|
776 #else // not enough (or too many) uITRON objects configured in |
|
|
777 #define N_A_MSG "not enough uITRON objects to run test" |
|
|
778 #endif // not enough (or too many) uITRON objects configured in |
|
|
779 #else // not C++ and some C++ specific options enabled |
|
|
780 #define N_A_MSG "C++ specific options selected but this is C" |
|
|
781 #endif // not C++ and some C++ specific options enabled |
|
|
782 #else // ! CYGVAR_KERNEL_COUNTERS_CLOCK - can't test without it |
|
|
783 #define N_A_MSG "no CYGVAR_KERNEL_COUNTERS_CLOCK" |
|
|
784 #endif // ! CYGVAR_KERNEL_COUNTERS_CLOCK - can't test without it |
|
|
785 #else // ! CYGFUN_KERNEL_THREADS_TIMER - can't test without it |
|
|
786 #define N_A_MSG "no CYGFUN_KERNEL_THREADS_TIMER" |
|
2
|
787 #endif // ! CYGFUN_KERNEL_THREADS_TIMER - can't test without it |
|
|
788 #else // ! CYGIMP_THREAD_PRIORITY - can't test without it |
|
0
|
789 #define N_A_MSG "no CYGSEM_KERNEL_SCHED_MLQUEUE" |
|
2
|
790 #endif // ! CYGSEM_KERNEL_SCHED_MLQUEUE - can't test without it |
|
0
|
791 #else // ! CYGPKG_UITRON |
|
|
792 #define N_A_MSG "uITRON Compatibility layer disabled" |
|
|
793 #endif // CYGPKG_UITRON |
|
|
794 |
|
|
795 #ifdef N_A_MSG |
|
|
796 void |
|
|
797 cyg_start( void ) |
|
|
798 { |
|
|
799 CYG_TEST_INIT(); |
|
2
|
800 CYG_TEST_NA( N_A_MSG ); |
|
0
|
801 } |
|
|
802 #endif // N_A_MSG defined ie. we are N/A. |
|
|
803 |
|
|
804 // EOF test1.c |
