Add test framework

Author: GabrielMajeri

tests/Cargo.toml

@@ -0,0 +1,16 @@
+[package]
+name = "tests"
+version = "0.1.0"
+authors = ["Gabriel Majeri <[email protected]>"]
+publish = false
+
+[lib]
+crate-type = ["staticlib"]
+
+[dependencies]
+rlibc = "1"
+compiler_builtins = { git = "https://github.com/rust-lang-nursery/compiler-builtins" }
+
+uefi = { path = ".." }
+uefi-logger = { path = "../uefi-logger" }
+log = { version = "0.3", default-features = false }

tests/src/lib.rs

@@ -0,0 +1,47 @@
+#![no_std]
+
+#![feature(lang_items)]
+#![feature(compiler_builtins_lib)]
+
+extern crate uefi;
+extern crate uefi_logger;
+
+#[macro_use]
+extern crate log;
+
+mod no_std;
+
+use uefi::{Handle, Status};
+use uefi::table;
+
+#[no_mangle]
+pub extern fn uefi_start(handle: Handle, st: &'static table::SystemTable) -> Status {
+    let stdout = st.stdout();
+    stdout.reset(false);
+
+    let logger = uefi_logger::UefiLogger::new(stdout);
+
+    unsafe {
+        log::set_logger_raw(|log_level| {
+            // Log everything.
+            log_level.set(log::LogLevelFilter::Info);
+
+            &logger
+        }).unwrap(); // Can only fail if already initialized.
+    }
+
+    info!("Hello world!");
+    info!("Image handle: {:?}", handle);
+    {
+        let revision = st.uefi_revision();
+        let (major, minor) = (revision.major(), revision.minor());
+
+        info!("UEFI {}.{}.{}", major, minor / 10, minor % 10);
+    }
+
+    loop {
+
+    }
+
+    Status::Success
+}

tests/src/no_std.rs

@@ -0,0 +1,12 @@
+extern crate rlibc;
+extern crate compiler_builtins;
+
+#[lang = "eh_personality"]
+fn eh_personality() {
+}
+
+#[lang = "panic_fmt"]
+#[no_mangle]
+#[allow(private_no_mangle_fns)]
+pub fn panic_fmt() {
+}

uefi-logger/Cargo.toml

@@ -0,0 +1,9 @@
+[package]
+name = "uefi-logger"
+version = "0.1.0"
+authors = ["Gabriel Majeri <[email protected]>"]
+publish = false
+
+[dependencies]
+uefi = { path = ".." }
+log = { version = "0.3", default-features = false }

uefi-logger/src/lib.rs

@@ -0,0 +1,43 @@
+#![no_std]
+
+extern crate uefi;
+use uefi::proto::console::text::Output;
+
+extern crate log;
+
+use core::cell::UnsafeCell;
+
+mod writer;
+use self::writer::OutputWriter;
+
+/// Logging implementation which writes to a UEFI output stream.
+pub struct UefiLogger {
+    writer: UnsafeCell<OutputWriter>,
+}
+
+impl UefiLogger {
+    /// Creates a new logger.
+    pub fn new(output: &'static mut Output) -> Self {
+        UefiLogger {
+            writer: UnsafeCell::new(OutputWriter::new(output))
+        }
+    }
+}
+
+impl log::Log for UefiLogger {
+    fn enabled(&self, _metadata: &log::LogMetadata) -> bool {
+        true
+    }
+
+    fn log(&self, record: &log::LogRecord) {
+        let args = record.args();
+
+        let writer = unsafe { &mut *self.writer.get() };
+        use core::fmt::Write;
+        writeln!(writer, "{}", args);
+    }
+}
+
+// The logger is not thread-safe, but the UEFI boot environment only uses one processor.
+unsafe impl Sync for UefiLogger {}
+unsafe impl Send for UefiLogger {}

uefi-logger/src/writer.rs

@@ -0,0 +1,66 @@
+use super::Output;
+use core::{fmt, str};
+
+/// Struct which is used to implement the `fmt::Write` trait on a UEFI output protocol.
+pub struct OutputWriter {
+    output: &'static mut Output
+}
+
+impl OutputWriter {
+    pub fn new(output: &'static mut Output) -> Self {
+        OutputWriter {
+            output
+        }
+    }
+}
+
+impl fmt::Write for OutputWriter {
+    fn write_str(&mut self, s: &str) -> fmt::Result {
+        // Allocate a small buffer on the stack.
+        const BUF_SIZE: usize = 128;
+        // Add 1 extra character for the null terminator.
+        let mut buf = [0u16; BUF_SIZE + 1];
+
+        let mut i = 0;
+
+        // This closure writes the local buffer to the output and resets the buffer.
+        let mut flush_buffer = |buf: &mut [u16], i: &mut usize| {
+            buf[*i] = 0;
+            *i = 0;
+
+            self.output.output_string(buf.as_ptr()).map_err(|_| fmt::Error)
+        };
+
+        {
+            // This closure converts a character to UCS-2 and adds it to the buffer,
+            // flushing it as necessary.
+            let mut add_char = |ch| {
+                // UEFI only supports UCS-2 characters, not UTF-16,
+                // so there are no multibyte characters.
+                let ch = ch as u16;
+
+                buf[i] = ch;
+
+                i += 1;
+
+                if i == BUF_SIZE {
+                    flush_buffer(&mut buf, &mut i)
+                } else {
+                    Ok(())
+                }
+            };
+
+            for ch in s.chars() {
+                if ch == '\n' {
+                    // Prepend an '\r'.
+                    add_char('\r')?;
+                }
+
+                add_char(ch)?;
+            }
+        }
+
+        // Flush whatever is left in the buffer.
+        flush_buffer(&mut buf, &mut i)
+    }
+}