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