Port uefi-test-runner to Completion

Author: HadrienG2

uefi-test-runner/src/boot/memory.rs

@@ -20,7 +20,8 @@ fn allocate_pages(bt: &BootServices) {
     let mem_ty = MemoryType::LOADER_DATA;
     let pgs = bt
         .allocate_pages(ty, mem_ty, 1)
-        .expect("Failed to allocate a page of memory");
+        .expect("Failed to allocate a page of memory")
+        .expect("Warnings encountered while allocating a page");
 
     assert_eq!(pgs % 4096, 0, "Page pointer is not page-aligned");
 
@@ -37,7 +38,7 @@ fn allocate_pages(bt: &BootServices) {
     buf[4095] = 0x23;
 
     // Clean up to avoid memory leaks.
-    bt.free_pages(pgs, 1).unwrap();
+    bt.free_pages(pgs, 1).unwrap().unwrap();
 }
 
 // Simple test to ensure our custom allocator works with the `alloc` crate.
@@ -91,7 +92,8 @@ fn memory_map(bt: &BootServices) {
 
     let (_key, mut desc_iter) = bt
         .memory_map(&mut buffer)
-        .expect("Failed to retrieve UEFI memory map");
+        .expect("Failed to retrieve UEFI memory map")
+        .expect("Warnings encountered while retrieving memory map");
 
     // Ensured we have at least one entry.
     // Real memory maps usually have dozens of entries.

uefi-test-runner/src/boot/misc.rs

@@ -7,5 +7,6 @@ pub fn test(bt: &BootServices) {
 fn test_watchdog(bt: &BootServices) {
     // Disable the UEFI watchdog timer
     bt.set_watchdog_timer(0, 0x10000, None)
-        .expect("Could not set watchdog timer");
+        .expect("Could not set watchdog timer")
+        .expect("Warnings encountered while setting watchdog timer");
 }

uefi-test-runner/src/main.rs

@@ -1,8 +1,9 @@
 #![no_std]
 #![no_main]
-#![feature(slice_patterns)]
 #![feature(alloc)]
 #![feature(asm)]
+#![feature(const_slice_len)]
+#![feature(slice_patterns)]
 
 #[macro_use]
 extern crate log;
@@ -22,7 +23,10 @@ pub extern "win64" fn uefi_start(_handle: uefi::Handle, st: &'static SystemTable
     uefi_services::init(st);
 
     // Reset the console before running all the other tests.
-    st.stdout().reset(false).expect("Failed to reset stdout");
+    st.stdout()
+        .reset(false)
+        .expect("Failed to reset stdout")
+        .expect("Warnings encountered while resetting stdout");
 
     // Ensure the tests are run on a version of UEFI we support.
     check_revision(st.uefi_revision());
@@ -71,25 +75,31 @@ fn check_screenshot(bt: &BootServices, name: &str) {
         io_mode.timeout = 3_000_000;
         serial
             .set_attributes(&io_mode)
-            .expect("Failed to configure serial port timeout");
+            .expect("Failed to configure serial port timeout")
+            .expect("Warnings encountered while configuring serial port timeout");
 
         // Send a screenshot request to the host
-        let mut len = serial
+        serial
             .write(b"SCREENSHOT: ")
-            .expect("Failed to send request");
-        assert_eq!(len, 12, "Screenshot request timed out");
+            .expect("Failed to send request")
+            .expect("Request triggered a warning");
         let name_bytes = name.as_bytes();
-        len = serial.write(name_bytes).expect("Failed to send request");
-        assert_eq!(len, name_bytes.len(), "Screenshot request timed out");
-        len = serial.write(b"\n").expect("Failed to send request");
-        assert_eq!(len, 1, "Screenshot request timed out");
+        serial
+            .write(name_bytes)
+            .expect("Failed to send request")
+            .expect("Request triggered a warning");
+        serial
+            .write(b"\n")
+            .expect("Failed to send request")
+            .expect("Request triggered a warning");
 
         // Wait for the host's acknowledgement before moving forward
         let mut reply = [0; 3];
-        let read_size = serial
+        serial
             .read(&mut reply[..])
-            .expect("Failed to read host reply");
-        assert_eq!(read_size, 3, "Screenshot request timed out");
+            .expect("Failed to read host reply")
+            .expect("Request triggered a warning");
+
         assert_eq!(&reply[..], b"OK\n", "Unexpected screenshot request reply");
     } else {
         // Outside of QEMU, give the user some time to inspect the output
@@ -101,7 +111,7 @@ fn shutdown(st: &SystemTable) -> ! {
     use uefi::table::runtime::ResetType;
 
     // Get our text output back.
-    st.stdout().reset(false).unwrap();
+    st.stdout().reset(false).unwrap().unwrap();
 
     // Inform the user, and give him time to read on real hardware
     if cfg!(not(feature = "qemu")) {

uefi-test-runner/src/proto/console/gop.rs

@@ -24,14 +24,16 @@ fn set_graphics_mode(gop: &mut GraphicsOutput) {
     // We know for sure QEMU has a 1024x768, mode.
     let mode = gop
         .modes()
+        .map(|mode| mode.expect("Warnings encountered while querying mode"))
         .find(|ref mode| {
             let info = mode.info();
-
             info.resolution() == (1024, 768)
         })
         .unwrap();
 
-    gop.set_mode(&mode).expect("Failed to set graphics mode");
+    gop.set_mode(&mode)
+        .expect("Failed to set graphics mode")
+        .expect("Warnings encountered while setting graphics mode");
 }
 
 // Fill the screen with color.
@@ -43,7 +45,9 @@ fn fill_color(gop: &mut GraphicsOutput) {
         dims: (1024, 768),
     };
 
-    gop.blt(op).expect("Failed to fill screen with color");
+    gop.blt(op)
+        .expect("Failed to fill screen with color")
+        .expect("Warnings encountered while filling screen with color");
 }
 
 // Draw directly to the frame buffer.

uefi-test-runner/src/proto/console/pointer.rs

@@ -10,11 +10,13 @@ pub fn test(bt: &BootServices) {
 
         pointer
             .reset(false)
-            .expect("Failed to reset pointer device");
+            .expect("Failed to reset pointer device")
+            .expect("Warnings encountered while resetting pointer device");
 
         let state = pointer
             .read_state()
-            .expect("Failed to retrieve pointer state");
+            .expect("Failed to retrieve pointer state")
+            .expect("Warnings encountered while retrieving pointer state");
         if let Some(state) = state {
             info!("New pointer State: {:#?}", state);
         } else {

uefi-test-runner/src/proto/console/serial.rs

@@ -9,7 +9,8 @@ pub fn test(bt: &BootServices) {
 
         let old_ctrl_bits = serial
             .get_control_bits()
-            .expect("Failed to get device control bits");
+            .expect("Failed to get device control bits")
+            .expect("Warnings encountered while getting device control bits");
         let mut ctrl_bits = ControlBits::empty();
 
         // For the purposes of testing, we're _not_ going to implement
@@ -21,30 +22,37 @@ pub fn test(bt: &BootServices) {
 
         serial
             .set_control_bits(ctrl_bits)
-            .expect("Failed to set device control bits");
+            .expect("Failed to set device control bits")
+            .expect("Warnings encountered while setting device control bits");
 
         // Keep this message short, we need it to fit in the FIFO.
-        let output = b"Hello world!";
-        let msg_len = output.len();
+        const OUTPUT: &[u8] = b"Hello world!";
+        const MSG_LEN: usize = OUTPUT.len();
 
         let len = serial
-            .write(output)
-            .expect("Failed to write to serial port");
-        assert_eq!(len, msg_len, "Serial port write timed-out!");
+            .write(OUTPUT)
+            .expect("Failed to write to serial port")
+            .expect("Warnings encountered while writing to serial port");
+        assert_eq!(len, MSG_LEN, "Bad serial port write length");
 
-        let mut input = [0u8; 128];
+        let mut input = [0u8; MSG_LEN];
         let len = serial
             .read(&mut input)
-            .expect("Failed to read from serial port");
-        assert_eq!(len, msg_len, "Serial port read timed-out!");
+            .expect("Failed to read from serial port")
+            .expect("Warnings encountered while reading from serial port");
+        assert_eq!(len, MSG_LEN, "Bad serial port read length");
 
-        assert_eq!(&output[..], &input[..msg_len]);
+        assert_eq!(&OUTPUT[..], &input[..MSG_LEN]);
 
         // Clean up after ourselves
-        serial.reset().expect("Could not reset the serial device");
+        serial
+            .reset()
+            .expect("Could not reset the serial device")
+            .expect("Warnings encountered while resetting serial device");
         serial
             .set_control_bits(old_ctrl_bits & ControlBits::SETTABLE)
-            .expect("Could not restore the serial device state");
+            .expect("Could not restore the serial device state")
+            .expect("Warnings encountered while restoring serial device state");
     } else {
         warn!("No serial device found");
     }

uefi-test-runner/src/proto/console/stdout.rs

@@ -10,48 +10,71 @@ pub fn test(stdout: &mut Output) {
 
     // Print all modes.
     for (index, mode) in stdout.modes().enumerate() {
+        let mode = mode.expect("Warnings encountered while querying text mode");
         info!(
-            "- Graphics mode #{}: {} rows by {} columns",
+            "- Text mode #{}: {} rows by {} columns",
             index,
             mode.rows(),
             mode.columns()
         );
     }
 
     // Should clean up after us.
-    stdout.reset(false).unwrap();
+    stdout.reset(false).unwrap().unwrap();
 }
 
-// Switch to the maximum supported graphics mode.
+// Switch to the maximum supported text mode.
 fn change_text_mode(stdout: &mut Output) {
-    let best_mode = stdout.modes().last().unwrap();
+    let best_mode = stdout
+        .modes()
+        .last()
+        .unwrap()
+        .expect("Warnings encountered while querying text mode");;
     stdout
         .set_mode(best_mode)
-        .expect("Failed to change graphics mode");
+        .expect("Failed to change text mode")
+        .expect("Warnings encountered while changing text mode");
 }
 
 // Set a new color, and paint the background with it.
 fn change_color(stdout: &mut Output) {
     stdout
         .set_color(Color::White, Color::Blue)
-        .expect("Failed to change console color");
-    stdout.clear().expect("Failed to clear screen");
+        .expect("Failed to change console color")
+        .expect("Warnings encountered while changing console color");
+    stdout
+        .clear()
+        .expect("Failed to clear screen")
+        .expect("Warnings encountered while clearing screen");
 }
 
 // Print a text centered on screen.
 fn center_text(stdout: &mut Output) {
     // Move the cursor.
     // This will make this `info!` line below be (somewhat) centered.
-    stdout.enable_cursor(true).unwrap_or_else(|s| match s {
-        Status::UNSUPPORTED => info!("Cursor visibility control unavailable"),
-        _ => panic!("Failed to show cursor"),
-    });
+    stdout
+        .enable_cursor(true)
+        .unwrap_or_else(|s| {
+            match s {
+                Status::UNSUPPORTED => info!("Cursor visibility control unavailable"),
+                _ => panic!("Failed to show cursor"),
+            }
+            .into()
+        })
+        .expect("Warnings encountered while enabling cursor");
     stdout
         .set_cursor_position(24, 0)
-        .expect("Failed to move cursor");
+        .expect("Failed to move cursor")
+        .expect("Warnings encountered while moving cursor");
     info!("# uefi-rs test runner");
-    stdout.enable_cursor(false).unwrap_or_else(|s| match s {
-        Status::UNSUPPORTED => info!("Cursor visibility control unavailable"),
-        _ => panic!("Failed to hide cursor"),
-    });
+    stdout
+        .enable_cursor(false)
+        .unwrap_or_else(|s| {
+            match s {
+                Status::UNSUPPORTED => info!("Cursor visibility control unavailable"),
+                _ => panic!("Failed to hide cursor"),
+            }
+            .into()
+        })
+        .expect("Warnings encountered while enabling cursor");
 }

uefi-test-runner/src/proto/mod.rs

@@ -19,7 +19,8 @@ fn find_protocol(bt: &BootServices) {
 
     let handles = bt
         .find_handles::<SearchedProtocol>()
-        .expect("Failed to retrieve list of handles");
+        .expect("Failed to retrieve list of handles")
+        .expect("Warnings encountered while retrieving list of handles");
     assert!(
         handles.len() > 1,
         "There should be at least one implementation of Simple Text Output (stdout)"