![](/media/cache/img/default_profile.jpg.50x50_q85.jpg)
Rtos API example
Embed:
(wiki syntax)
Show/hide line numbers
main.cpp
00001 /* 00002 * Copyright (c) 2013-2017, ARM Limited, All Rights Reserved 00003 * SPDX-License-Identifier: Apache-2.0 00004 * 00005 * Licensed under the Apache License, Version 2.0 (the "License"); you may 00006 * not use this file except in compliance with the License. 00007 * You may obtain a copy of the License at 00008 * 00009 * http://www.apache.org/licenses/LICENSE-2.0 00010 * 00011 * Unless required by applicable law or agreed to in writing, software 00012 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT 00013 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 00014 * See the License for the specific language governing permissions and 00015 * limitations under the License. 00016 */ 00017 00018 #include "mbed.h" 00019 #include "greentea-client/test_env.h" 00020 #include "unity/unity.h" 00021 #include "utest/utest.h" 00022 00023 using utest::v1::Case; 00024 00025 #if defined(MBED_RTOS_SINGLE_THREAD) 00026 #error [NOT_SUPPORTED] test not supported 00027 #endif 00028 00029 #define THREAD_STACK_SIZE 320 /* 512B stack on GCC_ARM compiler cause out of memory on some 16kB RAM boards e.g. NUCLEO_F070RB */ 00030 00031 #define MAX_FLAG_POS 30 00032 #define PROHIBITED_FLAG_POS 31 00033 00034 /* flags */ 00035 #define FLAG01 0x1FFF /* 00000000000000000001111111111111 */ 00036 #define FLAG02 0x3FFE000 /* 00000011111111111110000000000000 */ 00037 #define FLAG03 0x7C000000 /* 01111100000000000000000000000000 */ 00038 #define PROHIBITED_FLAG 0x80000000 /* 10000000000000000000000000000000 */ 00039 #define NO_FLAGS 0x0 00040 00041 Semaphore sync_sem(0, 1); 00042 00043 /* In order to successfully run this test suite when compiled with --profile=debug 00044 * error() has to be redefined as noop. 00045 * 00046 * EventFlags calls RTX API which uses Event Recorder functionality. When compiled 00047 * with MBED_TRAP_ERRORS_ENABLED=1 (set in debug profile) EvrRtxEventFlagsError() calls error() 00048 * which aborts test program. 00049 */ 00050 #if defined(MBED_TRAP_ERRORS_ENABLED) && MBED_TRAP_ERRORS_ENABLED 00051 void error(const char* format, ...) { 00052 (void) format; 00053 } 00054 #endif 00055 00056 template<uint32_t flags, uint32_t wait_ms> 00057 void send_thread(EventFlags *ef) 00058 { 00059 for (uint32_t i = 0; i <= MAX_FLAG_POS; i++) { 00060 const uint32_t flag = flags & (1 << i); 00061 if (flag) { 00062 ef->set(flag); 00063 Thread::wait(wait_ms); 00064 } 00065 } 00066 } 00067 00068 template<uint32_t flags, uint32_t wait_ms> 00069 void send_thread_sync(EventFlags *ef) 00070 { 00071 for (uint32_t i = 0; i <= MAX_FLAG_POS; i++) { 00072 const uint32_t flag = flags & (1 << i); 00073 if (flag) { 00074 sync_sem.wait(); 00075 ef->set(flag); 00076 Thread::wait(wait_ms); 00077 } 00078 } 00079 } 00080 00081 template<uint32_t flags> 00082 void wait_thread_all(EventFlags *ef) 00083 { 00084 uint32_t ret, flags_after_clear; 00085 ret = ef->wait_all(flags); 00086 flags_after_clear = ef->get(); 00087 TEST_ASSERT(flags | ret); 00088 TEST_ASSERT(flags | ~flags_after_clear); 00089 } 00090 00091 00092 /** Test if get on empty EventFlags object return NO_FLAGS 00093 00094 Given a empty EventFlags object 00095 When call @a get 00096 Then @a get return status is NO_FLAGS 00097 */ 00098 void test_empty_get(void) 00099 { 00100 EventFlags ev; 00101 uint32_t flags; 00102 00103 flags = ev.get(); 00104 TEST_ASSERT_EQUAL(NO_FLAGS, flags); 00105 } 00106 00107 /** Test if clear on empty EventFlags object return NO_FLAGS 00108 00109 Given a empty EventFlags object 00110 When call @a clear(NO_FLAGS) 00111 Then @a clear return status is NO_FLAGS 00112 */ 00113 void test_empty_clear(void) 00114 { 00115 EventFlags ev; 00116 uint32_t flags; 00117 00118 flags = ev.clear(NO_FLAGS); 00119 TEST_ASSERT_EQUAL(NO_FLAGS, flags); 00120 } 00121 00122 /** Test if set on empty EventFlags object return NO_FLAGS 00123 00124 Given a empty EventFlags object 00125 When call @a set(NO_FLAGS) 00126 Then @a set return status is NO_FLAGS 00127 */ 00128 void test_empty_set(void) 00129 { 00130 EventFlags ev; 00131 uint32_t flags; 00132 00133 flags = ev.set(NO_FLAGS); 00134 TEST_ASSERT_EQUAL(NO_FLAGS, flags); 00135 } 00136 00137 /** Test if call of set/clean with PROHIBITED_FLAG doesn't invalidates object flags 00138 00139 Given a EventFlags object with all flags already set 00140 When call @a clear(PROHIBITED_FLAG) with prohibited flag 00141 Then @a clear return status is osFlagsErrorParameter and object flags stays unchanged 00142 When call @a set(PROHIBITED_FLAG) with prohibited flag 00143 Then @a set return status is osFlagsErrorParameter and object flags stays unchanged 00144 00145 @note Each signal has up to 31 event flags 0x1, 0x2, 0x4, 0x8, ..., 0x40000000 00146 Most significant bit is reserved and thereby flag 0x80000000 is prohibited 00147 */ 00148 void test_prohibited(void) 00149 { 00150 EventFlags ev; 00151 uint32_t flags; 00152 00153 ev.set(FLAG01 | FLAG02 | FLAG03); 00154 00155 flags = ev.clear(PROHIBITED_FLAG); 00156 TEST_ASSERT_EQUAL(osFlagsErrorParameter, flags); 00157 00158 flags = ev.get(); 00159 TEST_ASSERT_EQUAL(FLAG01 | FLAG02 | FLAG03, flags); 00160 00161 flags = ev.set(PROHIBITED_FLAG); 00162 TEST_ASSERT_EQUAL(osFlagsErrorParameter, flags); 00163 00164 flags = ev.get(); 00165 TEST_ASSERT_EQUAL(FLAG01 | FLAG02 | FLAG03, flags); 00166 } 00167 00168 /** Test set/get/clear for full flag range 00169 00170 Given a EventFlags object 00171 When call @a clear 00172 Then @a clear return status is already set flags 00173 When call @a set with specified flag 00174 Then @a set return status is flags after setting 00175 When call @a get 00176 Then @a get return status is set flags 00177 */ 00178 void test_set_get_clear_full_flag_range(void) 00179 { 00180 EventFlags ev; 00181 uint32_t flag, flags, ret; 00182 00183 flags = NO_FLAGS; 00184 for (int i = 0; i <= MAX_FLAG_POS; i++) { 00185 ret = ev.clear(); 00186 TEST_ASSERT_EQUAL(flags, ret); 00187 flags = 1 << i; 00188 ret = ev.set(flags); 00189 TEST_ASSERT_EQUAL(flags, ret); 00190 ret = ev.get(); 00191 TEST_ASSERT_EQUAL(flags, ret); 00192 } 00193 00194 ev.clear(); 00195 flags = NO_FLAGS; 00196 for (int i = 0; i <= MAX_FLAG_POS; i++) { 00197 ret = ev.clear(NO_FLAGS); 00198 TEST_ASSERT_EQUAL(flags, ret); 00199 flag = 1 << i; 00200 flags |= flag; 00201 ret = ev.set(flag); 00202 TEST_ASSERT_EQUAL(flags, ret); 00203 ret = ev.get(); 00204 TEST_ASSERT_EQUAL(flags, ret); 00205 } 00206 } 00207 00208 /** Test if multi-threaded flag set cause wait_all to return 00209 00210 Given a EventFlags object and three threads are started in parallel 00211 When threads set specified flags 00212 Then main thread waits until receive all of them 00213 */ 00214 void test_multi_thread_all(void) 00215 { 00216 EventFlags ef; 00217 Thread thread1(osPriorityNormal, THREAD_STACK_SIZE); 00218 Thread thread2(osPriorityNormal, THREAD_STACK_SIZE); 00219 Thread thread3(osPriorityNormal, THREAD_STACK_SIZE); 00220 thread1.start(callback(send_thread<FLAG01, 1>, &ef)); 00221 thread2.start(callback(send_thread<FLAG02, 2>, &ef)); 00222 thread3.start(callback(send_thread<FLAG03, 3>, &ef)); 00223 00224 uint32_t ret = ef.wait_all(FLAG01 | FLAG02 | FLAG03); 00225 TEST_ASSERT_EQUAL(FLAG01 | FLAG02 | FLAG03, ret); 00226 } 00227 00228 /** Test if multi-threaded flag set cause wait_any to return 00229 00230 Given a EventFlags object and three threads are started in parallel 00231 When threads set specified flags 00232 Then main thread waits until receive all of them 00233 */ 00234 void test_multi_thread_any(void) 00235 { 00236 EventFlags ef; 00237 uint32_t ret; 00238 Thread thread1(osPriorityNormal, THREAD_STACK_SIZE); 00239 Thread thread2(osPriorityNormal, THREAD_STACK_SIZE); 00240 Thread thread3(osPriorityNormal, THREAD_STACK_SIZE); 00241 thread1.start(callback(send_thread<FLAG01, 1>, &ef)); 00242 thread2.start(callback(send_thread<FLAG02, 1>, &ef)); 00243 thread3.start(callback(send_thread<FLAG03, 1>, &ef)); 00244 00245 for (int i = 0; i <= MAX_FLAG_POS; i++) { 00246 uint32_t flag = 1 << i; 00247 ret = ef.wait_any(flag); 00248 TEST_ASSERT(flag | ret); 00249 } 00250 ret = ef.get(); 00251 TEST_ASSERT_EQUAL(NO_FLAGS, ret); 00252 } 00253 00254 /** Test if multi-threaded flag set cause wait_any(with timeout) to return 00255 00256 Given a EventFlags object and thread is running 00257 When main thread call @ wait_any with timeout 00258 Then when timeout expires @ wait_any return status is osFlagsErrorTimeout 00259 When main thread call @ wait_any with timeout and thread set specified flags 00260 Then main thread waits until receive all of them and @ wait_any return status is wait flag 00261 */ 00262 void test_multi_thread_any_timeout(void) 00263 { 00264 EventFlags ef; 00265 uint32_t ret; 00266 Thread thread(osPriorityNormal, THREAD_STACK_SIZE); 00267 thread.start(callback(send_thread_sync<FLAG01 | FLAG02 | FLAG03, 1>, &ef)); 00268 00269 for (int i = 0; i <= MAX_FLAG_POS; i++) { 00270 uint32_t flag = 1 << i; 00271 00272 ret = ef.wait_any(flag, 10); 00273 TEST_ASSERT_EQUAL(osFlagsErrorTimeout, ret); 00274 00275 sync_sem.release(); 00276 ret = ef.wait_any(flag, 10); 00277 TEST_ASSERT_EQUAL(flag, ret); 00278 } 00279 ret = ef.get(); 00280 TEST_ASSERT_EQUAL(NO_FLAGS, ret); 00281 } 00282 00283 /** Test if multi-threaded flag set cause wait_any(without clear) to return 00284 00285 Given a EventFlags object and three threads are started in parallel 00286 When threads set specified flags 00287 Then main thread waits until receive all of them 00288 */ 00289 void test_multi_thread_any_no_clear(void) 00290 { 00291 EventFlags ef; 00292 uint32_t ret; 00293 Thread thread1(osPriorityNormal, THREAD_STACK_SIZE); 00294 Thread thread2(osPriorityNormal, THREAD_STACK_SIZE); 00295 Thread thread3(osPriorityNormal, THREAD_STACK_SIZE); 00296 thread1.start(callback(send_thread<FLAG01, 1>, &ef)); 00297 thread2.start(callback(send_thread<FLAG02, 1>, &ef)); 00298 thread3.start(callback(send_thread<FLAG03, 1>, &ef)); 00299 00300 for (int i = 0; i <= MAX_FLAG_POS; i++) { 00301 uint32_t flag = 1 << i; 00302 ret = ef.wait_any(flag, osWaitForever, false); 00303 TEST_ASSERT(flag | ret); 00304 ret = ef.clear(flag); 00305 TEST_ASSERT(ret < osFlagsError); 00306 } 00307 ret = ef.get(); 00308 TEST_ASSERT_EQUAL(NO_FLAGS, ret); 00309 } 00310 00311 /** Test multi-threaded wait_any 00312 00313 Given a EventFlags object and three threads are started in parallel 00314 When flags are set in main thread 00315 Then other threads waits until receive all of them 00316 */ 00317 void test_multi_thread_all_many_wait(void) 00318 { 00319 EventFlags ef; 00320 { 00321 Thread thread1(osPriorityNormal, THREAD_STACK_SIZE); 00322 Thread thread2(osPriorityNormal, THREAD_STACK_SIZE); 00323 Thread thread3(osPriorityNormal, THREAD_STACK_SIZE); 00324 thread1.start(callback(wait_thread_all<FLAG01>, &ef)); 00325 thread2.start(callback(wait_thread_all<FLAG02>, &ef)); 00326 thread3.start(callback(wait_thread_all<FLAG03>, &ef)); 00327 00328 ef.set(FLAG01 | FLAG02 | FLAG03); 00329 thread1.join(); 00330 thread2.join(); 00331 thread3.join(); 00332 TEST_ASSERT_EQUAL(NO_FLAGS, ef.get()); 00333 } 00334 00335 { 00336 Thread thread1(osPriorityNormal, THREAD_STACK_SIZE); 00337 Thread thread2(osPriorityNormal, THREAD_STACK_SIZE); 00338 Thread thread3(osPriorityNormal, THREAD_STACK_SIZE); 00339 thread1.start(callback(wait_thread_all<FLAG01>, &ef)); 00340 thread2.start(callback(wait_thread_all<FLAG02>, &ef)); 00341 thread3.start(callback(wait_thread_all<FLAG03>, &ef)); 00342 00343 ef.set(FLAG01); 00344 thread1.join(); 00345 ef.set(FLAG02); 00346 thread2.join(); 00347 ef.set(FLAG03); 00348 thread3.join(); 00349 TEST_ASSERT_EQUAL(NO_FLAGS, ef.get()); 00350 } 00351 } 00352 00353 utest::v1::status_t test_setup(const size_t number_of_cases) 00354 { 00355 GREENTEA_SETUP(10, "default_auto"); 00356 return utest::v1::verbose_test_setup_handler(number_of_cases); 00357 } 00358 00359 Case cases[] = { 00360 Case("Test empty clear", test_empty_clear), 00361 Case("Test empty get", test_empty_get), 00362 Case("Test empty set", test_empty_set), 00363 Case("Test clear/set with prohibited flag", test_prohibited), 00364 Case("Test set/get/clear for full flag range", test_set_get_clear_full_flag_range), 00365 Case("Test multi-threaded wait_all", test_multi_thread_all), 00366 Case("Test multi-threaded wait_any", test_multi_thread_any), 00367 Case("Test multi-threaded wait_all many wait", test_multi_thread_all_many_wait), 00368 Case("Test multi-threaded wait_any timeout", test_multi_thread_any_timeout), 00369 Case("Test multi-threaded wait_any no clear", test_multi_thread_any_no_clear) 00370 }; 00371 00372 utest::v1::Specification specification(test_setup, cases); 00373 00374 int main() 00375 { 00376 return !utest::v1::Harness::run(specification); 00377 }
Generated on Sun Jul 17 2022 08:25:27 by
![doxygen](doxygen.png)