|
0
|
1 //=========================================================================== |
|
|
2 // |
|
2
|
3 // testcx2.cxx |
|
0
|
4 // |
|
2
|
5 // uITRON "C++" test program two |
|
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 /* test configuration for enough semaphores */ \ |
|
|
69 defined( CYGPKG_UITRON_SEMAS ) && \ |
|
|
70 (CYGNUM_UITRON_SEMAS >= 3) && \ |
|
|
71 (CYGNUM_UITRON_SEMAS < 90) && \ |
|
|
72 ( !defined(CYGPKG_UITRON_SEMAS_CREATE_DELETE) || \ |
|
|
73 CYGNUM_UITRON_SEMAS_INITIALLY >= 3 ) && \ |
|
|
74 \ |
|
|
75 /* test configuration for enough flag objects */ \ |
|
|
76 defined( CYGPKG_UITRON_FLAGS ) && \ |
|
|
77 (CYGNUM_UITRON_FLAGS >= 3) && \ |
|
|
78 (CYGNUM_UITRON_FLAGS < 90) && \ |
|
|
79 ( !defined(CYGPKG_UITRON_FLAGS_CREATE_DELETE) || \ |
|
|
80 CYGNUM_UITRON_FLAGS_INITIALLY >= 3 ) && \ |
|
|
81 \ |
|
|
82 /* test configuration for enough message boxes */ \ |
|
|
83 defined( CYGPKG_UITRON_MBOXES ) && \ |
|
|
84 (CYGNUM_UITRON_MBOXES >= 3) && \ |
|
|
85 (CYGNUM_UITRON_MBOXES < 90) && \ |
|
|
86 ( !defined(CYGPKG_UITRON_MBOXES_CREATE_DELETE) || \ |
|
|
87 CYGNUM_UITRON_MBOXES_INITIALLY >= 3 ) && \ |
|
|
88 \ |
|
|
89 /* test configuration for enough fixed memory pools */ \ |
|
|
90 defined( CYGPKG_UITRON_MEMPOOLFIXED ) && \ |
|
|
91 (CYGNUM_UITRON_MEMPOOLFIXED >= 3) && \ |
|
|
92 (CYGNUM_UITRON_MEMPOOLFIXED < 90) && \ |
|
|
93 ( !defined(CYGPKG_UITRON_MEMPOOLFIXED_CREATE_DELETE) || \ |
|
|
94 CYGNUM_UITRON_MEMPOOLFIXED_INITIALLY >= 3 ) && \ |
|
|
95 \ |
|
|
96 /* test configuration for enough variable mempools */ \ |
|
|
97 defined( CYGPKG_UITRON_MEMPOOLVAR ) && \ |
|
|
98 (CYGNUM_UITRON_MEMPOOLVAR >= 3) && \ |
|
|
99 (CYGNUM_UITRON_MEMPOOLVAR < 90) && \ |
|
|
100 ( !defined(CYGPKG_UITRON_MEMPOOLVAR_CREATE_DELETE) || \ |
|
|
101 CYGNUM_UITRON_MEMPOOLVAR_INITIALLY >= 3 ) && \ |
|
|
102 \ |
|
|
103 /* the end of the large #if statement */ \ |
|
|
104 1 |
|
|
105 |
|
|
106 // ============================ END ============================ |
|
|
107 |
|
|
108 |
|
|
109 |
|
|
110 #include <cyg/compat/uitron/uit_func.h> // uITRON |
|
|
111 |
|
|
112 externC void |
|
|
113 cyg_package_start( void ) |
|
|
114 { |
|
|
115 CYG_TEST_INIT(); |
|
|
116 CYG_TEST_INFO( "Calling cyg_uitron_start()" ); |
|
|
117 cyg_uitron_start(); |
|
|
118 } |
|
|
119 |
|
|
120 int intercom = 0; |
|
|
121 int intercount = 0; |
|
|
122 INT scratch = 0; |
|
|
123 |
|
|
124 extern "C" { |
|
|
125 void task1( unsigned int arg ); |
|
|
126 void task2( unsigned int arg ); |
|
|
127 void task3( unsigned int arg ); |
|
|
128 void task4( unsigned int arg ); |
|
|
129 } |
|
|
130 |
|
|
131 void task1( unsigned int arg ) |
|
|
132 { |
|
|
133 ER ercd; |
|
|
134 |
|
|
135 T_RSEM sem_info; |
|
|
136 T_RFLG flg_info; |
|
|
137 T_RMBX mbx_info; |
|
|
138 T_RMPF mpf_info; |
|
|
139 T_RMPL mpl_info; |
|
|
140 UINT flagptn; |
|
|
141 static char foo[] = "Test message"; |
|
|
142 T_MSG *msgptr = (T_MSG *)foo; |
|
|
143 T_MSG *rxptr = NULL; |
|
|
144 VP blfptr = (VP)foo; |
|
|
145 VP blkptr = (VP)foo; |
|
|
146 |
|
2
|
147 int delay = 10; |
|
|
148 if (cyg_test_is_simulator) |
|
|
149 delay = 3; |
|
|
150 |
|
0
|
151 CYG_TEST_INFO( "Task 1 running" ); |
|
|
152 ercd = get_tid( &scratch ); |
|
|
153 CYG_TEST_CHECK( E_OK == ercd, "get_tid bad ercd" ); |
|
|
154 CYG_TEST_CHECK( 1 == scratch, "tid not 1" ); |
|
|
155 |
|
|
156 // start a lower prio task to interact with |
|
|
157 intercom = 1; |
|
|
158 ercd = sta_tsk( 2, 222 ); |
|
|
159 CYG_TEST_CHECK( E_OK == ercd, "sta_tsk bad ercd" ); |
|
2
|
160 ercd = dly_tsk( delay ); |
|
0
|
161 CYG_TEST_CHECK( E_OK == ercd, "dly_tsk bad ercd" ); |
|
|
162 |
|
|
163 // Semaphores; all the illegal argument combinations first |
|
|
164 CYG_TEST_INFO( "Testing semaphore ops" ); |
|
|
165 #ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS |
|
|
166 ercd = sig_sem( -6 ); |
|
|
167 CYG_TEST_CHECK( E_ID == ercd, "sig_sem bad ercd !E_ID" ); |
|
|
168 ercd = sig_sem( 99 ); |
|
|
169 CYG_TEST_CHECK( E_ID == ercd, "sig_sem bad ercd !E_ID" ); |
|
|
170 ercd = wai_sem( -6 ); |
|
|
171 CYG_TEST_CHECK( E_ID == ercd, "wai_sem bad ercd !E_ID" ); |
|
|
172 ercd = wai_sem( 99 ); |
|
|
173 CYG_TEST_CHECK( E_ID == ercd, "wai_sem bad ercd !E_ID" ); |
|
|
174 ercd = preq_sem( -6 ); |
|
|
175 CYG_TEST_CHECK( E_ID == ercd, "preq_sem bad ercd !E_ID" ); |
|
|
176 ercd = preq_sem( 99 ); |
|
|
177 CYG_TEST_CHECK( E_ID == ercd, "preq_sem bad ercd !E_ID" ); |
|
2
|
178 ercd = twai_sem( -6, delay ); |
|
0
|
179 CYG_TEST_CHECK( E_ID == ercd, "twai_sem bad ercd !E_ID" ); |
|
2
|
180 ercd = twai_sem( 99, delay ); |
|
0
|
181 CYG_TEST_CHECK( E_ID == ercd, "twai_sem bad ercd !E_ID" ); |
|
|
182 ercd = twai_sem( 2, -999 ); |
|
|
183 CYG_TEST_CHECK( E_PAR == ercd, "twai_sem bad ercd !E_PAR" ); |
|
|
184 ercd = ref_sem( &sem_info, -6 ); |
|
|
185 CYG_TEST_CHECK( E_ID == ercd, "ref_sem bad ercd !E_ID" ); |
|
|
186 ercd = ref_sem( &sem_info, 99 ); |
|
|
187 CYG_TEST_CHECK( E_ID == ercd, "ref_sem bad ercd !E_ID" ); |
|
|
188 #ifndef CYGSEM_UITRON_PARAMS_NULL_IS_GOOD_PTR |
|
|
189 ercd = ref_sem( NULL, 2 ); |
|
|
190 CYG_TEST_CHECK( E_PAR == ercd, "ref_sem bad ercd !E_PAR" ); |
|
|
191 #endif |
|
|
192 CYG_TEST_PASS( "bad calls: sig_sem, [t]wai_sem, preq_sem, ref_sem" ); |
|
|
193 #endif // we can test bad param error returns |
|
|
194 |
|
|
195 // check the waitable functions versus dispatch disable |
|
|
196 ercd = preq_sem( 2 ); |
|
|
197 CYG_TEST_CHECK( E_TMOUT == ercd, "preq_sem bad ercd !E_TMOUT" ); |
|
2
|
198 ercd = twai_sem( 2, delay ); |
|
0
|
199 CYG_TEST_CHECK( E_TMOUT == ercd, "twai_sem bad ercd !E_TMOUT" ); |
|
|
200 ercd = twai_sem( 2, TMO_POL ); |
|
|
201 CYG_TEST_CHECK( E_TMOUT == ercd, "twai_sem(POL) bad ercd !E_TMOUT" ); |
|
|
202 ercd = dis_dsp(); |
|
|
203 CYG_TEST_CHECK( E_OK == ercd, "dis_dsp bad ercd" ); |
|
|
204 #ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS |
|
|
205 ercd = wai_sem( 2 ); |
|
|
206 CYG_TEST_CHECK( E_CTX == ercd, "wai_sem bad ercd !E_CTX" ); |
|
2
|
207 ercd = twai_sem( 2, delay ); |
|
0
|
208 CYG_TEST_CHECK( E_CTX == ercd, "twai_sem bad ercd !E_CTX" ); |
|
|
209 ercd = twai_sem( 2, TMO_FEVR ); |
|
|
210 CYG_TEST_CHECK( E_CTX == ercd, "twai_sem(FEVR) bad ercd !E_CTX" ); |
|
|
211 #endif // we can test bad param error returns |
|
|
212 ercd = twai_sem( 2, TMO_POL ); |
|
|
213 CYG_TEST_CHECK( E_TMOUT == ercd, "twai_sem(POL) bad ercd !E_TMOUT" ); |
|
|
214 ercd = preq_sem( 2 ); |
|
|
215 CYG_TEST_CHECK( E_TMOUT == ercd, "preq_sem bad ercd !E_TMOUT" ); |
|
|
216 ercd = ena_dsp(); |
|
|
217 CYG_TEST_CHECK( E_OK == ercd, "ena_dsp bad ercd" ); |
|
|
218 ercd = preq_sem( 2 ); |
|
|
219 CYG_TEST_CHECK( E_TMOUT == ercd, "preq_sem bad ercd !E_TMOUT" ); |
|
2
|
220 ercd = twai_sem( 2, delay ); |
|
0
|
221 CYG_TEST_CHECK( E_TMOUT == ercd, "twai_sem bad ercd !E_TMOUT" ); |
|
|
222 ercd = twai_sem( 2, TMO_POL ); |
|
|
223 CYG_TEST_CHECK( E_TMOUT == ercd, "twai_sem(POL) bad ercd !E_TMOUT" ); |
|
|
224 CYG_TEST_PASS( "bad calls: wai_sem, twai_sem with dis_dsp" ); |
|
|
225 |
|
|
226 // check ref_sem with various states |
|
|
227 ercd = ref_sem( &sem_info, 2 ); |
|
|
228 CYG_TEST_CHECK( E_OK == ercd, "ref_sem bad ercd" ); |
|
|
229 CYG_TEST_CHECK( 0 == sem_info.wtsk, "sem.wtsk should be 0" ); |
|
|
230 CYG_TEST_CHECK( 0 == sem_info.semcnt, "semcnt should be 0" ); |
|
|
231 ercd = sig_sem( 2 ); |
|
|
232 CYG_TEST_CHECK( E_OK == ercd, "sig_sem bad ercd" ); |
|
|
233 ercd = ref_sem( &sem_info, 2 ); |
|
|
234 CYG_TEST_CHECK( E_OK == ercd, "ref_sem bad ercd" ); |
|
|
235 CYG_TEST_CHECK( 0 == sem_info.wtsk, "sem.wtsk should be 0" ); |
|
|
236 CYG_TEST_CHECK( 1 == sem_info.semcnt, "semcnt should be 1" ); |
|
|
237 ercd = preq_sem( 2 ); |
|
|
238 CYG_TEST_CHECK( E_OK == ercd, "wai_sem bad ercd" ); |
|
|
239 ercd = ref_sem( &sem_info, 2 ); |
|
|
240 CYG_TEST_CHECK( E_OK == ercd, "ref_sem bad ercd" ); |
|
|
241 CYG_TEST_CHECK( 0 == sem_info.wtsk, "sem.wtsk should be 0" ); |
|
|
242 CYG_TEST_CHECK( 0 == sem_info.semcnt, "semcnt should be 0" ); |
|
|
243 ercd = ref_sem( &sem_info, 2 ); |
|
|
244 CYG_TEST_CHECK( E_OK == ercd, "ref_sem bad ercd" ); |
|
|
245 CYG_TEST_CHECK( 0 == sem_info.wtsk, "sem.wtsk should be 0" ); |
|
|
246 CYG_TEST_CHECK( 0 == sem_info.semcnt, "semcnt should be 0" ); |
|
|
247 ercd = sig_sem( 2 ); |
|
|
248 CYG_TEST_CHECK( E_OK == ercd, "sig_sem bad ercd" ); |
|
|
249 ercd = sig_sem( 2 ); |
|
|
250 CYG_TEST_CHECK( E_OK == ercd, "sig_sem bad ercd" ); |
|
|
251 ercd = ref_sem( &sem_info, 2 ); |
|
|
252 CYG_TEST_CHECK( E_OK == ercd, "ref_sem bad ercd" ); |
|
|
253 CYG_TEST_CHECK( 0 == sem_info.wtsk, "sem.wtsk should be 0" ); |
|
|
254 CYG_TEST_CHECK( 2 == sem_info.semcnt, "semcnt should be 2" ); |
|
|
255 ercd = wai_sem( 2 ); |
|
|
256 CYG_TEST_CHECK( E_OK == ercd, "wai_sem bad ercd" ); |
|
|
257 ercd = ref_sem( &sem_info, 2 ); |
|
|
258 CYG_TEST_CHECK( E_OK == ercd, "ref_sem bad ercd" ); |
|
|
259 CYG_TEST_CHECK( 0 == sem_info.wtsk, "sem.wtsk should be 0" ); |
|
|
260 CYG_TEST_CHECK( 1 == sem_info.semcnt, "semcnt should be 1" ); |
|
2
|
261 ercd = twai_sem( 2, delay ); |
|
0
|
262 CYG_TEST_CHECK( E_OK == ercd, "wai_sem bad ercd" ); |
|
|
263 ercd = ref_sem( &sem_info, 2 ); |
|
|
264 CYG_TEST_CHECK( E_OK == ercd, "ref_sem bad ercd" ); |
|
|
265 CYG_TEST_CHECK( 0 == sem_info.wtsk, "sem.wtsk should be 0" ); |
|
|
266 CYG_TEST_CHECK( 0 == sem_info.semcnt, "semcnt should be 0" ); |
|
|
267 intercom = 0; |
|
2
|
268 ercd = dly_tsk( delay ); |
|
0
|
269 CYG_TEST_CHECK( E_OK == ercd, "dly_tsk bad ercd" ); |
|
|
270 intercom = 1; |
|
|
271 ercd = ref_sem( &sem_info, 2 ); |
|
|
272 CYG_TEST_CHECK( E_OK == ercd, "ref_sem bad ercd" ); |
|
|
273 CYG_TEST_CHECK( 0 != sem_info.wtsk, "sem.wtsk should be non0" ); |
|
|
274 CYG_TEST_CHECK( 0 == sem_info.semcnt, "semcnt should be 0" ); |
|
|
275 ercd = sig_sem( 2 ); |
|
|
276 CYG_TEST_CHECK( E_OK == ercd, "sig_sem bad ercd" ); |
|
|
277 ercd = ref_sem( &sem_info, 2 ); |
|
|
278 CYG_TEST_CHECK( E_OK == ercd, "ref_sem bad ercd" ); |
|
|
279 CYG_TEST_CHECK( 0 == sem_info.wtsk, "sem.wtsk should be non0" ); |
|
|
280 #if 1 |
|
|
281 CYG_TEST_CHECK( 0 == sem_info.semcnt, "semcnt should be 0" ); |
|
|
282 #else // old, non-uITRON semantics |
|
|
283 CYG_TEST_CHECK( 1 == sem_info.semcnt, "semcnt should be 1" ); |
|
|
284 #endif |
|
2
|
285 ercd = dly_tsk( delay ); // let task 2 pick up the signal |
|
0
|
286 CYG_TEST_CHECK( E_OK == ercd, "dly_tsk bad ercd" ); |
|
|
287 ercd = ref_sem( &sem_info, 2 ); |
|
|
288 CYG_TEST_CHECK( E_OK == ercd, "ref_sem bad ercd" ); |
|
|
289 CYG_TEST_CHECK( 0 == sem_info.wtsk, "sem.wtsk should be 0" ); |
|
|
290 CYG_TEST_CHECK( 0 == sem_info.semcnt, "semcnt should be 0" ); |
|
|
291 CYG_TEST_PASS( "good calls: sig_sem, [t]wai,preq_sem with ref_sem" ); |
|
|
292 |
|
|
293 // Flags; all the illegal argument combinations first |
|
|
294 CYG_TEST_INFO( "Testing flag ops" ); |
|
|
295 #ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS |
|
|
296 ercd = set_flg( -6, 1 ); |
|
|
297 CYG_TEST_CHECK( E_ID == ercd, "set_flg bad ercd !E_ID" ); |
|
|
298 ercd = set_flg( 99, 1 ); |
|
|
299 CYG_TEST_CHECK( E_ID == ercd, "set_flg bad ercd !E_ID" ); |
|
|
300 ercd = clr_flg( -6, 1 ); |
|
|
301 CYG_TEST_CHECK( E_ID == ercd, "clr_flg bad ercd !E_ID" ); |
|
|
302 ercd = clr_flg( 99, 1 ); |
|
|
303 CYG_TEST_CHECK( E_ID == ercd, "sig_flg bad ercd !E_ID" ); |
|
|
304 ercd = wai_flg( &flagptn, -6, 7, TWF_ANDW ); |
|
|
305 CYG_TEST_CHECK( E_ID == ercd, "wai_flg bad ercd !E_ID" ); |
|
|
306 ercd = wai_flg( &flagptn, 99, 7, TWF_ANDW ); |
|
|
307 CYG_TEST_CHECK( E_ID == ercd, "wai_flg bad ercd !E_ID" ); |
|
|
308 #ifndef CYGSEM_UITRON_PARAMS_NULL_IS_GOOD_PTR |
|
|
309 ercd = wai_flg( NULL, 2, 7, TWF_ANDW ); |
|
|
310 CYG_TEST_CHECK( E_PAR == ercd, "wai_flg bad ercd !E_PAR" ); |
|
|
311 #endif |
|
|
312 ercd = wai_flg( &flagptn, 2, 7, 34657 ); |
|
|
313 CYG_TEST_CHECK( E_PAR == ercd, "wai_flg bad ercd !E_PAR" ); |
|
|
314 ercd = wai_flg( &flagptn, 2, 0, TWF_ANDW ); |
|
|
315 CYG_TEST_CHECK( E_PAR == ercd, "wai_flg bad ercd !E_PAR" ); |
|
|
316 ercd = pol_flg( &flagptn, -6, 7, TWF_ANDW ); |
|
|
317 CYG_TEST_CHECK( E_ID == ercd, "pol_flg bad ercd !E_ID" ); |
|
|
318 ercd = pol_flg( &flagptn, 99, 7, TWF_ANDW ); |
|
|
319 CYG_TEST_CHECK( E_ID == ercd, "pol_flg bad ercd !E_ID" ); |
|
|
320 #ifndef CYGSEM_UITRON_PARAMS_NULL_IS_GOOD_PTR |
|
|
321 ercd = pol_flg( NULL, 2, 7, TWF_ANDW ); |
|
|
322 CYG_TEST_CHECK( E_PAR == ercd, "pol_flg bad ercd !E_PAR" ); |
|
|
323 #endif |
|
|
324 ercd = pol_flg( &flagptn, 2, 7, 34657 ); |
|
|
325 CYG_TEST_CHECK( E_PAR == ercd, "pol_flg bad ercd !E_PAR" ); |
|
|
326 ercd = pol_flg( &flagptn, 2, 0, TWF_ANDW ); |
|
|
327 CYG_TEST_CHECK( E_PAR == ercd, "pol_flg bad ercd !E_PAR" ); |
|
2
|
328 ercd = twai_flg( &flagptn, -6, 7, TWF_ANDW, delay ); |
|
0
|
329 CYG_TEST_CHECK( E_ID == ercd, "twai_flg bad ercd !E_ID" ); |
|
2
|
330 ercd = twai_flg( &flagptn, 99, 7, TWF_ANDW, delay ); |
|
0
|
331 CYG_TEST_CHECK( E_ID == ercd, "twai_flg bad ercd !E_ID" ); |
|
|
332 #ifndef CYGSEM_UITRON_PARAMS_NULL_IS_GOOD_PTR |
|
2
|
333 ercd = twai_flg( NULL, 2, 7, TWF_ANDW, delay ); |
|
0
|
334 CYG_TEST_CHECK( E_PAR == ercd, "twai_flg bad ercd !E_PAR" ); |
|
|
335 #endif |
|
2
|
336 ercd = twai_flg( &flagptn, 2, 7, 34657, delay ); |
|
0
|
337 CYG_TEST_CHECK( E_PAR == ercd, "twai_flg bad ercd !E_PAR" ); |
|
|
338 ercd = twai_flg( &flagptn, 2, 7, TWF_ANDW, -999 ); |
|
|
339 CYG_TEST_CHECK( E_PAR == ercd, "twai_flg bad ercd !E_PAR" ); |
|
2
|
340 ercd = twai_flg( &flagptn, 2, 0, TWF_ANDW, delay ); |
|
0
|
341 CYG_TEST_CHECK( E_PAR == ercd, "twai_flg bad ercd !E_PAR" ); |
|
|
342 ercd = ref_flg( &flg_info, -6 ); |
|
|
343 CYG_TEST_CHECK( E_ID == ercd, "ref_flg bad ercd !E_ID" ); |
|
|
344 ercd = ref_flg( &flg_info, 99 ); |
|
|
345 CYG_TEST_CHECK( E_ID == ercd, "ref_flg bad ercd !E_ID" ); |
|
|
346 #ifndef CYGSEM_UITRON_PARAMS_NULL_IS_GOOD_PTR |
|
|
347 ercd = ref_flg( NULL, 2 ); |
|
|
348 CYG_TEST_CHECK( E_PAR == ercd, "ref_flg bad ercd !E_PAR" ); |
|
|
349 #endif |
|
|
350 CYG_TEST_PASS( "bad calls: set_flg, clr_flg, [t]wai,pol_flg, ref_flg" ); |
|
|
351 #endif // we can test bad param error returns |
|
|
352 |
|
|
353 // check the waitable functions versus dispatch disable |
|
|
354 ercd = pol_flg( &flagptn, 2, 7, TWF_ANDW ); |
|
|
355 CYG_TEST_CHECK( E_TMOUT == ercd, "pol_flg bad ercd !E_TMOUT" ); |
|
2
|
356 ercd = twai_flg( &flagptn, 2, 7, TWF_ANDW, delay ); |
|
0
|
357 CYG_TEST_CHECK( E_TMOUT == ercd, "twai_flg bad ercd !E_TMOUT" ); |
|
|
358 ercd = twai_flg( &flagptn, 2, 7, TWF_ANDW, TMO_POL ); |
|
|
359 CYG_TEST_CHECK( E_TMOUT == ercd, "twai_flg(POL) bad ercd !E_TMOUT" ); |
|
|
360 ercd = dis_dsp(); |
|
|
361 CYG_TEST_CHECK( E_OK == ercd, "dis_dsp bad ercd" ); |
|
|
362 #ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS |
|
|
363 ercd = wai_flg( &flagptn, 2, 7, TWF_ANDW ); |
|
|
364 CYG_TEST_CHECK( E_CTX == ercd, "wai_flg bad ercd !E_CTX" ); |
|
2
|
365 ercd = twai_flg( &flagptn, 2, 7, TWF_ANDW, delay ); |
|
0
|
366 CYG_TEST_CHECK( E_CTX == ercd, "twai_flg bad ercd !E_CTX" ); |
|
|
367 ercd = twai_flg( &flagptn, 2, 7, TWF_ANDW, TMO_FEVR ); |
|
|
368 CYG_TEST_CHECK( E_CTX == ercd, "twai_flg(FEVR) bad ercd !E_CTX" ); |
|
|
369 #endif // we can test bad param error returns |
|
|
370 ercd = twai_flg( &flagptn, 2, 7, TWF_ANDW, TMO_POL ); |
|
|
371 CYG_TEST_CHECK( E_TMOUT == ercd, "twai_flg(POL) bad ercd !E_TMOUT" ); |
|
|
372 ercd = pol_flg( &flagptn, 2, 7, TWF_ANDW ); |
|
|
373 CYG_TEST_CHECK( E_TMOUT == ercd, "pol_flg bad ercd !E_TMOUT" ); |
|
|
374 ercd = ena_dsp(); |
|
|
375 CYG_TEST_CHECK( E_OK == ercd, "ena_dsp bad ercd" ); |
|
|
376 ercd = pol_flg( &flagptn, 2, 7, TWF_ANDW ); |
|
|
377 CYG_TEST_CHECK( E_TMOUT == ercd, "pol_flg bad ercd !E_TMOUT" ); |
|
2
|
378 ercd = twai_flg( &flagptn, 2, 7, TWF_ANDW, delay ); |
|
0
|
379 CYG_TEST_CHECK( E_TMOUT == ercd, "twai_flg bad ercd !E_TMOUT" ); |
|
|
380 ercd = twai_flg( &flagptn, 2, 7, TWF_ANDW, TMO_POL ); |
|
|
381 CYG_TEST_CHECK( E_TMOUT == ercd, "twai_flg(POL) bad ercd !E_TMOUT" ); |
|
|
382 CYG_TEST_PASS( "bad calls: wai_flg, twai_flg with dis_dsp" ); |
|
|
383 |
|
|
384 // check ref_flg with various states |
|
|
385 ercd = ref_flg( &flg_info, 2 ); |
|
|
386 CYG_TEST_CHECK( E_OK == ercd, "ref_flg bad ercd" ); |
|
|
387 CYG_TEST_CHECK( 0 == flg_info.wtsk, "flg.wtsk should be non0" ); |
|
|
388 CYG_TEST_CHECK( 0 == flg_info.flgptn, "flgptn should be 0" ); |
|
|
389 intercom = 0; |
|
2
|
390 ercd = dly_tsk( delay ); // let task 2 start waiting |
|
0
|
391 CYG_TEST_CHECK( E_OK == ercd, "dly_tsk bad ercd" ); |
|
|
392 intercom = 1; |
|
|
393 ercd = ref_flg( &flg_info, 2 ); |
|
|
394 CYG_TEST_CHECK( E_OK == ercd, "ref_flg bad ercd" ); |
|
|
395 CYG_TEST_CHECK( 0 != flg_info.wtsk, "flg.wtsk should be non0" ); |
|
|
396 CYG_TEST_CHECK( 0 == flg_info.flgptn, "flgptn should be 0" ); |
|
|
397 ercd = set_flg( 2, 0x5555 ); |
|
|
398 CYG_TEST_CHECK( E_OK == ercd, "sig_flg bad ercd" ); |
|
2
|
399 ercd = dly_tsk( delay ); |
|
0
|
400 CYG_TEST_CHECK( E_OK == ercd, "dly_tsk bad ercd" ); |
|
|
401 ercd = ref_flg( &flg_info, 2 ); |
|
|
402 CYG_TEST_CHECK( E_OK == ercd, "ref_flg bad ercd" ); |
|
|
403 CYG_TEST_CHECK( 0 != flg_info.wtsk, "flg.wtsk should be non0" ); |
|
|
404 CYG_TEST_CHECK( 0x5555 == flg_info.flgptn, "flgptn should be 0x5555" ); |
|
|
405 ercd = clr_flg( 2, 0xF0F0 ); |
|
|
406 CYG_TEST_CHECK( E_OK == ercd, "clr_flg bad ercd" ); |
|
2
|
407 ercd = dly_tsk( delay ); |
|
0
|
408 CYG_TEST_CHECK( E_OK == ercd, "dly_tsk bad ercd" ); |
|
|
409 ercd = ref_flg( &flg_info, 2 ); |
|
|
410 CYG_TEST_CHECK( E_OK == ercd, "ref_flg bad ercd" ); |
|
|
411 CYG_TEST_CHECK( 0 != flg_info.wtsk, "flg.wtsk should be non0" ); |
|
|
412 CYG_TEST_CHECK( 0x5050 == flg_info.flgptn, "flgptn should be 0x5050" ); |
|
|
413 ercd = set_flg( 2, 0xFFFF ); |
|
|
414 CYG_TEST_CHECK( E_OK == ercd, "sig_flg bad ercd" ); |
|
2
|
415 ercd = dly_tsk( delay ); |
|
0
|
416 CYG_TEST_CHECK( E_OK == ercd, "dly_tsk bad ercd" ); |
|
|
417 ercd = ref_flg( &flg_info, 2 ); |
|
|
418 CYG_TEST_CHECK( E_OK == ercd, "ref_flg bad ercd" ); |
|
|
419 CYG_TEST_CHECK( 0 == flg_info.wtsk, "flg.wtsk should be 0" ); |
|
|
420 CYG_TEST_CHECK( 0xFFFF == flg_info.flgptn, "flgptn should be 0xFFFF" ); |
|
|
421 CYG_TEST_PASS( "good calls: clr_flg, set_flg, wai_flg with ref_flg" ); |
|
|
422 |
|
|
423 // Mailboxes; all the illegal argument combinations first |
|
|
424 CYG_TEST_INFO( "Testing mailbox ops" ); |
|
|
425 #ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS |
|
|
426 ercd = snd_msg( -6, msgptr ); |
|
|
427 CYG_TEST_CHECK( E_ID == ercd, "snd_msg bad ercd !E_ID" ); |
|
|
428 ercd = snd_msg( 99, msgptr ); |
|
|
429 CYG_TEST_CHECK( E_ID == ercd, "snd_msg bad ercd !E_ID" ); |
|
|
430 #ifndef CYGSEM_UITRON_PARAMS_NULL_IS_GOOD_PTR |
|
|
431 ercd = snd_msg( 2, NULL ); |
|
|
432 CYG_TEST_CHECK( E_PAR == ercd, "snd_msg bad ercd !E_PAR" ); |
|
|
433 #endif |
|
|
434 ercd = rcv_msg( &rxptr, -6 ); |
|
|
435 CYG_TEST_CHECK( E_ID == ercd, "rcv_msg bad ercd !E_ID" ); |
|
|
436 ercd = rcv_msg( &rxptr, 99 ); |
|
|
437 CYG_TEST_CHECK( E_ID == ercd, "rcv_msg bad ercd !E_ID" ); |
|
|
438 #ifndef CYGSEM_UITRON_PARAMS_NULL_IS_GOOD_PTR |
|
|
439 ercd = rcv_msg( NULL, 2 ); |
|
|
440 CYG_TEST_CHECK( E_PAR == ercd, "rcv_msg bad ercd !E_PAR" ); |
|
|
441 #endif |
|
|
442 ercd = prcv_msg( &rxptr, -6 ); |
|
|
443 CYG_TEST_CHECK( E_ID == ercd, "prcv_msg bad ercd !E_ID" ); |
|
|
444 ercd = prcv_msg( &rxptr, 99 ); |
|
|
445 CYG_TEST_CHECK( E_ID == ercd, "prcv_msg bad ercd !E_ID" ); |
|
|
446 #ifndef CYGSEM_UITRON_PARAMS_NULL_IS_GOOD_PTR |
|
|
447 ercd = prcv_msg( NULL, 2 ); |
|
|
448 CYG_TEST_CHECK( E_PAR == ercd, "prcv_msg bad ercd !E_PAR" ); |
|
|
449 #endif |
|
2
|
450 ercd = trcv_msg( &rxptr, -6, delay ); |
|
0
|
451 CYG_TEST_CHECK( E_ID == ercd, "trcv_msg bad ercd !E_ID" ); |
|
2
|
452 ercd = trcv_msg( &rxptr, 99, delay ); |
|
0
|
453 CYG_TEST_CHECK( E_ID == ercd, "trcv_msg bad ercd !E_ID" ); |
|
|
454 ercd = trcv_msg( &rxptr, 2, -999 ); |
|
|
455 CYG_TEST_CHECK( E_PAR == ercd, "trcv_msg bad ercd !E_PAR" ); |
|
|
456 #ifndef CYGSEM_UITRON_PARAMS_NULL_IS_GOOD_PTR |
|
2
|
457 ercd = trcv_msg( NULL, 2, delay ); |
|
0
|
458 CYG_TEST_CHECK( E_PAR == ercd, "trcv_msg bad ercd !E_PAR" ); |
|
|
459 #endif |
|
|
460 ercd = ref_mbx( &mbx_info, -6 ); |
|
|
461 CYG_TEST_CHECK( E_ID == ercd, "ref_mbx bad ercd !E_ID" ); |
|
|
462 ercd = ref_mbx( &mbx_info, 99 ); |
|
|
463 CYG_TEST_CHECK( E_ID == ercd, "ref_mbx bad ercd !E_ID" ); |
|
|
464 #ifndef CYGSEM_UITRON_PARAMS_NULL_IS_GOOD_PTR |
|
|
465 ercd = ref_mbx( NULL, 2 ); |
|
|
466 CYG_TEST_CHECK( E_PAR == ercd, "ref_mbx bad ercd !E_PAR" ); |
|
|
467 #endif |
|
|
468 CYG_TEST_PASS( "bad calls: snd_msg, [pt]rcv_msg, ref_mbx" ); |
|
|
469 #endif // we can test bad param error returns |
|
|
470 |
|
|
471 // check the waitable functions versus dispatch disable |
|
|
472 ercd = prcv_msg( &rxptr, 2 ); |
|
|
473 CYG_TEST_CHECK( E_TMOUT == ercd, "prcv_msg bad ercd !E_TMOUT" ); |
|
2
|
474 ercd = trcv_msg( &rxptr, 2, delay ); |
|
0
|
475 CYG_TEST_CHECK( E_TMOUT == ercd, "trcv_msg bad ercd !E_TMOUT" ); |
|
|
476 ercd = trcv_msg( &rxptr, 2, TMO_POL ); |
|
|
477 CYG_TEST_CHECK( E_TMOUT == ercd, "trcv_msg(POL) bad ercd !E_TMOUT" ); |
|
|
478 ercd = dis_dsp(); |
|
|
479 CYG_TEST_CHECK( E_OK == ercd, "dis_dsp bad ercd" ); |
|
|
480 #ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS |
|
|
481 ercd = rcv_msg( &rxptr, 2 ); |
|
|
482 CYG_TEST_CHECK( E_CTX == ercd, "rcv_msg bad ercd !E_CTX" ); |
|
2
|
483 ercd = trcv_msg( &rxptr, 2, delay ); |
|
0
|
484 CYG_TEST_CHECK( E_CTX == ercd, "trcv_msg bad ercd !E_CTX" ); |
|
|
485 ercd = trcv_msg( &rxptr, 2, TMO_FEVR ); |
|
|
486 CYG_TEST_CHECK( E_CTX == ercd, "trcv_msg(FEVR) bad ercd !E_CTX" ); |
|
|
487 #endif // we can test bad param error returns |
|
|
488 ercd = trcv_msg( &rxptr, 2, TMO_POL ); |
|
|
489 CYG_TEST_CHECK( E_TMOUT == ercd, "trcv_msg(POL) bad ercd !E_TMOUT" ); |
|
|
490 ercd = prcv_msg( &rxptr, 2 ); |
|
|
491 CYG_TEST_CHECK( E_TMOUT == ercd, "prcv_msg bad ercd !E_TMOUT" ); |
|
|
492 ercd = ena_dsp(); |
|
|
493 CYG_TEST_CHECK( E_OK == ercd, "ena_dsp bad ercd" ); |
|
|
494 ercd = prcv_msg( &rxptr, 2 ); |
|
|
495 CYG_TEST_CHECK( E_TMOUT == ercd, "prcv_msg bad ercd !E_TMOUT" ); |
|
2
|
496 ercd = trcv_msg( &rxptr, 2, delay ); |
|
0
|
497 CYG_TEST_CHECK( E_TMOUT == ercd, "trcv_msg bad ercd !E_TMOUT" ); |
|
|
498 ercd = trcv_msg( &rxptr, 2, TMO_POL ); |
|
|
499 CYG_TEST_CHECK( E_TMOUT == ercd, "trcv_msg(POL) bad ercd !E_TMOUT" ); |
|
|
500 CYG_TEST_PASS( "bad calls: rcv_msg, trcv_msg with dis_dsp" ); |
|
|
501 |
|
|
502 // check ref_mbx with various states |
|
|
503 ercd = ref_mbx( &mbx_info, 2 ); |
|
|
504 CYG_TEST_CHECK( E_OK == ercd, "ref_mbx bad ercd" ); |
|
|
505 CYG_TEST_CHECK( 0 == mbx_info.wtsk, "mbx.wtsk should be 0" ); |
|
|
506 CYG_TEST_CHECK( NADR == mbx_info.pk_msg, "mbx peek should be NADR" ); |
|
|
507 intercom = 0; |
|
2
|
508 ercd = dly_tsk( delay ); // let task 2 start waiting |
|
0
|
509 CYG_TEST_CHECK( E_OK == ercd, "dly_tsk bad ercd" ); |
|
|
510 intercom = 1; |
|
|
511 ercd = ref_mbx( &mbx_info, 2 ); |
|
|
512 CYG_TEST_CHECK( E_OK == ercd, "ref_mbx bad ercd" ); |
|
|
513 CYG_TEST_CHECK( 0 != mbx_info.wtsk, "mbx.wtsk should be non0" ); |
|
|
514 CYG_TEST_CHECK( NADR == mbx_info.pk_msg, "mbx peek should be NADR" ); |
|
|
515 ercd = snd_msg( 2, msgptr ); |
|
|
516 CYG_TEST_CHECK( E_OK == ercd, "snd_msg bad ercd" ); |
|
|
517 ercd = ref_mbx( &mbx_info, 2 ); |
|
|
518 CYG_TEST_CHECK( E_OK == ercd, "ref_mbx bad ercd" ); |
|
|
519 CYG_TEST_CHECK( 0 == mbx_info.wtsk, "mbx.wtsk should be 0" ); |
|
|
520 #if 1 |
|
|
521 CYG_TEST_CHECK( NADR == mbx_info.pk_msg, "mbx peek should be NADR" ); |
|
|
522 #else // old, non-uITRON semantics |
|
|
523 CYG_TEST_CHECK( msgptr == mbx_info.pk_msg, "mbx peek should be msgptr" ); |
|
|
524 #endif |
|
2
|
525 ercd = dly_tsk( delay ); |
|
0
|
526 CYG_TEST_CHECK( E_OK == ercd, "dly_tsk bad ercd" ); |
|
|
527 ercd = ref_mbx( &mbx_info, 2 ); |
|
|
528 CYG_TEST_CHECK( E_OK == ercd, "ref_mbx bad ercd" ); |
|
|
529 CYG_TEST_CHECK( 0 == mbx_info.wtsk, "mbx.wtsk should be 0" ); |
|
|
530 CYG_TEST_CHECK( NADR == mbx_info.pk_msg, "mbx peek should be NADR" ); |
|
|
531 // fill the message box, expect E_QOVR |
|
|
532 for ( scratch = 0 ; scratch < 100 ; scratch++ ) { |
|
|
533 if ( E_OK != ( ercd = snd_msg( 2, msgptr ) ) ) |
|
|
534 break; |
|
|
535 } |
|
|
536 CYG_TEST_CHECK( (100 == scratch) || (E_QOVR == ercd), |
|
|
537 "snd_msg bad ercd !E_QOVR/E_OK" ); |
|
|
538 // empty the message box, expect the right number and E_TMOUT |
|
|
539 for ( ; 1 ; scratch-- ) { |
|
|
540 if ( E_OK != ( ercd = prcv_msg( &rxptr, 2 ) ) ) |
|
|
541 break; |
|
|
542 } |
|
|
543 CYG_TEST_CHECK( 0 == scratch, "rcv_msg count bad scratch!=0" ); |
|
|
544 CYG_TEST_CHECK( E_TMOUT == ercd, "rcv_msg bad ercd !E_TMOUT" ); |
|
|
545 |
|
|
546 CYG_TEST_PASS( "good calls: rcv_msg, snd_msg with ref_msg" ); |
|
|
547 |
|
|
548 // Fixed block memory pools: all the illegal argument combinations first |
|
|
549 CYG_TEST_INFO( "Testing fixed block memory ops" ); |
|
|
550 #ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS |
|
|
551 ercd = rel_blf( -6, blfptr ); |
|
|
552 CYG_TEST_CHECK( E_ID == ercd, "rel_blf bad ercd !E_ID" ); |
|
|
553 ercd = rel_blf( 99, blfptr ); |
|
|
554 CYG_TEST_CHECK( E_ID == ercd, "rel_blf bad ercd !E_ID" ); |
|
|
555 #ifndef CYGSEM_UITRON_PARAMS_NULL_IS_GOOD_PTR |
|
|
556 ercd = rel_blf( 2, NULL ); |
|
|
557 CYG_TEST_CHECK( E_PAR == ercd, "rel_blf bad ercd !E_PAR" ); |
|
|
558 #endif |
|
|
559 #endif // we can test bad param error returns |
|
|
560 ercd = rel_blf( 2, blfptr ); // it did not come from a mpf |
|
|
561 CYG_TEST_CHECK( E_PAR == ercd, "rel_blf bad ercd !E_PAR" ); |
|
|
562 #ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS |
|
|
563 ercd = get_blf( &blfptr, -6 ); |
|
|
564 CYG_TEST_CHECK( E_ID == ercd, "get_blf bad ercd !E_ID" ); |
|
|
565 ercd = get_blf( &blfptr, 99 ); |
|
|
566 CYG_TEST_CHECK( E_ID == ercd, "get_blf bad ercd !E_ID" ); |
|
|
567 #ifndef CYGSEM_UITRON_PARAMS_NULL_IS_GOOD_PTR |
|
|
568 ercd = get_blf( NULL, 2 ); |
|
|
569 CYG_TEST_CHECK( E_PAR == ercd, "get_blf bad ercd !E_PAR" ); |
|
|
570 #endif |
|
|
571 ercd = pget_blf( &blfptr, -6 ); |
|
|
572 CYG_TEST_CHECK( E_ID == ercd, "pget_blf bad ercd !E_ID" ); |
|
|
573 ercd = pget_blf( &blfptr, 99 ); |
|
|
574 CYG_TEST_CHECK( E_ID == ercd, "pget_blf bad ercd !E_ID" ); |
|
|
575 #ifndef CYGSEM_UITRON_PARAMS_NULL_IS_GOOD_PTR |
|
|
576 ercd = pget_blf( NULL, 2 ); |
|
|
577 CYG_TEST_CHECK( E_PAR == ercd, "pget_blf bad ercd !E_PAR" ); |
|
|
578 #endif |
|
2
|
579 ercd = tget_blf( &blfptr, -6, delay ); |
|
0
|
580 CYG_TEST_CHECK( E_ID == ercd, "tget_blf bad ercd !E_ID" ); |
|
2
|
581 ercd = tget_blf( &blfptr, 99, delay ); |
|
0
|
582 CYG_TEST_CHECK( E_ID == ercd, "tget_blf bad ercd !E_ID" ); |
|
|
583 ercd = tget_blf( &blfptr, 2, -999 ); |
|
|
584 CYG_TEST_CHECK( E_PAR == ercd, "tget_blf bad ercd !E_PAR" ); |
|
|
585 #ifndef CYGSEM_UITRON_PARAMS_NULL_IS_GOOD_PTR |
|
2
|
586 ercd = tget_blf( NULL, 2, delay ); |
|
0
|
587 CYG_TEST_CHECK( E_PAR == ercd, "tget_blf bad ercd !E_PAR" ); |
|
|
588 #endif |
|
|
589 ercd = ref_mpf( &mpf_info, -6 ); |
|
|
590 CYG_TEST_CHECK( E_ID == ercd, "ref_mpf bad ercd !E_ID" ); |
|
|
591 ercd = ref_mpf( &mpf_info, 99 ); |
|
|
592 CYG_TEST_CHECK( E_ID == ercd, "ref_mpf bad ercd !E_ID" ); |
|
|
593 #ifndef CYGSEM_UITRON_PARAMS_NULL_IS_GOOD_PTR |
|
|
594 ercd = ref_mpf( NULL, 2 ); |
|
|
595 CYG_TEST_CHECK( E_PAR == ercd, "ref_mpf bad ercd !E_PAR" ); |
|
|
596 #endif |
|
|
597 CYG_TEST_PASS( "bad calls: rel_blf, [pt]get_blf, ref_mpf " ); |
|
|
598 #endif // we can test bad param error returns |
|
|
599 |
|
|
600 // check the waitable functions versus dispatch disable |
|
|
601 ercd = pget_blf( &blfptr, 2 ); |
|
|
602 CYG_TEST_CHECK( E_OK == ercd, "pget_blf bad ercd" ); |
|
|
603 ercd = rel_blf( 2, blfptr ); |
|
|
604 CYG_TEST_CHECK( E_OK == ercd, "rel_blf bad ercd" ); |
|
2
|
605 ercd = tget_blf( &blfptr, 2, delay ); |
|
0
|
606 CYG_TEST_CHECK( E_OK == ercd, "tget_blf bad ercd" ); |
|
|
607 ercd = dis_dsp(); |
|
|
608 CYG_TEST_CHECK( E_OK == ercd, "dis_dsp bad ercd" ); |
|
|
609 ercd = rel_blf( 2, blfptr ); |
|
|
610 CYG_TEST_CHECK( E_OK == ercd, "rel_blf bad ercd" ); |
|
|
611 #ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS |
|
|
612 ercd = get_blf( &blfptr, 2 ); |
|
|
613 CYG_TEST_CHECK( E_CTX == ercd, "get_blf bad ercd !E_CTX" ); |
|
2
|
614 ercd = tget_blf( &blfptr, 2, delay ); |
|
0
|
615 CYG_TEST_CHECK( E_CTX == ercd, "tget_blf bad ercd !E_CTX" ); |
|
|
616 #endif // we can test bad param error returns |
|
|
617 ercd = ena_dsp(); |
|
|
618 CYG_TEST_CHECK( E_OK == ercd, "ena_dsp bad ercd" ); |
|
|
619 ercd = pget_blf( &blfptr, 2 ); |
|
|
620 CYG_TEST_CHECK( E_OK == ercd, "pget_blf bad ercd" ); |
|
|
621 ercd = rel_blf( 2, blfptr ); |
|
|
622 CYG_TEST_CHECK( E_OK == ercd, "rel_blf bad ercd" ); |
|
2
|
623 ercd = tget_blf( &blfptr, 2, delay ); |
|
0
|
624 CYG_TEST_CHECK( E_OK == ercd, "tget_blf bad ercd" ); |
|
|
625 ercd = rel_blf( 2, blfptr ); |
|
|
626 CYG_TEST_CHECK( E_OK == ercd, "rel_blf bad ercd" ); |
|
|
627 // consume the whole thing then do it again, expecting E_TMOUT |
|
|
628 while ( E_OK == (ercd = pget_blf( &blfptr, 2 ) ) ) |
|
|
629 continue; |
|
|
630 CYG_TEST_CHECK( E_TMOUT == ercd, "pget_blf bad ercd !E_TMOUT" ); |
|
|
631 ercd = pget_blf( &blfptr, 2 ); |
|
|
632 CYG_TEST_CHECK( E_TMOUT == ercd, "pget_blf bad ercd !E_TMOUT" ); |
|
2
|
633 ercd = tget_blf( &blfptr, 2, delay ); |
|
0
|
634 CYG_TEST_CHECK( E_TMOUT == ercd, "tget_blf bad ercd !E_TMOUT" ); |
|
|
635 ercd = tget_blf( &blfptr, 2, TMO_POL ); |
|
|
636 CYG_TEST_CHECK( E_TMOUT == ercd, "tget_blf(POL) bad ercd !E_TMOUT" ); |
|
|
637 ercd = dis_dsp(); |
|
|
638 CYG_TEST_CHECK( E_OK == ercd, "dis_dsp bad ercd" ); |
|
|
639 #ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS |
|
|
640 ercd = get_blf( &blfptr, 2 ); |
|
|
641 CYG_TEST_CHECK( E_CTX == ercd, "get_blf bad ercd !E_CTX" ); |
|
2
|
642 ercd = tget_blf( &blfptr, 2, delay ); |
|
0
|
643 CYG_TEST_CHECK( E_CTX == ercd, "tget_blf bad ercd !E_CTX" ); |
|
|
644 ercd = tget_blf( &blfptr, 2, TMO_FEVR ); |
|
|
645 CYG_TEST_CHECK( E_CTX == ercd, "tget_blf(FEVR) bad ercd !E_CTX" ); |
|
|
646 #endif // we can test bad param error returns |
|
|
647 ercd = tget_blf( &blfptr, 2, TMO_POL ); |
|
|
648 CYG_TEST_CHECK( E_TMOUT == ercd, "tget_blf(POL) bad ercd !E_TMOUT" ); |
|
|
649 ercd = ena_dsp(); |
|
|
650 CYG_TEST_CHECK( E_OK == ercd, "ena_dsp bad ercd" ); |
|
|
651 ercd = pget_blf( &blfptr, 2 ); |
|
|
652 CYG_TEST_CHECK( E_TMOUT == ercd, "pget_blf bad ercd !E_TMOUT" ); |
|
2
|
653 ercd = tget_blf( &blfptr, 2, delay ); |
|
0
|
654 CYG_TEST_CHECK( E_TMOUT == ercd, "pget_blf bad ercd !E_TMOUT" ); |
|
|
655 ercd = tget_blf( &blfptr, 2, TMO_POL ); |
|
|
656 CYG_TEST_CHECK( E_TMOUT == ercd, "tget_blf(POL) bad ercd !E_TMOUT" ); |
|
|
657 CYG_TEST_PASS( "bad calls: rel_blf, [pt]get_blf with ena_dsp" ); |
|
|
658 |
|
|
659 // check ref_mpf with various states |
|
|
660 ercd = ref_mpf( &mpf_info, 2 ); |
|
|
661 CYG_TEST_CHECK( E_OK == ercd, "ref_mpf bad ercd" ); |
|
|
662 CYG_TEST_CHECK( 0 == mpf_info.wtsk, "mpf.wtsk should be 0" ); |
|
|
663 CYG_TEST_CHECK( 0 == mpf_info.frbcnt, "mpf.frbcnt should be 0" ); |
|
|
664 intercom = 0; |
|
2
|
665 ercd = dly_tsk( delay ); // let task 2 start waiting |
|
0
|
666 CYG_TEST_CHECK( E_OK == ercd, "dly_tsk bad ercd" ); |
|
|
667 intercom = 1; |
|
|
668 ercd = ref_mpf( &mpf_info, 2 ); |
|
|
669 CYG_TEST_CHECK( E_OK == ercd, "ref_mpf bad ercd" ); |
|
|
670 CYG_TEST_CHECK( 0 != mpf_info.wtsk, "mpf.wtsk should be non0" ); |
|
|
671 CYG_TEST_CHECK( 0 == mpf_info.frbcnt, "mpf.frbcnt should be 0" ); |
|
|
672 ercd = rel_blf( 2, blfptr ); |
|
|
673 CYG_TEST_CHECK( E_OK == ercd, "rel_blf bad ercd" ); |
|
|
674 ercd = ref_mpf( &mpf_info, 2 ); |
|
|
675 CYG_TEST_CHECK( E_OK == ercd, "ref_mpf bad ercd" ); |
|
|
676 CYG_TEST_CHECK( 0 == mpf_info.wtsk, "mpf.wtsk should be 0" ); |
|
|
677 #if 1 |
|
|
678 CYG_TEST_CHECK( 0 == mpf_info.frbcnt, "mpf.frbcnt should be 0" ); |
|
|
679 #else // old, non-uITRON semantics |
|
|
680 CYG_TEST_CHECK( 0 != mpf_info.frbcnt, "mpf.frbcnt should be non0" ); |
|
|
681 #endif |
|
2
|
682 ercd = dly_tsk( delay ); // let task 2 start waiting |
|
0
|
683 CYG_TEST_CHECK( E_OK == ercd, "dly_tsk bad ercd" ); |
|
|
684 ercd = ref_mpf( &mpf_info, 2 ); |
|
|
685 CYG_TEST_CHECK( E_OK == ercd, "ref_mpf bad ercd" ); |
|
|
686 CYG_TEST_CHECK( 0 == mpf_info.wtsk, "mpf.wtsk should be 0" ); |
|
|
687 CYG_TEST_CHECK( 0 == mpf_info.frbcnt, "mpf.frbcnt should be 0" ); |
|
|
688 CYG_TEST_PASS( "good calls: rel_blf, get_blf with ref_mpf" ); |
|
|
689 |
|
|
690 // Variable block memory pools; illegal arguments |
|
|
691 CYG_TEST_INFO( "Testing variable block memory ops" ); |
|
|
692 #ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS |
|
|
693 ercd = rel_blk( -6, blkptr ); |
|
|
694 CYG_TEST_CHECK( E_ID == ercd, "rel_blk bad ercd !E_ID" ); |
|
|
695 ercd = rel_blk( 99, blkptr ); |
|
|
696 CYG_TEST_CHECK( E_ID == ercd, "rel_blk bad ercd !E_ID" ); |
|
|
697 #ifndef CYGSEM_UITRON_PARAMS_NULL_IS_GOOD_PTR |
|
|
698 ercd = rel_blk( 2, NULL ); |
|
|
699 CYG_TEST_CHECK( E_PAR == ercd, "rel_blk bad ercd !E_PAR" ); |
|
|
700 #endif |
|
|
701 #endif // we can test bad param error returns |
|
|
702 ercd = rel_blk( 2, blkptr ); // it did not come from a mpl |
|
|
703 CYG_TEST_CHECK( E_PAR == ercd, "rel_blk bad ercd !E_PAR" ); |
|
|
704 #ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS |
|
|
705 ercd = get_blk( &blkptr, -6, 100 ); |
|
|
706 CYG_TEST_CHECK( E_ID == ercd, "get_blk bad ercd !E_ID" ); |
|
|
707 ercd = get_blk( &blkptr, 99, 100 ); |
|
|
708 CYG_TEST_CHECK( E_ID == ercd, "get_blk bad ercd !E_ID" ); |
|
|
709 #ifndef CYGSEM_UITRON_PARAMS_NULL_IS_GOOD_PTR |
|
|
710 ercd = get_blk( NULL, 2, 100 ); |
|
|
711 CYG_TEST_CHECK( E_PAR == ercd, "get_blk bad ercd !E_PAR" ); |
|
|
712 #endif |
|
|
713 ercd = pget_blk( &blkptr, -6, 100 ); |
|
|
714 CYG_TEST_CHECK( E_ID == ercd, "pget_blk bad ercd !E_ID" ); |
|
|
715 ercd = pget_blk( &blkptr, 99, 100 ); |
|
|
716 CYG_TEST_CHECK( E_ID == ercd, "pget_blk bad ercd !E_ID" ); |
|
|
717 #ifndef CYGSEM_UITRON_PARAMS_NULL_IS_GOOD_PTR |
|
|
718 ercd = pget_blk( NULL, 2, 100 ); |
|
|
719 CYG_TEST_CHECK( E_PAR == ercd, "pget_blk bad ercd !E_PAR" ); |
|
|
720 #endif |
|
2
|
721 ercd = tget_blk( &blkptr, -6, 100, delay ); |
|
0
|
722 CYG_TEST_CHECK( E_ID == ercd, "tget_blk bad ercd !E_ID" ); |
|
2
|
723 ercd = tget_blk( &blkptr, 99, 100, delay ); |
|
0
|
724 CYG_TEST_CHECK( E_ID == ercd, "tget_blk bad ercd !E_ID" ); |
|
|
725 ercd = tget_blk( &blkptr, 2, 100, -999 ); |
|
|
726 CYG_TEST_CHECK( E_PAR == ercd, "tget_blk bad ercd !E_PAR" ); |
|
|
727 #ifndef CYGSEM_UITRON_PARAMS_NULL_IS_GOOD_PTR |
|
2
|
728 ercd = tget_blk( NULL, 2, 100, delay ); |
|
0
|
729 CYG_TEST_CHECK( E_PAR == ercd, "tget_blk bad ercd !E_PAR" ); |
|
|
730 #endif |
|
|
731 ercd = ref_mpl( &mpl_info, -6 ); |
|
|
732 CYG_TEST_CHECK( E_ID == ercd, "ref_mpl bad ercd !E_ID" ); |
|
|
733 ercd = ref_mpl( &mpl_info, 99 ); |
|
|
734 CYG_TEST_CHECK( E_ID == ercd, "ref_mpl bad ercd !E_ID" ); |
|
|
735 #ifndef CYGSEM_UITRON_PARAMS_NULL_IS_GOOD_PTR |
|
|
736 ercd = ref_mpl( NULL, 2 ); |
|
|
737 CYG_TEST_CHECK( E_PAR == ercd, "ref_mpl bad ercd !E_PAR" ); |
|
|
738 #endif |
|
|
739 CYG_TEST_PASS( "bad calls: rel_blk, [pt]get_blk, ref_mpl " ); |
|
|
740 #endif // we can test bad param error returns |
|
|
741 |
|
|
742 // check the waitable functions versus dispatch disable |
|
|
743 ercd = pget_blk( &blkptr, 2, 100 ); |
|
|
744 CYG_TEST_CHECK( E_OK == ercd, "pget_blk bad ercd" ); |
|
|
745 ercd = rel_blk( 2, blkptr ); |
|
|
746 CYG_TEST_CHECK( E_OK == ercd, "rel_blk bad ercd" ); |
|
2
|
747 ercd = tget_blk( &blkptr, 2, 100, delay ); |
|
0
|
748 CYG_TEST_CHECK( E_OK == ercd, "tget_blk bad ercd" ); |
|
|
749 ercd = dis_dsp(); |
|
|
750 CYG_TEST_CHECK( E_OK == ercd, "dis_dsp bad ercd" ); |
|
|
751 ercd = rel_blk( 2, blkptr ); |
|
|
752 CYG_TEST_CHECK( E_OK == ercd, "rel_blk bad ercd" ); |
|
|
753 #ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS |
|
|
754 ercd = get_blk( &blkptr, 2, 100 ); |
|
|
755 CYG_TEST_CHECK( E_CTX == ercd, "get_blk bad ercd !E_CTX" ); |
|
2
|
756 ercd = tget_blk( &blkptr, 2, 100, delay ); |
|
0
|
757 CYG_TEST_CHECK( E_CTX == ercd, "tget_blk bad ercd !E_CTX" ); |
|
|
758 #endif // we can test bad param error returns |
|
|
759 ercd = ena_dsp(); |
|
|
760 CYG_TEST_CHECK( E_OK == ercd, "ena_dsp bad ercd" ); |
|
|
761 ercd = pget_blk( &blkptr, 2, 100 ); |
|
|
762 CYG_TEST_CHECK( E_OK == ercd, "pget_blk bad ercd" ); |
|
|
763 ercd = rel_blk( 2, blkptr ); |
|
|
764 CYG_TEST_CHECK( E_OK == ercd, "rel_blk bad ercd" ); |
|
2
|
765 ercd = tget_blk( &blkptr, 2, 100, delay ); |
|
0
|
766 CYG_TEST_CHECK( E_OK == ercd, "tget_blk bad ercd" ); |
|
|
767 ercd = rel_blk( 2, blkptr ); |
|
|
768 CYG_TEST_CHECK( E_OK == ercd, "rel_blk bad ercd" ); |
|
|
769 // consume the whole thing then do it again, expecting E_TMOUT |
|
|
770 while ( E_OK == (ercd = pget_blk( &blkptr, 2, 100 ) ) ) |
|
|
771 continue; |
|
|
772 CYG_TEST_CHECK( E_TMOUT == ercd, "pget_blk bad ercd !E_TMOUT" ); |
|
|
773 ercd = pget_blk( &blkptr, 2, 100 ); |
|
|
774 CYG_TEST_CHECK( E_TMOUT == ercd, "pget_blk bad ercd !E_TMOUT" ); |
|
2
|
775 ercd = tget_blk( &blkptr, 2, 100, delay ); |
|
0
|
776 CYG_TEST_CHECK( E_TMOUT == ercd, "tget_blk bad ercd !E_TMOUT" ); |
|
|
777 ercd = tget_blk( &blkptr, 2, 100, TMO_POL ); |
|
|
778 CYG_TEST_CHECK( E_TMOUT == ercd, "tget_blk(POL) bad ercd !E_TMOUT" ); |
|
|
779 ercd = dis_dsp(); |
|
|
780 CYG_TEST_CHECK( E_OK == ercd, "dis_dsp bad ercd" ); |
|
|
781 #ifdef CYGSEM_UITRON_BAD_PARAMS_RETURN_ERRORS |
|
|
782 ercd = get_blk( &blkptr, 2, 100 ); |
|
|
783 CYG_TEST_CHECK( E_CTX == ercd, "get_blk bad ercd !E_CTX" ); |
|
2
|
784 ercd = tget_blk( &blkptr, 2, 100, delay ); |
|
0
|
785 CYG_TEST_CHECK( E_CTX == ercd, "tget_blk bad ercd !E_CTX" ); |
|
|
786 ercd = tget_blk( &blkptr, 2, 100, TMO_FEVR ); |
|
|
787 CYG_TEST_CHECK( E_CTX == ercd, "tget_blk(FEVR) bad ercd !E_CTX" ); |
|
|
788 #endif // we can test bad param error returns |
|
|
789 ercd = tget_blk( &blkptr, 2, 100, TMO_POL ); |
|
|
790 CYG_TEST_CHECK( E_TMOUT == ercd, "tget_blk(POL) bad ercd !E_TMOUT" ); |
|
|
791 ercd = ena_dsp(); |
|
|
792 CYG_TEST_CHECK( E_OK == ercd, "ena_dsp bad ercd" ); |
|
|
793 ercd = pget_blk( &blkptr, 2, 100 ); |
|
|
794 CYG_TEST_CHECK( E_TMOUT == ercd, "pget_blk bad ercd !E_TMOUT" ); |
|
2
|
795 ercd = tget_blk( &blkptr, 2, 100, delay ); |
|
0
|
796 CYG_TEST_CHECK( E_TMOUT == ercd, "pget_blk bad ercd !E_TMOUT" ); |
|
|
797 ercd = tget_blk( &blkptr, 2, 100, TMO_POL ); |
|
|
798 CYG_TEST_CHECK( E_TMOUT == ercd, "tget_blk(POL) bad ercd !E_TMOUT" ); |
|
|
799 CYG_TEST_PASS( "bad calls: rel_blk, [pt]get_blk with ena_dsp" ); |
|
|
800 |
|
|
801 // check ref_mpl with various states |
|
|
802 ercd = ref_mpl( &mpl_info, 2 ); |
|
|
803 CYG_TEST_CHECK( E_OK == ercd, "ref_mpl bad ercd" ); |
|
|
804 CYG_TEST_CHECK( 0 == mpl_info.wtsk, "mpl.wtsk should be 0" ); |
|
|
805 CYG_TEST_CHECK( mpl_info.maxsz <= mpl_info.frsz, |
|
|
806 "mpl.maxsz not < mpl.frsz" ); |
|
|
807 intercom = 0; |
|
2
|
808 ercd = dly_tsk( delay ); // let task 2 start waiting |
|
0
|
809 CYG_TEST_CHECK( E_OK == ercd, "dly_tsk bad ercd" ); |
|
|
810 intercom = 1; |
|
|
811 ercd = ref_mpl( &mpl_info, 2 ); |
|
|
812 CYG_TEST_CHECK( E_OK == ercd, "ref_mpl bad ercd" ); |
|
|
813 CYG_TEST_CHECK( 0 != mpl_info.wtsk, "mpl.wtsk should be non0" ); |
|
|
814 ercd = rel_blk( 2, blkptr ); |
|
|
815 CYG_TEST_CHECK( E_OK == ercd, "rel_blk bad ercd" ); |
|
|
816 ercd = ref_mpl( &mpl_info, 2 ); |
|
|
817 CYG_TEST_CHECK( E_OK == ercd, "ref_mpl bad ercd" ); |
|
|
818 CYG_TEST_CHECK( 0 == mpl_info.wtsk, "mpl.wtsk should be 0" ); |
|
2
|
819 ercd = dly_tsk( delay ); // let task 2 start waiting |
|
0
|
820 CYG_TEST_CHECK( E_OK == ercd, "dly_tsk bad ercd" ); |
|
|
821 ercd = ref_mpl( &mpl_info, 2 ); |
|
|
822 CYG_TEST_CHECK( E_OK == ercd, "ref_mpl bad ercd" ); |
|
|
823 CYG_TEST_CHECK( 0 == mpl_info.wtsk, "mpl.wtsk should be 0" ); |
|
|
824 CYG_TEST_PASS( "good calls: rel_blk, get_blk with ref_mpl" ); |
|
|
825 |
|
|
826 // all done |
|
|
827 CYG_TEST_EXIT( "All done" ); |
|
|
828 ext_tsk(); |
|
|
829 } |
|
|
830 |
|
|
831 |
|
|
832 |
|
|
833 void task2( unsigned int arg ) |
|
|
834 { |
|
|
835 ER ercd; |
|
|
836 T_MSG *msgp = NULL; |
|
|
837 UINT flgval = 0; |
|
|
838 VP blfp = NULL; |
|
|
839 VP blkp = NULL; |
|
|
840 |
|
|
841 CYG_TEST_INFO( "Task 2 running" ); |
|
|
842 ercd = get_tid( &scratch ); |
|
|
843 CYG_TEST_CHECK( E_OK == ercd, "get_tid bad ercd" ); |
|
|
844 CYG_TEST_CHECK( 2 == scratch, "tid not 2" ); |
|
|
845 if ( 222 != arg ) |
|
|
846 CYG_TEST_FAIL( "Task 2 arg not 222" ); |
|
|
847 |
|
|
848 while ( intercom ) { |
|
|
849 ercd = rot_rdq( 0 ); |
|
|
850 CYG_TEST_CHECK( E_OK == ercd, "rot_rdq bad ercd" ); |
|
|
851 } |
|
|
852 ercd = wai_sem( 2 ); |
|
|
853 CYG_TEST_CHECK( E_OK == ercd, "wai_sem bad ercd" ); |
|
|
854 while ( intercom ) { |
|
|
855 ercd = rot_rdq( 0 ); |
|
|
856 CYG_TEST_CHECK( E_OK == ercd, "rot_rdq bad ercd" ); |
|
|
857 } |
|
|
858 ercd = wai_flg( &flgval, 2, 99, TWF_ANDW ); |
|
|
859 CYG_TEST_CHECK( E_OK == ercd, "wai_flg bad ercd" ); |
|
|
860 CYG_TEST_CHECK( 99 == (99 & flgval), "flg value no good" ); |
|
|
861 while ( intercom ) { |
|
|
862 ercd = rot_rdq( 0 ); |
|
|
863 CYG_TEST_CHECK( E_OK == ercd, "rot_rdq bad ercd" ); |
|
|
864 } |
|
|
865 ercd = rcv_msg( &msgp, 2 ); |
|
|
866 CYG_TEST_CHECK( E_OK == ercd, "rcv_msg bad ercd" ); |
|
|
867 CYG_TEST_CHECK( NULL != msgp, "no msg received" ); |
|
|
868 CYG_TEST_CHECK( NADR != msgp, "no msg received" ); |
|
|
869 while ( intercom ) { |
|
|
870 ercd = rot_rdq( 0 ); |
|
|
871 CYG_TEST_CHECK( E_OK == ercd, "rot_rdq bad ercd" ); |
|
|
872 } |
|
|
873 ercd = get_blf( &blfp, 2 ); |
|
|
874 CYG_TEST_CHECK( E_OK == ercd, "get_blf bad ercd" ); |
|
|
875 CYG_TEST_CHECK( NULL != blfp, "no blf allocated" ); |
|
|
876 CYG_TEST_CHECK( NADR != blfp, "no blf allocated" ); |
|
|
877 while ( intercom ) { |
|
|
878 ercd = rot_rdq( 0 ); |
|
|
879 CYG_TEST_CHECK( E_OK == ercd, "rot_rdq bad ercd" ); |
|
|
880 } |
|
|
881 ercd = get_blk( &blkp, 2, 100 ); |
|
|
882 CYG_TEST_CHECK( E_OK == ercd, "get_blk bad ercd" ); |
|
|
883 CYG_TEST_CHECK( NULL != blkp, "no blk allocated" ); |
|
|
884 CYG_TEST_CHECK( NADR != blkp, "no blk allocated" ); |
|
|
885 |
|
|
886 ext_tsk(); |
|
|
887 CYG_TEST_FAIL( "Task 2 failed to exit" ); |
|
|
888 } |
|
|
889 |
|
|
890 void task3( unsigned int arg ) |
|
|
891 { |
|
|
892 } |
|
|
893 |
|
|
894 void task4( unsigned int arg ) |
|
|
895 { |
|
|
896 } |
|
|
897 |
|
|
898 #else // not enough (or too many) uITRON objects configured in |
|
|
899 #define N_A_MSG "not enough uITRON objects to run test" |
|
|
900 #endif // not enough (or too many) uITRON objects configured in |
|
|
901 #else // not C++ and some C++ specific options enabled |
|
|
902 #define N_A_MSG "C++ specific options selected but this is C" |
|
|
903 #endif // not C++ and some C++ specific options enabled |
|
|
904 #else // ! CYGVAR_KERNEL_COUNTERS_CLOCK - can't test without it |
|
|
905 #define N_A_MSG "no CYGVAR_KERNEL_COUNTERS_CLOCK " |
|
|
906 #endif // ! CYGVAR_KERNEL_COUNTERS_CLOCK - can't test without it |
|
2
|
907 #else // ! CYGFUN_KERNEL_THREADS_TIMER - can't test without it |
|
0
|
908 #define N_A_MSG "no CYGFUN_KERNEL_THREADS_TIMER" |
|
2
|
909 #endif // ! CYGFUN_KERNEL_THREADS_TIMER - can't test without it |
|
|
910 #else // ! CYGIMP_THREAD_PRIORITY - can't test without it |
|
0
|
911 #define N_A_MSG "no CYGSEM_KERNEL_SCHED_MLQUEUE" |
|
2
|
912 #endif // ! CYGSEM_KERNEL_SCHED_MLQUEUE - can't test without it |
|
0
|
913 #else // ! CYGPKG_UITRON |
|
|
914 #define N_A_MSG "uITRON Compatibility layer disabled" |
|
|
915 #endif // CYGPKG_UITRON |
|
|
916 |
|
|
917 #ifdef N_A_MSG |
|
|
918 externC void |
|
|
919 cyg_start( void ) |
|
|
920 { |
|
|
921 CYG_TEST_INIT(); |
|
2
|
922 CYG_TEST_NA( N_A_MSG ); |
|
0
|
923 } |
|
|
924 #endif // N_A_MSG defined ie. we are N/A. |
|
|
925 |
|
|
926 // EOF testcx2.cxx |
