Test: Watchdog: Fix test_restart case

Filip Jagodzinski · 0xc0170 · commit a7178b3519b0 · 2019-07-11T11:55:28.000+01:00
Watchdog::stop() is called in this test. If the target does not support
stopping the watchdog this case needs to be skipped.
Also improve handling ignored test cases.
diff --git a/TESTS/mbed_drivers/watchdog/main.cpp b/TESTS/mbed_drivers/watchdog/main.cpp
@@ -60,6 +60,7 @@
 
 int CASE_INDEX_START;
 int CASE_INDEX_CURRENT;
+bool CASE_IGNORED = false;
 
 using utest::v1::Case;
 using utest::v1::Specification;
@@ -91,6 +92,7 @@ void test_stop()
     Watchdog &watchdog = Watchdog::get_instance();
     if (!features.disable_watchdog) {
         TEST_ASSERT_FALSE(watchdog.stop());
+        CASE_IGNORED = true;
         TEST_IGNORE_MESSAGE("Disabling watchdog not supported for this platform");
         return;
     }
@@ -114,9 +116,15 @@ void test_restart()
 {
     watchdog_features_t features = hal_watchdog_get_platform_features();
     if (!features.update_config) {
+        CASE_IGNORED = true;
         TEST_IGNORE_MESSAGE("Updating watchdog config not supported for this platform");
         return;
     }
+    if (!features.disable_watchdog) {
+        CASE_IGNORED = true;
+        TEST_IGNORE_MESSAGE("Disabling watchdog not supported for this platform");
+        return;
+    }
 
     Watchdog &watchdog = Watchdog::get_instance();
     uint32_t max_timeout = watchdog.get_max_timeout();
@@ -129,6 +137,7 @@ void test_restart()
 
     for (size_t i = 0; i < num_timeouts; i++) {
         if (timeouts[i] < WDG_MIN_TIMEOUT_MS) {
+            CASE_IGNORED = true;
             TEST_IGNORE_MESSAGE("Requested timeout value is too short -- ignoring test case.");
             return;
         }
@@ -148,12 +157,16 @@ void test_restart()
 utest::v1::status_t case_setup_sync_on_reset(const Case *const source, const size_t index_of_case)
 {
     CASE_INDEX_CURRENT = index_of_case;
+    CASE_IGNORED = false;
     return utest::v1::greentea_case_setup_handler(source, index_of_case);
 }
 
 utest::v1::status_t case_teardown_sync_on_reset(const Case *const source, const size_t passed, const size_t failed,
                                                 const utest::v1::failure_t failure)
 {
+    if (CASE_IGNORED) {
+        return utest::v1::greentea_case_teardown_handler(source, passed, failed, failure);
+    }
     // Unlock kicking the watchdog during teardown.
     kick_wdg_during_test_teardown.release();
     utest::v1::status_t status = utest::v1::greentea_case_teardown_handler(source, passed, failed, failure);
@@ -178,6 +191,9 @@ utest::v1::status_t case_teardown_sync_on_reset(const Case *const source, const
 utest::v1::status_t case_teardown_wdg_stop_or_reset(const Case *const source, const size_t passed, const size_t failed,
                                                     const utest::v1::failure_t failure)
 {
+    if (CASE_IGNORED) {
+        return utest::v1::greentea_case_teardown_handler(source, passed, failed, failure);
+    }
     watchdog_features_t features = hal_watchdog_get_platform_features();
     if (features.disable_watchdog) {
         hal_watchdog_stop();
@@ -191,6 +207,7 @@ template<uint32_t timeout_ms>
 void test_start()
 {
     if (timeout_ms < WDG_MIN_TIMEOUT_MS) {
+        CASE_IGNORED = true;
         TEST_IGNORE_MESSAGE("Requested timeout value is too short -- ignoring test case.");
         return;
     }
diff --git a/TESTS/mbed_hal/watchdog/main.cpp b/TESTS/mbed_hal/watchdog/main.cpp
@@ -61,6 +61,7 @@
 
 int CASE_INDEX_START;
 int CASE_INDEX_CURRENT;
+bool CASE_IGNORED = false;
 
 using utest::v1::Case;
 using utest::v1::Specification;
@@ -89,6 +90,7 @@ void test_restart_is_possible()
 {
     watchdog_features_t features = hal_watchdog_get_platform_features();
     if (!features.disable_watchdog) {
+        CASE_IGNORED = true;
         TEST_IGNORE_MESSAGE("Disabling watchdog not supported for this platform");
         return;
     }
@@ -100,6 +102,7 @@ void test_stop()
     watchdog_features_t features = hal_watchdog_get_platform_features();
     if (!features.disable_watchdog) {
         TEST_ASSERT_EQUAL(WATCHDOG_STATUS_NOT_SUPPORTED, hal_watchdog_stop());
+        CASE_IGNORED = true;
         TEST_IGNORE_MESSAGE("Disabling watchdog not supported for this platform");
         return;
     }
@@ -118,6 +121,7 @@ void test_update_config()
 {
     watchdog_features_t features = hal_watchdog_get_platform_features();
     if (!features.update_config) {
+        CASE_IGNORED = true;
         TEST_IGNORE_MESSAGE("Updating watchdog config not supported for this platform");
         return;
     }
@@ -132,6 +136,7 @@ void test_update_config()
 
     for (size_t i = 0; i < num_timeouts; i++) {
         if (timeouts[i] < WDG_MIN_TIMEOUT_MS) {
+            CASE_IGNORED = true;
             TEST_IGNORE_MESSAGE("Requested timeout value is too short -- ignoring test case.");
             return;
         }
@@ -149,12 +154,16 @@ void test_update_config()
 utest::v1::status_t case_setup_sync_on_reset(const Case *const source, const size_t index_of_case)
 {
     CASE_INDEX_CURRENT = index_of_case;
+    CASE_IGNORED = false;
     return utest::v1::greentea_case_setup_handler(source, index_of_case);
 }
 
 utest::v1::status_t case_teardown_sync_on_reset(const Case *const source, const size_t passed, const size_t failed,
                                                 const utest::v1::failure_t failure)
 {
+    if (CASE_IGNORED) {
+        return utest::v1::greentea_case_teardown_handler(source, passed, failed, failure);
+    }
     // Unlock kicking the watchdog during teardown.
     kick_wdg_during_test_teardown.release();
     utest::v1::status_t status = utest::v1::greentea_case_teardown_handler(source, passed, failed, failure);
@@ -179,6 +188,9 @@ utest::v1::status_t case_teardown_sync_on_reset(const Case *const source, const
 utest::v1::status_t case_teardown_wdg_stop_or_reset(const Case *const source, const size_t passed, const size_t failed,
                                                     const utest::v1::failure_t failure)
 {
+    if (CASE_IGNORED) {
+        return utest::v1::greentea_case_teardown_handler(source, passed, failed, failure);
+    }
     watchdog_features_t features = hal_watchdog_get_platform_features();
     if (features.disable_watchdog) {
         hal_watchdog_stop();
@@ -192,6 +204,7 @@ template<uint32_t timeout_ms>
 void test_init()
 {
     if (timeout_ms < WDG_MIN_TIMEOUT_MS) {
+        CASE_IGNORED = true;
         TEST_IGNORE_MESSAGE("Requested timeout value is too short -- ignoring test case.");
         return;
     }

Original file line number	Diff line number	Diff line change
`@@ -61,6 +61,7 @@`
`61`	`61`
`62`	`62`	`int CASE_INDEX_START;`
`63`	`63`	`int CASE_INDEX_CURRENT;`
	`64`	`+bool CASE_IGNORED = false;`
`64`	`65`
`65`	`66`	`using utest::v1::Case;`
`66`	`67`	`using utest::v1::Specification;`
`@@ -89,6 +90,7 @@ void test_restart_is_possible()`
`89`	`90`	`{`
`90`	`91`	`watchdog_features_t features = hal_watchdog_get_platform_features();`
`91`	`92`	`if (!features.disable_watchdog) {`
	`93`	`+ CASE_IGNORED = true;`
`92`	`94`	`TEST_IGNORE_MESSAGE("Disabling watchdog not supported for this platform");`
`93`	`95`	`return;`
`94`	`96`	`}`
`@@ -100,6 +102,7 @@ void test_stop()`
`100`	`102`	`watchdog_features_t features = hal_watchdog_get_platform_features();`
`101`	`103`	`if (!features.disable_watchdog) {`
`102`	`104`	`TEST_ASSERT_EQUAL(WATCHDOG_STATUS_NOT_SUPPORTED, hal_watchdog_stop());`
	`105`	`+ CASE_IGNORED = true;`
`103`	`106`	`TEST_IGNORE_MESSAGE("Disabling watchdog not supported for this platform");`
`104`	`107`	`return;`
`105`	`108`	`}`
`@@ -118,6 +121,7 @@ void test_update_config()`
`118`	`121`	`{`
`119`	`122`	`watchdog_features_t features = hal_watchdog_get_platform_features();`
`120`	`123`	`if (!features.update_config) {`
	`124`	`+ CASE_IGNORED = true;`
`121`	`125`	`TEST_IGNORE_MESSAGE("Updating watchdog config not supported for this platform");`
`122`	`126`	`return;`
`123`	`127`	`}`
`@@ -132,6 +136,7 @@ void test_update_config()`
`132`	`136`
`133`	`137`	`for (size_t i = 0; i < num_timeouts; i++) {`
`134`	`138`	`if (timeouts[i] < WDG_MIN_TIMEOUT_MS) {`
	`139`	`+ CASE_IGNORED = true;`
`135`	`140`	`TEST_IGNORE_MESSAGE("Requested timeout value is too short -- ignoring test case.");`
`136`	`141`	`return;`
`137`	`142`	`}`
`@@ -149,12 +154,16 @@ void test_update_config()`
`149`	`154`	`utest::v1::status_t case_setup_sync_on_reset(const Case *const source, const size_t index_of_case)`
`150`	`155`	`{`
`151`	`156`	`CASE_INDEX_CURRENT = index_of_case;`
	`157`	`+ CASE_IGNORED = false;`
`152`	`158`	`return utest::v1::greentea_case_setup_handler(source, index_of_case);`
`153`	`159`	`}`
`154`	`160`
`155`	`161`	`utest::v1::status_t case_teardown_sync_on_reset(const Case *const source, const size_t passed, const size_t failed,`
`156`	`162`	`const utest::v1::failure_t failure)`
`157`	`163`	`{`
	`164`	`+ if (CASE_IGNORED) {`
	`165`	`+ return utest::v1::greentea_case_teardown_handler(source, passed, failed, failure);`
	`166`	`+ }`
`158`	`167`	`// Unlock kicking the watchdog during teardown.`
`159`	`168`	`kick_wdg_during_test_teardown.release();`
`160`	`169`	`utest::v1::status_t status = utest::v1::greentea_case_teardown_handler(source, passed, failed, failure);`
`@@ -179,6 +188,9 @@ utest::v1::status_t case_teardown_sync_on_reset(const Case *const source, const`
`179`	`188`	`utest::v1::status_t case_teardown_wdg_stop_or_reset(const Case *const source, const size_t passed, const size_t failed,`
`180`	`189`	`const utest::v1::failure_t failure)`
`181`	`190`	`{`
	`191`	`+ if (CASE_IGNORED) {`
	`192`	`+ return utest::v1::greentea_case_teardown_handler(source, passed, failed, failure);`
	`193`	`+ }`
`182`	`194`	`watchdog_features_t features = hal_watchdog_get_platform_features();`
`183`	`195`	`if (features.disable_watchdog) {`
`184`	`196`	`hal_watchdog_stop();`
`@@ -192,6 +204,7 @@ template<uint32_t timeout_ms>`
`192`	`204`	`void test_init()`
`193`	`205`	`{`
`194`	`206`	`if (timeout_ms < WDG_MIN_TIMEOUT_MS) {`
	`207`	`+ CASE_IGNORED = true;`
`195`	`208`	`TEST_IGNORE_MESSAGE("Requested timeout value is too short -- ignoring test case.");`
`196`	`209`	`return;`
`197`	`210`	`}`