Struct OwnedHandle 

pub struct OwnedHandle<'a, T> { /* private fields */ }

An owned handle to a Source or Sink.

It’s common to want an object which owns a type implementing Read or Write. But for testing purposes, the object under test can’t consume the mock, as we might want to verify some expectations on it afterwards. To get around this, an OwnedHandle can be taken from a Source or Sink, which also implements the underlying traits but only contains a mutable reference to the underlying mock.

Once the object under test is dropped, the mock object itself still exists and can be used to verify any expectations.

Example

use embedded_io::Write;

struct MySerialProtocol<T: embedded_io::Write> {
    serial: T,
}

impl<T: embedded_io::Write> MySerialProtocol<T> {
    fn hello(&mut self) -> Result<(), T::Error> {
        self.serial.write_all("hello".as_bytes())
    }
}

let mut mock_sink = Sink::new().accept_data(64);

// MySerialProtocol requires an owned `serial` type here
let mut my_protocol = MySerialProtocol {
    serial: mock_sink.owned_handle(),
};

let res = my_protocol.hello();
assert!(res.is_ok());

// Because we constructed `my_protocol` with an `OwnedHandle`, we still have access to the
// original `mock_sink` here to verify that the correct bytes were written.
let written = mock_sink.into_inner_data();
assert_eq!(written, "hello".as_bytes());

Trait Implementations

impl<'a, T: Debug> Debug for OwnedHandle<'a, T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T: ErrorType> ErrorType for OwnedHandle<'_, T>

type Error = <T as ErrorType>::Error

Error type of all the IO operations on this type.

impl<T: Read> Read for OwnedHandle<'_, T>

fn read(&mut self, buf: &mut [u8]) -> Result<usize, Self::Error>

Read some bytes from this source into the specified buffer, returning how many bytes were read.

fn read_exact( &mut self, buf: &mut [u8], ) -> Result<(), ReadExactError<Self::Error>>

Read the exact number of bytes required to fill buf.

impl<T: Read> Read for OwnedHandle<'_, T>

async fn read(&mut self, buf: &mut [u8]) -> Result<usize, Self::Error>

Read some bytes from this source into the specified buffer, returning how many bytes were read.

async fn read_exact( &mut self, buf: &mut [u8], ) -> Result<(), ReadExactError<Self::Error>>

Read the exact number of bytes required to fill buf.

impl<T: Write> Write for OwnedHandle<'_, T>

fn write(&mut self, buf: &[u8]) -> Result<usize, Self::Error>

Write a buffer into this writer, returning how many bytes were written.

fn flush(&mut self) -> Result<(), Self::Error>

Flush this output stream, blocking until all intermediately buffered contents reach their destination.

fn write_all(&mut self, buf: &[u8]) -> Result<(), Self::Error>

Write an entire buffer into this writer.

fn write_fmt( &mut self, fmt: Arguments<'_>, ) -> Result<(), WriteFmtError<Self::Error>>

Write a formatted string into this writer, returning any error encountered.

impl<T: Write> Write for OwnedHandle<'_, T>

async fn write(&mut self, buf: &[u8]) -> Result<usize, Self::Error>

Write a buffer into this writer, returning how many bytes were written.

async fn flush(&mut self) -> Result<(), Self::Error>

Flush this output stream, ensuring that all intermediately buffered contents reach their destination.

async fn write_all(&mut self, buf: &[u8]) -> Result<(), Self::Error>

Write an entire buffer into this writer.