Add unittest binary.

Cargo.toml

@@ -41,6 +41,7 @@ members = [
     "src/bin/gadget",
     "src/lib/devmgr",
     "src/srv/devmgr-srv",
+    "src/bin/unittest",
 ]
 
 exclude = ["toolchain/src/rust"]
@@ -67,6 +68,7 @@ initrd = [
     "lib:logboi-srv",
     "lib:pager-srv",
     "crate:gadget",
+    "crate:unittest",
     #"third-party:hello-world-rs"
 ]
 

src/bin/init/src/main.rs

@@ -6,7 +6,7 @@ use tracing::{info, warn};
 use twizzler::object::RawObject;
 use twizzler_abi::{
     aux::KernelInitInfo,
-    object::{ObjID, Protections, MAX_SIZE, NULLPAGE_SIZE},
+    object::{ObjID, MAX_SIZE, NULLPAGE_SIZE},
     pager::{CompletionToKernel, CompletionToPager, RequestFromKernel, RequestFromPager},
     syscall::{sys_new_handle, NewHandleFlags},
 };
@@ -217,39 +217,22 @@ fn find_init_name(name: &str) -> Option<ObjID> {
     None
 }
 
-fn run_tests(test_list_name: &str, benches: bool) {
-    if let Some(id) = find_init_name(test_list_name) {
+fn run_tests(test_list_name: &str, _benches: bool) {
+    if let Some(_id) = find_init_name(test_list_name) {
         println!("=== found init test list ===");
-        let handle =
-            twizzler_rt_abi::object::twz_rt_map_object(id, Protections::READ.into()).unwrap();
-
-        let addr = unsafe { handle.start().add(NULLPAGE_SIZE) };
-        let bytes = unsafe {
-            core::slice::from_raw_parts(addr as *const u8, twizzler_abi::object::MAX_SIZE)
-        };
-        let bytes = &bytes[0..bytes.iter().position(|r| *r == 0).unwrap_or(0)];
-        let str = String::from_utf8(bytes.to_vec()).unwrap();
-        let test_failed = false;
-        for line in str.split("\n").filter(|l| !l.is_empty()) {
-            println!("STARTING TEST {}", line);
-            let test_comp = monitor_api::CompartmentLoader::new(
-                line,
-                line,
-                monitor_api::NewCompartmentFlags::empty(),
-            )
-            .args(&[line, if benches { "--bench" } else { "--test" }])
+
+        let comp = CompartmentLoader::new("unittest", "unittest", NewCompartmentFlags::empty())
+            .args(&["unittest"])
             .load()
-            .expect("failed to load specified test");
-            let mut flags = test_comp.info().flags;
-            while !flags.contains(monitor_api::CompartmentFlags::EXITED) {
-                flags = test_comp.wait(flags);
-            }
-        }
-        // TODO: get exit status, and set this
-        if test_failed {
-            println!("!!! TEST MODE FAILED");
+            .expect("failed to start unittest");
+        let mut flags = comp.info().flags;
+        while !flags.contains(CompartmentFlags::EXITED) {
+            flags = comp.wait(flags);
         }
+
+        println!("unittests finished");
+
         #[allow(deprecated)]
-        twizzler_abi::syscall::sys_debug_shutdown(if test_failed { 1 } else { 0 });
+        twizzler_abi::syscall::sys_debug_shutdown(0);
     }
 }

src/bin/unittest/Cargo.toml

@@ -0,0 +1,9 @@
+[package]
+name = "unittest"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+serde = "*"
+serde_json = "*"
+monitor-api = { path = "../../rt/monitor-api" }

src/bin/unittest/src/main.rs

@@ -0,0 +1,113 @@
+use std::{
+    io::BufRead,
+    sync::OnceLock,
+    time::{Duration, Instant},
+};
+
+use serde::Serialize;
+
+#[derive(Serialize, Debug)]
+struct Report {
+    status: ReportStatus,
+}
+
+impl Report {
+    fn pending() -> Self {
+        Self {
+            status: ReportStatus::Pending,
+        }
+    }
+
+    fn ready(info: ReportInfo) -> Self {
+        Self {
+            status: ReportStatus::Ready(info),
+        }
+    }
+}
+
+#[derive(Serialize, Debug)]
+enum ReportStatus {
+    Pending,
+    Ready(ReportInfo),
+}
+
+#[derive(Serialize, Debug)]
+struct ReportInfo {
+    time: Duration,
+    tests: Vec<TestResult>,
+}
+
+#[derive(Serialize, Debug)]
+struct TestResult {
+    name: String,
+    passed: bool,
+}
+
+static RESULT: OnceLock<Report> = OnceLock::new();
+
+fn main() {
+    let file = std::fs::File::open("/initrd/test_bins").expect("no test binaries specified");
+
+    let heartbeat_thread = std::thread::spawn(|| io_heartbeat());
+
+    let mut reports = vec![];
+    let start = Instant::now();
+    for line in std::io::BufReader::new(file).lines() {
+        if let Ok(line) = &line {
+            println!("STARTING {}", line);
+            if let Ok(test_comp) = monitor_api::CompartmentLoader::new(
+                line,
+                line,
+                monitor_api::NewCompartmentFlags::empty(),
+            )
+            .args(&[line.as_str(), "--test"])
+            .load()
+            {
+                let mut flags = test_comp.info().flags;
+                while !flags.contains(monitor_api::CompartmentFlags::EXITED) {
+                    flags = test_comp.wait(flags);
+                }
+                reports.push(TestResult {
+                    name: line.clone(),
+                    passed: true,
+                });
+            } else {
+                reports.push(TestResult {
+                    name: line.clone(),
+                    passed: false,
+                });
+            }
+        }
+    }
+    let dur = Instant::now() - start;
+    RESULT
+        .set(Report::ready(ReportInfo {
+            time: dur,
+            tests: reports,
+        }))
+        .unwrap();
+    heartbeat_thread.join().unwrap();
+}
+
+fn io_heartbeat() {
+    let mut buf = String::new();
+    while let Ok(_) = std::io::stdin().read_line(&mut buf) {
+        match buf.as_str().trim() {
+            "status" => {
+                if let Some(report) = RESULT.get() {
+                    println!("REPORT {}", serde_json::to_string(report).unwrap());
+                    return;
+                } else {
+                    println!(
+                        "REPORT {}",
+                        serde_json::to_string(&Report::pending()).unwrap()
+                    );
+                }
+            }
+            _ => {
+                println!("!! unknown command: {}", buf);
+            }
+        }
+        buf.clear();
+    }
+}

src/lib/twizzler-driver/src/dma/pin.rs

@@ -119,15 +119,12 @@ pub enum PinError {
 
 #[cfg(test)]
 mod tests {
-    use twizzler_abi::syscall::{BackingType, LifetimeType};
-    use twizzler_object::CreateSpec;
-
     use crate::dma::{Access, DmaOptions, DmaPool};
 
     #[test]
     fn pin_kaction() {
         let pool = DmaPool::new(
-            CreateSpec::new(LifetimeType::Volatile, BackingType::Normal),
+            DmaPool::default_spec(),
             Access::BiDirectional,
             DmaOptions::default(),
         );