Fix and update tests to use Chronos APIs

Author: kjbracey

TESTS/mbedmicro-rtos-mbed/basic/main.cpp

@@ -28,22 +28,24 @@
 #else
 
 using utest::v1::Case;
+using std::milli;
+using std::micro;
+using namespace std::chrono;
 
 #if defined(__CORTEX_M23) || defined(__CORTEX_M33)
 #define TEST_STACK_SIZE 512
 #else
 #define TEST_STACK_SIZE 256
 #endif
-#define ONE_MILLI_SEC 1000
 
-volatile uint32_t elapsed_time_ms = 0;
+static duration<uint32_t, milli> elapsed_time_ms;
 static const int test_timeout = 40;
 
 
 void update_tick_thread(Mutex *mutex)
 {
     while (true) {
-        ThisThread::sleep_for(1);
+        ThisThread::sleep_for(1ms);
         mutex->lock();
         ++elapsed_time_ms;
         mutex->unlock();
@@ -69,7 +71,7 @@ void test(void)
     char _value[128] = { };
     int expected_key = 1;
     Mutex mutex;
-    uint32_t elapsed_time;
+    duration<uint32_t, micro> elapsed_time;
 
     Thread tick_thread(osPriorityHigh, TEST_STACK_SIZE);
     tick_thread.start(callback(update_tick_thread, &mutex));
@@ -86,7 +88,7 @@ void test(void)
     elapsed_time = elapsed_time_ms;
     mutex.unlock();
     // send base_time
-    greentea_send_kv(_key, elapsed_time * ONE_MILLI_SEC);
+    greentea_send_kv(_key, elapsed_time.count());
 
     // wait for 2nd signal from host
     greentea_parse_kv(_key, _value, sizeof(_key), sizeof(_value));
@@ -95,7 +97,7 @@ void test(void)
     elapsed_time = elapsed_time_ms;
     mutex.unlock();
     // send final_time
-    greentea_send_kv(_key, elapsed_time * ONE_MILLI_SEC);
+    greentea_send_kv(_key, elapsed_time.count());
 
     //get the results from host
     greentea_parse_kv(_key, _value, sizeof(_key), sizeof(_value));

TESTS/mbedmicro-rtos-mbed/condition_variable/main.cpp

@@ -28,9 +28,10 @@
 #include "rtos.h"
 
 using namespace utest::v1;
+using namespace std::chrono_literals;
 
 #define TEST_STACK_SIZE 512
-#define TEST_DELAY 10
+#define TEST_DELAY 10ms
 
 static int change_counter = 0;
 static Mutex mutex;
@@ -55,14 +56,14 @@ void test_notify_one()
     t1.start(increment_on_signal);
     t2.start(increment_on_signal);
 
-    wait_ms(TEST_DELAY);
+    ThisThread::sleep_for(TEST_DELAY);
     TEST_ASSERT_EQUAL(0, change_counter);
 
     mutex.lock();
     cond.notify_one();
     mutex.unlock();
 
-    wait_ms(TEST_DELAY);
+    ThisThread::sleep_for(TEST_DELAY);
     TEST_ASSERT_EQUAL(1, change_counter);
 
     mutex.lock();
@@ -82,14 +83,14 @@ void test_notify_all()
     t1.start(increment_on_signal);
     t2.start(increment_on_signal);
 
-    wait_ms(TEST_DELAY);
+    ThisThread::sleep_for(TEST_DELAY);
     TEST_ASSERT_EQUAL(0, change_counter);
 
     mutex.lock();
     cond.notify_all();
     mutex.unlock();
 
-    wait_ms(TEST_DELAY);
+    ThisThread::sleep_for(TEST_DELAY);
     TEST_ASSERT_EQUAL(2, change_counter);
 
     t1.join();

TESTS/mbedmicro-rtos-mbed/event_flags/main.cpp

@@ -54,7 +54,7 @@ void send_thread(EventFlags *ef)
         const uint32_t flag = flags & (1 << i);
         if (flag) {
             ef->set(flag);
-            ThisThread::sleep_for(wait_ms);
+            ThisThread::sleep_for(std::chrono::milliseconds(wait_ms));
         }
     }
 }
@@ -67,7 +67,7 @@ void send_thread_sync(EventFlags *ef)
         if (flag) {
             sync_sem.acquire();
             ef->set(flag);
-            ThisThread::sleep_for(wait_ms);
+            ThisThread::sleep_for(std::chrono::milliseconds(wait_ms));
         }
     }
 }
@@ -267,11 +267,11 @@ void test_multi_thread_any_timeout(void)
     for (int i = 0; i <= MAX_FLAG_POS; i++) {
         uint32_t flag = 1 << i;
 
-        ret = ef.wait_any(flag, 10);
+        ret = ef.wait_any_for(flag, 10ms);
         TEST_ASSERT_EQUAL(osFlagsErrorTimeout, ret);
 
         sync_sem.release();
-        ret = ef.wait_any(flag, 10);
+        ret = ef.wait_any_for(flag, 10ms);
         TEST_ASSERT_EQUAL(flag, ret);
     }
     ret = ef.get();
