feat(testing): add basic section-based test declaration support

.cargo/config

@@ -5,3 +5,4 @@ runner = "bootimage runner"
 dev-env = "install cargo-xbuild bootimage"
 run-x64 = "xrun --target=x86_64-mycelium.json"
 debug-x64 = "xrun --target=x86_64-mycelium.json -- -gdb tcp::1234 -S"
+test-x64 = "xtest --target=x86_64-mycelium.json"

.github/workflows/rust.yml

@@ -22,10 +22,27 @@ jobs:
       with:
         command: bootimage
         args: --target=x86_64-mycelium.json
-    - name: Test
+
+  test:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v1
+    - name: install rust toolchain
+      uses: actions-rs/toolchain@v1
+      with:
+        profile: minimal
+        toolchain: nightly
+        components: rust-src, llvm-tools-preview
+    - name: install dev env
+      uses: actions-rs/[email protected]
+      with:
+        command: dev-env
+    - name: install qemu
+      run: sudo apt-get update && sudo apt-get install qemu
+    - name: run tests
       uses: actions-rs/[email protected]
       with:
-        command: test
+        command: test-x64
 
   clippy:
     runs-on: ubuntu-latest

Cargo.toml

@@ -14,10 +14,17 @@ edition = "2018"
 
 [lib]
 name = "mycelium_kernel"
+harness = false
+
+[[bin]]
+name = "mycelium_kernel"
+path = "src/main.rs"
+test = false
 
 [dependencies]
 hal-core = { path = "hal-core" }
 mycelium-alloc = { path = "alloc" }
+mycelium-util = { path = "util" }
 tracing = { version = "0.1", default_features = false }
 
 [target.'cfg(target_arch = "x86_64")'.dependencies]
@@ -35,6 +42,11 @@ wat = "1.0"
 
 [package.metadata.bootimage]
 default-target = "x86_64-mycelium.json"
+test-success-exit-code = 33 # (0x10 << 1) | 1
+test-args = [
+    "-device", "isa-debug-exit,iobase=0xf4,iosize=0x04",
+    "-serial", "stdio", "-display", "none"
+]
 
 [package.metadata.target.'cfg(target_arch = "x86_64")'.cargo-xbuild]
 memcpy = true

src/arch/x86_64.rs

@@ -159,3 +159,22 @@ pub fn oops(cause: &dyn core::fmt::Display) -> ! {
         }
     }
 }
+
+#[cfg(test)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+#[repr(u32)]
+pub(crate) enum QemuExitCode {
+    Success = 0x10,
+    Failed = 0x11,
+}
+
+/// Exit using `isa-debug-exit`, for use in tests.
+///
+/// NOTE: This is a temporary mechanism until we get proper shutdown implemented.
+#[cfg(test)]
+pub(crate) fn qemu_exit(exit_code: QemuExitCode) {
+    let code = exit_code as u32;
+    unsafe {
+        asm!("out 0xf4, eax" :: "{eax}"(code) :: "intel","volatile");
+    }
+}

src/lib.rs

@@ -1,5 +1,7 @@
+#![cfg_attr(test, no_main)]
 #![cfg_attr(target_os = "none", no_std)]
 #![cfg_attr(target_os = "none", feature(alloc_error_handler))]
+#![cfg_attr(target_os = "none", feature(panic_info_message, track_caller))]
 #![feature(asm)]
 extern crate alloc;
 
