test(test_suite): test Kernel::{is_task_context, is_interrupt_context, is_boot_complete}

Author: yvt

src/r3_test_suite/src/kernel_tests/interrupt_misc.rs

@@ -1,7 +1,12 @@
 //! Validates error codes returned by interrupt line manipulation methods. Also,
 //! checks miscellaneous properties of interrupt lines.
-use r3::kernel::{
-    self, prelude::*, traits, Cfg, InterruptLine, StartupHook, StaticInterruptHandler, StaticTask,
+use core::sync::atomic::{AtomicBool, Ordering};
+use r3::{
+    hunk::Hunk,
+    kernel::{
+        self, prelude::*, traits, Cfg, InterruptLine, StartupHook, StaticInterruptHandler,
+        StaticTask,
+    },
 };
 
 use super::Driver;
@@ -17,6 +22,7 @@ impl<T: traits::KernelBase + traits::KernelInterruptLine + traits::KernelStatic>
 
 pub struct App<System: SupportedSystem> {
     int: Option<InterruptLine<System>>,
+    interrupt_expected: Hunk<System, AtomicBool>,
 }
 
 impl<System: SupportedSystem> App<System> {
@@ -36,6 +42,8 @@ impl<System: SupportedSystem> App<System> {
             .start(startup_hook::<System, D>)
             .finish(b);
 
+        let interrupt_expected = Hunk::<System, AtomicBool>::define().finish(b);
+
         let int = if let [int_line, ..] = *D::INTERRUPT_LINES {
             unsafe {
                 StaticInterruptHandler::define()
@@ -50,7 +58,10 @@ impl<System: SupportedSystem> App<System> {
             None
         };
 
-        App { int }
+        App {
+            int,
+            interrupt_expected,
+        }
     }
 }
 
@@ -167,9 +178,25 @@ fn task_body<System: SupportedSystem, D: Driver<App<System>>>() {
         value => panic!("{:?}", value),
     }
 
-    D::success();
+    if let &[pri, ..] = D::INTERRUPT_PRIORITIES {
+        D::app().interrupt_expected.store(true, Ordering::Relaxed);
+        log::debug!("Pending the interrupt line");
+        int.set_priority(pri).unwrap();
+        int.pend().unwrap();
+    } else {
+        log::warn!("No interrupt priorities defined, skipping the rest of the test");
+        D::success();
+    }
 }
 
 fn isr<System: SupportedSystem, D: Driver<App<System>>>() {
-    unreachable!();
+    log::debug!("The interrupt handler is running");
+    assert!(D::app().interrupt_expected.load(Ordering::Relaxed));
+
+    // Context query
+    assert!(!System::is_task_context());
+    assert!(System::is_interrupt_context());
+    assert!(System::is_boot_complete());
+
+    D::success();
 }

src/r3_test_suite/src/kernel_tests/startup_hook_misc.rs

@@ -0,0 +1,36 @@
+//! Checks miscellaneous properties of `StartupHook`.
+use core::marker::PhantomData;
+use r3::kernel::{prelude::*, traits, Cfg, StartupHook};
+
+use super::Driver;
+
+pub trait SupportedSystem: traits::KernelBase + traits::KernelStatic {}
+impl<T: traits::KernelBase + traits::KernelStatic> SupportedSystem for T {}
+
+pub struct App<System: SupportedSystem> {
+    _phantom: PhantomData<System>,
+}
+
+impl<System: SupportedSystem> App<System> {
+    pub const fn new<C, D: Driver<Self>>(b: &mut Cfg<C>) -> Self
+    where
+        C: ~const traits::CfgBase<System = System> + ~const traits::CfgTask,
+    {
+        StartupHook::define().start(hook::<System, D>).finish(b);
+
+        App {
+            _phantom: PhantomData,
+        }
+    }
+}
+
+fn hook<System: SupportedSystem, D: Driver<App<System>>>() {
+    log::trace!("The startup hook is running");
+
+    // Context query
+    assert!(!System::is_task_context());
+    assert!(!System::is_interrupt_context());
+    assert!(!System::is_boot_complete());
+
+    D::success();
+}

src/r3_test_suite/src/kernel_tests/task_misc.rs

@@ -129,6 +129,11 @@ fn task1_body<System: SupportedSystem, D: Driver<App<System>, System = System>>(
     // task.
     assert_eq!(LocalTask::current().unwrap(), app.task1);
 
+    // Context query
+    assert!(System::is_task_context());
+    assert!(!System::is_interrupt_context());
+    assert!(System::is_boot_complete());
+
     // CPU Lock active
     System::acquire_cpu_lock().unwrap();
     assert_eq!(

src/r3_test_suite/src/kernel_tests/timer_misc.rs

@@ -146,8 +146,10 @@ fn timer1_body<System: SupportedSystem, D: Driver<App<System>, System = System>>
 
     assert_eq!(param, 42);
 
-    // FIXME: Re-add this assertion
-    // assert!(!System::is_task_context());
+    // Context query
+    assert!(!System::is_task_context());
+    assert!(System::is_interrupt_context());
+    assert!(System::is_boot_complete());
 
     // Check `timer1`'s expiration time in `task`
     // (`System::time` is disallowed in a non-task context)

src/r3_test_suite/src/lib.rs

@@ -270,6 +270,7 @@ pub mod kernel_tests {
         (mod semaphore_signal_and_dispatch {}, "semaphore_signal_and_dispatch"),
         (mod semaphore_timeout {}, "semaphore_timeout"),
         (mod startup_hook_disallowed_services {}, "startup_hook_disallowed_services"),
+        (mod startup_hook_misc {}, "startup_hook_misc"),
         (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"),