test(test_suite): add tests for timeout waits

Author: yvt

src/constance_test_suite/src/kernel_tests/event_group_interrupt.rs

@@ -1,13 +1,19 @@
 //! Interrupts a task waiting for an event bit to be set.
 //!
-//! 1. (`seq`: 0 → 1) `task0` activates `task[1-4]` in a particular order.
-//! 2. (`seq`: 1 → 5) `task[1-4]` start waiting for a event bit to be set.
-//! 3. (`seq`: 5 → 9) `task0` sets the event bit for four times. `task[1-4]`
-//!    should be unblocked in the same order.
+//! 1. (`seq`: 0 → 1) `task1` starts waiting for an event bit to be set.
+//! 2. (`seq`: 1 → 2) `task0` starts running and interrupts `task0`.
+//! 3. (`seq`: 2 → 3) `task1` starts waiting for an event bit to be set, this
+//!    time with a timeout.
+//! 4. (`seq`: 3 → 4) `task0` interrupts `task0`.
+//! 5. (`seq`: 4 → 5) `task1` completes.
 //!
 use constance::{
-    kernel::{EventGroup, EventGroupWaitFlags, Hunk, QueueOrder, Task, WaitEventGroupError},
+    kernel::{
+        EventGroup, EventGroupWaitFlags, Hunk, QueueOrder, Task, WaitEventGroupError,
+        WaitEventGroupTimeoutError,
+    },
     prelude::*,
+    time::Duration,
 };
 
 use super::Driver;
@@ -36,6 +42,8 @@ impl<System: Kernel> App<System> {
 fn task0_body<System: Kernel, D: Driver<App<System>>>(_: usize) {
     D::app().seq.expect_and_replace(1, 2);
     D::app().task1.interrupt().unwrap();
+    D::app().seq.expect_and_replace(3, 4);
+    D::app().task1.interrupt().unwrap();
 }
 
 fn task1_body<System: Kernel, D: Driver<App<System>>>(_: usize) {
@@ -48,5 +56,18 @@ fn task1_body<System: Kernel, D: Driver<App<System>>>(_: usize) {
         Err(WaitEventGroupError::Interrupted),
     );
 
+    D::app().seq.expect_and_replace(2, 3);
+
+    assert_eq!(
+        // start waiting, switching to `task0`
+        D::app()
+            .eg
+            .wait_timeout(0b1, EventGroupWaitFlags::CLEAR, Duration::from_millis(100)),
+        // ... the control is returned when `task0` interrupts `task1`
+        Err(WaitEventGroupTimeoutError::Interrupted),
+    );
+
+    D::app().seq.expect_and_replace(4, 5);
+
     D::success();
 }

src/constance_test_suite/src/kernel_tests/event_group_timeout.rs

@@ -0,0 +1,96 @@
+//! A task waits for an event bit to be set with timeout.
+//!
+//! 1. (`seq`: 0 → 1, 0ms) `task1` starts waiting for an event bit to be set.
+//! 2. (`seq`: 1 → 2, 0ms) `task0` starts sleeping, which will last for 300
+//!    milliseconds.
+//! 3. (`seq`: 2 → 3, 200ms) `task1` wakes up, seeing that the wait operation
+//!    timed out. `task1` again starts waiting for the event bit to be set.
+//! 4. (`seq`: 3 → 4, 300ms) `task0` wakes up and sets the event bit.
+//! 5. (`seq`: 4 → 5, 300ms) `task1` wakes up and preempts `task0`, seeing that
+//!    the wait operation was successful. Another wait operation will not block
+//!    because the event bit is already set.
+//! 6. (`seq`: 5 → 6, 300ms) `task1` exits.
+//! 7. (`seq`: 6 → 7, 300ms) `task0` starts running.
+//!
+use constance::{
+    kernel::{EventGroup, EventGroupWaitFlags, Hunk, QueueOrder, Task, WaitEventGroupTimeoutError},
+    prelude::*,
+    time::Duration,
+};
+
+use super::Driver;
+use crate::utils::SeqTracker;
+
+pub struct App<System> {
+    eg: EventGroup<System>,
+    seq: Hunk<System, SeqTracker>,
+}
+
+impl<System: Kernel> App<System> {
+    constance::configure! {
+        pub const fn new<D: Driver<Self>>(_: &mut CfgBuilder<System>) -> Self {
+            new! { Task<_>, start = task0_body::<System, D>, priority = 2, active = true };
+            new! { Task<_>, start = task1_body::<System, D>, priority = 1, active = true };
+
+            let eg = new! { EventGroup<_>, queue_order = QueueOrder::Fifo };
+            let seq = new! { Hunk<_, SeqTracker> };
+
+            App { eg, seq }
+        }
+    }
+}
+
+fn task0_body<System: Kernel, D: Driver<App<System>>>(_: usize) {
+    D::app().seq.expect_and_replace(1, 2);
+    System::sleep(Duration::from_millis(300)).unwrap();
+    // `task0` goes into sleep. `task1` wakes up first.
+    // `task0` follows:
+    D::app().seq.expect_and_replace(3, 4);
+    D::app().eg.set(0b1).unwrap();
+    // preempted by `task1`, which we just woke up
+
+    // back from `task1`
+    D::app().seq.expect_and_replace(6, 7);
+    D::success();
+}
+
+fn task1_body<System: Kernel, D: Driver<App<System>>>(_: usize) {
+    D::app().seq.expect_and_replace(0, 1);
+
+    assert_eq!(
+        // start waiting, switching to `task0`
+        D::app().eg.wait_timeout(
+            0b1,
+            EventGroupWaitFlags::empty(),
+            Duration::from_millis(200)
+        ),
+        // ... the control is returned on timeout
+        Err(WaitEventGroupTimeoutError::Timeout),
+    );
+
+    D::app().seq.expect_and_replace(2, 3);
+
+    // start waiting. wakes up when `task0` sets the event bit
+    D::app()
+        .eg
+        .wait_timeout(
+            0b1,
+            EventGroupWaitFlags::empty(),
+            Duration::from_millis(200),
+        )
+        .unwrap();
+
+    D::app().seq.expect_and_replace(4, 5);
+
+    // this doesn't block because the event bit is already set
+    D::app()
+        .eg
+        .wait_timeout(
+            0b1,
+            EventGroupWaitFlags::empty(),
+            Duration::from_millis(200),
+        )
+        .unwrap();
+
+    D::app().seq.expect_and_replace(5, 6);
+}

src/constance_test_suite/src/kernel_tests/time_misc.rs

@@ -1,6 +1,10 @@
 //! Validates error codes returned by time-related methods. Also, checks
 //! miscellaneous properties of such methods.
-use constance::{kernel::Task, prelude::*, time::Time};
+use constance::{
+    kernel::Task,
+    prelude::*,
+    time::{Duration, Time},
+};
 
 use super::Driver;
 
@@ -50,5 +54,20 @@ fn task_body<System: Kernel, D: Driver<App<System>>>(_: usize) {
     );
     unsafe { System::release_cpu_lock().unwrap() };
 
+    // System time should wrap around
+    let now3 = Time::from_micros(0xfffffffffffe0000);
+    log::trace!("changing system time to {:?}", now3);
+    System::set_time(now3).unwrap();
+
+    let d = Duration::from_micros(0x40000);
+    log::trace!("sleeping for {:?}", d);
+    System::sleep(d).unwrap();
+
+    // TODO: `impl Add<Duration> for Time`
+    let now4 = Time::from_micros(now3.as_micros().wrapping_add(d.as_micros() as _));
+    let now4_got = System::time().unwrap();
+    log::trace!("time = {:?} (expected >= {:?})", now4_got, now4);
+    assert!(now4_got.as_micros() >= now4.as_micros());
+
     D::success();
 }

