wookie 0.3.2

Async test/bench toolkit including single stepping executors. No-std compatible.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105

use core::future::Future;
use core::mem::ManuallyDrop;
use core::pin::Pin;
use core::task::{Context, Poll};
use dummy_waker::dummy_waker;

/// A single-stepping executor whose waker does absolutely nothing,
/// but quite quickly.
///
/// ## Example
///
/// ```
/// use core::task::Poll;
/// use wookie::dummy;
/// dummy!(future: async { true });
/// assert_eq!(future.poll(), Poll::Ready(true));
/// ```
#[repr(transparent)]
pub struct Dummy<F>(F);

impl<F: Future> Dummy<F> {
    #[doc(hidden)]
    #[inline(always)]
    pub fn new(future: F) -> Self{ Dummy(future) }

    /// Polls the contained future once.
    ///
    /// ## Example
    ///
    /// ```
    /// use core::task::Poll;
    /// use wookie::dummy;
    /// dummy!(future: async { true });
    /// assert_eq!(future.poll(), Poll::Ready(true)); 
    /// ```
    #[inline(always)]
    pub fn poll(
        self: &mut Pin<&mut Self>
    ) -> Poll<<F as Future>::Output> {
        let this = self.as_mut().project();
        let waker = ManuallyDrop::new(dummy_waker());
        let future = unsafe { Pin::new_unchecked(&mut this.0) };
        let mut ctx = Context::from_waker(&waker);
        Future::poll(future, &mut ctx)
    }

    #[inline(always)]
    fn project(self: Pin<&mut Self>) -> &mut Self {
        unsafe { Pin::into_inner_unchecked(self) }
    }
}

/// Wraps a future in a single-stepping executor whose waker does
/// nothing and pins it to the stack.
///
/// ## Example
///
/// ```
/// use core::task::Poll;
/// use wookie::dummy;
/// dummy!(future: async { true });
/// assert_eq!(future.poll(), Poll::Ready(true));
/// ```
#[cfg(feature="alloc")]
#[macro_export]
macro_rules! dummy {
    ($name:ident) => {
        let mut $name = unsafe { $crate::Dummy::new($name) };
        #[allow(unused_mut)]
        let mut $name = unsafe { core::pin::Pin::new_unchecked(&mut $name) };
    };
    ($name:ident : $future:expr) => {
        let mut $name = unsafe { $crate::Dummy::new($future) };
        #[allow(unused_mut)]
        let mut $name = unsafe { core::pin::Pin::new_unchecked(&mut $name) };
    }
}

/// Like [`dummy!`] but wraps in a [`ManuallyDrop`].
///
/// Warning: this has the potential to cause resource leakage, do not
/// use this for on anything that really ought to be dropped.
///
/// ## Example
///
/// ```
/// use core::task::Poll;
/// use wookie::leaky_dummy;
/// leaky_dummy!(future: async { true });
/// assert_eq!(future.poll(), Poll::Ready(true));
/// ```
#[cfg(feature="alloc")]
#[macro_export]
macro_rules! leaky_dummy {
    ($name:ident) => {
        let mut $name = unsafe { $crate::Dummy::new($name) };
        #[allow(unused_mut)]
        let mut $name = unsafe { core::pin::Pin::new_unchecked(&mut $name) };
    };
    ($name:ident : $future:expr) => {
        let mut $name = unsafe { $crate::Dummy::new($future) };
        #[allow(unused_mut)]
        let mut $name = unsafe { core::pin::Pin::new_unchecked(&mut $name) };
    }
}