IO implementation for embedded-io

Cargo.toml

@@ -22,10 +22,10 @@ rust-version = "1.63"
 
 [features]
 eh0 = ["dep:eh0", "dep:nb"]
-eh1 = ["dep:eh1", "dep:embedded-hal-nb"]
+eh1 = ["dep:eh1", "dep:embedded-hal-nb", "dep:embedded-io"]
 
 embedded-time = ["dep:embedded-time", "dep:void"]
-embedded-hal-async = ["dep:embedded-hal-async"]
+embedded-hal-async = ["dep:embedded-hal-async", "dep:embedded-io-async"]
 
 default = ["eh0", "eh1", "embedded-time"]
 
@@ -35,6 +35,8 @@ eh1 = { package = "embedded-hal", version = "1.0", optional = true }
 embedded-hal-nb = { version = "1.0", optional = true }
 embedded-hal-async = { version = "1.0", optional = true }
 embedded-time = { version = "0.12", optional = true }
+embedded-io = { version = "0.6.1", optional = true }
+embedded-io-async = { version = "0.6.1", optional = true }
 nb = { version = "1.1", optional = true }
 void = { version = "^1.0", optional = true }
 

src/common.rs

@@ -20,26 +20,32 @@ use std::{
 /// Note that the implementation uses an `Arc<Mutex<...>>` internally, so a
 /// cloned instance of the mock can be used to check the expectations of the
 /// original instance that has been moved into a driver.
+///
+/// Optional Data type allows for storage of arbitrary state data in mocks.
+/// Mock data can be accessed via appropriate getter/setter methods, i.e. `mock_data()` and `set_mock_data()`.
+///
 #[derive(Debug, Clone)]
-pub struct Generic<T: Clone + Debug + PartialEq> {
+pub struct Generic<T: Clone + Debug + PartialEq, Data = ()> {
     expected: Arc<Mutex<VecDeque<T>>>,
     done_called: Arc<Mutex<DoneCallDetector>>,
+    mock_data: Option<Data>,
 }
 
-impl<'a, T: 'a> Generic<T>
+impl<'a, T: 'a, Data> Generic<T, Data>
 where
     T: Clone + Debug + PartialEq,
 {
     /// Create a new mock interface
     ///
     /// This creates a new generic mock interface with initial expectations
-    pub fn new<E>(expected: E) -> Generic<T>
+    pub fn new<E>(expected: E) -> Generic<T, Data>
     where
         E: IntoIterator<Item = &'a T>,
     {
         let mut g = Generic {
             expected: Arc::new(Mutex::new(VecDeque::new())),
             done_called: Arc::new(Mutex::new(DoneCallDetector::new())),
+            mock_data: None,
         };
 
         g.update_expectations(expected);
@@ -99,10 +105,20 @@ where
         let e = self.expected.lock().unwrap();
         assert!(e.is_empty(), "Not all expectations consumed");
     }
+
+    /// Get the mock data
+    pub fn mock_data(&self) -> &Option<Data> {
+        &self.mock_data
+    }
+
+    /// Set the mock data
+    pub fn set_mock_data(&mut self, data: Option<Data>) {
+        self.mock_data = data;
+    }
 }
 
 /// Iterator impl for use in mock impls
-impl<T> Iterator for Generic<T>
+impl<T, Data> Iterator for Generic<T, Data>
 where
     T: Clone + Debug + PartialEq,
 {

src/eh1.rs

@@ -9,6 +9,7 @@ pub use crate::eh1::error::MockError;
 
 pub mod delay;
 pub mod i2c;
+pub mod io;
 pub mod pin;
 pub mod pwm;
 pub mod serial;