@@ -62,9 +64,42 @@ pub fn kernel_main(bootinfo: &impl BootInfo) -> ! {
 
     arch::interrupt::init::<arch::InterruptHandlers>();
 
+    #[cfg(test)]
     {
-        let span = tracing::info_span!("alloc test");
+        let span = tracing::info_span!("run tests");
         let _enter = span.enter();
+
+        let mut passed = 0;
+        let mut failed = 0;
+        for test in mycelium_util::testing::all_tests() {
+            let span = tracing::info_span!("test", test.name, test.module);
+            let _enter = span.enter();
+
+            if (test.run)() {
+                passed += 1;
+            } else {
+                failed += 1;
+            }
+        }
+
+        tracing::warn!("{} passed | {} failed", passed, failed);
+        if failed == 0 {
+            arch::qemu_exit(arch::QemuExitCode::Success);
+        } else {
+            arch::qemu_exit(arch::QemuExitCode::Failed);
+        }
+    }
+
+    // if this function returns we would boot loop. Hang, instead, so the debug
+    // output can be read.
+    //
+    // eventually we'll call into a kernel main loop here...
+    #[allow(clippy::empty_loop)]
+    loop {}
+}
+
+mycelium_util::decl_test! {
+    fn basic_alloc() {
         // Let's allocate something, for funsies
         let mut v = Vec::new();
         tracing::info!(vec = ?v, vec.addr = ?v.as_ptr());
@@ -75,23 +110,12 @@ pub fn kernel_main(bootinfo: &impl BootInfo) -> ! {
         assert_eq!(v.pop(), Some(10));
         assert_eq!(v.pop(), Some(5));
     }
+}
 
-    {
-        let span = tracing::info_span!("wasm test");
-        let _enter = span.enter();
-
-        match wasm::run_wasm(HELLOWORLD_WASM) {
-            Ok(()) => tracing::info!("wasm test Ok!"),
-            Err(err) => tracing::error!(?err, "wasm test Err"),
-        }
+mycelium_util::decl_test! {
+    fn wasm_hello_world() -> Result<(), wasmi::Error> {
+        wasm::run_wasm(HELLOWORLD_WASM)
     }
-
-    // if this function returns we would boot loop. Hang, instead, so the debug
-    // output can be read.
-    //
-    // eventually we'll call into a kernel main loop here...
-    #[allow(clippy::empty_loop)]
-    loop {}
 }
 
 #[global_allocator]
@@ -103,3 +127,40 @@ pub static GLOBAL: mycelium_alloc::Alloc = mycelium_alloc::Alloc;
 fn alloc_error(layout: core::alloc::Layout) -> ! {
     panic!("alloc error: {:?}", layout);
 }
+
+#[cfg(target_os = "none")]
+#[panic_handler]
+#[cold]
+fn panic(panic: &core::panic::PanicInfo) -> ! {
+    use core::fmt;
+
+    struct PrettyPanic<'a>(&'a core::panic::PanicInfo<'a>);
+    impl<'a> fmt::Display for PrettyPanic<'a> {
+        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+            let message = self.0.message();
+            let location = self.0.location();
+            let caller = core::panic::Location::caller();
+            if let Some(message) = message {
+                writeln!(f, "  mycelium panicked: {}", message)?;
+                if let Some(loc) = location {
+                    writeln!(f, "  at: {}:{}:{}", loc.file(), loc.line(), loc.column(),)?;
+                }
+            } else {
+                writeln!(f, "  mycelium panicked: {}", self.0)?;
+            }
+            writeln!(
+                f,
+                "  in: {}:{}:{}",
+                caller.file(),
+                caller.line(),
+                caller.column()
+            )?;
+            Ok(())
+        }
+    }
+
+    let caller = core::panic::Location::caller();
+    tracing::error!(%panic, ?caller);
+    let pp = PrettyPanic(panic);
+    arch::oops(&pp)
+}

src/main.rs

@@ -3,47 +3,6 @@
 #![cfg_attr(target_os = "none", feature(alloc_error_handler))]
 #![cfg_attr(target_os = "none", feature(asm))]
 #![cfg_attr(target_os = "none", feature(panic_info_message, track_caller))]
-use mycelium_kernel::arch;
 
-#[cfg(target_os = "none")]
-#[panic_handler]
-#[cold]
-fn panic(panic: &core::panic::PanicInfo) -> ! {
-    use core::fmt;
-
-    struct PrettyPanic<'a>(&'a core::panic::PanicInfo<'a>);
-    impl<'a> fmt::Display for PrettyPanic<'a> {
-        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-            let message = self.0.message();
-            let location = self.0.location();
-            let caller = core::panic::Location::caller();
-            if let Some(message) = message {
-                writeln!(f, "  mycelium panicked: {}", message)?;
-                if let Some(loc) = location {
-                    writeln!(f, "  at: {}:{}:{}", loc.file(), loc.line(), loc.column(),)?;
-                }
-            } else {
-                writeln!(f, "  mycelium panicked: {}", self.0)?;
-            }
-            writeln!(
-                f,
-                "  in: {}:{}:{}",
-                caller.file(),
-                caller.line(),
-                caller.column()
-            )?;
-            Ok(())
-        }
-    }
-
-    let caller = core::panic::Location::caller();
-    tracing::error!(%panic, ?caller);
-    let pp = PrettyPanic(panic);
-    arch::oops(&pp)
-}
-
-fn main() {
-    unsafe {
-        core::hint::unreachable_unchecked();
-    }
-}
+// Force linking to the `mycelium_kernel` lib.
+use mycelium_kernel;

