transactional-spi.rs

extern crate embedded_hal;
use embedded_hal::blocking::spi::{Write, Transfer};

extern crate embedded_hal_mock;
use embedded_hal_mock::MockError;
use embedded_hal_mock::spi::{Mock as SpiMock, Transaction as SpiTransaction};

enum Operation<'a> {
    Write(&'a [u8]),
    Transfer(&'a mut[u8]),
    Handle(&'a Fn(&Option<&[u8]>) -> bool)
}

trait Transactional {
    type Error;
    fn transaction(&mut self, transaction: &mut [Operation])-> Result<(), Self::Error>;
}

impl Transactional for SpiMock {
    type Error = MockError;

    fn transaction<'a>(&mut self, transaction: &mut [Operation]) -> Result<(), Self::Error>{
        println!("Starting transaction");

        let mut last = None;
        for o in transaction {
            last = match o {
                Operation::Write(ref w) => { self.write(w)?; None },
                Operation::Transfer(ref mut d) => Some(self.transfer(d)?),
                Operation::Handle(ref mut f) => { 
                    if f(&last) {
                        break;
                    }
                    None
                }
            };
        }

        println!("Finalising transaction");
        Ok(())
    }
}


#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn it_works() {
        let mut m = SpiMock::new();
         m.expect(vec![
            SpiTransaction::write(vec![0xde, 0xad]),
            SpiTransaction::transfer(vec![0u8; 2], vec![1u8; 2]),
        ]);

        let mut values = vec![0u8; 2];
        m.transaction(&mut [
            Operation::Write(&[0xde, 0xad]),
            Operation::Transfer(&mut values),
            Operation::Handle(&|d: &Option<&[u8]>| { d.unwrap()[0] != 0 }),
            Operation::Write(&[0xde, 0xad]),
        ]).unwrap();

        assert_eq!(2 + 2, 4);

        m.done();
    }
}

Neat! What does "Handle()" allow here?