Update alpha branch to embedded-hal 1.0.0-alpha.8

* Added `TransactionStart`/`TransactionEnd` markers for the new transaction methods
* ADC traits were removed in rust-embedded/embedded-hal#376

Author: Mousius

Cargo.toml

@@ -21,11 +21,5 @@ edition = "2021"
 rust-version = "1.60"
 
 [dependencies]
-embedded-hal = "=1.0.0-alpha.6"
-embedded-time = { version = "0.12", optional = true }
-void = { version = "^1.0", optional = true }
+embedded-hal = "=1.0.0-alpha.8"
 nb = "0.1.1"
-
-[features]
-default = ["embedded-time"]
-embedded-time = ["dep:embedded-time", "dep:void"]

src/i2c.rs

@@ -7,7 +7,8 @@
 //! extern crate embedded_hal_mock;
 //!
 //! use embedded_hal::i2c::ErrorKind;
-//! use embedded_hal::i2c::blocking::{Read, Write, WriteRead};
+//! use embedded_hal::i2c::blocking::I2c;
+//! use embedded_hal::i2c::blocking::Operation;
 //! use embedded_hal_mock::i2c::{Mock as I2cMock, Transaction as I2cTransaction};
 //!
 //! // Configure expectations
@@ -46,7 +47,7 @@
 //! ```
 //! # extern crate embedded_hal;
 //! # extern crate embedded_hal_mock;
-//! # use embedded_hal::i2c::blocking::{Read, Write, WriteRead};
+//! # use embedded_hal::i2c::blocking::I2c;
 //! # use embedded_hal::i2c::ErrorKind;
 //! # use embedded_hal_mock::i2c::{Mock as I2cMock, Transaction as I2cTransaction};
 //!
@@ -71,6 +72,7 @@
 
 use embedded_hal::i2c::blocking as i2c;
 use embedded_hal::i2c::ErrorKind;
+use embedded_hal::i2c::ErrorType;
 
 use crate::common::Generic;
 
@@ -83,6 +85,10 @@ pub enum Mode {
     Read,
     /// Write and read transaction
     WriteRead,
+    /// Mark the start of a transaction
+    TransactionStart,
+    /// Mark the end of a transaction
+    TransactionEnd,
 }
 
 /// I2C Transaction type
@@ -135,6 +141,28 @@ impl Transaction {
         }
     }
 
+    /// Create nested transactions
+    pub fn transaction_start(addr: u8) -> Transaction {
+        Transaction {
+            expected_mode: Mode::TransactionStart,
+            expected_addr: addr,
+            expected_data: Vec::new(),
+            response_data: Vec::new(),
+            expected_err: None,
+        }
+    }
+
+    /// Create nested transactions
+    pub fn transaction_end(addr: u8) -> Transaction {
+        Transaction {
+            expected_mode: Mode::TransactionEnd,
+            expected_addr: addr,
+            expected_data: Vec::new(),
+            response_data: Vec::new(),
+            expected_err: None,
+        }
+    }
+
     /// Add an error return to a transaction
     ///
     /// This is used to mock failure behaviours.
