Mercurial > ecos

comparison packages/compat/uitron/current/tests/test9.c @ 0:3111d98ba7b3 ecos-v1_1-release

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Initial commit of eCos version 1.1
author jlarmour
date Tue, 11 May 1999 11:16:07 +0000
parents
children 443894e2e912
comparison
equal deleted inserted replaced
-1:000000000000 0:3111d98ba7b3
1 //===========================================================================
2 //
3 // test9.c
4 //
5 // uITRON "C" test program nine
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
25 // by Cygnus are Copyright (C) 1998 Cygnus Solutions. All Rights Reserved.
26 // -------------------------------------------
27 //
28 //####COPYRIGHTEND####
29 //===========================================================================
30 //#####DESCRIPTIONBEGIN####
31 //
32 // Author(s): hmt
33 // Contributors: hmt
34 // Date: 1998-10-16
35 // Purpose: uITRON API testing
36 // Description:
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 /* test configuration for enough fixed memory pools */ \
69 defined( CYGPKG_UITRON_MEMPOOLFIXED ) && \
70 (CYGNUM_UITRON_MEMPOOLFIXED >= 3) && \
71 (CYGNUM_UITRON_MEMPOOLFIXED < 90) && \
72 ( !defined(CYGPKG_UITRON_MEMPOOLFIXED_CREATE_DELETE) || \
73 CYGNUM_UITRON_MEMPOOLFIXED_INITIALLY >= 3 ) && \
74 \
75 /* test configuration for enough variable mempools */ \
76 defined( CYGPKG_UITRON_MEMPOOLVAR ) && \
77 (CYGNUM_UITRON_MEMPOOLVAR >= 3) && \
78 (CYGNUM_UITRON_MEMPOOLVAR < 90) && \
79 ( !defined(CYGPKG_UITRON_MEMPOOLVAR_CREATE_DELETE) || \
80 CYGNUM_UITRON_MEMPOOLVAR_INITIALLY >= 3 ) && \
81 \
82 /* the end of the large #if statement */ \
83 1
84
85 // ============================ END ============================
86
87
88
89 #include <cyg/compat/uitron/uit_func.h> // uITRON
90
91 externC void
92 cyg_package_start( void )
93 {
94 CYG_TEST_INIT();
95 CYG_TEST_INFO( "Calling cyg_uitron_start()" );
96 cyg_uitron_start();
97 }
98
99 VP vp;
100
101 T_CMPL t_cmpl = { NULL, 0, 1000 };
102 T_RMPL t_rmpl;
103 T_CMPF t_cmpf = { NULL, 0, 10, 100 };
104 T_RMPF t_rmpf;
105
106
107 void task1( unsigned int arg )
108 {
109 ER ercd;
110 int tests = 0;
111
112 CYG_TEST_INFO( "Task 1 running" );
113
114 ercd = dis_dsp();
115 CYG_TEST_CHECK( E_OK == ercd, "dis_dsp bad ercd" );
116 ercd = sta_tsk( 2, 22222 );
117 CYG_TEST_CHECK( E_OK == ercd, "sta_tsk bad ercd" );
118 ercd = chg_pri( 2, 5 );
119 CYG_TEST_CHECK( E_OK == ercd, "chg_pri bad ercd" );
120 ercd = ena_dsp();
121 CYG_TEST_CHECK( E_OK == ercd, "ena_dsp bad ercd" );
122 ercd = dly_tsk( 10 );
123 CYG_TEST_CHECK( E_OK == ercd, "dly_tsk bad ercd" );
124
125 #ifdef CYGPKG_UITRON_MEMPOOLFIXED_CREATE_DELETE
126 tests++;
127 #ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS
128 ercd = del_mpf( -6 );
129 CYG_TEST_CHECK( E_ID == ercd, "del_mpf bad ercd !E_ID" );
130 ercd = del_mpf( 99 );
131 CYG_TEST_CHECK( E_ID == ercd, "del_mpf bad ercd !E_ID" );
132 ercd = cre_mpf( -6, &t_cmpf );
133 CYG_TEST_CHECK( E_ID == ercd, "cre_mpf bad ercd !E_ID" );
134 ercd = cre_mpf( 99, &t_cmpf );
135 CYG_TEST_CHECK( E_ID == ercd, "cre_mpf bad ercd !E_ID" );
136 #endif // we can test bad param error returns
137 // try a pre-existing object
138 // [first get a valid block from it for the freeing test later]
139 ercd = pget_blf( &vp, 3 );
140 CYG_TEST_CHECK( E_OK == ercd, "pget_blf bad ercd" );
141 ercd = cre_mpf( 3, &t_cmpf );
142 CYG_TEST_CHECK( E_OBJ == ercd, "cre_mpf bad ercd !E_OBJ" );
143 // delete it so we can play
144 ercd = del_mpf( 3 );
145 CYG_TEST_CHECK( E_OK == ercd, "del_mpf bad ercd" );
146 // check it is deleted
147 ercd = rel_blf( 3, vp ); // vp did come from this pool
148 CYG_TEST_CHECK( E_NOEXS == ercd, "rel_blf bad ercd !E_NOEXS" );
149 ercd = pget_blf( &vp, 3 );
150 CYG_TEST_CHECK( E_NOEXS == ercd, "pget_blf bad ercd !E_NOEXS" );
151 ercd = tget_blf( &vp, 3, 10 );
152 CYG_TEST_CHECK( E_NOEXS == ercd, "tget_blf bad ercd !E_NOEXS" );
153 ercd = get_blf( &vp, 3 );
154 CYG_TEST_CHECK( E_NOEXS == ercd, "get_blf bad ercd !E_NOEXS" );
155 ercd = ref_mpf( &t_rmpf, 3 );
156 CYG_TEST_CHECK( E_NOEXS == ercd, "ref_mpf bad ercd !E_NOEXS" );
157 #ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS
158 // now try creating it (badly)
159 #ifndef CYGSEM_UITRON_PARAMS_NULL_IS_GOOD_PTR
160 ercd = cre_mpf( 3, NULL );
161 CYG_TEST_CHECK( E_PAR == ercd, "cre_mpf bad ercd !E_PAR" );
162 #endif
163 ercd = cre_mpf( 3, NADR );
164 CYG_TEST_CHECK( E_PAR == ercd, "cre_mpf bad ercd !E_PAR" );
165 t_cmpf.mpfatr = 0xfff;
166 ercd = cre_mpf( 3, &t_cmpf );
167 CYG_TEST_CHECK( E_RSATR == ercd, "cre_mpf bad ercd !E_RSATR" );
168 #endif // we can test bad param error returns
169 t_cmpf.mpfatr = 0;
170 t_cmpf.mpfcnt = 10000;
171 t_cmpf.blfsz = 100;
172 ercd = cre_mpf( 3, &t_cmpf );
173 CYG_TEST_CHECK( E_NOMEM == ercd, "cre_mpf bad ercd" );
174 t_cmpf.mpfcnt = 100;
175 t_cmpf.blfsz = 100000;
176 ercd = cre_mpf( 3, &t_cmpf );
177 CYG_TEST_CHECK( E_NOMEM == ercd, "cre_mpf bad ercd" );
178 // now create it well
179 t_cmpf.mpfatr = 0;
180 t_cmpf.mpfcnt = 10;
181 t_cmpf.blfsz = 100;
182 ercd = cre_mpf( 3, &t_cmpf );
183 CYG_TEST_CHECK( E_OK == ercd, "cre_mpf bad ercd" );
184 // and check we can use it
185 ercd = pget_blf( &vp, 3 );
186 CYG_TEST_CHECK( E_OK == ercd, "pget_blf bad ercd" );
187 ercd = tget_blf( &vp, 3, 10 );
188 CYG_TEST_CHECK( E_OK == ercd, "tget_blf bad ercd" );
189 ercd = get_blf( &vp, 3 );
190 CYG_TEST_CHECK( E_OK == ercd, "get_blf bad ercd" );
191 ercd = rel_blf( 3, vp ); // vp did come from new pool
192 CYG_TEST_CHECK( E_OK == ercd, "rel_blf bad ercd" );
193 ercd = rel_blf( 3, vp ); // vp already freed
194 CYG_TEST_CHECK( E_PAR == ercd, "rel_blf bad ercd !E_PAR" );
195 ercd = ref_mpf( &t_rmpf, 3 );
196 CYG_TEST_CHECK( E_OK == ercd, "ref_mpf bad ercd" );
197
198 // In order to wait on the pools, we must first consume all they have:
199 while ( E_OK == (ercd = pget_blf( &vp, 1 )) ) /* nothing */;
200 CYG_TEST_CHECK( E_TMOUT == ercd, "pget_blf bad ercd !E_TMOUT" );
201 while ( E_OK == (ercd = tget_blf( &vp, 2, 1 )) ) /* nothing */;
202 CYG_TEST_CHECK( E_TMOUT == ercd, "tget_blf bad ercd !E_TMOUT" );
203 // now wait while task 2 deletes the wait objects
204 ercd = wup_tsk( 2 );
205 CYG_TEST_CHECK( E_OK == ercd, "wup_tsk bad ercd" );
206 ercd = get_blf( &vp, 1 );
207 CYG_TEST_CHECK( E_DLT == ercd, "get_blf bad ercd !E_DLT" );
208 ercd = wup_tsk( 2 );
209 CYG_TEST_CHECK( E_OK == ercd, "wup_tsk bad ercd" );
210 ercd = tget_blf( &vp, 2, 20 );
211 CYG_TEST_CHECK( E_DLT == ercd, "tget_blf bad ercd !E_DLT" );
212 // check they are deleted
213 ercd = get_blf( &vp, 1 );
214 CYG_TEST_CHECK( E_NOEXS == ercd, "get_blf bad ercd !E_NOEXS" );
215 ercd = pget_blf( &vp, 2 );
216 CYG_TEST_CHECK( E_NOEXS == ercd, "pget_blf bad ercd !E_NOEXS" );
217
218 // re-create and do it again
219 t_cmpf.mpfcnt = 90;
220 t_cmpf.blfsz = 20;
221 ercd = cre_mpf( 1, &t_cmpf );
222 CYG_TEST_CHECK( E_OK == ercd, "cre_mpf bad ercd" );
223 t_cmpf.mpfcnt = 5;
224 t_cmpf.blfsz = 200;
225 ercd = cre_mpf( 2, &t_cmpf );
226 CYG_TEST_CHECK( E_OK == ercd, "cre_mpf bad ercd" );
227
228 // In order to wait on the pools, we must first consume all they have:
229 while ( E_OK == (ercd = pget_blf( &vp, 1 )) ) /* nothing */;
230 CYG_TEST_CHECK( E_TMOUT == ercd, "pget_blf bad ercd !E_TMOUT" );
231 while ( E_OK == (ercd = tget_blf( &vp, 2, 1 )) ) /* nothing */;
232 CYG_TEST_CHECK( E_TMOUT == ercd, "tget_blf bad ercd !E_TMOUT" );
233 // now wait while task 2 deletes the wait objects
234 ercd = wup_tsk( 2 );
235 CYG_TEST_CHECK( E_OK == ercd, "wup_tsk bad ercd" );
236 ercd = get_blf( &vp, 1 );
237 CYG_TEST_CHECK( E_DLT == ercd, "get_blf bad ercd !E_DLT" );
238 ercd = wup_tsk( 2 );
239 CYG_TEST_CHECK( E_OK == ercd, "wup_tsk bad ercd" );
240 ercd = tget_blf( &vp, 2, 10 );
241 CYG_TEST_CHECK( E_DLT == ercd, "tget_blf bad ercd !E_DLT" );
242 // check they are deleted
243 ercd = tget_blf( &vp, 1, 1 );
244 CYG_TEST_CHECK( E_NOEXS == ercd, "get_blf bad ercd !E_NOEXS" );
245 ercd = get_blf( &vp, 2 );
246 CYG_TEST_CHECK( E_NOEXS == ercd, "pget_blf bad ercd !E_NOEXS" );
247
248 CYG_TEST_PASS("create/delete fixed mempools");
249 #endif // CYGPKG_UITRON_MEMPOOLFIXED_CREATE_DELETE
250
251 #ifdef CYGPKG_UITRON_MEMPOOLVAR_CREATE_DELETE
252 tests++;
253 #ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS
254 ercd = del_mpl( -6 );
255 CYG_TEST_CHECK( E_ID == ercd, "del_mpl bad ercd !E_ID" );
256 ercd = del_mpl( 99 );
257 CYG_TEST_CHECK( E_ID == ercd, "del_mpl bad ercd !E_ID" );
258 ercd = cre_mpl( -6, &t_cmpl );
259 CYG_TEST_CHECK( E_ID == ercd, "cre_mpl bad ercd !E_ID" );
260 ercd = cre_mpl( 99, &t_cmpl );
261 CYG_TEST_CHECK( E_ID == ercd, "cre_mpl bad ercd !E_ID" );
262 #endif // we can test bad param error returns
263 // try a pre-existing object
264 // [first get a valid block from it for the freeing test later]
265 ercd = pget_blk( &vp, 3, 100 );
266 CYG_TEST_CHECK( E_OK == ercd, "pget_blk bad ercd" );
267 ercd = cre_mpl( 3, &t_cmpl );
268 CYG_TEST_CHECK( E_OBJ == ercd, "cre_mpl bad ercd !E_OBJ" );
269 // delete it so we can play
270 ercd = del_mpl( 3 );
271 CYG_TEST_CHECK( E_OK == ercd, "del_mpl bad ercd" );
272 // check it is deleted
273 ercd = rel_blk( 3, vp ); // vp did come from this pool
274 CYG_TEST_CHECK( E_NOEXS == ercd, "rel_blk bad ercd !E_NOEXS" );
275 ercd = pget_blk( &vp, 3, 100 );
276 CYG_TEST_CHECK( E_NOEXS == ercd, "pget_blk bad ercd !E_NOEXS" );
277 ercd = tget_blk( &vp, 3, 100, 10 );
278 CYG_TEST_CHECK( E_NOEXS == ercd, "tget_blk bad ercd !E_NOEXS" );
279 ercd = get_blk( &vp, 3, 100 );
280 CYG_TEST_CHECK( E_NOEXS == ercd, "get_blk bad ercd !E_NOEXS" );
281 ercd = ref_mpl( &t_rmpl, 3 );
282 CYG_TEST_CHECK( E_NOEXS == ercd, "ref_mpl bad ercd !E_NOEXS" );
283 #ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS
284 // now try creating it (badly)
285 #ifndef CYGSEM_UITRON_PARAMS_NULL_IS_GOOD_PTR
286 ercd = cre_mpl( 3, NULL );
287 CYG_TEST_CHECK( E_PAR == ercd, "cre_mpl bad ercd !E_PAR" );
288 #endif
289 ercd = cre_mpl( 3, NADR );
290 CYG_TEST_CHECK( E_PAR == ercd, "cre_mpl bad ercd !E_PAR" );
291 t_cmpl.mplatr = 0xfff;
292 ercd = cre_mpl( 3, &t_cmpl );
293 CYG_TEST_CHECK( E_RSATR == ercd, "cre_mpl bad ercd !E_RSATR" );
294 #endif // we can test bad param error returns
295 t_cmpl.mplatr = 0;
296 t_cmpl.mplsz = 100000000;
297 ercd = cre_mpl( 3, &t_cmpl );
298 CYG_TEST_CHECK( E_NOMEM == ercd, "cre_mpl bad ercd" );
299 // now create it well
300 t_cmpl.mplatr = 0;
301 t_cmpl.mplsz = 1000;
302 ercd = cre_mpl( 3, &t_cmpl );
303 CYG_TEST_CHECK( E_OK == ercd, "cre_mpl bad ercd" );
304 // and check we can use it
305 ercd = pget_blk( &vp, 3, 100 );
306 CYG_TEST_CHECK( E_OK == ercd, "pget_blk bad ercd" );
307 ercd = pget_blk( &vp, 3, 100000000 ); // way too large
308 CYG_TEST_CHECK( E_TMOUT == ercd, "pget_blk bad ercd !E_TMOUT" );
309 ercd = tget_blk( &vp, 3, 100, 10 );
310 CYG_TEST_CHECK( E_OK == ercd, "tget_blk bad ercd" );
311 ercd = get_blk( &vp, 3, 100 );
312 CYG_TEST_CHECK( E_OK == ercd, "get_blk bad ercd" );
313 ercd = rel_blk( 3, vp ); // vp did come from new pool
314 CYG_TEST_CHECK( E_OK == ercd, "rel_blk bad ercd" );
315 ercd = rel_blk( 3, vp ); // vp already freed
316 CYG_TEST_CHECK( E_PAR == ercd, "rel_blk bad ercd !E_PAR" );
317 ercd = ref_mpl( &t_rmpl, 3 );
318 CYG_TEST_CHECK( E_OK == ercd, "ref_mpl bad ercd" );
319
320 // In order to wait on the pools, we must first consume all they have:
321 while ( E_OK == (ercd = pget_blk( &vp, 1, 100 )) ) /* nothing */;
322 CYG_TEST_CHECK( E_TMOUT == ercd, "pget_blk bad ercd !E_TMOUT" );
323 while ( E_OK == (ercd = tget_blk( &vp, 2, 100, 1 )) ) /* nothing */;
324 CYG_TEST_CHECK( E_TMOUT == ercd, "tget_blk bad ercd !E_TMOUT" );
325 // now wait while task 2 deletes the wait objects
326 ercd = wup_tsk( 2 );
327 CYG_TEST_CHECK( E_OK == ercd, "wup_tsk bad ercd" );
328 ercd = get_blk( &vp, 1, 200 );
329 CYG_TEST_CHECK( E_DLT == ercd, "get_blk bad ercd !E_DLT" );
330 ercd = wup_tsk( 2 );
331 CYG_TEST_CHECK( E_OK == ercd, "wup_tsk bad ercd" );
332 ercd = tget_blk( &vp, 2, 100, 20 );
333 CYG_TEST_CHECK( E_DLT == ercd, "tget_blk bad ercd !E_DLT" );
334 // check they are deleted
335 ercd = get_blk( &vp, 1, 200 );
336 CYG_TEST_CHECK( E_NOEXS == ercd, "get_blk bad ercd !E_NOEXS" );
337 ercd = pget_blk( &vp, 2, 20 );
338 CYG_TEST_CHECK( E_NOEXS == ercd, "pget_blk bad ercd !E_NOEXS" );
339
340 // re-create and do it again
341 ercd = cre_mpl( 1, &t_cmpl );
342 CYG_TEST_CHECK( E_OK == ercd, "cre_mpl bad ercd" );
343 ercd = cre_mpl( 2, &t_cmpl );
344 CYG_TEST_CHECK( E_OK == ercd, "cre_mpl bad ercd" );
345
346 // In order to wait on the pools, we must first consume all they have:
347 while ( E_OK == (ercd = pget_blk( &vp, 1, 20 )) ) /* nothing */;
348 CYG_TEST_CHECK( E_TMOUT == ercd, "pget_blk bad ercd !E_TMOUT" );
349 while ( E_OK == (ercd = tget_blk( &vp, 2, 400, 1 )) ) /* nothing */;
350 CYG_TEST_CHECK( E_TMOUT == ercd, "tget_blk bad ercd !E_TMOUT" );
351 // now wait while task 2 deletes the wait objects
352 ercd = wup_tsk( 2 );
353 CYG_TEST_CHECK( E_OK == ercd, "wup_tsk bad ercd" );
354 ercd = get_blk( &vp, 1, 200 );
355 CYG_TEST_CHECK( E_DLT == ercd, "get_blk bad ercd !E_DLT" );
356 ercd = wup_tsk( 2 );
357 CYG_TEST_CHECK( E_OK == ercd, "wup_tsk bad ercd" );
358 ercd = tget_blk( &vp, 2, 500, 20 );
359 CYG_TEST_CHECK( E_DLT == ercd, "tget_blk bad ercd !E_DLT" );
360 // check they are deleted
361 ercd = tget_blk( &vp, 1, 200, 1 );
362 CYG_TEST_CHECK( E_NOEXS == ercd, "get_blk bad ercd !E_NOEXS" );
363 ercd = get_blk( &vp, 2, 20 );
364 CYG_TEST_CHECK( E_NOEXS == ercd, "pget_blk bad ercd !E_NOEXS" );
365
366 CYG_TEST_PASS("create/delete variable mempools");
367 #endif // CYGPKG_UITRON_MEMPOOLVAR_CREATE_DELETE
368
369 ercd = ter_tsk( 2 );
370 CYG_TEST_CHECK( E_OK == ercd, "ter_tsk bad ercd" );
371 ercd = dly_tsk( 5 );
372 CYG_TEST_CHECK( E_OK == ercd, "dly_tsk bad ercd" );
373
374 // all done
375 if ( 0 == tests ) {
376 CYG_TEST_PASS( "N/A: no objects have create/delete enabled" );
377 CYG_TEST_EXIT( "N/A" );
378 }
379 else {
380 CYG_TEST_EXIT( "All done" );
381 }
382 ext_tsk();
383 }
384
385
386
387 void task2( unsigned int arg )
388 {
389 ER ercd;
390 int i;
391 CYG_TEST_INFO( "Task 2 running" );
392 ercd = get_tid( &i );
393 CYG_TEST_CHECK( E_OK == ercd, "get_tid bad ercd" );
394 CYG_TEST_CHECK( 2 == i, "tid not 2" );
395 if ( 22222 != arg )
396 CYG_TEST_FAIL( "Task 2 arg not 22222" );
397
398 ercd = slp_tsk();
399 CYG_TEST_CHECK( E_OK == ercd, "slp_tsk bad ercd" );
400
401 #ifdef CYGPKG_UITRON_MEMPOOLFIXED_CREATE_DELETE
402 ercd = del_mpf( 1 );
403 CYG_TEST_CHECK( E_OK == ercd, "del_mpf bad ercd" );
404 ercd = slp_tsk();
405 CYG_TEST_CHECK( E_OK == ercd, "slp_tsk bad ercd" );
406 ercd = del_mpf( 2 );
407 CYG_TEST_CHECK( E_OK == ercd, "del_mpf bad ercd" );
408 ercd = slp_tsk();
409 CYG_TEST_CHECK( E_OK == ercd, "slp_tsk bad ercd" );
410 ercd = del_mpf( 1 );
411 CYG_TEST_CHECK( E_OK == ercd, "del_mpf bad ercd" );
412 ercd = slp_tsk();
413 CYG_TEST_CHECK( E_OK == ercd, "slp_tsk bad ercd" );
414 ercd = del_mpf( 2 );
415 CYG_TEST_CHECK( E_OK == ercd, "del_mpf bad ercd" );
416 ercd = slp_tsk();
417 CYG_TEST_CHECK( E_OK == ercd, "slp_tsk bad ercd" );
418 #endif // CYGPKG_UITRON_MEMPOOLFIXED_CREATE_DELETE
419
420 #ifdef CYGPKG_UITRON_MEMPOOLVAR_CREATE_DELETE
421 ercd = del_mpl( 1 );
422 CYG_TEST_CHECK( E_OK == ercd, "del_mpl bad ercd" );
423 ercd = slp_tsk();
424 CYG_TEST_CHECK( E_OK == ercd, "slp_tsk bad ercd" );
425 ercd = del_mpl( 2 );
426 CYG_TEST_CHECK( E_OK == ercd, "del_mpl bad ercd" );
427 ercd = slp_tsk();
428 CYG_TEST_CHECK( E_OK == ercd, "slp_tsk bad ercd" );
429 ercd = del_mpl( 1 );
430 CYG_TEST_CHECK( E_OK == ercd, "del_mpl bad ercd" );
431 ercd = slp_tsk();
432 CYG_TEST_CHECK( E_OK == ercd, "slp_tsk bad ercd" );
433 ercd = del_mpl( 2 );
434 CYG_TEST_CHECK( E_OK == ercd, "del_mpl bad ercd" );
435 ercd = slp_tsk();
436 CYG_TEST_CHECK( E_OK == ercd, "slp_tsk bad ercd" );
437 #endif // CYGPKG_UITRON_MEMPOOLVAR_CREATE_DELETE
438
439 // we expect task2 to be killed here
440 CYG_TEST_FAIL( "Task 2 ran to completion!" );
441 }
442
443 void task3( unsigned int arg )
444 {
445 }
446
447 void task4( unsigned int arg )
448 {
449 }
450
451 #else // not enough (or too many) uITRON objects configured in
452 #define N_A_MSG "not enough uITRON objects to run test"
453 #endif // not enough (or too many) uITRON objects configured in
454 #else // not C++ and some C++ specific options enabled
455 #define N_A_MSG "C++ specific options selected but this is C"
456 #endif // not C++ and some C++ specific options enabled
457 #else // ! CYGVAR_KERNEL_COUNTERS_CLOCK - can't test without it
458 #define N_A_MSG "no CYGVAR_KERNEL_COUNTERS_CLOCK"
459 #endif // ! CYGVAR_KERNEL_COUNTERS_CLOCK - can't test without it
460 #else // ! CYGFUN_KERNEL_THREADS_TIMER - can't test without it
461 #define N_A_MSG "no CYGFUN_KERNEL_THREADS_TIMER"
462 #endif // ! CYGFUN_KERNEL_THREADS_TIMER - can't test without it
463 #else // ! CYGIMP_THREAD_PRIORITY - can't test without it
464 #define N_A_MSG "no CYGSEM_KERNEL_SCHED_MLQUEUE"
465 #endif // ! CYGSEM_KERNEL_SCHED_MLQUEUE - can't test without it
466 #else // ! CYGPKG_UITRON
467 #define N_A_MSG "uITRON Compatibility layer disabled"
468 #endif // CYGPKG_UITRON
469
470 #ifdef N_A_MSG
471 void
472 cyg_start( void )
473 {
474 CYG_TEST_INIT();
475 CYG_TEST_PASS( "N/A: " N_A_MSG );
476 CYG_TEST_EXIT( "N/A" );
477 }
478 #endif // N_A_MSG defined ie. we are N/A.
479
480 // EOF test9.c