Struct futures_ringbuf::Sketchy

pub struct Sketchy<T> { /* fields omitted */ }

A wrapper for any type that implements AsyncRead/AsyncWrite, that will randomly return pending and reschedule or only process partial buffers. This helps with testing consumers of these interfaces on in memory objects like a mock network connection created with Endpoint which would otherwise always be ready. This simulates a more random behavior you might observe on a real network connection.

The randomness is based on a seed, so that you can reproduce failing tests. In order be reproducible, your test should be deterministic. In general avoid spawning and executor schedulers, prefer join! from the futures library to run parts of your test concurrently.

Example

#[test]
//
fn my_test()
{
   // Make sure to log for failing tests, so you can rerun with the same seed.
   // futures-ringbuf will log any decisions made by `Sketchy` and will log the
   // seed.
   //
   let _ = flexi_logger::Logger::with_str( "trace" ).start();

   // Since we want to test a random combination of events (pending, partial buffer fills, normal behavior)
   // let's run this several times.
   //
   for _ in 0..500
   {
      let seed = Dictator::seed();
      let (server, client) = Endpoint::pair( 64, 64 );
      let server = Sketchy::new( server, seed );
      let client = Sketchy::new( client, seed );


      // now use AsyncRead/AsyncWrite on server and client to test your code,
      // eg. a codec implementation.
   }
}

Implementations

impl<T> Sketchy<T>

pub fn new(inner: T, seed: u64) -> Self

Create a new wrapper with random behavior based on seed.

Trait Implementations

impl<T> AsyncRead for Sketchy<T> where
    T: AsyncRead + Unpin, 

fn poll_read(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>,
    buf: &mut [u8]
) -> Poll<Result<usize, Error>>

About one third of the time, this will return pending and reschedule the waker, one third will only pass a partial buffer to the wrapped type and one third will just forward the call unmodified.

fn poll_read_vectored(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>,
    bufs: &mut [IoSliceMut<'_>]
) -> Poll<Result<usize, Error>>

Attempt to read from the AsyncRead into bufs using vectored IO operations.

impl<T> AsyncWrite for Sketchy<T> where
    T: AsyncWrite + Unpin, 

fn poll_write(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>,
    buf: &[u8]
) -> Poll<Result<usize>>

Attempt to write bytes from buf into the object.

fn poll_flush(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<()>>

Attempt to flush the object, ensuring that any buffered data reach their destination.

fn poll_close(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<()>>

Attempt to close the object.

fn poll_write_vectored(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>,
    bufs: &[IoSlice<'_>]
) -> Poll<Result<usize, Error>>

Attempt to write bytes from bufs into the object using vectored IO operations.

impl<T: Debug> Debug for Sketchy<T>

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

Formats the value using the given formatter.