Code review rework:

Updated include files within tests to use subdirectory/header.h
Updated global variables within tests to be static
Fixed indentation issue.
Renamed Timeout class variables to be more meaningful
Moved definition of utest_trace into stack_trace.cpp
Removed unecessary call to .clear() method in utest_add_to_trace()
Changed UTEST_LOG_FUNCTION macro to UTEST_LOG_FUNCTION();

Author: adbridge

frameworks/utest/TESTS/readme/main.cpp renamed to frameworks/utest/TESTS/readme/main_cpp_template

@@ -17,14 +17,14 @@
  * unit test.
  *
  */
-#include "mbed-drivers/mbed.h"
+#include "mbed.h"
 #include "greentea-client/test_env.h"
-#include "utest/utest.h"
-#include "unity/unity.h"
+#include "utest.h"
+#include "unity.h"
 
 using namespace utest::v1;
 
-Timeout to;
+static Timeout utest_to;
 
 void test_simple() {
     TEST_ASSERT_EQUAL(0, 0);
@@ -53,7 +53,7 @@ void test_callback_validate() {
 control_t test_asynchronous() {
     TEST_ASSERT_TRUE_MESSAGE(true, "(true == false) o_O");
     // Set up a callback in the future. This may also be an interrupt!
-    to.attach_us(test_callback_validate, (100*1000)); // Fire after 100 ms
+    utest_to.attach_us(test_callback_validate, (100*1000)); // Fire after 100 ms
 
     // Set a 200ms timeout starting from now
     return CaseTimeout(200);
@@ -65,7 +65,7 @@ control_t test_asynchronous_timeout(const size_t call_count) {
     // but automatically repeat only this handler on timeout.
     if (call_count >= 5) {
         // but after the 5th call, the callback finally gets validated
-        to.attach_us(test_callback_validate, (100*1000)); // Fire after 100 ms
+        utest_to.attach_us(test_callback_validate, (100*1000)); // Fire after 100 ms
     }
     return CaseRepeatHandlerOnTimeout(200);
 }

frameworks/utest/TESTS/unit_tests/basic_test/main.cpp

@@ -1,22 +1,26 @@
-#include "test_env.h"
-#include "mbed.h"
-#include "utest.h"
-#include "unity.h"
+#include "mbed-drivers/mbed.h"
+#include "greentea-client/test_env.h"
+#include "utest/utest.h"
+#include "unity/unity.h"
+#include "stack_trace.h"
 
 using namespace utest::v1;
 
 void test_simple() {
+    UTEST_LOG_FUNCTION();
     TEST_ASSERT_EQUAL(0, 0);
     printf("Simple test called\n");
 }
 
 status_t test_repeats_setup(const Case *const source, const size_t index_of_case) {
+    UTEST_LOG_FUNCTION();
     // Call the default handler for proper reporting
     status_t status = greentea_case_setup_handler(source, index_of_case);
     printf("Setting up for '%s'\n", source->get_description());
     return status;
 }
 control_t test_repeats(const size_t call_count) {
+    UTEST_LOG_FUNCTION();
     printf("Called for the %u. time\n", call_count);
     TEST_ASSERT_NOT_EQUAL(3, call_count);
     // Specify how often this test is repeated ie. n total calls
@@ -25,6 +29,7 @@ control_t test_repeats(const size_t call_count) {
 
 // Custom setup handler required for proper Greentea support
 status_t greentea_setup(const size_t number_of_cases) {
+    UTEST_LOG_FUNCTION();
     GREENTEA_SETUP(20, "default_auto");
     // Call the default reporting function
     return greentea_test_setup_handler(number_of_cases);
@@ -43,8 +48,7 @@ extern void utest_run(const Specification& specification);
 
 int main()
 {
-    // You MUST set the custom scheduler before running the specification.
-    Harness::set_scheduler(utest_v1_get_scheduler());
+    UTEST_LOG_FUNCTION();
     // Run the specification only AFTER setting the custom scheduler.
     Harness::run(specification);
 }

frameworks/utest/TESTS/unit_tests/case_async_validate/main.cpp

@@ -14,19 +14,18 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-#include "test_env.h"
-#include "mbed.h"
-#include "utest.h"
-#include "unity.h"
+#include "mbed-drivers/mbed.h"
+#include "greentea-client/test_env.h"
+#include "utest/utest.h"
+#include "unity/unity.h"
 
 #include <stdio.h>
 
 using namespace utest::v1;
 
-int call_counter(0);
+static int call_counter(0);
 
-Timeout to1;
-Timeout to;
+static Timeout utest_to;
 
 // Validate: Simple Validation ----------------------------------------------------------------------------------------
 void simple_validation()
@@ -40,7 +39,7 @@ control_t simple_validation_case()
 {
     printf("Simple validation, posting callback\n");
     TEST_ASSERT_EQUAL(0, call_counter++);
-    to.attach_us(simple_validation, 100); // Fire after 100 us
+    utest_to.attach_us(simple_validation, 100); // Fire after 100 us
 
     return CaseAwait;
 }
@@ -69,7 +68,7 @@ control_t multiple_validation_case()
 {
     TEST_ASSERT_EQUAL(2, call_counter++);
     printf("Multiple validation callback posted.\n");
-    to1.attach_us(multiple_validation, 100000); // Fire after 100 ms
+    utest_to.attach_us(multiple_validation, 100000); // Fire after 100 ms
     return CaseAwait;
 }
 
@@ -146,7 +145,7 @@ control_t attributed_validation_cancel_repeat_case()
     TEST_ASSERT_EQUAL(18, call_counter++);
     printf("Validation cancel repeat callback posted.\n");
 
-    to1.attach_us(attributed_validation_cancel_repeat, 100000); // Fire after 100 ms
+    utest_to.attach_us(attributed_validation_cancel_repeat, 100000); // Fire after 100 ms
     // the RepeatAll will be cancelled during callback validation
     return CaseRepeatAll + CaseAwait;
 }
@@ -178,8 +177,8 @@ control_t attributed_validation_enable_repeat_case(const size_t call_count)
 {
     if (call_count == 1) {
         TEST_ASSERT_EQUAL(21, call_counter++);
-    printf("Validation enable repeat callback posted.\n");
-    to1.attach_us(attributed_validation_enable_repeat, 100000); // Fire after 100 ms
+        printf("Validation enable repeat callback posted.\n");
+        utest_to.attach_us(attributed_validation_enable_repeat, 100000); // Fire after 100 ms
         // the RepeatAll will be cancelled during callback validation
         return CaseAwait;
     }

frameworks/utest/TESTS/unit_tests/case_control_async/main.cpp

@@ -14,20 +14,17 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-#include "mbed.h"
-#include "test_env.h"
-#include "utest.h"
-#include "unity.h"
-#include "stack_trace.h"
+#include "mbed-drivers/mbed.h"
+#include "greentea-client/test_env.h"
+#include "utest/utest.h"
+#include "unity/unity.h"
+#include "utest/stack_trace.h"
 
 using namespace utest::v1;
 
-#ifdef UTEST_STACK_TRACE
-std::string utest_trace[UTEST_MAX_BACKTRACE];
-#endif // UTEST_STACK_TRACE
 
-int call_counter(0);
-Timeout to;
+static int call_counter(0);
+static Timeout utest_to;
 
 class Utest_func_bind {
 
@@ -48,29 +45,29 @@ class Utest_func_bind {
 
 void await_case_validate(int expected_call_count) 
 {
-    UTEST_LOG_FUNCTION
+    UTEST_LOG_FUNCTION();
     printf("await_case_validate called with expected call count of %d\n", expected_call_count);
     TEST_ASSERT_EQUAL(expected_call_count, call_counter++);
     Harness::validate_callback();
 }
 
-Utest_func_bind validate1(await_case_validate, 7);
-Utest_func_bind validate2(await_case_validate, 37);
-Utest_func_bind validate3(await_case_validate, 50);
+static Utest_func_bind validate1(await_case_validate, 7);
+static Utest_func_bind validate2(await_case_validate, 37);
+static Utest_func_bind validate3(await_case_validate, 50);
 
 
 
 // Control: Timeout (Failure) -----------------------------------------------------------------------------------------
 control_t timeout_failure_case(const size_t call_count)
 {
-    UTEST_LOG_FUNCTION
+    UTEST_LOG_FUNCTION();
     TEST_ASSERT_EQUAL(1, call_count);
     TEST_ASSERT_EQUAL(0, call_counter++);
     return CaseTimeout(100);
 }
 status_t timeout_failure_case_failure_handler(const Case *const source, const failure_t failure)
 {
-    UTEST_LOG_FUNCTION
+    UTEST_LOG_FUNCTION();
     TEST_ASSERT_EQUAL(1, call_counter++);
     TEST_ASSERT_EQUAL(REASON_TIMEOUT, failure.reason);
     TEST_ASSERT_EQUAL(LOCATION_CASE_HANDLER, failure.location);
@@ -79,7 +76,7 @@ status_t timeout_failure_case_failure_handler(const Case *const source, const fa
 }
 status_t timeout_failure_case_teardown(const Case *const source, const size_t passed, const size_t failed, const failure_t failure)
 {
-    UTEST_LOG_FUNCTION
+    UTEST_LOG_FUNCTION();
     TEST_ASSERT_EQUAL(2, call_counter++);
     TEST_ASSERT_EQUAL(0, passed);
     TEST_ASSERT_EQUAL(1, failed);
@@ -90,23 +87,23 @@ status_t timeout_failure_case_teardown(const Case *const source, const size_t pa
 
 // Control: Timeout (Success) -----------------------------------------------------------------------------------------
 void timeout_success_case_validate() {
-    UTEST_LOG_FUNCTION
+    UTEST_LOG_FUNCTION();
     TEST_ASSERT_EQUAL(4, call_counter++);
     Harness::validate_callback();
 }
 
 control_t timeout_success_case(const size_t call_count)
 {
-    UTEST_LOG_FUNCTION
+    UTEST_LOG_FUNCTION();
     TEST_ASSERT_EQUAL(1, call_count);
     TEST_ASSERT_EQUAL(3, call_counter++);
-    to.attach_us(timeout_success_case_validate, 100000); // Fire after 100 ms 
+    utest_to.attach_us(timeout_success_case_validate, 100000); // Fire after 100 ms 
 
     return CaseTimeout(200);
 }
 status_t timeout_success_case_failure_handler(const Case *const source, const size_t passed, const size_t failed, const failure_t failure)
 {
-    UTEST_LOG_FUNCTION
+    UTEST_LOG_FUNCTION();
     TEST_ASSERT_EQUAL(5, call_counter++);
     TEST_ASSERT_EQUAL(1, passed);
     TEST_ASSERT_EQUAL(0, failed);
@@ -118,11 +115,11 @@ status_t timeout_success_case_failure_handler(const Case *const source, const si
 // Control: Await -----------------------------------------------------------------------------------------------------
 control_t await_case(const size_t call_count)
 {
-    UTEST_LOG_FUNCTION
+    UTEST_LOG_FUNCTION();
     TEST_ASSERT_EQUAL(1, call_count);
     TEST_ASSERT_EQUAL(6, call_counter++);
 
-    to.attach_us(&validate1, &Utest_func_bind::callback, (1372*1000)); // Fire after 1372 ms 
+    utest_to.attach_us(&validate1, &Utest_func_bind::callback, (1372*1000)); // Fire after 1372 ms 
 
     return CaseAwait;
 }
@@ -135,7 +132,7 @@ status_t repeat_all_on_timeout_case_setup(const Case *const source, const size_t
         UTEST_TRACE_START 
         repeat_all_start_flag = false;    
     }
-    UTEST_LOG_FUNCTION
+    UTEST_LOG_FUNCTION();
     static int repeat_counter(0);
     TEST_ASSERT_EQUAL(3, index_of_case);
     TEST_ASSERT_EQUAL(repeat_counter*3 + 8, call_counter++);
@@ -144,21 +141,21 @@ status_t repeat_all_on_timeout_case_setup(const Case *const source, const size_t
 }
 control_t repeat_all_on_timeout_case(const size_t call_count)
 {
-    UTEST_LOG_FUNCTION
+    UTEST_LOG_FUNCTION();
     printf("Running case handler for %u. time\n", call_count);
     static int repeat_counter(1);
     TEST_ASSERT_EQUAL(repeat_counter++, call_count);
     TEST_ASSERT(call_count <= 10);
     TEST_ASSERT_EQUAL((call_count-1)*3 + 9, call_counter++);
     if (call_count == 10) {
         printf("Scheduling await_case_validate with value 37");
-        to.attach_us(&validate2, &Utest_func_bind::callback, (50*1000)); // Fire after 50ms
+        utest_to.attach_us(&validate2, &Utest_func_bind::callback, (50*1000)); // Fire after 50ms
     }
     return CaseRepeatAllOnTimeout(100);
 }
 status_t repeat_all_on_timeout_case_teardown(const Case *const source, const size_t passed, const size_t failed, const failure_t failure)
 {
-    UTEST_LOG_FUNCTION
+    UTEST_LOG_FUNCTION();
     static int repeat_counter(0);
     printf("Call counter = %d, passed =%u, failed = %u\n", call_counter, passed, failed);
 
@@ -174,29 +171,29 @@ status_t repeat_all_on_timeout_case_teardown(const Case *const source, const siz
 // Control: RepeatAllOnTimeout ----------------------------------------------------------------------------------------
 status_t repeat_handler_on_timeout_case_setup(const Case *const source, const size_t index_of_case)
 {
-    UTEST_LOG_FUNCTION
+    UTEST_LOG_FUNCTION();
     TEST_ASSERT_EQUAL(4, index_of_case);
     TEST_ASSERT_EQUAL(39, call_counter++);
     return greentea_case_setup_handler(source, index_of_case);
 }
 
 control_t repeat_handler_on_timeout_case(const size_t call_count)
 {
-    UTEST_LOG_FUNCTION
+    UTEST_LOG_FUNCTION();
     printf("Running case handler for %u. time\n", call_count);
     static int repeat_counter(1);
     TEST_ASSERT_EQUAL(repeat_counter++, call_count);
     TEST_ASSERT(call_count <= 10);
     TEST_ASSERT_EQUAL(call_count-1 + 40, call_counter++);
     if (call_count == 10) {
         printf("Scheduling await_case_validate with value 50");
-        to.attach_us(&validate3, &Utest_func_bind::callback, (50*1000)); // Fire after 50ms
+        utest_to.attach_us(&validate3, &Utest_func_bind::callback, (50*1000)); // Fire after 50ms
     }
     return CaseRepeatHandlerOnTimeout(100);
 }
 status_t repeat_handler_on_timeout_case_teardown(const Case *const source, const size_t passed, const size_t failed, const failure_t failure)
 {
-    UTEST_LOG_FUNCTION
+    UTEST_LOG_FUNCTION();
     TEST_ASSERT_EQUAL(1, passed);
     TEST_ASSERT_EQUAL(0, failed);
     TEST_ASSERT_EQUAL(REASON_NONE, failure.reason);
@@ -208,7 +205,7 @@ status_t repeat_handler_on_timeout_case_teardown(const Case *const source, const
 // Control: NoTimeout -------------------------------------------------------------------------------------------------
 control_t no_timeout_case(const size_t call_count)
 {
-    UTEST_LOG_FUNCTION
+    UTEST_LOG_FUNCTION();
     TEST_ASSERT_EQUAL(1, call_count);
     TEST_ASSERT_EQUAL(52, call_counter++);
     return CaseNoTimeout;
@@ -217,7 +214,7 @@ control_t no_timeout_case(const size_t call_count)
 // Control: NoTimeout -------------------------------------------------------------------------------------------------
 control_t next_case(const size_t call_count)
 {
-    UTEST_LOG_FUNCTION
+    UTEST_LOG_FUNCTION();
     TEST_ASSERT_EQUAL(1, call_count);
     TEST_ASSERT_EQUAL(53, call_counter++);
     return CaseNoTimeout;

frameworks/utest/TESTS/unit_tests/case_control_repeat/main.cpp

@@ -21,7 +21,7 @@
 
 using namespace utest::v1;
 
-int call_counter(0);
+static int call_counter(0);
 
 // Control: RepeatAll -------------------------------------------------------------------------------------------------
 status_t repeat_all_case_setup(const Case *const source, const size_t index_of_case)

frameworks/utest/TESTS/unit_tests/case_selection/main.cpp

@@ -22,7 +22,7 @@
 
 using namespace utest::v1;
 
-int call_counter(0);
+static int call_counter(0);
 
 void handler_case_2()
 {

frameworks/utest/TESTS/unit_tests/case_setup_failure/main.cpp

@@ -21,7 +21,7 @@
 
 using namespace utest::v1;
 
-int call_counter(0);
+static int call_counter(0);
 
 void never_call_case()
 {

frameworks/utest/TESTS/unit_tests/case_teardown_failure/main.cpp

@@ -21,7 +21,7 @@
 
 using namespace utest::v1;
 
-int call_counter(0);
+static int call_counter(0);
 
 // Continue Teardown Handler ------------------------------------------------------------------------------------------
 void continue_case()