SQUASHME: Fix tests

Fix doc tests, e2e tests, and fuzz tests. This entails:
* Using the new `manticore::Result` in tests
* Allow error helper macros to be called from external crates (e.g. the
  e2e crate) and use them to generate errors where needed

Author: kesyog

e2e/src/support/rot.rs

@@ -29,6 +29,7 @@ use manticore::protocol::spdm;
 use manticore::server;
 use manticore::server::pa_rot::PaRot;
 use manticore::session::ring::Session;
+use manticore::Result;
 
 use crate::support::fakes;
 use crate::support::tcp;

e2e/src/support/tcp.rs

@@ -47,6 +47,8 @@ use manticore::protocol::wire::WireEnum;
 use manticore::protocol::Command;
 use manticore::protocol::Message;
 use manticore::server;
+use manticore::Result;
+use manticore::{check, fail};
 
 /// Sends `req` to a virtual RoT listening on `localhost:{port}`, using
 /// Cerberus-over-TCP.
@@ -84,7 +86,7 @@ pub fn send_cerberus<
         Ok(Ok(FromWire::from_wire(&mut r, arena)?))
     } else if header.command == cerberus::CommandType::Error {
         log::info!("deserializing {}", type_name::<protocol::Error<'a, Cmd>>());
-        Ok(Err(FromWire::from_wire(&mut r, arena)?))
+        Ok(Err(fail!(FromWire::from_wire(&mut r, arena)?)))
     } else {
         Err(net::Error::BadHeader.into())
     }
@@ -125,7 +127,7 @@ pub fn send_spdm<'a, Cmd: Command<'a, CommandType = spdm::CommandType>>(
         Ok(Ok(FromWire::from_wire(&mut r, arena)?))
     } else if header.command == spdm::CommandType::Error {
         log::info!("deserializing {}", type_name::<protocol::Error<'a, Cmd>>());
-        Ok(Err(FromWire::from_wire(&mut r, arena)?))
+        Ok(Err(fail!(FromWire::from_wire(&mut r, arena)?)))
     } else {
         Err(net::Error::BadHeader.into())
     }
@@ -140,7 +142,7 @@ impl io::Read for TcpReader {
     fn read_bytes(&mut self, out: &mut [u8]) -> Result<(), io::Error> {
         let Self { tcp, len } = self;
         if *len < out.len() {
-            return Err(io::Error::BufferExhausted);
+            return Err(fail!(io::Error::BufferExhausted));
         }
         tcp.read_exact(out).map_err(|e| {
             log::error!("{}", e);
@@ -365,22 +367,22 @@ impl<'req, H: Header + 'req> HostRequest<'req, H> for Inner<H> {
     fn header(&self) -> Result<H, net::Error> {
         if self.output_buffer.is_some() {
             log::error!("header() called out-of-order");
-            return Err(net::Error::OutOfOrder);
+            return Err(fail!(net::Error::OutOfOrder));
         }
         self.stream
             .as_ref()
             .map(|(h, _, _)| *h)
-            .ok_or(net::Error::Disconnected)
+            .ok_or_else(|| fail!(net::Error::Disconnected))
     }
 
     fn payload(&mut self) -> Result<&mut dyn io::ReadZero<'req>, net::Error> {
         if self.stream.is_none() {
             log::error!("payload() called out-of-order");
-            return Err(net::Error::Disconnected);
+            return Err(fail!(net::Error::Disconnected));
         }
         if self.output_buffer.is_some() {
             log::error!("payload() called out-of-order");
-            return Err(net::Error::OutOfOrder);
+            return Err(fail!(net::Error::OutOfOrder));
         }
 
         Ok(self)
@@ -392,11 +394,11 @@ impl<'req, H: Header + 'req> HostRequest<'req, H> for Inner<H> {
     ) -> Result<&mut dyn HostResponse<'req>, net::Error> {
         if self.stream.is_none() {
             log::error!("payload() called out-of-order");
-            return Err(net::Error::Disconnected);
+            return Err(fail!(net::Error::Disconnected));
         }
         if self.output_buffer.is_some() {
             log::error!("payload() called out-of-order");
-            return Err(net::Error::OutOfOrder);
+            return Err(fail!(net::Error::OutOfOrder));
         }
 
         self.output_buffer = Some(Writer::new(header));
@@ -408,13 +410,13 @@ impl<'req, H: Header + 'req> HostResponse<'req> for Inner<H> {
     fn sink(&mut self) -> Result<&mut dyn io::Write, net::Error> {
         if self.stream.is_none() {
             log::error!("sink() called out-of-order");
-            return Err(net::Error::Disconnected);
+            return Err(fail!(net::Error::Disconnected));
         }
 
         self.output_buffer
             .as_mut()
             .map(|w| w as &mut dyn io::Write)
-            .ok_or(net::Error::OutOfOrder)
+            .ok_or_else(|| fail!(net::Error::OutOfOrder))
     }
 
     fn finish(&mut self) -> Result<(), net::Error> {
@@ -434,7 +436,7 @@ impl<'req, H: Header + 'req> HostResponse<'req> for Inner<H> {
                 self.output_buffer = None;
                 Ok(())
             }
-            _ => Err(net::Error::Disconnected),
+            _ => Err(fail!(net::Error::Disconnected)),
         }
     }
 }
@@ -443,9 +445,7 @@ impl<H> io::Read for Inner<H> {
     fn read_bytes(&mut self, out: &mut [u8]) -> Result<(), io::Error> {
         let (_, len, stream) =
             self.stream.as_mut().ok_or(io::Error::Internal)?;
-        if *len < out.len() {
-            return Err(io::Error::BufferExhausted);
-        }
+        check!(*len >= out.len(), io::Error::BufferExhausted);
         stream.read_exact(out).map_err(|e| {
             log::error!("{}", e);
             io::Error::Internal

fuzz/targets/x509_unsigned.rs

@@ -13,16 +13,13 @@ use manticore::cert::Cert;
 use manticore::cert::CertFormat;
 use manticore::crypto::sig;
 use manticore::protocol::cerberus::capabilities;
+use manticore::Result;
 
 /// A `Ciphers` that blindly accepts all signatures.
 struct NoVerify;
 
 impl sig::Verify for NoVerify {
-    fn verify(
-        &mut self,
-        _: &[&[u8]],
-        _: &[u8],
-    ) -> Result<(), sig::Error> {
+    fn verify(&mut self, _: &[&[u8]], _: &[u8]) -> Result<(), sig::Error> {
         Ok(())
     }
 }
@@ -39,12 +36,7 @@ impl sig::Ciphers for NoVerify {
 }
 
 fuzz_target!(|data: &[u8]| {
-    let _ = Cert::parse(
-        data,
-        CertFormat::RiotX509,
-        None,
-        &mut NoVerify,
-    );
+    let _ = Cert::parse(data, CertFormat::RiotX509, None, &mut NoVerify);
 
     // NOTE: we might actually succeed at creating a valid cert, so we can't
     // check for is_err() here.

src/debug.rs

@@ -198,11 +198,12 @@ macro_rules! debug_from {
 ///
 /// If the condition does not hold, constructs the given error, logs it, and
 /// returns out of the current function with it.
+#[macro_export]
 macro_rules! check {
     ($cond:expr, $error:expr) => {
         if !$cond {
             let error = $error;
-            return Err(fail!(
+            return Err($crate::fail!(
                 error,
                 "check failure: `{}`; returned {:?}",
                 stringify!($cond),
@@ -218,19 +219,21 @@ macro_rules! check {
 ///
 /// For example, instead of writing `foo.ok_or(MyError)`, instead write
 /// `foo.ok_or_else(|| fail!(MyError))`.
+#[macro_export]
 macro_rules! fail {
     ($error:expr, $($format:tt)+) => {{
-        error!($($format)+);
-        $crate::debug::Error::__new($error)
+        $crate::error!($($format)+);
+        $crate::Error::__new($error)
     }};
     ($error:expr) => {{
         let error = $error;
-        error!("generated error: `{:?}`", error);
-        $crate::debug::Error::__new(error)
+        $crate::error!("generated error: `{:?}`", error);
+        $crate::Error::__new(error)
     }};
 }
 
 /// Redactable version of [`log::trace!()`].
+#[macro_export]
 macro_rules! trace {
     ($($args:tt)*) => {
         #[cfg(feature = "log")]
@@ -239,6 +242,7 @@ macro_rules! trace {
 }
 
 /// Redactable version of [`log::info!()`].
+#[macro_export]
 macro_rules! info {
     ($($args:tt)*) => {
         #[cfg(feature = "log")]
@@ -247,6 +251,7 @@ macro_rules! info {
 }
 
 /// Redactable version of [`log::warn!()`].
+#[macro_export]
 macro_rules! warn {
     ($($args:tt)*) => {
         #[cfg(feature = "log")]
@@ -255,6 +260,7 @@ macro_rules! warn {
 }
 
 /// Redactable version of [`log::error!()`].
+#[macro_export]
 macro_rules! error {
     ($($args:tt)*) => {
         #[cfg(feature = "log")]

src/hardware/flash.rs

@@ -96,8 +96,9 @@ pub unsafe trait Flash {
     /// the following should be a sufficient starting point:
     /// ```
     /// # use core::alloc::Layout;
-    /// # use manticore::mem::*;
+    /// # use manticore::Result;
     /// # use manticore::hardware::flash::*;
+    /// # use manticore::mem::*;
     /// # struct Foo;
     /// # impl Foo {
     /// # fn read(&self, offset: u32, out: &mut [u8]) -> Result<(), Error> {

src/io/cursor.rs

@@ -13,6 +13,7 @@
 //! buffer was read or written. This is especialy useful when used in
 //! conjunction with [`ToWire`]:
 //! ```
+//! # use manticore::Result;
 //! # use manticore::io::*;
 //! # use manticore::protocol::wire::{self, *};
 //! # struct MyMessage;
@@ -119,7 +120,7 @@ impl<'a> Cursor<'a> {
     /// cursor.seek(SeekPos::Abs(mark))?;
     /// assert_eq!(cursor.consumed_bytes(), b"bfooar");
     ///
-    /// # Ok::<(), Error>(())
+    /// # Ok::<(), manticore::Error<Error>>(())
     /// ```
     pub fn seek(&mut self, pos: SeekPos) -> Result<(), io::Error> {
         let offset = match pos {

src/mem/arena.rs

@@ -207,7 +207,7 @@ impl<'arena, A: Arena + ?Sized> ArenaExt<'arena> for &'arena A {
 /// arena.reset();
 /// let buf3 = arena.alloc_slice::<u8>(64)?;
 /// assert_eq!(buf3.len(), 64);
-/// # Ok::<(), OutOfMemory>(())
+/// # Ok::<(), manticore::Error<OutOfMemory>>(())
 /// ```
 ///
 /// Note that `BumpArena`'s interface protects callers from mistakedly

src/net/host.rs

@@ -26,6 +26,7 @@ use crate::Result;
 /// `HostPort` uses the traits [`HostRequest`] and [`HostResponse`] to describe
 /// a generic state machine, where a request is processed and replied to.
 /// ```
+/// # use manticore::Result;
 /// # use manticore::net::{*, host::*};
 /// fn process_request<'req, Header>(port: &mut impl HostPort<'req, Header>) -> Result<(), Error> {
 ///     let req = port.receive()?;
@@ -198,7 +199,7 @@ pub trait HostResponse<'req> {
 ///     &mut resp_bytes, &arena
 /// ).unwrap();
 /// assert_eq!(resp.version, &[0xba; 32]);
-/// # Ok::<(), manticore::net::Error>(())
+/// # Ok::<(), manticore::Error<manticore::net::Error>>(())
 /// ```
 pub struct InMemHost<'buf, Header>(InMemInner<'buf, Header>);