test(test_suite): add tests for constance::sync::Mutex

Author: yvt

src/constance_test_suite/src/kernel_tests/sync_mutex_lock_and_dispatch.rs

@@ -0,0 +1,77 @@
+//! Checks miscellaneous properties of [`constance::sync::Mutex`].
+use constance::{
+    kernel::{cfg::CfgBuilder, Hunk, Task},
+    prelude::*,
+    sync::mutex::Mutex,
+};
+
+use super::Driver;
+use crate::utils::SeqTracker;
+
+pub struct App<System> {
+    task2: Task<System>,
+    mutex: Mutex<System, u32>,
+    seq: Hunk<System, SeqTracker>,
+}
+
+impl<System: Kernel> App<System> {
+    pub const fn new<D: Driver<Self>>(b: &mut CfgBuilder<System>) -> Self {
+        Task::build()
+            .start(task1_body::<System, D>)
+            .priority(2)
+            .active(true)
+            .finish(b);
+        let task2 = Task::build()
+            .start(task2_body::<System, D>)
+            .priority(1)
+            .active(false)
+            .finish(b);
+
+        let mutex = Mutex::new(b);
+
+        let seq = Hunk::<_, SeqTracker>::build().finish(b);
+
+        App { task2, mutex, seq }
+    }
+}
+
+fn task1_body<System: Kernel, D: Driver<App<System>>>(_: usize) {
+    let app = D::app();
+
+    app.seq.expect_and_replace(0, 1);
+
+    {
+        let mut lock = app.mutex.lock().unwrap();
+        app.task2.activate().unwrap(); // giving the control to `task2`
+
+        // back from `task2`, which is being blocked...
+        app.seq.expect_and_replace(2, 3);
+        *lock = 42;
+
+        // release the lock and let `task2` continue. the control will return to
+        // here when `task2` completes
+    }
+
+    app.seq.expect_and_replace(5, 6);
+
+    assert_eq!(*app.mutex.lock().unwrap(), 56);
+
+    D::success();
+}
+
+fn task2_body<System: Kernel, D: Driver<App<System>>>(_: usize) {
+    let app = D::app();
+
+    app.seq.expect_and_replace(1, 2);
+
+    {
+        let mut lock = app.mutex.lock().unwrap(); // blocks because `task1` has lock
+
+        // preempts `task1` when it releases the lock
+        app.seq.expect_and_replace(3, 4);
+        assert_eq!(*lock, 42);
+        *lock = 56;
+    }
+
+    app.seq.expect_and_replace(4, 5);
+}

src/constance_test_suite/src/kernel_tests/sync_mutex_misc.rs

@@ -0,0 +1,125 @@
+//! Checks miscellaneous properties of [`constance::sync::Mutex`].
+use constance::{
+    kernel::{cfg::CfgBuilder, Hunk, InterruptHandler, InterruptLine, Task},
+    prelude::*,
+    sync::mutex::{self, Mutex},
+};
+
+use super::Driver;
+use crate::utils::SeqTracker;
+
+pub struct App<System> {
+    int: Option<InterruptLine<System>>,
+    eg1: Mutex<System, u32>,
+    eg2: Mutex<System, u32>,
+    seq: Hunk<System, SeqTracker>,
+}
+
+impl<System: Kernel> App<System> {
+    pub const fn new<D: Driver<Self>>(b: &mut CfgBuilder<System>) -> Self {
+        Task::build()
+            .start(task_body::<System, D>)
+            .priority(2)
+            .active(true)
+            .finish(b);
+        let eg1 = Mutex::new(b);
+        let eg2 = Mutex::new(b);
+
+        let int = if let (&[int_line, ..], &[int_pri, ..]) =
+            (D::INTERRUPT_LINES, D::INTERRUPT_PRIORITIES)
+        {
+            InterruptHandler::build()
+                .line(int_line)
+                .start(isr::<System, D>)
+                .finish(b);
+
+            Some(
+                InterruptLine::build()
+                    .line(int_line)
+                    .enabled(true)
+                    .priority(int_pri)
+                    .finish(b),
+            )
+        } else {
+            None
+        };
+
+        let seq = Hunk::<_, SeqTracker>::build().finish(b);
+
+        App { eg1, eg2, int, seq }
+    }
+}
+
+fn task_body<System: Kernel, D: Driver<App<System>>>(_: usize) {
+    let app = D::app();
+
+    app.seq.expect_and_replace(0, 1);
+
+    if let Some(int) = app.int {
+        int.pend().unwrap();
+    } else {
+        log::warn!("No interrupt lines defined, skipping a portion of the test");
+        app.seq.expect_and_replace(1, 2);
+    }
+
+    // CPU Lock active
+    System::acquire_cpu_lock().unwrap();
+    assert_eq!(app.eg1.lock().err(), Some(mutex::LockError::BadContext));
+    assert_eq!(
+        app.eg1.try_lock().err(),
+        Some(mutex::TryLockError::BadContext),
+    );
+    unsafe { System::release_cpu_lock().unwrap() };
+
+    // Smoke test
+    drop(app.eg1.lock());
+    drop(app.eg1.lock());
+    {
+        let _eg1 = app.eg1.lock();
+        drop(app.eg2.lock());
+        drop(app.eg2.lock());
+    }
+
+    drop(app.eg1.try_lock());
+    drop(app.eg1.try_lock());
+
+    // Double lock
+    {
+        let _eg1 = app.eg1.lock();
+        assert_eq!(
+            app.eg1.try_lock().err(),
+            Some(mutex::TryLockError::WouldBlock),
+        );
+        assert_eq!(
+            app.eg1.try_lock().err(),
+            Some(mutex::TryLockError::WouldBlock),
+        );
+    }
+
+    // Inner data
+    *app.eg1.lock().unwrap() = 0x12345678;
+    *app.eg1.try_lock().unwrap() += 1;
+    *app.eg2.lock().unwrap() = 0x87654321;
+    *app.eg2.try_lock().unwrap() -= 1;
+
+    assert_eq!(*app.eg1.lock().unwrap(), 0x12345679);
+    assert_eq!(*app.eg2.lock().unwrap(), 0x87654320);
+
+    assert_eq!(unsafe { *app.eg1.get_ptr() }, 0x12345679);
+    assert_eq!(unsafe { *app.eg2.get_ptr() }, 0x87654320);
+
+    D::success();
+}
+
+fn isr<System: Kernel, D: Driver<App<System>>>(_: usize) {
+    let app = D::app();
+
+    app.seq.expect_and_replace(1, 2);
+
+    // Non-task context
+    assert_eq!(app.eg1.lock().err(), Some(mutex::LockError::BadContext));
+    assert_eq!(
+        app.eg1.try_lock().err(),
+        Some(mutex::TryLockError::BadContext),
+    );
+}

src/constance_test_suite/src/lib.rs

@@ -191,6 +191,8 @@ pub mod kernel_tests {
         (mod startup_hook_disallowed_services {}, "startup_hook_disallowed_services"),
         (mod startup_hook_pend_interrupt {}, "startup_hook_pend_interrupt"),
         (mod startup_hook_priority {}, "startup_hook_priority"),
+        (mod sync_mutex_lock_and_dispatch {}, "sync_mutex_lock_and_dispatch"),
+        (mod sync_mutex_misc {}, "sync_mutex_misc"),
         (mod task_activate_and_dispatch {}, "task_activate_and_dispatch"),
         (mod task_activate_and_do_not_dispatch {}, "task_activate_and_do_not_dispatch"),
         (mod task_cpu_lock_reset {}, "task_cpu_lock_reset"),