Page 04: Testing (Partial Impl) (#7)

* Impl rough testing framework

* Partial implementation of page 04

Author: c1m50c

Cargo.lock

@@ -8,17 +8,13 @@ publish = false
 [workspace]
 members = [ "kernel" ]
 
-[profile.release]
-panic = "abort"
-
-[profile.dev]
-panic = "abort"
-
-
 [build-dependencies]
 rust-os-kernel = { path = "kernel", artifact = "bin", target = "x86_64-unknown-none" }
 bootloader = "0.11.3"
 
 [dependencies]
 clap = { version = "4.2.4", features = ["derive"] }
 ovmf-prebuilt = "0.1.0-alpha.1"
+
+[features]
+testing = [  ]

Cargo.toml

@@ -62,4 +62,16 @@ $ cargo run --release -- uefi
 
 $ cargo run --release -- bios
 > ... # QEMU Window should pop up launching our kernel's BIOS image
+```
+
+## Testing
+
+Due to the way this currently setup, testing is a bit funky. You can run the following commands to launch the kernel in test mode:
+
+```bash
+# This can be set to any value, as long as its present the kernel will be compiled in test mode.
+$ export KERNEL_TEST_MODE="true"
+
+$ cargo run --release -F testing -- <uefi||bios>
+> ...
 ```

README.md

@@ -7,8 +7,10 @@ publish = false
 
 [dependencies]
 lazy_static = { version = "1.4.0", features = [ "spin_no_std" ] }
+uart_16550 = { version = "0.2.18", features = ["nightly"] }
 noto-sans-mono-bitmap = "0.2.0"
 bootloader_api = "0.11.3"
 fixed-vectors = "3.2.1"
+x86_64 = "0.14.10"
 spin = "0.9.8"
-libm = "0.2.6"
+libm = "0.2.6"

kernel/Cargo.toml

@@ -0,0 +1,5 @@
+fn main() {
+    if std::env::var_os("KERNEL_TEST_MODE").is_some() {
+        println!("cargo:rustc-cfg=test");
+    }
+}

kernel/build.rs

@@ -3,6 +3,8 @@ use core::ops::DerefMut;
 
 use crate::FRAME_BUFFER_WRITER;
 
+pub mod serial;
+
 
 #[macro_export]
 macro_rules! print {

kernel/src/macros/mod.rs

@@ -0,0 +1,34 @@
+use core::fmt::{self, Write};
+
+use crate::SERIAL_ONE;
+
+
+#[macro_export]
+macro_rules! serial_print {
+    ($($arg: tt)*) => {
+        $crate::macros::serial::_print(
+            format_args!( $($arg)* )
+        );
+    };
+}
+
+
+#[macro_export]
+macro_rules! serial_println {
+    () => {
+        $crate::serial_print!("\n");
+    };
+
+    ($($arg: tt)*) => {
+        $crate::serial_print!("{}\n", format_args!($($arg)*));
+    }
+}
+
+
+#[doc(hidden)]
+pub fn _print(args: fmt::Arguments) {
+    let mut lock = SERIAL_ONE.lock();
+
+    lock.write_fmt(args)
+        .expect("In `_print()`, the `write_fmt()` function is expected not to fail");
+}

kernel/src/macros/serial.rs

@@ -2,39 +2,64 @@
 #![no_main]
 #![no_std]
 
+#![test_runner(tests::_empty_test_runner)]
+#![feature(custom_test_frameworks)]
+
 use bootloader_api::info::Optional;
 use bootloader_api::BootInfo;
 
 use lazy_static::lazy_static;
 use fixed_vectors::Vector2;
+use uart_16550::SerialPort;
 use spin::Mutex;
 
 use core::ops::DerefMut;
-#[cfg(not(test))]
-use core::panic::PanicInfo;
 
 pub mod raytracer;
 pub mod writer;
 pub mod macros;
+pub mod qemu;
+
+#[cfg(test)]
+mod tests;
 
 
 lazy_static!{
     pub static ref FRAME_BUFFER_WRITER: Mutex<Option<writer::FrameBufferWriter<'static>>> = Mutex::new(
         // The `FRAME_BUFFER_WRITER` needs to be initialized in `main` with the `info.framebuffer`
         None
     );
+
+    pub static ref SERIAL_ONE: Mutex<SerialPort> = {
+        let mut serial_port = unsafe { SerialPort::new(0x3F8) };
+        serial_port.init();
+
+        Mutex::new(serial_port)
+    };
 }
 
 
 #[panic_handler]
 #[cfg(not(test))]
-fn panic(info: &PanicInfo) -> ! {
+fn panic(info: &core::panic::PanicInfo) -> ! {
     println!("PANIC: {}", info);
 
     loop {  }
 }
 
 
+#[panic_handler]
+#[cfg(test)]
+fn panic(info: &core::panic::PanicInfo) -> ! {
+    serial_println!("[failed]\n");
+
+    serial_println!("Error: {}\n", info);
+    qemu::exit_qemu(qemu::QemuExitCode::Failed);
+
+    loop {  }
+}
+
+
 fn main(info: &'static mut BootInfo) -> ! {
     // Initialize `FRAME_BUFFER_WRITER` with `info.framebuffer`
     if let Optional::Some(buffer) = &mut info.framebuffer {
@@ -49,6 +74,10 @@ fn main(info: &'static mut BootInfo) -> ! {
         *lock = Some(writer);
     }
 
+    #[cfg(test)] {
+        tests::_testing_main(); loop {  }
+    }
+
     let mut lock = FRAME_BUFFER_WRITER.lock();
     let Some(writer) = lock.deref_mut() else { unreachable!() };
 

kernel/src/main.rs

@@ -0,0 +1,17 @@
+use x86_64::instructions::port::Port;
+
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+#[repr(u32)]
+pub enum QemuExitCode {
+    Success = 0x10,
+    Failed = 0x11,
+}
+
+pub fn exit_qemu(exit_code: QemuExitCode) {
+
+    unsafe {
+        let mut port = Port::new(0xf4);
+        port.write(exit_code as u32);
+    }
+}

kernel/src/qemu.rs

@@ -0,0 +1,29 @@
+
+use lazy_static::lazy_static;
+use spin::Lazy;
+
+use crate::qemu::{QemuExitCode, exit_qemu};
+use crate::{serial_println, serial_print};
+
+
+lazy_static!{
+    pub static ref TESTS: Lazy<&'static [(&'static str, fn())]> = Lazy::new(|| &[
+        ("Basic Assertion", || assert_eq!(2 + 2, 4)),
+    ]);
+}
+
+
+#[doc(hidden)]
+pub fn _empty_test_runner() { unimplemented!() }
+
+
+#[doc(hidden)]
+pub fn _testing_main() {
+    for (name, func) in TESTS.iter() {
+        serial_print!("Running `{}`... ", name);
+        func();
+        serial_println!("[ok]");
+    }
+
+    exit_qemu(QemuExitCode::Success);
+}

kernel/src/tests/mod.rs

@@ -1,3 +1,6 @@
+#![feature(custom_test_frameworks)]
+#![test_runner(test_runner)]
+
 use std::io::Error;
 use std::process;
 
@@ -39,8 +42,17 @@ fn main() -> Result<(), Error> {
         },
     }
 
+    #[cfg(feature = "testing")] {
+        command.arg("-device")
+            .arg("isa-debug-exit,iobase=0xf4,iosize=0x04");
+        command.arg("-serial")
+            .arg("stdio");
+        command.arg("-display")
+            .arg("none");
+    }
+
     let mut child_process = command.spawn()?;
     child_process.wait()?;
 
-     Ok(())
+    Ok(())
 }