src/constance_test_suite/src/kernel_tests/time_stress.rs

@@ -0,0 +1,61 @@
+//! Launches multiple tasks, each of which calls `sleep` repeatedly.
+use constance::{
+    kernel::{Hunk, Task},
+    prelude::*,
+    time::{Duration, Time},
+};
+use core::sync::atomic::{AtomicUsize, Ordering};
+
+use super::Driver;
+
+pub struct App<System> {
+    counter: Hunk<System, AtomicUsize>,
+}
+
+const TASKS: &[usize] = &[300, 150, 300, 320, 580, 900, 500, 750, 170];
+
+impl<System: Kernel> App<System> {
+    constance::configure! {
+        pub const fn new<D: Driver<Self>>(_: &mut CfgBuilder<System>) -> Self {
+            let mut i = 0;
+            // FIXME: Work-around for `for` being unsupported in `const fn`
+            while i < TASKS.len() {
+                new! { Task<_>,
+                    start = task_body::<System, D>, param = i, priority = 0, active = true };
+                i += 1;
+            }
+
+            let counter = new! { Hunk<_, AtomicUsize> };
+
+            App { counter }
+        }
+    }
+}
+
+fn task_body<System: Kernel, D: Driver<App<System>>>(i: usize) {
+    let delay = Duration::from_millis(TASKS[i] as _);
+
+    loop {
+        let now = System::time().unwrap();
+        log::trace!("[{}] time = {:?}", i, now);
+
+        if now.as_secs() >= 2 {
+            break;
+        }
+
+        System::sleep(delay).unwrap();
+
+        let now2 = Time::from_micros(now.as_micros().wrapping_add(delay.as_micros() as _));
+        let now2_got = System::time().unwrap();
+        log::trace!("[{}] time = {:?} (expected = {:?})", i, now2_got, now2);
+
+        // `now2 <= now2_got < now2 + timing_error`
+        let delta = now2_got.duration_since(now2);
+        assert!(!delta.unwrap().is_negative());
+        assert!(delta.unwrap().as_millis() < 100);
+    }
+
+    if D::app().counter.fetch_add(1, Ordering::Relaxed) == TASKS.len() - 1 {
+        D::success();
+    }
+}

src/constance_test_suite/src/lib.rs

@@ -145,6 +145,7 @@ pub mod kernel_tests {
         (mod event_group_order_fifo {}, "event_group_order_fifo"),
         (mod event_group_order_task_priority {}, "event_group_order_task_priority"),
         (mod event_group_set_and_dispatch {}, "event_group_set_and_dispatch"),
+        (mod event_group_timeout {}, "event_group_timeout"),
         (mod event_group_wait_types {}, "event_group_wait_types"),
         (mod interrupt_disallowed_services {}, "interrupt_disallowed_services"),
         (mod interrupt_handler_priority {}, "interrupt_handler_priority"),
@@ -162,6 +163,7 @@ pub mod kernel_tests {
         (mod task_priority_boost_reset {}, "task_priority_boost_reset"),
         (mod task_queue_fifo {}, "task_queue_fifo"),
         (mod time_misc {}, "time_misc"),
+        (mod time_stress {}, "time_stress"),
     }
 
     /// Invoke the specified macro with a description of test cases