util/Cargo.toml

@@ -10,6 +10,7 @@ edition = "2018"
 alloc = []
 
 [dependencies]
+tracing = { version = "0.1", default_features = false }
 loom = { version = "0.2.14", optional = true }
 
 [dev-dependencies]

util/src/lib.rs

@@ -9,3 +9,4 @@ pub mod cell;
 pub mod error;
 pub mod io;
 pub mod sync;
+pub mod testing;

util/src/testing.rs

@@ -0,0 +1,95 @@
+use core::fmt;
+use core::mem;
+use core::slice;
+
+/// Internal definition type used for a test.
+pub struct Test {
+    pub module: &'static str,
+    pub name: &'static str,
+    pub run: fn() -> bool,
+}
+
+/// Type which may be used as a test return type.
+pub trait TestResult {
+    /// Report any errors to `tracing`, then returns either `true` for a
+    /// success, or `false` for a failure.
+    fn report(self) -> bool;
+}
+
+impl TestResult for () {
+    fn report(self) -> bool {
+        true
+    }
+}
+
+impl<T: fmt::Debug> TestResult for Result<(), T> {
+    fn report(self) -> bool {
+        match self {
+            Ok(_) => true,
+            Err(err) => {
+                tracing::error!("FAIL {:?}", err);
+                false
+            }
+        }
+    }
+}
+
+/// Declare a new test, sort-of like the `#[test]` attribute.
+// FIXME: Declare a `#[test]` custom attribute instead?
+#[macro_export]
+macro_rules! decl_test {
+    (fn $name:ident $($t:tt)*) => {
+        fn $name $($t)*
+
+        // Introduce an anonymous const to avoid name conflicts. The `#[used]`
+        // will prevent the symbol from being dropped, and `link_section` will
+        // make it visible.
+        const _: () = {
+            #[used]
+            #[link_section = "MyceliumTests"]
+            static TEST: $crate::testing::Test = $crate::testing::Test {
+                module: module_path!(),
+                name: stringify!($name),
+                run: || $crate::testing::TestResult::report($name()),
+            };
+        };
+    }
+}
+
+// These symbols are auto-generated by lld (and similar linkers) for data
+// `link_section` sections, and are located at the beginning and end of the
+// section.
+//
+// The memory region between the two symbols will contain an array of `Test`
+// instances.
+extern "C" {
+    static __start_MyceliumTests: ();
+    static __stop_MyceliumTests: ();
+}
+
+/// Get a list of test objects.
+pub fn all_tests() -> &'static [Test] {
+    unsafe {
+        // FIXME: These should probably be `&raw const __start_*`.
+        let start: *const () = &__start_MyceliumTests;
+        let stop: *const () = &__stop_MyceliumTests;
+
+        let len_bytes = (stop as usize) - (start as usize);
+        let len = len_bytes / mem::size_of::<Test>();
+        assert!(len_bytes % mem::size_of::<Test>() == 0,
+                "Section should contain a whole number of `Test`s");
+
+        if len > 0 {
+            slice::from_raw_parts(start as *const Test, len)
+        } else {
+            &[]
+        }
+    }
+}
+
+decl_test! {
+    fn it_works() -> Result<(), ()> {
+        tracing::info!("I'm running in a test!");
+        Ok(())
+    }
+}