mirror of
https://github.com/tokio-rs/tokio.git
synced 2025-09-25 12:00:35 +00:00
8bf2e9aeb0
This patch introduces `Timeout`. This new type allows setting a timeout both using a duration and an instant. Given this overlap with `Deadline`, `Deadline` is deprecated. In addition to supporting future timeouts, the `Timeout` combinator is able to provide timeout functionality to streams. It does this by applying a duration based timeout to each item being yielded. The main reason for introducing `Timeout` is that a deadline approach does not work with streams. Since `Timeout` needed to be introduced anyway, keeping `Deadline` around does not make sense.
155 lines
3.2 KiB
Rust
155 lines
3.2 KiB
Rust
extern crate futures;
|
|
extern crate tokio_executor;
|
|
extern crate tokio_timer;
|
|
|
|
#[macro_use]
|
|
mod support;
|
|
use support::*;
|
|
|
|
use tokio_timer::*;
|
|
|
|
use futures::{future, Future, Stream};
|
|
use futures::sync::{oneshot, mpsc};
|
|
|
|
#[test]
|
|
fn simultaneous_deadline_future_completion() {
|
|
mocked(|_, time| {
|
|
// Create a future that is immediately ready
|
|
let fut = future::ok::<_, ()>(());
|
|
|
|
// Wrap it with a deadline
|
|
let mut fut = Timeout::new_at(fut, time.now());
|
|
|
|
// Ready!
|
|
assert_ready!(fut);
|
|
});
|
|
}
|
|
|
|
#[test]
|
|
fn completed_future_past_deadline() {
|
|
mocked(|_, time| {
|
|
// Create a future that is immediately ready
|
|
let fut = future::ok::<_, ()>(());
|
|
|
|
// Wrap it with a deadline
|
|
let mut fut = Timeout::new_at(fut, time.now() - ms(1000));
|
|
|
|
// Ready!
|
|
assert_ready!(fut);
|
|
});
|
|
}
|
|
|
|
#[test]
|
|
fn future_and_deadline_in_future() {
|
|
mocked(|timer, time| {
|
|
// Not yet complete
|
|
let (tx, rx) = oneshot::channel();
|
|
|
|
// Wrap it with a deadline
|
|
let mut fut = Timeout::new_at(rx, time.now() + ms(100));
|
|
|
|
// Ready!
|
|
assert_not_ready!(fut);
|
|
|
|
// Turn the timer, it runs for the elapsed time
|
|
advance(timer, ms(90));
|
|
|
|
assert_not_ready!(fut);
|
|
|
|
// Complete the future
|
|
tx.send(()).unwrap();
|
|
|
|
assert_ready!(fut);
|
|
});
|
|
}
|
|
|
|
#[test]
|
|
fn future_and_timeout_in_future() {
|
|
mocked(|timer, _time| {
|
|
// Not yet complete
|
|
let (tx, rx) = oneshot::channel();
|
|
|
|
// Wrap it with a deadline
|
|
let mut fut = Timeout::new(rx, ms(100));
|
|
|
|
// Ready!
|
|
assert_not_ready!(fut);
|
|
|
|
// Turn the timer, it runs for the elapsed time
|
|
advance(timer, ms(90));
|
|
|
|
assert_not_ready!(fut);
|
|
|
|
// Complete the future
|
|
tx.send(()).unwrap();
|
|
|
|
assert_ready!(fut);
|
|
});
|
|
}
|
|
|
|
#[test]
|
|
fn deadline_now_elapses() {
|
|
mocked(|_, time| {
|
|
let fut = future::empty::<(), ()>();
|
|
|
|
// Wrap it with a deadline
|
|
let mut fut = Timeout::new_at(fut, time.now());
|
|
|
|
assert_elapsed!(fut);
|
|
});
|
|
}
|
|
|
|
#[test]
|
|
fn deadline_future_elapses() {
|
|
mocked(|timer, time| {
|
|
let fut = future::empty::<(), ()>();
|
|
|
|
// Wrap it with a deadline
|
|
let mut fut = Timeout::new_at(fut, time.now() + ms(300));
|
|
|
|
assert_not_ready!(fut);
|
|
|
|
advance(timer, ms(300));
|
|
|
|
assert_elapsed!(fut);
|
|
});
|
|
}
|
|
|
|
#[test]
|
|
fn future_errors_first() {
|
|
mocked(|_, time| {
|
|
let fut = future::err::<(), ()>(());
|
|
|
|
// Wrap it with a deadline
|
|
let mut fut = Timeout::new_at(fut, time.now() + ms(100));
|
|
|
|
// Ready!
|
|
assert!(fut.poll().unwrap_err().is_inner());
|
|
});
|
|
}
|
|
|
|
#[test]
|
|
fn stream_and_timeout_in_future() {
|
|
mocked(|timer, _time| {
|
|
// Not yet complete
|
|
let (tx, rx) = mpsc::unbounded();
|
|
|
|
// Wrap it with a deadline
|
|
let mut stream = Timeout::new(rx, ms(100));
|
|
|
|
// Not ready
|
|
assert_not_ready!(stream);
|
|
|
|
// Turn the timer, it runs for the elapsed time
|
|
advance(timer, ms(90));
|
|
|
|
assert_not_ready!(stream);
|
|
|
|
// Complete the future
|
|
tx.unbounded_send(()).unwrap();
|
|
|
|
let item = assert_ready!(stream);
|
|
assert!(item.is_some());
|
|
});
|
|
}
|