Add tests

.travis.yml

@@ -0,0 +1,12 @@
+language: rust
+cache: cargo
+rust:
+  - nightly
+install:
+  - sudo apt-get -qqy install qemu-system-x86
+before_script:
+  - rustup component add rust-src
+  - rustup component add llvm-tools-preview
+  - cargo install bootimage
+script:
+  - cargo test --lib --no-default-features --features serial,qwerty,pcnet -- -display none -serial stdio -device isa-debug-exit,iobase=0xf4,iosize=0x04

Cargo.toml

@@ -43,3 +43,6 @@ volatile = "0.2.6"
 vte = "0.8.0"
 x86_64 = "0.12.2"
 time = { version = "0.2.22", default-features = false }
+
+[package.metadata.bootimage]
+test-success-exit-code = 33 # (0x10 << 1) | 1

Makefile

@@ -32,3 +32,7 @@ endif
 
 qemu:
 	qemu-system-x86_64 $(opts)
+
+test:
+	cargo test --lib --no-default-features --features serial,$(keyboard),$(nic) -- \
+		-display none -serial stdio -device isa-debug-exit,iobase=0xf4,iosize=0x04

src/kernel/allocator.rs

@@ -117,3 +117,28 @@ pub fn used() -> usize {
 pub fn free() -> usize {
     ALLOCATOR.lock().free()
 }
+
+#[test_case]
+fn many_boxes() {
+    use alloc::boxed::Box;
+
+    let heap_value_1 = Box::new(42);
+    let heap_value_2 = Box::new(1337);
+    assert_eq!(*heap_value_1, 42);
+    assert_eq!(*heap_value_2, 1337);
+
+    for i in 0..1000 {
+        let x = Box::new(i);
+        assert_eq!(*x, i);
+    }
+}
+
+#[test_case]
+fn large_vec() {
+    let n = 1000;
+    let mut vec = Vec::new();
+    for i in 0..n {
+        vec.push(i);
+    }
+    assert_eq!(vec.iter().sum::<u64>(), (n - 1) * n / 2);
+}

src/kernel/clock.rs

@@ -47,3 +47,13 @@ fn is_leap_year(year: u64) -> bool {
         true
     }
 }
+
+#[test_case]
+fn uptime_assertion() {
+    assert!(uptime() > 0.0);
+}
+
+#[test_case]
+fn realtime_assertion() {
+    assert!(realtime() > 1234567890.0);
+}

src/kernel/console.rs

