test(test_suite): add tests for Kernel::{set_time, adjust_time}

yvt · yvt · commit cbfb2ed3bcea · 2020-07-09T23:00:48.000+09:00
diff --git a/src/constance_test_suite/src/kernel_tests/time_adjust_event.rs b/src/constance_test_suite/src/kernel_tests/time_adjust_event.rs
@@ -0,0 +1,99 @@
+//! Verifies that [`adjust_time`] maintains the absolute arrival times of
+//! timeouts.
+//!
+//! [`adjust_time`]: constance::kernel::Kernel::adjust_time
+//!
+//! 1. (`seq`: 0 → 1, 0ms) `task1` activates `task2` and `task3`.
+//! 2. (`seq`: 1 → 2, 0ms) `task2` starts sleeping, expecting to be woken up
+//!    at system time 600ms.
+//! 3. (`seq`: 2 → 3, 0ms) `task3` starts sleeping, expecting to be woken up
+//!    at system time 100ms.
+//! 4. (`seq`: 3 → 4, 0ms) `task1` changes the system time to 300ms using
+//!    `adjust_time`.
+//! 5. (`seq`: 4 → 5, 300ms) `task3` wakes up, finding it's late by 200ms.
+//! 6. (`seq`: 5 → 6, 300ms) `task1` exits.
+//! 7. (`seq`: 6 → 7, 600ms) `tsak2` wakes up.
+//!
+use constance::{
+    kernel::{Hunk, Task},
+    prelude::*,
+    time::{Duration, Time},
+};
+
+use super::Driver;
+use crate::utils::SeqTracker;
+
+pub struct App<System> {
+    task2: Task<System>,
+    task3: Task<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 = task1_body::<System, D>, priority = 3, active = true };
+            let task2 = new! { Task<_>, start = task2_body::<System, D>, priority = 1 };
+            let task3 = new! { Task<_>, start = task3_body::<System, D>, priority = 2 };
+
+            let seq = new! { Hunk<_, SeqTracker> };
+
+            App { task2, task3, seq }
+        }
+    }
+}
+
+fn task1_body<System: Kernel, D: Driver<App<System>>>(_: usize) {
+    D::app().seq.expect_and_replace(0, 1);
+    System::set_time(Time::from_millis(0)).unwrap();
+    D::app().task2.activate().unwrap();
+    D::app().task3.activate().unwrap();
+    D::app().seq.expect_and_replace(3, 4);
+
+    // Adjust the system time while `task2` and `task3` are sleeping.
+    System::adjust_time(Duration::from_millis(300)).unwrap();
+    // This will cause `task3` to wake up immediately.
+
+    D::app().seq.expect_and_replace(5, 6);
+}
+
+fn task2_body<System: Kernel, D: Driver<App<System>>>(_: usize) {
+    D::app().seq.expect_and_replace(1, 2);
+
+    // Start sleeping at system time 0ms
+    System::sleep(Duration::from_millis(600)).unwrap();
+
+    D::app().seq.expect_and_replace(6, 7);
+
+    // Sleeping should conclude at system time 600ms
+    let now = Time::from_millis(600);
+    let now_got = System::time().unwrap();
+    log::trace!("time = {:?} (expected = {:?})", now_got, now);
+
+    // `now <= now_got < now + timing_error`
+    let delta = now_got.duration_since(now);
+    assert!(!delta.unwrap().is_negative());
+    assert!(delta.unwrap().as_millis() < 100);
+
+    D::success();
+}
+
+fn task3_body<System: Kernel, D: Driver<App<System>>>(_: usize) {
+    D::app().seq.expect_and_replace(2, 3);
+
+    // Start sleeping at system time 0ms
+    System::sleep(Duration::from_millis(100)).unwrap();
+
+    D::app().seq.expect_and_replace(4, 5);
+
+    // Sleeping should conclude at system time 300ms (late by 200ms)
+    // because it jumped to 300ms
+    let now = Time::from_millis(300);
+    let now_got = System::time().unwrap();
+    log::trace!("time = {:?} (expected = {:?})", now_got, now);
+
+    // `now <= now_got < now + timing_error`
+    let delta = now_got.duration_since(now);
+    assert!(!delta.unwrap().is_negative());
+    assert!(delta.unwrap().as_millis() < 100);
+}
diff --git a/src/constance_test_suite/src/kernel_tests/time_adjust_limits.rs b/src/constance_test_suite/src/kernel_tests/time_adjust_limits.rs
@@ -0,0 +1,88 @@
+//! Verifies the adjustable range of [`adjust_time`].
+use constance::{
+    kernel::{AdjustTimeError, Hunk, Task, TIME_USER_HEADROOM},
+    prelude::*,
+    time::{Duration, Time},
+};
+
+use super::Driver;
+use crate::utils::SeqTracker;
+
+pub struct App<System> {
+    task2: Task<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 = task1_body::<System, D>, priority = 3, active = true };
+            let task2 = new! { Task<_>, start = task2_body::<System, D>, priority = 1 };
+
+            let seq = new! { Hunk<_, SeqTracker> };
+
+            App { task2, seq }
+        }
+    }
+}
+
+fn task1_body<System: Kernel, D: Driver<App<System>>>(_: usize) {
+    D::app().seq.expect_and_replace(0, 1);
+    System::set_time(Time::from_millis(0)).unwrap();
+    D::app().task2.activate().unwrap();
+    D::app().seq.expect_and_replace(2, 3);
+
+    System::boost_priority().unwrap();
+
+    // `system_time += TIME_USER_HEADROOM + 1300ms`, which should fail because
+    // `task2`'s timeout would be late by `300ms`
+    log::debug!("system_time += TIME_USER_HEADROOM + 1300ms (should fail)");
+    // TODO: `impl Add for Duration`
+    assert_eq!(
+        System::adjust_time(Duration::from_millis(1300 + TIME_USER_HEADROOM.as_millis())),
+        Err(AdjustTimeError::BadObjectState),
+    );
+
+    // `system_time += 500ms`, which should succeed because
+    // `task2`'s timeout will not be late
+    log::debug!("system_time += 500ms");
+    System::adjust_time(Duration::from_millis(500)).unwrap();
+
+    // `system_time += 800ms`, which should succeed because
+    // `task2`'s timeout will be only late by `300ms`
+    log::debug!("system_time += 800ms");
+    System::adjust_time(Duration::from_millis(800)).unwrap();
+
+    // `system_time -= 700ms`, which should succeed because the frontier will be
+    // only away by `700ms`
+    log::debug!("system_time -= 700ms");
+    System::adjust_time(Duration::from_millis(-700)).unwrap();
+
+    // `system_time -= TIME_USER_HEADROOM`, which should fail because the
+    // frontier would be away by `700ms + TIME_USER_HEADROOM`
+    log::debug!("system_time -= TIME_USER_HEADROOM (should fail)");
+    assert_eq!(
+        System::adjust_time(Duration::from_millis(-TIME_USER_HEADROOM.as_millis())),
+        Err(AdjustTimeError::BadObjectState),
+    );
+
+    // `system_time -= TIME_USER_HEADROOM - 900ms`, which should succeed because the frontier will be
+    // only away by `TIME_USER_HEADROOM - 200ms`
+    log::debug!("system_time -= TIME_USER_HEADROOM - 900ms");
+    System::adjust_time(Duration::from_millis(TIME_USER_HEADROOM.as_millis() - 900)).unwrap();
+
+    D::app().seq.expect_and_replace(3, 4);
+
+    unsafe { System::unboost_priority().unwrap() };
+}
+
+fn task2_body<System: Kernel, D: Driver<App<System>>>(_: usize) {
+    D::app().seq.expect_and_replace(1, 2);
+
+    // Create a timeout scheduled at 1000ms
+    System::sleep(Duration::from_millis(1000)).unwrap();
+
+    D::app().seq.expect_and_replace(4, 5);
+
+    D::success();
+}
diff --git a/src/constance_test_suite/src/kernel_tests/time_set_event.rs b/src/constance_test_suite/src/kernel_tests/time_set_event.rs
@@ -0,0 +1,97 @@
+//! Verifies that `set_time` maintains the relative arrival times of
+//! timeouts.
+//!
+//! [`set_time`]: constance::kernel::Kernel::set_time
+//!
+//! 1. (`seq`: 0 → 1, 0ms) `task1` activates `task2` and `task3`.
+//! 2. (`seq`: 1 → 2, 0ms) `task2` starts sleeping, expecting to be woken up
+//!    at system time 300ms.
+//! 3. (`seq`: 2 → 3, 0ms) `task3` starts sleeping, expecting to be woken up
+//!    at system time 100ms.
+//! 4. (`seq`: 3 → 4, 0ms) `task1` changes the system time to 300ms using
+//!    `set_time`.
+//! 6. (`seq`: 4 → 5, 300ms) `task1` exits.
+//! 5. (`seq`: 5 → 6, 400ms) `task3` wakes up.
+//! 7. (`seq`: 6 → 7, 600ms) `tsak2` wakes up.
+//!
+use constance::{
+    kernel::{Hunk, Task},
+    prelude::*,
+    time::{Duration, Time},
+};
+
+use super::Driver;
+use crate::utils::SeqTracker;
+
+pub struct App<System> {
+    task2: Task<System>,
+    task3: Task<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 = task1_body::<System, D>, priority = 3, active = true };
+            let task2 = new! { Task<_>, start = task2_body::<System, D>, priority = 1 };
+            let task3 = new! { Task<_>, start = task3_body::<System, D>, priority = 2 };
+
+            let seq = new! { Hunk<_, SeqTracker> };
+
+            App { task2, task3, seq }
+        }
+    }
+}
+
+fn task1_body<System: Kernel, D: Driver<App<System>>>(_: usize) {
+    D::app().seq.expect_and_replace(0, 1);
+    System::set_time(Time::from_millis(0)).unwrap();
+    D::app().task2.activate().unwrap();
+    D::app().task3.activate().unwrap();
+    D::app().seq.expect_and_replace(3, 4);
+
+    // Adjust the system time while `task2` and `task3` are sleeping.
+    System::set_time(Time::from_millis(300)).unwrap();
+
+    D::app().seq.expect_and_replace(4, 5);
+}
+
+fn task2_body<System: Kernel, D: Driver<App<System>>>(_: usize) {
+    D::app().seq.expect_and_replace(1, 2);
+
+    // Start sleeping at system time 0ms
+    System::sleep(Duration::from_millis(300)).unwrap();
+
+    D::app().seq.expect_and_replace(6, 7);
+
+    // Sleeping should conclude at system time 600ms
+    let now = Time::from_millis(600);
+    let now_got = System::time().unwrap();
+    log::trace!("time = {:?} (expected = {:?})", now_got, now);
+
+    // `now <= now_got < now + timing_error`
+    let delta = now_got.duration_since(now);
+    assert!(!delta.unwrap().is_negative());
+    assert!(delta.unwrap().as_millis() < 100);
+
+    D::success();
+}
+
+fn task3_body<System: Kernel, D: Driver<App<System>>>(_: usize) {
+    D::app().seq.expect_and_replace(2, 3);
+
+    // Start sleeping at system time 0ms
+    System::sleep(Duration::from_millis(100)).unwrap();
+
+    D::app().seq.expect_and_replace(5, 6);
+
+    // Sleeping should conclude at system time 400ms
+    let now = Time::from_millis(400);
+    let now_got = System::time().unwrap();
+    log::trace!("time = {:?} (expected = {:?})", now_got, now);
+
+    // `now <= now_got < now + timing_error`
+    let delta = now_got.duration_since(now);
+    assert!(!delta.unwrap().is_negative());
+    assert!(delta.unwrap().as_millis() < 100);
+}
diff --git a/src/constance_test_suite/src/lib.rs b/src/constance_test_suite/src/lib.rs
@@ -162,7 +162,10 @@ pub mod kernel_tests {
         (mod task_park_reset {}, "task_park_reset"),
         (mod task_priority_boost_reset {}, "task_priority_boost_reset"),
         (mod task_queue_fifo {}, "task_queue_fifo"),
+        (mod time_adjust_event {}, "time_adjust_event"),
+        (mod time_adjust_limits {}, "time_adjust_limits"),
         (mod time_misc {}, "time_misc"),
+        (mod time_set_event {}, "time_set_event"),
         (mod time_stress {}, "time_stress"),
     }
 