@@ -153,9 +181,11 @@ impl Transaction {
 /// Mismatches between expectations will cause runtime assertions to assist in locating the source of the fault.
 pub type Mock = Generic<Transaction>;
 
-impl i2c::Read for Mock {
+impl ErrorType for Mock {
     type Error = ErrorKind;
+}
 
+impl i2c::I2c for Mock {
     fn read(&mut self, address: u8, buffer: &mut [u8]) -> Result<(), Self::Error> {
         let e = self
             .next()
@@ -178,10 +208,6 @@ impl i2c::Read for Mock {
             }
         }
     }
-}
-
-impl i2c::Write for Mock {
-    type Error = ErrorKind;
 
     fn write(&mut self, address: u8, bytes: &[u8]) -> Result<(), Self::Error> {
         let e = self
@@ -200,10 +226,31 @@ impl i2c::Write for Mock {
             None => Ok(()),
         }
     }
-}
 
-impl i2c::WriteRead for Mock {
-    type Error = ErrorKind;
+    fn write_iter<B>(&mut self, address: u8, bytes: B) -> Result<(), Self::Error>
+    where
+        B: IntoIterator<Item = u8>,
+    {
+        let w = self
+            .next()
+            .expect("no pending expectation for i2c::write call");
+
+        assert_eq!(
+            w.expected_mode,
+            Mode::Write,
+            "i2c::write_iter unexpected mode"
+        );
+        assert_eq!(w.expected_addr, address, "i2c::write_iter address mismatch");
+        assert!(
+            bytes.into_iter().eq(w.expected_data),
+            "i2c::write_iter data does not match expectation"
+        );
+
+        match w.expected_err {
+            Some(err) => Err(err),
+            None => Ok(()),
+        }
+    }
 
     fn write_read(
         &mut self,
@@ -240,10 +287,6 @@ impl i2c::WriteRead for Mock {
             }
         }
     }
-}
-
-impl i2c::WriteIterRead for Mock {
-    type Error = ErrorKind;
 
     fn write_iter_read<B>(
         &mut self,
@@ -254,24 +297,108 @@ impl i2c::WriteIterRead for Mock {
     where
         B: IntoIterator<Item = u8>,
     {
-        // Just collect the bytes and pass them on to the WriteRead::write_read implementation
-        use embedded_hal::i2c::blocking::WriteRead;
-        let bytes: Vec<_> = bytes.into_iter().collect();
-        self.write_read(address, bytes.as_slice(), buffer)
+        let w = self
+            .next()
+            .expect("no pending expectation for i2c::write_read call");
+
+        assert_eq!(
+            w.expected_mode,
+            Mode::WriteRead,
+            "i2c::write_iter_read unexpected mode"
+        );
+        assert_eq!(
+            w.expected_addr, address,
+            "i2c::write_iter_read address mismatch"
+        );
+        assert!(
+            bytes.into_iter().eq(w.expected_data),
+            "i2c::write_iter_read write data does not match expectation"
+        );
+
+        assert_eq!(
+            buffer.len(),
+            w.response_data.len(),
+            "i2c::write_iter_read mismatched response length"
+        );
+
+        match w.expected_err {
+            Some(err) => Err(err),
+            None => {
+                buffer.copy_from_slice(&w.response_data);
+                Ok(())
+            }
+        }
     }
-}
 
-impl i2c::WriteIter for Mock {
-    type Error = ErrorKind;
+    fn transaction<'a>(
+        &mut self,
+        address: u8,
+        operations: &mut [i2c::Operation<'a>],
+    ) -> Result<(), Self::Error> {
+        let w = self
+            .next()
+            .expect("no pending expectation for i2c::transaction call");
 
-    fn write_iter<B>(&mut self, address: u8, bytes: B) -> Result<(), Self::Error>
+        assert_eq!(
+            w.expected_mode,
+            Mode::TransactionStart,
+            "i2c::transaction_start unexpected mode"
+        );
+
+        for op in operations {
+            match op {
+                i2c::Operation::Read(r) => self.read(address, r),
+                i2c::Operation::Write(w) => self.write(address, w),
+            }
+            .unwrap();
+        }
+
+        let w = self
+            .next()
+            .expect("no pending expectation for i2c::transaction call");
+
+        assert_eq!(
+            w.expected_mode,
+            Mode::TransactionEnd,
+            "i2c::transaction_end unexpected mode"
+        );
+
+        Ok(())
+    }
+
+    fn transaction_iter<'a, O>(&mut self, address: u8, operations: O) -> Result<(), Self::Error>
     where
-        B: IntoIterator<Item = u8>,
+        O: IntoIterator<Item = i2c::Operation<'a>>,
     {
-        // Just collect the bytes and pass them on to the Write::write implementation
-        use embedded_hal::i2c::blocking::Write;
-        let bytes: Vec<_> = bytes.into_iter().collect();
-        Write::write(self, address, bytes.as_slice())
+        let w = self
+            .next()
+            .expect("no pending expectation for i2c::transaction call");
+
+        assert_eq!(
+            w.expected_mode,
+            Mode::TransactionStart,
+            "i2c::transaction_start unexpected mode"
+        );
+
+        for op in operations {
+            match op {
+                i2c::Operation::Read(r) => self.read(address, r),
+                i2c::Operation::Write(w) => self.write(address, w),
+            }
+            .unwrap();
+        }
+
+        let w = self
+            .next()
+            .expect("no pending expectation for i2c::transaction call");
+
+        assert_eq!(
+            w.expected_mode,
+            Mode::TransactionEnd,
+            "i2c::transaction_end unexpected mode"
+        );
+
+        Ok(())
     }
 }
 
@@ -281,7 +408,7 @@ mod test {
 
     use std::time::SystemTime;
 
-    use embedded_hal::i2c::blocking::{Read, Write, WriteRead};
+    use embedded_hal::i2c::blocking::I2c;
 
     #[test]
     fn write() {
@@ -293,6 +420,16 @@ mod test {
         i2c.done();
     }
 
+    #[test]
+    fn write_iter() {
+        let expectations = [Transaction::write(0xaa, vec![10, 12])];
+        let mut i2c = Mock::new(&expectations);
+
+        i2c.write_iter(0xaa, vec![10, 12]).unwrap();
+
+        i2c.done();
+    }
+
     #[test]
     fn read() {
         let expectations = [Transaction::read(0xaa, vec![1, 2])];
@@ -318,6 +455,19 @@ mod test {
         i2c.done();
     }
 
+    #[test]
+    fn write_iter_read() {
+        let expectations = [Transaction::write_read(0xaa, vec![1, 2], vec![3, 4])];
+        let mut i2c = Mock::new(&expectations);
+
+        let v = vec![1, 2];
+        let mut buff = vec![0u8; 2];
+        i2c.write_iter_read(0xaa, v, &mut buff).unwrap();
+        assert_eq!(vec![3, 4], buff);
+
+        i2c.done();
+    }
+
     #[test]
     fn multiple_transactions() {
         let expectations = [
@@ -336,6 +486,56 @@ mod test {
         i2c.done();
     }
 
+    #[test]
+    fn test_i2c_mock_multiple_transaction() {
+        let expectations = [
+            Transaction::transaction_start(0xaa),
+            Transaction::write(0xaa, vec![1, 2]),
+            Transaction::read(0xaa, vec![3, 4]),
+            Transaction::transaction_end(0xaa),
+        ];
+        let mut i2c = Mock::new(&expectations);
+
+        let mut v = vec![0u8; 2];
+        i2c.transaction(
+            0xaa,
+            &mut [
+                i2c::Operation::Write(&vec![1, 2]),
+                i2c::Operation::Read(&mut v),
+            ],
+        )
+        .unwrap();
+
+        assert_eq!(v, vec![3, 4]);
+
+        i2c.done();
+    }
+
+    #[test]
+    fn test_i2c_mock_multiple_transaction_iter() {
+        let expectations = [
+            Transaction::transaction_start(0xaa),
+            Transaction::write(0xaa, vec![1, 2]),
+            Transaction::read(0xaa, vec![3, 4]),
+            Transaction::transaction_end(0xaa),
+        ];
+        let mut i2c = Mock::new(&expectations);
+
+        let mut v = vec![0u8; 2];
+        i2c.transaction_iter(
+            0xaa,
+            [
+                i2c::Operation::Write(&vec![1, 2]),
+                i2c::Operation::Read(&mut v),
+            ],
+        )
+        .unwrap();
+
+        assert_eq!(v, vec![3, 4]);
+
+        i2c.done();
+    }
+
     #[test]
     #[should_panic]
     fn write_data_mismatch() {

src/lib.rs

@@ -26,12 +26,9 @@
 mod error;
 pub use crate::error::MockError;
 
-pub mod adc;
 pub mod common;
 pub mod delay;
 pub mod i2c;
 pub mod pin;
 pub mod serial;
 pub mod spi;
-#[cfg(feature = "embedded-time")]
-pub mod timer;