@@ -157,15 +157,17 @@ macro_rules! print {
 #[macro_export]
 macro_rules! log {
     ($($arg:tt)*) => ({
-        let uptime = $crate::kernel::clock::uptime();
-        let csi_color = $crate::kernel::console::Style::color("LightGreen");
-        let csi_reset = $crate::kernel::console::Style::reset();
-        if cfg!(feature="vga") {
-            $crate::kernel::vga::print_fmt(format_args!("{}[{:.6}]{} ", csi_color, uptime, csi_reset));
-            $crate::kernel::vga::print_fmt(format_args!($($arg)*));
-        } else {
-            $crate::kernel::serial::print_fmt(format_args!("{}[{:.6}]{} ", csi_color, uptime, csi_reset));
-            $crate::kernel::serial::print_fmt(format_args!($($arg)*));
+        if !cfg!(test) {
+            let uptime = $crate::kernel::clock::uptime();
+            let csi_color = $crate::kernel::console::Style::color("LightGreen");
+            let csi_reset = $crate::kernel::console::Style::reset();
+            if cfg!(feature="vga") {
+                $crate::kernel::vga::print_fmt(format_args!("{}[{:.6}]{} ", csi_color, uptime, csi_reset));
+                $crate::kernel::vga::print_fmt(format_args!($($arg)*));
+            } else {
+                $crate::kernel::serial::print_fmt(format_args!("{}[{:.6}]{} ", csi_color, uptime, csi_reset));
+                $crate::kernel::serial::print_fmt(format_args!($($arg)*));
+            }
         }
     });
 }

src/kernel/random.rs

@@ -1,7 +1,12 @@
+#[cfg(not(test))]
 use rand_chacha::ChaChaRng;
+#[cfg(not(test))]
 use rand_core::{RngCore, SeedableRng};
 use x86_64::instructions::random::RdRand;
 
+// FIXME: Compiling this in test generate the following error:
+// LLVM ERROR: Do not know how to split the result of this operator!
+#[cfg(not(test))]
 pub fn get_u64() -> u64 {
     let mut seed = [0u8; 32];
     if let Some(rdrand) = RdRand::new() {
@@ -19,6 +24,16 @@ pub fn get_u64() -> u64 {
     chacha.next_u64()
 }
 
+#[cfg(test)]
+pub fn get_u64() -> u64 {
+    if let Some(rdrand) = RdRand::new() {
+        if let Some(rand) = rdrand.get_u64() {
+            return rand;
+        }
+    }
+    0
+}
+
 pub fn get_u32() -> u32 {
     get_u64() as u32
 }

src/lib.rs

@@ -1,6 +1,10 @@
 #![no_std]
 #![feature(alloc_error_handler)]
 #![feature(abi_x86_interrupt)]
+#![cfg_attr(test, no_main)]
+#![feature(custom_test_frameworks)]
+#![test_runner(crate::test_runner)]
+#![reexport_test_harness_main = "test_main"]
 
 extern crate alloc;
 
@@ -33,3 +37,81 @@ pub fn init(boot_info: &'static BootInfo) {
 fn alloc_error_handler(layout: alloc::alloc::Layout) -> ! {
     panic!("allocation error: {:?}", layout)
 }
+
+pub trait Testable {
+    fn run(&self) -> ();
+}
+
+impl<T> Testable for T where T: Fn() {
+    fn run(&self) {
+        print!("test {} ... ", core::any::type_name::<T>());
+        self();
+        let csi_color = kernel::console::Style::color("LightGreen");
+        let csi_reset = kernel::console::Style::reset();
+        print!("{}ok{}\n", csi_color, csi_reset);
+    }
+}
+
+pub fn test_runner(tests: &[&dyn Testable]) {
+    let n = tests.len();
+    print!("\nrunning {} test{}\n", n, if n == 1 { "" } else { "s" });
+    for test in tests {
+        test.run();
+    }
+    exit_qemu(QemuExitCode::Success);
+}
+
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+#[repr(u32)]
+pub enum QemuExitCode {
+    Success = 0x10,
+    Failed = 0x11,
+}
+
+pub fn exit_qemu(exit_code: QemuExitCode) {
+    use x86_64::instructions::port::Port;
+
+    unsafe {
+        let mut port = Port::new(0xf4);
+        port.write(exit_code as u32);
+    }
+}
+
+pub fn hlt_loop() -> ! {
+    loop {
+        x86_64::instructions::hlt();
+    }
+}
+
+#[cfg(test)]
+use bootloader::entry_point;
+
+#[cfg(test)]
+use core::panic::PanicInfo;
+
+#[cfg(test)]
+entry_point!(test_kernel_main);
+
+#[cfg(test)]
+fn test_kernel_main(boot_info: &'static BootInfo) -> ! {
+    init(boot_info);
+    test_main();
+    hlt_loop();
+}
+
+#[cfg(test)]
+#[panic_handler]
+fn panic(info: &PanicInfo) -> ! {
+    let csi_color = kernel::console::Style::color("LightRed");
+    let csi_reset = kernel::console::Style::reset();
+    print!("{}failed{}\n\n", csi_color, csi_reset);
+    print!("{}\n\n", info);
+    exit_qemu(QemuExitCode::Failed);
+    hlt_loop();
+}
+
+#[test_case]
+fn trivial_assertion() {
+    assert_eq!(1, 1);
+}