Update deep sleep lock check in tests

c1728p9 · c1728p9 · commit 472ababfefa9 · 2018-08-17T09:29:41.000-05:00
When the define LPTICKER_DELAY_TICKS is set deep sleep can be randomly
disallowed when using the low power ticker. This is because a Timer
object, which locks deep sleep, is used to protect from back-to-back
writes to lp tickers which can't support that. This causes tests which
assert that deep sleep is allowed to intermittently fail.

To fix this intermittent failure this patch adds the function
sleep_manager_can_deep_sleep_test_check() which checks if deep sleep
is allowed over a duration. It updates all the tests to use
sleep_manager_can_deep_sleep_test_check() rather
than sleep_manager_can_deep_sleep() so the tests work even if deep
sleep is spuriously blocked.
diff --git a/TESTS/mbed_drivers/sleep_lock/main.cpp b/TESTS/mbed_drivers/sleep_lock/main.cpp
@@ -29,90 +29,90 @@ using namespace utest::v1;
 
 void deep_sleep_lock_lock_test()
 {
-    TEST_ASSERT_EQUAL(true, sleep_manager_can_deep_sleep());
+    TEST_ASSERT_EQUAL(true, sleep_manager_can_deep_sleep_test_check());
     {
         // Check basic usage works
         DeepSleepLock lock;
-        TEST_ASSERT_EQUAL(false, sleep_manager_can_deep_sleep());
+        TEST_ASSERT_EQUAL(false, sleep_manager_can_deep_sleep_test_check());
     }
 
-    TEST_ASSERT_EQUAL(true, sleep_manager_can_deep_sleep());
+    TEST_ASSERT_EQUAL(true, sleep_manager_can_deep_sleep_test_check());
     {
         // Check that unlock and lock change can deep sleep as expected
         DeepSleepLock lock;
-        TEST_ASSERT_EQUAL(false, sleep_manager_can_deep_sleep());
+        TEST_ASSERT_EQUAL(false, sleep_manager_can_deep_sleep_test_check());
         lock.unlock();
-        TEST_ASSERT_EQUAL(true, sleep_manager_can_deep_sleep());
+        TEST_ASSERT_EQUAL(true, sleep_manager_can_deep_sleep_test_check());
         lock.lock();
-        TEST_ASSERT_EQUAL(false, sleep_manager_can_deep_sleep());
+        TEST_ASSERT_EQUAL(false, sleep_manager_can_deep_sleep_test_check());
     }
 
-    TEST_ASSERT_EQUAL(true, sleep_manager_can_deep_sleep());
+    TEST_ASSERT_EQUAL(true, sleep_manager_can_deep_sleep_test_check());
     {
         // Check that unlock releases sleep based on count
         DeepSleepLock lock;
         lock.lock();
         lock.lock();
         lock.unlock();
-        TEST_ASSERT_EQUAL(false, sleep_manager_can_deep_sleep());
+        TEST_ASSERT_EQUAL(false, sleep_manager_can_deep_sleep_test_check());
     }
 
-    TEST_ASSERT_EQUAL(true, sleep_manager_can_deep_sleep());
+    TEST_ASSERT_EQUAL(true, sleep_manager_can_deep_sleep_test_check());
     {
         // Check that unbalanced locks do not leave deep sleep locked
         DeepSleepLock lock;
         lock.lock();
-        TEST_ASSERT_EQUAL(false, sleep_manager_can_deep_sleep());
+        TEST_ASSERT_EQUAL(false, sleep_manager_can_deep_sleep_test_check());
     }
-    TEST_ASSERT_EQUAL(true, sleep_manager_can_deep_sleep());
+    TEST_ASSERT_EQUAL(true, sleep_manager_can_deep_sleep_test_check());
 
 }
 
 void timer_lock_test()
 {
-    TEST_ASSERT_EQUAL(true, sleep_manager_can_deep_sleep());
+    TEST_ASSERT_EQUAL(true, sleep_manager_can_deep_sleep_test_check());
     {
         // Just creating a timer object does not lock sleep
         Timer timer;
-        TEST_ASSERT_EQUAL(true, sleep_manager_can_deep_sleep());
+        TEST_ASSERT_EQUAL(true, sleep_manager_can_deep_sleep_test_check());
     }
 
-    TEST_ASSERT_EQUAL(true, sleep_manager_can_deep_sleep());
+    TEST_ASSERT_EQUAL(true, sleep_manager_can_deep_sleep_test_check());
     {
         // Starting a timer does lock sleep
         Timer timer;
         timer.start();
-        TEST_ASSERT_EQUAL(false, sleep_manager_can_deep_sleep());
+        TEST_ASSERT_EQUAL(false, sleep_manager_can_deep_sleep_test_check());
     }
 
-    TEST_ASSERT_EQUAL(true, sleep_manager_can_deep_sleep());
+    TEST_ASSERT_EQUAL(true, sleep_manager_can_deep_sleep_test_check());
     {
         // Stopping a timer after starting it allows sleep
         Timer timer;
         timer.start();
         timer.stop();
-        TEST_ASSERT_EQUAL(true, sleep_manager_can_deep_sleep());
+        TEST_ASSERT_EQUAL(true, sleep_manager_can_deep_sleep_test_check());
     }
 
-    TEST_ASSERT_EQUAL(true, sleep_manager_can_deep_sleep());
+    TEST_ASSERT_EQUAL(true, sleep_manager_can_deep_sleep_test_check());
     {
         // Starting a timer multiple times still lets you sleep
         Timer timer;
         timer.start();
         timer.start();
     }
-    TEST_ASSERT_EQUAL(true, sleep_manager_can_deep_sleep());
+    TEST_ASSERT_EQUAL(true, sleep_manager_can_deep_sleep_test_check());
 
-    TEST_ASSERT_EQUAL(true, sleep_manager_can_deep_sleep());
+    TEST_ASSERT_EQUAL(true, sleep_manager_can_deep_sleep_test_check());
     {
         // Stopping a timer multiple times still lets you sleep
         Timer timer;
         timer.start();
         timer.stop();
         timer.stop();
-        TEST_ASSERT_EQUAL(true, sleep_manager_can_deep_sleep());
+        TEST_ASSERT_EQUAL(true, sleep_manager_can_deep_sleep_test_check());
     }
-    TEST_ASSERT_EQUAL(true, sleep_manager_can_deep_sleep());
+    TEST_ASSERT_EQUAL(true, sleep_manager_can_deep_sleep_test_check());
 }
 
 Case cases[] = {
diff --git a/TESTS/mbed_drivers/timeout/timeout_tests.h b/TESTS/mbed_drivers/timeout/timeout_tests.h
@@ -263,7 +263,7 @@ void test_sleep(void)
     timer.start();
     timeout.attach_callback(mbed::callback(sem_callback, &sem), delay_us);
 
-    bool deep_sleep_allowed = sleep_manager_can_deep_sleep();
+    bool deep_sleep_allowed = sleep_manager_can_deep_sleep_test_check();
     TEST_ASSERT_FALSE_MESSAGE(deep_sleep_allowed, "Deep sleep should be disallowed");
     while (sem.wait(0) != 1) {
         sleep();
@@ -322,7 +322,7 @@ void test_deepsleep(void)
     timer.start();
     timeout.attach_callback(mbed::callback(sem_callback, &sem), delay_us);
 
-    bool deep_sleep_allowed = sleep_manager_can_deep_sleep();
+    bool deep_sleep_allowed = sleep_manager_can_deep_sleep_test_check();
     TEST_ASSERT_TRUE_MESSAGE(deep_sleep_allowed, "Deep sleep should be allowed");
     while (sem.wait(0) != 1) {
         sleep();
diff --git a/TESTS/mbed_hal/lp_ticker/main.cpp b/TESTS/mbed_hal/lp_ticker/main.cpp
@@ -130,7 +130,7 @@ void lp_ticker_deepsleep_test()
      * tick_count + TICKER_INT_VAL. */
     lp_ticker_set_interrupt(tick_count + TICKER_INT_VAL);
 
-    TEST_ASSERT_TRUE(sleep_manager_can_deep_sleep());
+    TEST_ASSERT_TRUE(sleep_manager_can_deep_sleep_test_check());
 
     while (!intFlag) {
         sleep();
diff --git a/TESTS/mbed_hal/rtc/main.cpp b/TESTS/mbed_hal/rtc/main.cpp
@@ -74,7 +74,7 @@ void rtc_sleep_test_support(bool deepsleep_mode)
 
     timeout.attach(callback, DELAY_4S);
 
-    TEST_ASSERT(sleep_manager_can_deep_sleep() == deepsleep_mode);
+    TEST_ASSERT(sleep_manager_can_deep_sleep_test_check() == deepsleep_mode);
 
     while (!expired) {
         sleep();
diff --git a/TESTS/mbed_hal/sleep_manager/main.cpp b/TESTS/mbed_hal/sleep_manager/main.cpp
@@ -25,15 +25,15 @@ using namespace utest::v1;
 
 void sleep_manager_deepsleep_counter_test()
 {
-    bool deep_sleep_allowed = sleep_manager_can_deep_sleep();
+    bool deep_sleep_allowed = sleep_manager_can_deep_sleep_test_check();
     TEST_ASSERT_TRUE(deep_sleep_allowed);
 
     sleep_manager_lock_deep_sleep();
-    deep_sleep_allowed = sleep_manager_can_deep_sleep();
+    deep_sleep_allowed = sleep_manager_can_deep_sleep_test_check();
     TEST_ASSERT_FALSE(deep_sleep_allowed);
 
     sleep_manager_unlock_deep_sleep();
-    deep_sleep_allowed = sleep_manager_can_deep_sleep();
+    deep_sleep_allowed = sleep_manager_can_deep_sleep_test_check();
     TEST_ASSERT_TRUE(deep_sleep_allowed);
 }
 
diff --git a/TESTS/mbed_hal/sleep_manager_racecondition/main.cpp b/TESTS/mbed_hal/sleep_manager_racecondition/main.cpp
@@ -55,7 +55,7 @@ void sleep_manager_multithread_test()
         t2.join();
     }
 
-    bool deep_sleep_allowed = sleep_manager_can_deep_sleep();
+    bool deep_sleep_allowed = sleep_manager_can_deep_sleep_test_check();
     TEST_ASSERT_TRUE_MESSAGE(deep_sleep_allowed, "Deep sleep should be allowed");
 }
 
@@ -83,7 +83,7 @@ void sleep_manager_irq_test()
         timer.stop();
     }
 
-    bool deep_sleep_allowed = sleep_manager_can_deep_sleep();
+    bool deep_sleep_allowed = sleep_manager_can_deep_sleep_test_check();
     TEST_ASSERT_TRUE_MESSAGE(deep_sleep_allowed, "Deep sleep should be allowed");
 }
 
diff --git a/TESTS/mbedmicro-rtos-mbed/systimer/main.cpp b/TESTS/mbedmicro-rtos-mbed/systimer/main.cpp
@@ -313,7 +313,7 @@ void test_deepsleep(void)
 
     lptimer.start();
     st.schedule_tick(TEST_TICKS);
-    TEST_ASSERT_TRUE_MESSAGE(sleep_manager_can_deep_sleep(), "Deep sleep should be allowed");
+    TEST_ASSERT_TRUE_MESSAGE(sleep_manager_can_deep_sleep_test_check(), "Deep sleep should be allowed");
     while (st.sem_wait(0) != 1) {
         sleep();
     }
diff --git a/hal/mbed_sleep_manager.c b/hal/mbed_sleep_manager.c
@@ -21,6 +21,7 @@
 #include "mbed_error.h"
 #include "mbed_debug.h"
 #include "mbed_stats.h"
+#include "us_ticker_api.h"
 #include "lp_ticker_api.h"
 #include <limits.h>
 #include <stdio.h>
@@ -183,6 +184,19 @@ bool sleep_manager_can_deep_sleep(void)
     return deep_sleep_lock == 0 ? true : false;
 }
 