@@ -297,7 +297,7 @@ void test_multi_thread_any_no_clear(void)
 
     for (int i = 0; i <= MAX_FLAG_POS; i++) {
         uint32_t flag = 1 << i;
-        ret = ef.wait_any(flag, osWaitForever, false);
+        ret = ef.wait_any(flag, Kernel::wait_for_u32_forever, false);
         TEST_ASSERT(flag | ret);
         ret = ef.clear(flag);
         TEST_ASSERT(ret < osFlagsError);
@@ -375,4 +375,4 @@ int main()
 }
 
 #endif // !DEVICE_USTICKER
-#endif // defined(MBED_RTOS_SINGLE_THREAD) || !defined(MBED_CONF_RTOS_PRESENT)
+#endif // defined(MBED_RTOS_SINGLE_THREAD) || !defined(MBED_CONF_RTOS_PRESENT)

TESTS/mbedmicro-rtos-mbed/kernel_tick_count/main.cpp

@@ -24,16 +24,16 @@
 #include "rtos/Kernel.h"
 #include "mbed.h"
 
+using namespace std::chrono_literals;
 
 using utest::v1::Case;
 
 #define TEST_REPEAT_COUNT   1000
-#define NUM_WAIT_TICKS      1000
+#define NUM_WAIT_TICKS      rtos::Kernel::Clock::duration(1s)
 
-// all in [us]
-#define ONE_SECOND          1000000
-#define SMALL_DELTA         1500        // 0.15%
-#define BIG_DELTA           15000       // 1.5%
+#define ONE_SECOND          Timer::duration(1s)
+#define SMALL_DELTA         Timer::duration(1500us)        // 0.15%
+#define BIG_DELTA           Timer::duration(15000us)       // 1.5%
 
 /** Test if kernel ticker frequency is 1kHz
 
@@ -45,22 +45,23 @@ void test_frequency()
 {
     uint32_t freq = osKernelGetTickFreq();
     TEST_ASSERT_EQUAL_UINT32_MESSAGE(1000, freq, "Expected SysTick frequency is 1kHz");
+    TEST_ASSERT_TRUE_MESSAGE((std::ratio_equal<rtos::Kernel::Clock::period, std::milli>::value), "Expected Kernel::Clock frequency is 1kHz");
 }
 
 /** Test if kernel ticker increments by one
 
     Given a RTOS kernel ticker
-    When perform subsequent calls of @a rtos::Kernel::get_ms_count
+    When perform subsequent calls of @a rtos::Kernel::Clock::now
     Then subsequent reads should not differ by more than one
  */
 void test_increment(void)
 {
     for (uint32_t i = 0; i < TEST_REPEAT_COUNT; i++) {
-        const uint64_t start = rtos::Kernel::get_ms_count();
+        auto start = rtos::Kernel::Clock::now();
         while (true) {
-            uint64_t diff = rtos::Kernel::get_ms_count() - start;
-            if (diff != 0) {
-                TEST_ASSERT_EQUAL_UINT64(1, diff);
+            rtos::Kernel::Clock::duration diff = rtos::Kernel::Clock::now() - start;
+            if (diff.count() != 0) {
+                TEST_ASSERT_EQUAL_INT64(1, diff.count());
                 break;
             }
         }
@@ -70,35 +71,35 @@ void test_increment(void)
 /** Test if kernel ticker interval is 1ms
 
     Given a RTOS kernel ticker
-    When perform subsequent calls of @a rtos::Kernel::get_ms_count
+    When perform subsequent calls of @a rtos::Kernel::Clock::now
     Then the ticker interval should be 1ms
  */
 void test_interval()
 {
-    uint64_t start, stop;
+    Kernel::Clock::time_point start, stop;
     Timer timer;
 
-    start = rtos::Kernel::get_ms_count();
+    start = rtos::Kernel::Clock::now();
     // wait for tick
     do {
-        stop = rtos::Kernel::get_ms_count();
-    } while ((stop - start) == 0);
+        stop = rtos::Kernel::Clock::now();
+    } while (stop == start);
     timer.start();
     start = stop;
 
     // wait for NUM_WAIT_TICKS ticks
     do {
-        stop = rtos::Kernel::get_ms_count();
+        stop = rtos::Kernel::Clock::now();
     } while ((stop - start) != NUM_WAIT_TICKS);
     timer.stop();
-    TEST_ASSERT_EQUAL_UINT64(NUM_WAIT_TICKS, (stop - start));
+    TEST_ASSERT_EQUAL_INT64(NUM_WAIT_TICKS.count(), (stop - start).count());
 
 #if defined(NO_SYSTICK) || defined(MBED_TICKLESS)
     // On targets with NO_SYSTICK/MBED_TICKLESS enabled, systick is emulated by lp_ticker what makes it less accurate
     // for more details https://os.mbed.com/docs/latest/reference/tickless.html
-    TEST_ASSERT_UINT64_WITHIN(BIG_DELTA, ONE_SECOND, timer.read_high_resolution_us());
+    TEST_ASSERT_INT64_WITHIN(BIG_DELTA.count(), ONE_SECOND.count(), timer.read_duration().count());
 #else
-    TEST_ASSERT_UINT64_WITHIN(SMALL_DELTA, ONE_SECOND, timer.read_high_resolution_us());
+    TEST_ASSERT_INT64_WITHIN(SMALL_DELTA.count(), ONE_SECOND.count(), timer.read_duration().count());
 #endif
 }
 

TESTS/mbedmicro-rtos-mbed/mutex/main.cpp

@@ -28,15 +28,16 @@
 #include "rtos.h"
 
 using namespace utest::v1;
+using namespace std::chrono;
 
 #if defined(__CORTEX_M23) || defined(__CORTEX_M33)
 #define TEST_STACK_SIZE 768
 #else
 #define TEST_STACK_SIZE 512
 #endif
 
-#define TEST_LONG_DELAY 20
-#define TEST_DELAY 10
+#define TEST_LONG_DELAY 20ms
+#define TEST_DELAY 10ms
 #define SIGNALS_TO_EMIT 100
 
 Mutex stdio_mutex;
@@ -88,9 +89,9 @@ void test_thread(int const *thread_delay)
 */
 void test_multiple_threads(void)
 {
-    const int t1_delay = TEST_DELAY * 1;
-    const int t2_delay = TEST_DELAY * 2;
-    const int t3_delay = TEST_DELAY * 3;
+    const Kernel::Clock::duration t1_delay = TEST_DELAY * 1;
+    const Kernel::Clock::duration t2_delay = TEST_DELAY * 2;
+    const Kernel::Clock::duration t3_delay = TEST_DELAY * 3;
 
     Thread t2(osPriorityNormal, TEST_STACK_SIZE);
     Thread t3(osPriorityNormal, TEST_STACK_SIZE);
@@ -154,7 +155,7 @@ void test_dual_thread_nolock(void)
 
     thread.start(callback(F, &mutex));
 
-    wait_ms(TEST_DELAY);
+    ThisThread::sleep_for(TEST_DELAY);
 }
 
 void test_dual_thread_lock_unlock_thread(Mutex *mutex)
@@ -183,7 +184,7 @@ void test_dual_thread_lock_unlock(void)
 
     mutex.unlock();
 
-    wait_ms(TEST_DELAY);
+    ThisThread::sleep_for(TEST_DELAY);
 }
 
 void test_dual_thread_lock_trylock_thread(Mutex *mutex)
@@ -227,7 +228,7 @@ void test_dual_thread_lock(void)
 
     thread.start(callback(F, &mutex));
 
-    wait_ms(TEST_LONG_DELAY);
+    ThisThread::sleep_for(TEST_LONG_DELAY);
 
     mutex.unlock();
 }

