![](/media/cache/img/default_profile.jpg.50x50_q85.jpg)
Rtos API example
Embed:
(wiki syntax)
Show/hide line numbers
main.cpp
00001 00002 /* mbed Microcontroller Library 00003 * Copyright (c) 2013-2015 ARM Limited 00004 * 00005 * Licensed under the Apache License, Version 2.0 (the "License"); 00006 * you may 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, 00013 * WITHOUT 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 #include "mbed.h" 00018 #include "greentea-client/test_env.h" 00019 #include "utest/utest.h" 00020 #include "unity/unity.h" 00021 #include "utest/utest_stack_trace.h" 00022 00023 using namespace utest::v1; 00024 00025 00026 static int call_counter(0); 00027 static Timeout utest_to; 00028 00029 class Utest_func_bind { 00030 00031 public: 00032 inline Utest_func_bind( void (*f)(int), int v) : _callback_fn(f), _callback_value(v) 00033 {} 00034 00035 inline void callback() { 00036 (*_callback_fn)(_callback_value); 00037 } 00038 00039 private: 00040 void (*_callback_fn)(int); 00041 int _callback_value; 00042 }; 00043 00044 00045 00046 void await_case_validate(int expected_call_count) 00047 { 00048 UTEST_LOG_FUNCTION(); 00049 TEST_ASSERT_EQUAL(expected_call_count, call_counter++); 00050 Harness::validate_callback(); 00051 } 00052 00053 static Utest_func_bind validate1(await_case_validate, 7); 00054 static Utest_func_bind validate2(await_case_validate, 37); 00055 static Utest_func_bind validate3(await_case_validate, 50); 00056 00057 00058 00059 // Control: Timeout (Failure) ----------------------------------------------------------------------------------------- 00060 control_t timeout_failure_case(const size_t call_count) 00061 { 00062 UTEST_LOG_FUNCTION(); 00063 TEST_ASSERT_EQUAL(1, call_count); 00064 TEST_ASSERT_EQUAL(0, call_counter++); 00065 return CaseTimeout(100); 00066 } 00067 utest::v1::status_t timeout_failure_case_failure_handler(const Case *const source, const failure_t failure) 00068 { 00069 UTEST_LOG_FUNCTION(); 00070 TEST_ASSERT_EQUAL(1, call_counter++); 00071 TEST_ASSERT_EQUAL(REASON_TIMEOUT, failure.reason); 00072 TEST_ASSERT_EQUAL(LOCATION_CASE_HANDLER, failure.location); 00073 verbose_case_failure_handler(source, failure); 00074 return STATUS_CONTINUE; 00075 } 00076 utest::v1::status_t timeout_failure_case_teardown(const Case *const source, const size_t passed, const size_t failed, const failure_t failure) 00077 { 00078 UTEST_LOG_FUNCTION(); 00079 TEST_ASSERT_EQUAL(2, call_counter++); 00080 TEST_ASSERT_EQUAL(0, passed); 00081 TEST_ASSERT_EQUAL(1, failed); 00082 TEST_ASSERT_EQUAL(REASON_CASES, failure.reason); 00083 TEST_ASSERT_EQUAL(LOCATION_UNKNOWN, failure.location); 00084 return greentea_case_teardown_handler(source, 1, 0, REASON_NONE); 00085 } 00086 00087 // Control: Timeout (Success) ----------------------------------------------------------------------------------------- 00088 void timeout_success_case_validate() { 00089 UTEST_LOG_FUNCTION(); 00090 TEST_ASSERT_EQUAL(4, call_counter++); 00091 Harness::validate_callback(); 00092 } 00093 00094 control_t timeout_success_case(const size_t call_count) 00095 { 00096 UTEST_LOG_FUNCTION(); 00097 TEST_ASSERT_EQUAL(1, call_count); 00098 TEST_ASSERT_EQUAL(3, call_counter++); 00099 utest_to.attach_us(timeout_success_case_validate, 100000); // Fire after 100 ms 00100 00101 return CaseTimeout(200); 00102 } 00103 utest::v1::status_t timeout_success_case_failure_handler(const Case *const source, const size_t passed, const size_t failed, const failure_t failure) 00104 { 00105 UTEST_LOG_FUNCTION(); 00106 TEST_ASSERT_EQUAL(5, call_counter++); 00107 TEST_ASSERT_EQUAL(1, passed); 00108 TEST_ASSERT_EQUAL(0, failed); 00109 TEST_ASSERT_EQUAL(REASON_NONE, failure.reason); 00110 TEST_ASSERT_EQUAL(LOCATION_NONE, failure.location); 00111 return greentea_case_teardown_handler(source, passed, failed, failure); 00112 } 00113 00114 // Control: Await ----------------------------------------------------------------------------------------------------- 00115 control_t await_case(const size_t call_count) 00116 { 00117 UTEST_LOG_FUNCTION(); 00118 TEST_ASSERT_EQUAL(1, call_count); 00119 TEST_ASSERT_EQUAL(6, call_counter++); 00120 00121 utest_to.attach_us(&validate1, &Utest_func_bind::callback, (1372*1000)); // Fire after 1372 ms 00122 00123 return CaseAwait; 00124 } 00125 00126 // Control: RepeatAllOnTimeout ---------------------------------------------------------------------------------------- 00127 bool repeat_all_start_flag = true; 00128 utest::v1::status_t repeat_all_on_timeout_case_setup(const Case *const source, const size_t index_of_case) 00129 { 00130 if (repeat_all_start_flag){ 00131 UTEST_TRACE_START 00132 repeat_all_start_flag = false; 00133 } 00134 UTEST_LOG_FUNCTION(); 00135 static int repeat_counter(0); 00136 TEST_ASSERT_EQUAL(3, index_of_case); 00137 TEST_ASSERT_EQUAL(repeat_counter*3 + 8, call_counter++); 00138 repeat_counter++; 00139 return greentea_case_setup_handler(source, index_of_case); 00140 } 00141 control_t repeat_all_on_timeout_case(const size_t call_count) 00142 { 00143 UTEST_LOG_FUNCTION(); 00144 static int repeat_counter(1); 00145 TEST_ASSERT_EQUAL(repeat_counter++, call_count); 00146 TEST_ASSERT(call_count <= 10); 00147 TEST_ASSERT_EQUAL((call_count-1)*3 + 9, call_counter++); 00148 if (call_count == 10) { 00149 utest_to.attach_us(&validate2, &Utest_func_bind::callback, (50*1000)); // Fire after 50ms 00150 } 00151 return CaseRepeatAllOnTimeout(100); 00152 } 00153 utest::v1::status_t repeat_all_on_timeout_case_teardown(const Case *const source, const size_t passed, const size_t failed, const failure_t failure) 00154 { 00155 UTEST_LOG_FUNCTION(); 00156 static int repeat_counter(0); 00157 00158 TEST_ASSERT_EQUAL((call_counter == 38) ? 1 : 0, passed); 00159 TEST_ASSERT_EQUAL(0, failed); 00160 TEST_ASSERT_EQUAL(REASON_NONE, failure.reason); 00161 TEST_ASSERT_EQUAL(LOCATION_NONE, failure.location); 00162 TEST_ASSERT_EQUAL(repeat_counter*3 + ((repeat_counter == 9) ? 11 : 10), call_counter++); 00163 repeat_counter++; 00164 return greentea_case_teardown_handler(source, passed, failed, failure); 00165 } 00166 00167 // Control: RepeatAllOnTimeout ---------------------------------------------------------------------------------------- 00168 utest::v1::status_t repeat_handler_on_timeout_case_setup(const Case *const source, const size_t index_of_case) 00169 { 00170 UTEST_LOG_FUNCTION(); 00171 TEST_ASSERT_EQUAL(4, index_of_case); 00172 TEST_ASSERT_EQUAL(39, call_counter++); 00173 return greentea_case_setup_handler(source, index_of_case); 00174 } 00175 00176 control_t repeat_handler_on_timeout_case(const size_t call_count) 00177 { 00178 UTEST_LOG_FUNCTION(); 00179 static int repeat_counter(1); 00180 TEST_ASSERT_EQUAL(repeat_counter++, call_count); 00181 TEST_ASSERT(call_count <= 10); 00182 TEST_ASSERT_EQUAL(call_count-1 + 40, call_counter++); 00183 if (call_count == 10) { 00184 utest_to.attach_us(&validate3, &Utest_func_bind::callback, (50*1000)); // Fire after 50ms 00185 } 00186 return CaseRepeatHandlerOnTimeout(100); 00187 } 00188 utest::v1::status_t repeat_handler_on_timeout_case_teardown(const Case *const source, const size_t passed, const size_t failed, const failure_t failure) 00189 { 00190 UTEST_LOG_FUNCTION(); 00191 TEST_ASSERT_EQUAL(1, passed); 00192 TEST_ASSERT_EQUAL(0, failed); 00193 TEST_ASSERT_EQUAL(REASON_NONE, failure.reason); 00194 TEST_ASSERT_EQUAL(LOCATION_NONE, failure.location); 00195 TEST_ASSERT_EQUAL(51, call_counter++); 00196 return greentea_case_teardown_handler(source, passed, failed, failure); 00197 } 00198 00199 // Control: NoTimeout ------------------------------------------------------------------------------------------------- 00200 control_t no_timeout_case(const size_t call_count) 00201 { 00202 UTEST_LOG_FUNCTION(); 00203 TEST_ASSERT_EQUAL(1, call_count); 00204 TEST_ASSERT_EQUAL(52, call_counter++); 00205 return CaseNoTimeout; 00206 } 00207 00208 // Control: NoTimeout ------------------------------------------------------------------------------------------------- 00209 control_t next_case(const size_t call_count) 00210 { 00211 UTEST_LOG_FUNCTION(); 00212 TEST_ASSERT_EQUAL(1, call_count); 00213 TEST_ASSERT_EQUAL(53, call_counter++); 00214 return CaseNoTimeout; 00215 } 00216 00217 // Cases -------------------------------------------------------------------------------------------------------------- 00218 Case cases[] = { 00219 Case("Control: Timeout (Failure)", timeout_failure_case, timeout_failure_case_teardown, timeout_failure_case_failure_handler), 00220 Case("Control: Timeout (Success)", timeout_success_case, timeout_success_case_failure_handler), 00221 Case("Control: Await", await_case), 00222 Case("Control: RepeatAllOnTimeout", repeat_all_on_timeout_case_setup, repeat_all_on_timeout_case, repeat_all_on_timeout_case_teardown), 00223 Case("Control: RepeatHandlerOnTimeout", repeat_handler_on_timeout_case_setup, repeat_handler_on_timeout_case, repeat_handler_on_timeout_case_teardown), 00224 Case("Control: NoTimeout", no_timeout_case), 00225 Case("Control: CaseNext", next_case) 00226 }; 00227 00228 // Specification: Setup & Teardown ------------------------------------------------------------------------------------ 00229 utest::v1::status_t greentea_setup(const size_t number_of_cases) 00230 { 00231 GREENTEA_SETUP(15, "default_auto"); 00232 00233 return verbose_test_setup_handler(number_of_cases); 00234 } 00235 void greentea_teardown(const size_t passed, const size_t failed, const failure_t failure) 00236 { 00237 TEST_ASSERT_EQUAL(54, call_counter++); 00238 TEST_ASSERT_EQUAL(6, passed); 00239 TEST_ASSERT_EQUAL(1, failed); 00240 TEST_ASSERT_EQUAL(REASON_CASES, failure.reason); 00241 TEST_ASSERT_EQUAL(LOCATION_UNKNOWN, failure.location); 00242 greentea_test_teardown_handler(7, 0, REASON_NONE); 00243 } 00244 00245 Specification specification(greentea_setup, cases, greentea_teardown, selftest_handlers); 00246 00247 int main() 00248 { 00249 // Run the specification only AFTER setting the custom scheduler(if required). 00250 Harness::run(specification); 00251 }
Generated on Sun Jul 17 2022 08:25:26 by
![doxygen](doxygen.png)