tokio-rs/tokio
1
0
Fork 0
mirror of https://github.com/tokio-rs/tokio.git synced 2026-08-22 00:00:11 +02:00
Code Issues Packages Projects Releases Wiki Activity

Remove git dep and add macro examples (#1404)

Browse Source 
Signed-off-by: Lucio Franco <[email protected]>
This commit is contained in:
Lucio Franco
2019-08-07 15:02:38 -07:00
committed by Carl Lerche
parent 7268b0bb3a
commit 0a05332648
5 changed files with 231 additions and 9 deletions
Download Patch File Download Diff File Expand all files Collapse all files
tokio-test/Cargo.toml
+2 -2
View File
@@ -22,13 +22,13 @@ categories = ["asynchronous", "testing"]
publish = false
[dependencies]
assertive = { git = "http://github.com/carllerche/assertive" }
pin-convert = "0.1.0"
tokio-executor = { version = "0.2.0", path = "../tokio-executor" }
tokio-io = { version = "0.2.0", path = "../tokio-io" }
tokio-sync = { version = "0.2.0", path = "../tokio-sync" }
tokio-timer = { version = "0.3.0", path = "../tokio-timer" }
futures-core-preview = "0.3.0-alpha.17"
futures-core-preview = "=0.3.0-alpha.17"
[dev-dependencies]
tokio = { path = "../tokio" }
futures-util-preview = "=0.3.0-alpha.17"
tokio-test/src/clock.rs
+1 -1
View File
@@ -2,7 +2,7 @@
//!
//! # Example
//!
//! ```
//! ```ignore
//! use tokio_test::clock;
//! use tokio_test::{assert_ready, assert_not_ready};
//! use tokio_timer::Delay;
tokio-test/src/lib.rs
+1 -3
View File
@@ -12,7 +12,7 @@
//!
//! # Example
//!
//! ```
//! ```ignore
//! # use futures::{Future, future};
//! use tokio_test::assert_ready;
//!
@@ -25,8 +25,6 @@ pub mod io;
mod macros;
pub mod task;
pub use assertive::{assert_err, assert_ok};
/*
#[doc(hidden)]
pub mod codegen {
tokio-test/src/macros.rs
+201 -1
View File
@@ -1,6 +1,29 @@
//! A collection of useful macros for testing futures and tokio based code
/// Assert a `Poll` is ready, returning the value.
///
/// This will invoke `panic!` if the provided `Poll` does not evaluate to `Poll::Ready` at
/// runtime.
///
/// # Custom Messages
///
/// This macro has a second form, where a custom panic message can be provided with or without
/// arguments for formatting.
///
/// # Examples
///
/// ```
/// use std::future::Future;
/// use futures_util::{future, pin_mut};
/// use tokio_test::{assert_ready, task};
///
/// task::mock(|cx| {
/// let fut = future::ready(());
///
/// pin_mut!(fut);
/// assert_ready!(fut.poll(cx));
/// })
/// ```
#[macro_export]
macro_rules! assert_ready {
($e:expr) => {{
@@ -23,6 +46,29 @@ macro_rules! assert_ready {
}
/// Assert a `Poll<Result<...>>` is ready and `Ok`, returning the value.
///
/// This will invoke `panic!` if the provided `Poll` does not evaluate to `Poll::Ready(Ok(..))` at
/// runtime.
///
/// # Custom Messages
///
/// This macro has a second form, where a custom panic message can be provided with or without
/// arguments for formatting.
///
/// # Examples
///
/// ```
/// use std::future::Future;
/// use futures_util::{future, pin_mut};
/// use tokio_test::{assert_ready_ok, task};
///
/// task::mock(|cx| {
/// let fut = future::ok::<_, ()>(());
///
/// pin_mut!(fut);
/// assert_ready_ok!(fut.poll(cx));
/// })
/// ```
#[macro_export]
macro_rules! assert_ready_ok {
($e:expr) => {{
@@ -38,6 +84,29 @@ macro_rules! assert_ready_ok {
}
/// Assert a `Poll<Result<...>>` is ready and `Err`, returning the error.
///
/// This will invoke `panic!` if the provided `Poll` does not evaluate to `Poll::Ready(Err(..))` at
/// runtime.
///
/// # Custom Messages
///
/// This macro has a second form, where a custom panic message can be provided with or without
/// arguments for formatting.
///
/// # Examples
///
/// ```
/// use std::future::Future;
/// use futures_util::{future, pin_mut};
/// use tokio_test::{assert_ready_err, task};
///
/// task::mock(|cx| {
/// let fut = future::err::<(), _>(());
///
/// pin_mut!(fut);
/// assert_ready_err!(fut.poll(cx));
/// })
/// ```
#[macro_export]
macro_rules! assert_ready_err {
($e:expr) => {{
@@ -52,7 +121,31 @@ macro_rules! assert_ready_err {
}};
}
/// Asset a `Poll` is pending.
/// Assert a `Poll` is pending.
///
/// This will invoke `panic!` if the provided `Poll` does not evaluate to `Poll::Pending` at
/// runtime.
///
/// # Custom Messages
///
/// This macro has a second form, where a custom panic message can be provided with or without
/// arguments for formatting.
///
/// # Examples
///
/// ```
/// use std::future::Future;
/// use std::task::Poll;
/// use futures_util::{future, pin_mut};
/// use tokio_test::{assert_pending, task};
///
/// task::mock(|cx| {
/// let fut = future::pending::<()>();
///
/// pin_mut!(fut);
/// assert_pending!(fut.poll(cx));
/// })
/// ```
#[macro_export]
macro_rules! assert_pending {
($e:expr) => {{
@@ -75,6 +168,29 @@ macro_rules! assert_pending {
}
/// Assert if a poll is ready and check for equality on the value
///
/// This will invoke `panic!` if the provided `Poll` does not evaluate to `Poll::Ready` at
/// runtime and the value produced does not partially equal the expected value.
///
/// # Custom Messages
///
/// This macro has a second form, where a custom panic message can be provided with or without
/// arguments for formatting.
///
/// # Examples
///
/// ```
/// use std::future::Future;
/// use futures_util::{future, pin_mut};
/// use tokio_test::{assert_ready_eq, task};
///
/// task::mock(|cx| {
/// let fut = future::ready(42);
///
/// pin_mut!(fut);
/// assert_ready_eq!(fut.poll(cx), 42);
/// })
/// ```
#[macro_export]
macro_rules! assert_ready_eq {
($e:expr, $expect:expr) => {
@@ -87,3 +203,87 @@ macro_rules! assert_ready_eq {
assert_eq!(val, $expect, $($msg),*)
};
}
/// Asserts that the expression evaluates to `Ok` and returns the value.
///
/// This will invoke the `panic!` macro if the provided expression does not evaluate to `Ok` at
/// runtime.
///
/// # Custom Messages
///
/// This macro has a second form, where a custom panic message can be provided with or without
/// arguments for formatting.
///
/// # Examples
///
/// ```
/// use tokio_test::assert_ok;
///
/// let n: u32 = assert_ok!("123".parse());
///
/// let s = "123";
/// let n: u32 = assert_ok!(s.parse(), "testing parsing {:?} as a u32", s);
/// ```
#[macro_export]
macro_rules! assert_ok {
($e:expr) => {
assert_ok!($e,)
};
($e:expr,) => {{
use std::result::Result::*;
match $e {
Ok(v) => v,
Err(e) => panic!("assertion failed: Err({:?})", e),
}
}};
($e:expr, $($arg:tt)+) => {{
use std::result::Result::*;
match $e {
Ok(v) => v,
Err(e) => panic!("assertion failed: Err({:?}): {}", e, format_args!($($arg)+)),
}
}};
}
/// Asserts that the expression evaluates to `Err` and returns the error.
///
/// This will invoke the `panic!` macro if the provided expression does not evaluate to `Err` at
/// runtime.
///
/// # Custom Messages
///
/// This macro has a second form, where a custom panic message can be provided with or without
/// arguments for formatting.
///
/// # Examples
///
/// ```
/// use tokio_test::assert_err;
/// use std::str::FromStr;
///
///
/// let err = assert_err!(u32::from_str("fail"));
///
/// let msg = "fail";
/// let err = assert_err!(u32::from_str(msg), "testing parsing {:?} as u32", msg);
/// ```
#[macro_export]
macro_rules! assert_err {
($e:expr) => {
assert_err!($e,);
};
($e:expr,) => {{
use std::result::Result::*;
match $e {
Ok(v) => panic!("assertion failed: Ok({:?})", v),
Err(e) => e,
}
}};
($e:expr, $($arg:tt)+) => {{
use std::result::Result::*;
match $e {
Ok(v) => panic!("assertion failed: Ok({:?}): {}", v, format_args!($($arg)+)),
Err(e) => e,
}
}};
}
tokio-test/src/task.rs
+26 -2
View File
@@ -5,7 +5,7 @@
//! This example will use the `MockTask` to set the current task on
//! poll.
//!
//! ```
//! ```ignore
//! # use tokio_test::assert_ready_eq;
//! # use tokio_test::task::MockTask;
//! # use futures::{sync::mpsc, Stream, Sink, Future, Async};
@@ -26,10 +26,34 @@ use std::pin::Pin;
use std::sync::{Arc, Condvar, Mutex};
use std::task::{Context, Poll, RawWaker, RawWakerVTable, Waker};
/// Run the provided closure in a `MockTask` context.
///
/// # Examples
///
/// ```
/// use std::future::Future;
/// use futures_util::{future, pin_mut};
/// use tokio_test::task;
///
/// task::mock(|cx| {
/// let fut = future::ready(());
///
/// pin_mut!(fut);
/// assert!(fut.poll(cx).is_ready());
/// })
/// ```
pub fn mock<F, R>(f: F) -> R
where
F: Fn(&mut Context<'_>) -> R,
{
let mut task = MockTask::new();
task.enter(|cx| f(cx))
}
/// Mock task
///
/// A mock task is able to intercept and track wake notifications.
#[derive(Debug)]
#[derive(Debug, Clone)]
pub struct MockTask {
waker: Arc<ThreadWaker>,
}