TESTS/mbedmicro-rtos-mbed/semaphore/main.cpp

@@ -28,11 +28,12 @@
 #include "rtos.h"
 
 using namespace utest::v1;
+using namespace std::chrono;
 
-#define THREAD_DELAY     30
+#define THREAD_DELAY     30ms
 #define SEMAPHORE_SLOTS  2
 #define SEM_CHANGES      100
-#define SHORT_WAIT       5
+#define SHORT_WAIT       5ms
 
 #define THREAD_STACK_SIZE 320 /* larger stack cause out of heap memory on some 16kB RAM boards in multi thread test*/
 
@@ -42,9 +43,9 @@ volatile int change_counter = 0;
 volatile int sem_counter = 0;
 volatile bool sem_defect = false;
 
-void test_thread(int const *delay)
+void test_thread(rtos::Kernel::Clock::duration const *delay)
 {
-    const int thread_delay = *delay;
+    const auto thread_delay = *delay;
     while (true) {
         two_slots.acquire();
         sem_counter++;
@@ -67,9 +68,9 @@ void test_thread(int const *delay)
 */
 void test_multi()
 {
-    const int t1_delay = THREAD_DELAY * 1;
-    const int t2_delay = THREAD_DELAY * 2;
-    const int t3_delay = THREAD_DELAY * 3;
+    const rtos::Kernel::Clock::duration t1_delay = THREAD_DELAY * 1;
+    const rtos::Kernel::Clock::duration t2_delay = THREAD_DELAY * 2;
+    const rtos::Kernel::Clock::duration t3_delay = THREAD_DELAY * 3;
 
     Thread t1(osPriorityNormal, THREAD_STACK_SIZE);
     Thread t2(osPriorityNormal, THREAD_STACK_SIZE);
@@ -139,7 +140,7 @@ void test_single_thread()
 
 void timeout_thread(Semaphore *sem)
 {
-    bool acquired = sem->try_acquire_for(30);
+    bool acquired = sem->try_acquire_for(30ms);
     TEST_ASSERT_FALSE(acquired);
 }