Add failing unit tests

Author: jasoncouture

Diff for: Cargo.lock

@@ -23,6 +23,7 @@ members = [
     "tests/test_kernels/higher_half",
     "tests/test_kernels/pie",
     "tests/test_kernels/lto",
+    "tests/test_kernels/ramdisk"
 ]
 exclude = ["examples/basic", "examples/test_framework"]
 
@@ -50,6 +51,7 @@ test_kernel_default_settings = { path = "tests/test_kernels/default_settings", a
 test_kernel_higher_half = { path = "tests/test_kernels/higher_half", artifact = "bin", target = "x86_64-unknown-none" }
 test_kernel_map_phys_mem = { path = "tests/test_kernels/map_phys_mem", artifact = "bin", target = "x86_64-unknown-none" }
 test_kernel_pie = { path = "tests/test_kernels/pie", artifact = "bin", target = "x86_64-unknown-none" }
+test_kernel_ramdisk = { path = "tests/test_kernels/ramdisk", artifact = "bin", target = "x86_64-unknown-none" }
 
 [profile.dev]
 panic = "abort"

Diff for: Cargo.toml

@@ -0,0 +1,21 @@
+use std::path::Path;
+
+use bootloader_test_runner::run_test_kernel;
+
+#[test]
+fn basic_boot() {
+    let ramdisk = Path::new("ramdisk.txt").canonicalize().unwrap();
+    run_test_kernel(
+        env!("CARGO_BIN_FILE_TEST_KERNEL_RAMDISK_basic_boot"),
+        Some(&ramdisk),
+    );
+}
+
+#[test]
+fn check_ramdisk() {
+    let ramdisk = Path::new("ramdisk.txt").canonicalize().unwrap();
+    run_test_kernel(
+        env!("CARGO_BIN_FILE_TEST_KERNEL_RAMDISK_ramdisk"),
+        Some(&ramdisk),
+    );
+}

Diff for: tests/ramdisk.rs

@@ -0,0 +1 @@
+Test ramdisk.

Diff for: tests/ramdisk.txt

@@ -0,0 +1,13 @@
+[package]
+name = "test_kernel_ramdisk"
+version = "0.1.0"
+authors = ["Philipp Oppermann <[email protected]>"]
+edition = "2021"
+
+[dependencies]
+bootloader_api = { path = "../../../api" }
+x86_64 = { version = "0.14.7", default-features = false, features = [
+    "instructions",
+    "inline_asm",
+] }
+uart_16550 = "0.2.10"

Diff for: tests/test_kernels/ramdisk/Cargo.toml

@@ -0,0 +1,21 @@
+#![no_std] // don't link the Rust standard library
+#![no_main] // disable all Rust-level entry points
+
+use bootloader_api::{entry_point, BootInfo};
+use test_kernel_ramdisk::{exit_qemu, QemuExitCode};
+
+entry_point!(kernel_main);
+
+fn kernel_main(_boot_info: &'static mut BootInfo) -> ! {
+    exit_qemu(QemuExitCode::Success);
+}
+
+/// This function is called on panic.
+#[panic_handler]
+#[cfg(not(test))]
+fn panic(info: &core::panic::PanicInfo) -> ! {
+    use core::fmt::Write;
+
+    let _ = writeln!(test_kernel_ramdisk::serial(), "PANIC: {}", info);
+    exit_qemu(QemuExitCode::Failed);
+}

Diff for: tests/test_kernels/ramdisk/src/bin/basic_boot.rs

@@ -0,0 +1,36 @@
+#![no_std] // don't link the Rust standard library
+#![no_main] // disable all Rust-level entry points
+
+use bootloader_api::{entry_point, BootInfo};
+use test_kernel_ramdisk::{exit_qemu, QemuExitCode, RAMDISK_CONTENTS};
+
+
+
+entry_point!(kernel_main);
+
+fn kernel_main(boot_info: &'static mut BootInfo) -> ! {   
+    assert!(boot_info.ramdisk_addr.into_option().is_some());
+    assert_eq!(boot_info.ramdisk_len as usize, RAMDISK_CONTENTS.len());
+
+    let ramdisk = boot_info.ramdisk_addr.into_option().unwrap() as *const u8;
+    compare_ramdisk_contents(ramdisk);    
+
+
+    exit_qemu(QemuExitCode::Success);
+}
+
+fn compare_ramdisk_contents(ramdisk: *const u8) {
+    let expected = RAMDISK_CONTENTS;
+    for i in 0..expected.len() {
+        unsafe { assert_eq!(expected[i], *ramdisk.offset(i as isize)); }
+    }
+}
+/// This function is called on panic.
+#[cfg(not(test))]
+#[panic_handler]
+fn panic(info: &core::panic::PanicInfo) -> ! {
+    use core::fmt::Write;
+
+    let _ = writeln!(test_kernel_ramdisk::serial(), "PANIC: {}", info);
+    exit_qemu(QemuExitCode::Failed);
+}

Diff for: tests/test_kernels/ramdisk/src/bin/ramdisk.rs

@@ -0,0 +1,29 @@
+#![no_std]
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+#[repr(u32)]
+pub enum QemuExitCode {
+    Success = 0x10,
+    Failed = 0x11,
+}
+
+pub static RAMDISK_CONTENTS: &[u8] = include_bytes!("../../../ramdisk.txt");
+
+pub fn exit_qemu(exit_code: QemuExitCode) -> ! {
+    use x86_64::instructions::{nop, port::Port};
+
+    unsafe {
+        let mut port = Port::new(0xf4);
+        port.write(exit_code as u32);
+    }
+
+    loop {
+        nop();
+    }
+}
+
+pub fn serial() -> uart_16550::SerialPort {
+    let mut port = unsafe { uart_16550::SerialPort::new(0x3F8) };
+    port.init();
+    port
+}