+bool sleep_manager_can_deep_sleep_test_check()
+{
+    const uint32_t check_time_us = 2000;
+    const ticker_data_t *const ticker = get_us_ticker_data();
+    uint32_t start = ticker_read(ticker);
+    while ((ticker_read(ticker) - start) < check_time_us) {
+        if (sleep_manager_can_deep_sleep()) {
+            return true;
+        }
+    }
+    return false;
+}
+
 void sleep_manager_sleep_auto(void)
 {
 #ifdef MBED_SLEEP_TRACING_ENABLED
diff --git a/platform/mbed_power_mgmt.h b/platform/mbed_power_mgmt.h
@@ -122,6 +122,17 @@ void sleep_manager_unlock_deep_sleep_internal(void);
  */
 bool sleep_manager_can_deep_sleep(void);
 
+/** Check if the target can deep sleep within a period of time
+ *
+ * This function in intended for use in testing. The amount
+ * of time this functions waits for deeps sleep to be available
+ * is currently 2ms. This may change in the future depending
+ * on testing requirements.
+ *
+ * @return true if a target can go to deepsleep, false otherwise
+ */
+bool sleep_manager_can_deep_sleep_test_check(void);
+
 /** Enter auto selected sleep mode. It chooses the sleep or deeepsleep modes based
  *  on the deepsleep locking counter
  *

Original file line number	Diff line number	Diff line change
`@@ -29,90 +29,90 @@ using namespace utest::v1;`
`29`	`29`
`30`	`30`	`void deep_sleep_lock_lock_test()`
`31`	`31`	`{`
`32`		`- TEST_ASSERT_EQUAL(true, sleep_manager_can_deep_sleep());`
	`32`	`+ TEST_ASSERT_EQUAL(true, sleep_manager_can_deep_sleep_test_check());`
`33`	`33`	`{`
`34`	`34`	`// Check basic usage works`
`35`	`35`	`DeepSleepLock lock;`
`36`		`- TEST_ASSERT_EQUAL(false, sleep_manager_can_deep_sleep());`
	`36`	`+ TEST_ASSERT_EQUAL(false, sleep_manager_can_deep_sleep_test_check());`
`37`	`37`	`}`
`38`	`38`
`39`		`- TEST_ASSERT_EQUAL(true, sleep_manager_can_deep_sleep());`
	`39`	`+ TEST_ASSERT_EQUAL(true, sleep_manager_can_deep_sleep_test_check());`
`40`	`40`	`{`
`41`	`41`	`// Check that unlock and lock change can deep sleep as expected`
`42`	`42`	`DeepSleepLock lock;`
`43`		`- TEST_ASSERT_EQUAL(false, sleep_manager_can_deep_sleep());`
	`43`	`+ TEST_ASSERT_EQUAL(false, sleep_manager_can_deep_sleep_test_check());`
`44`	`44`	`lock.unlock();`
`45`		`- TEST_ASSERT_EQUAL(true, sleep_manager_can_deep_sleep());`
	`45`	`+ TEST_ASSERT_EQUAL(true, sleep_manager_can_deep_sleep_test_check());`
`46`	`46`	`lock.lock();`
`47`		`- TEST_ASSERT_EQUAL(false, sleep_manager_can_deep_sleep());`
	`47`	`+ TEST_ASSERT_EQUAL(false, sleep_manager_can_deep_sleep_test_check());`
`48`	`48`	`}`
`49`	`49`
`50`		`- TEST_ASSERT_EQUAL(true, sleep_manager_can_deep_sleep());`
	`50`	`+ TEST_ASSERT_EQUAL(true, sleep_manager_can_deep_sleep_test_check());`
`51`	`51`	`{`
`52`	`52`	`// Check that unlock releases sleep based on count`
`53`	`53`	`DeepSleepLock lock;`
`54`	`54`	`lock.lock();`
`55`	`55`	`lock.lock();`
`56`	`56`	`lock.unlock();`
`57`		`- TEST_ASSERT_EQUAL(false, sleep_manager_can_deep_sleep());`
	`57`	`+ TEST_ASSERT_EQUAL(false, sleep_manager_can_deep_sleep_test_check());`
`58`	`58`	`}`
`59`	`59`
`60`		`- TEST_ASSERT_EQUAL(true, sleep_manager_can_deep_sleep());`
	`60`	`+ TEST_ASSERT_EQUAL(true, sleep_manager_can_deep_sleep_test_check());`
`61`	`61`	`{`
`62`	`62`	`// Check that unbalanced locks do not leave deep sleep locked`
`63`	`63`	`DeepSleepLock lock;`
`64`	`64`	`lock.lock();`
`65`		`- TEST_ASSERT_EQUAL(false, sleep_manager_can_deep_sleep());`
	`65`	`+ TEST_ASSERT_EQUAL(false, sleep_manager_can_deep_sleep_test_check());`
`66`	`66`	`}`
`67`		`- TEST_ASSERT_EQUAL(true, sleep_manager_can_deep_sleep());`
	`67`	`+ TEST_ASSERT_EQUAL(true, sleep_manager_can_deep_sleep_test_check());`
`68`	`68`
`69`	`69`	`}`
`70`	`70`
`71`	`71`	`void timer_lock_test()`
`72`	`72`	`{`
`73`		`- TEST_ASSERT_EQUAL(true, sleep_manager_can_deep_sleep());`
	`73`	`+ TEST_ASSERT_EQUAL(true, sleep_manager_can_deep_sleep_test_check());`
`74`	`74`	`{`
`75`	`75`	`// Just creating a timer object does not lock sleep`
`76`	`76`	`Timer timer;`
`77`		`- TEST_ASSERT_EQUAL(true, sleep_manager_can_deep_sleep());`
	`77`	`+ TEST_ASSERT_EQUAL(true, sleep_manager_can_deep_sleep_test_check());`
`78`	`78`	`}`
`79`	`79`
`80`		`- TEST_ASSERT_EQUAL(true, sleep_manager_can_deep_sleep());`
	`80`	`+ TEST_ASSERT_EQUAL(true, sleep_manager_can_deep_sleep_test_check());`
`81`	`81`	`{`
`82`	`82`	`// Starting a timer does lock sleep`
`83`	`83`	`Timer timer;`
`84`	`84`	`timer.start();`
`85`		`- TEST_ASSERT_EQUAL(false, sleep_manager_can_deep_sleep());`
	`85`	`+ TEST_ASSERT_EQUAL(false, sleep_manager_can_deep_sleep_test_check());`
`86`	`86`	`}`
`87`	`87`
`88`		`- TEST_ASSERT_EQUAL(true, sleep_manager_can_deep_sleep());`
	`88`	`+ TEST_ASSERT_EQUAL(true, sleep_manager_can_deep_sleep_test_check());`
`89`	`89`	`{`
`90`	`90`	`// Stopping a timer after starting it allows sleep`
`91`	`91`	`Timer timer;`
`92`	`92`	`timer.start();`
`93`	`93`	`timer.stop();`
`94`		`- TEST_ASSERT_EQUAL(true, sleep_manager_can_deep_sleep());`
	`94`	`+ TEST_ASSERT_EQUAL(true, sleep_manager_can_deep_sleep_test_check());`
`95`	`95`	`}`
`96`	`96`
`97`		`- TEST_ASSERT_EQUAL(true, sleep_manager_can_deep_sleep());`
	`97`	`+ TEST_ASSERT_EQUAL(true, sleep_manager_can_deep_sleep_test_check());`
`98`	`98`	`{`
`99`	`99`	`// Starting a timer multiple times still lets you sleep`
`100`	`100`	`Timer timer;`
`101`	`101`	`timer.start();`
`102`	`102`	`timer.start();`
`103`	`103`	`}`
`104`		`- TEST_ASSERT_EQUAL(true, sleep_manager_can_deep_sleep());`
	`104`	`+ TEST_ASSERT_EQUAL(true, sleep_manager_can_deep_sleep_test_check());`
`105`	`105`
`106`		`- TEST_ASSERT_EQUAL(true, sleep_manager_can_deep_sleep());`
	`106`	`+ TEST_ASSERT_EQUAL(true, sleep_manager_can_deep_sleep_test_check());`
`107`	`107`	`{`
`108`	`108`	`// Stopping a timer multiple times still lets you sleep`
`109`	`109`	`Timer timer;`
`110`	`110`	`timer.start();`
`111`	`111`	`timer.stop();`
`112`	`112`	`timer.stop();`
`113`		`- TEST_ASSERT_EQUAL(true, sleep_manager_can_deep_sleep());`
	`113`	`+ TEST_ASSERT_EQUAL(true, sleep_manager_can_deep_sleep_test_check());`
`114`	`114`	`}`
`115`		`- TEST_ASSERT_EQUAL(true, sleep_manager_can_deep_sleep());`
	`115`	`+ TEST_ASSERT_EQUAL(true, sleep_manager_can_deep_sleep_test_check());`
`116`	`116`	`}`
`117`	`117`
`118`	`118`	`Case cases[] = {`
Original file line number	Diff line number	Diff line change
`@@ -55,7 +55,7 @@ void sleep_manager_multithread_test()`
`55`	`55`	`t2.join();`
`56`	`56`	`}`
`57`	`57`
`58`		`- bool deep_sleep_allowed = sleep_manager_can_deep_sleep();`
	`58`	`+ bool deep_sleep_allowed = sleep_manager_can_deep_sleep_test_check();`
`59`	`59`	`TEST_ASSERT_TRUE_MESSAGE(deep_sleep_allowed, "Deep sleep should be allowed");`
`60`	`60`	`}`
`61`	`61`
`@@ -83,7 +83,7 @@ void sleep_manager_irq_test()`
`83`	`83`	`timer.stop();`
`84`	`84`	`}`
`85`	`85`
`86`		`- bool deep_sleep_allowed = sleep_manager_can_deep_sleep();`
	`86`	`+ bool deep_sleep_allowed = sleep_manager_can_deep_sleep_test_check();`
`87`	`87`	`TEST_ASSERT_TRUE_MESSAGE(deep_sleep_allowed, "Deep sleep should be allowed");`
`88`	`88`	`}`
`89`	`89`
Original file line number	Diff line number	Diff line change
`@@ -313,7 +313,7 @@ void test_deepsleep(void)`
`313`	`313`
`314`	`314`	`lptimer.start();`
`315`	`315`	`st.schedule_tick(TEST_TICKS);`
`316`		`- TEST_ASSERT_TRUE_MESSAGE(sleep_manager_can_deep_sleep(), "Deep sleep should be allowed");`
	`316`	`+ TEST_ASSERT_TRUE_MESSAGE(sleep_manager_can_deep_sleep_test_check(), "Deep sleep should be allowed");`
`317`	`317`	`while (st.sem_wait(0) != 1) {`
`318`	`318`	`sleep();`
`319`	`319`	`}`