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