You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
300 lines
8.6 KiB
300 lines
8.6 KiB
use std::future::Future;
|
|
use std::pin::Pin;
|
|
use std::sync::atomic::{AtomicUsize, Ordering};
|
|
use std::task::{Context, Poll};
|
|
|
|
use async_task::Runnable;
|
|
use smol::future;
|
|
|
|
// Creates a future with event counters.
|
|
//
|
|
// Usage: `future!(f, POLL, DROP)`
|
|
//
|
|
// The future `f` always returns `Poll::Ready`.
|
|
// When it gets polled, `POLL` is incremented.
|
|
// When it gets dropped, `DROP` is incremented.
|
|
macro_rules! future {
|
|
($name:pat, $poll:ident, $drop:ident) => {
|
|
static $poll: AtomicUsize = AtomicUsize::new(0);
|
|
static $drop: AtomicUsize = AtomicUsize::new(0);
|
|
|
|
let $name = {
|
|
struct Fut(Box<i32>);
|
|
|
|
impl Future for Fut {
|
|
type Output = Box<i32>;
|
|
|
|
fn poll(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<Self::Output> {
|
|
$poll.fetch_add(1, Ordering::SeqCst);
|
|
Poll::Ready(Box::new(0))
|
|
}
|
|
}
|
|
|
|
impl Drop for Fut {
|
|
fn drop(&mut self) {
|
|
$drop.fetch_add(1, Ordering::SeqCst);
|
|
}
|
|
}
|
|
|
|
Fut(Box::new(0))
|
|
};
|
|
};
|
|
}
|
|
|
|
// Creates a schedule function with event counters.
|
|
//
|
|
// Usage: `schedule!(s, SCHED, DROP)`
|
|
//
|
|
// The schedule function `s` does nothing.
|
|
// When it gets invoked, `SCHED` is incremented.
|
|
// When it gets dropped, `DROP` is incremented.
|
|
macro_rules! schedule {
|
|
($name:pat, $sched:ident, $drop:ident) => {
|
|
static $drop: AtomicUsize = AtomicUsize::new(0);
|
|
static $sched: AtomicUsize = AtomicUsize::new(0);
|
|
|
|
let $name = {
|
|
struct Guard(Box<i32>);
|
|
|
|
impl Drop for Guard {
|
|
fn drop(&mut self) {
|
|
$drop.fetch_add(1, Ordering::SeqCst);
|
|
}
|
|
}
|
|
|
|
let guard = Guard(Box::new(0));
|
|
move |_runnable| {
|
|
&guard;
|
|
$sched.fetch_add(1, Ordering::SeqCst);
|
|
}
|
|
};
|
|
};
|
|
}
|
|
|
|
fn try_await<T>(f: impl Future<Output = T>) -> Option<T> {
|
|
future::block_on(future::poll_once(f))
|
|
}
|
|
|
|
#[test]
|
|
fn drop_and_detach() {
|
|
future!(f, POLL, DROP_F);
|
|
schedule!(s, SCHEDULE, DROP_S);
|
|
let (runnable, task) = async_task::spawn(f, s);
|
|
|
|
assert_eq!(POLL.load(Ordering::SeqCst), 0);
|
|
assert_eq!(SCHEDULE.load(Ordering::SeqCst), 0);
|
|
assert_eq!(DROP_F.load(Ordering::SeqCst), 0);
|
|
assert_eq!(DROP_S.load(Ordering::SeqCst), 0);
|
|
|
|
drop(runnable);
|
|
assert_eq!(POLL.load(Ordering::SeqCst), 0);
|
|
assert_eq!(SCHEDULE.load(Ordering::SeqCst), 0);
|
|
assert_eq!(DROP_F.load(Ordering::SeqCst), 1);
|
|
assert_eq!(DROP_S.load(Ordering::SeqCst), 0);
|
|
|
|
task.detach();
|
|
assert_eq!(POLL.load(Ordering::SeqCst), 0);
|
|
assert_eq!(SCHEDULE.load(Ordering::SeqCst), 0);
|
|
assert_eq!(DROP_F.load(Ordering::SeqCst), 1);
|
|
assert_eq!(DROP_S.load(Ordering::SeqCst), 1);
|
|
}
|
|
|
|
#[test]
|
|
fn detach_and_drop() {
|
|
future!(f, POLL, DROP_F);
|
|
schedule!(s, SCHEDULE, DROP_S);
|
|
let (runnable, task) = async_task::spawn(f, s);
|
|
|
|
task.detach();
|
|
assert_eq!(POLL.load(Ordering::SeqCst), 0);
|
|
assert_eq!(SCHEDULE.load(Ordering::SeqCst), 0);
|
|
assert_eq!(DROP_F.load(Ordering::SeqCst), 0);
|
|
assert_eq!(DROP_S.load(Ordering::SeqCst), 0);
|
|
|
|
drop(runnable);
|
|
assert_eq!(POLL.load(Ordering::SeqCst), 0);
|
|
assert_eq!(SCHEDULE.load(Ordering::SeqCst), 0);
|
|
assert_eq!(DROP_F.load(Ordering::SeqCst), 1);
|
|
assert_eq!(DROP_S.load(Ordering::SeqCst), 1);
|
|
}
|
|
|
|
#[test]
|
|
fn detach_and_run() {
|
|
future!(f, POLL, DROP_F);
|
|
schedule!(s, SCHEDULE, DROP_S);
|
|
let (runnable, task) = async_task::spawn(f, s);
|
|
|
|
task.detach();
|
|
assert_eq!(POLL.load(Ordering::SeqCst), 0);
|
|
assert_eq!(SCHEDULE.load(Ordering::SeqCst), 0);
|
|
assert_eq!(DROP_F.load(Ordering::SeqCst), 0);
|
|
assert_eq!(DROP_S.load(Ordering::SeqCst), 0);
|
|
|
|
runnable.run();
|
|
assert_eq!(POLL.load(Ordering::SeqCst), 1);
|
|
assert_eq!(SCHEDULE.load(Ordering::SeqCst), 0);
|
|
assert_eq!(DROP_F.load(Ordering::SeqCst), 1);
|
|
assert_eq!(DROP_S.load(Ordering::SeqCst), 1);
|
|
}
|
|
|
|
#[test]
|
|
fn run_and_detach() {
|
|
future!(f, POLL, DROP_F);
|
|
schedule!(s, SCHEDULE, DROP_S);
|
|
let (runnable, task) = async_task::spawn(f, s);
|
|
|
|
runnable.run();
|
|
assert_eq!(POLL.load(Ordering::SeqCst), 1);
|
|
assert_eq!(SCHEDULE.load(Ordering::SeqCst), 0);
|
|
assert_eq!(DROP_F.load(Ordering::SeqCst), 1);
|
|
assert_eq!(DROP_S.load(Ordering::SeqCst), 0);
|
|
|
|
task.detach();
|
|
assert_eq!(POLL.load(Ordering::SeqCst), 1);
|
|
assert_eq!(SCHEDULE.load(Ordering::SeqCst), 0);
|
|
assert_eq!(DROP_F.load(Ordering::SeqCst), 1);
|
|
assert_eq!(DROP_S.load(Ordering::SeqCst), 1);
|
|
}
|
|
|
|
#[test]
|
|
fn cancel_and_run() {
|
|
future!(f, POLL, DROP_F);
|
|
schedule!(s, SCHEDULE, DROP_S);
|
|
let (runnable, task) = async_task::spawn(f, s);
|
|
|
|
drop(task);
|
|
assert_eq!(POLL.load(Ordering::SeqCst), 0);
|
|
assert_eq!(SCHEDULE.load(Ordering::SeqCst), 0);
|
|
assert_eq!(DROP_F.load(Ordering::SeqCst), 0);
|
|
assert_eq!(DROP_S.load(Ordering::SeqCst), 0);
|
|
|
|
runnable.run();
|
|
assert_eq!(POLL.load(Ordering::SeqCst), 0);
|
|
assert_eq!(SCHEDULE.load(Ordering::SeqCst), 0);
|
|
assert_eq!(DROP_F.load(Ordering::SeqCst), 1);
|
|
assert_eq!(DROP_S.load(Ordering::SeqCst), 1);
|
|
}
|
|
|
|
#[test]
|
|
fn run_and_cancel() {
|
|
future!(f, POLL, DROP_F);
|
|
schedule!(s, SCHEDULE, DROP_S);
|
|
let (runnable, task) = async_task::spawn(f, s);
|
|
|
|
runnable.run();
|
|
assert_eq!(POLL.load(Ordering::SeqCst), 1);
|
|
assert_eq!(SCHEDULE.load(Ordering::SeqCst), 0);
|
|
assert_eq!(DROP_F.load(Ordering::SeqCst), 1);
|
|
assert_eq!(DROP_S.load(Ordering::SeqCst), 0);
|
|
|
|
drop(task);
|
|
assert_eq!(POLL.load(Ordering::SeqCst), 1);
|
|
assert_eq!(SCHEDULE.load(Ordering::SeqCst), 0);
|
|
assert_eq!(DROP_F.load(Ordering::SeqCst), 1);
|
|
assert_eq!(DROP_S.load(Ordering::SeqCst), 1);
|
|
}
|
|
|
|
#[test]
|
|
fn cancel_join() {
|
|
future!(f, POLL, DROP_F);
|
|
schedule!(s, SCHEDULE, DROP_S);
|
|
let (runnable, mut task) = async_task::spawn(f, s);
|
|
|
|
assert!(try_await(&mut task).is_none());
|
|
assert_eq!(POLL.load(Ordering::SeqCst), 0);
|
|
assert_eq!(SCHEDULE.load(Ordering::SeqCst), 0);
|
|
assert_eq!(DROP_F.load(Ordering::SeqCst), 0);
|
|
assert_eq!(DROP_S.load(Ordering::SeqCst), 0);
|
|
|
|
runnable.run();
|
|
assert_eq!(POLL.load(Ordering::SeqCst), 1);
|
|
assert_eq!(SCHEDULE.load(Ordering::SeqCst), 0);
|
|
assert_eq!(DROP_F.load(Ordering::SeqCst), 1);
|
|
assert_eq!(DROP_S.load(Ordering::SeqCst), 0);
|
|
|
|
assert!(try_await(&mut task).is_some());
|
|
assert_eq!(POLL.load(Ordering::SeqCst), 1);
|
|
assert_eq!(SCHEDULE.load(Ordering::SeqCst), 0);
|
|
assert_eq!(DROP_F.load(Ordering::SeqCst), 1);
|
|
assert_eq!(DROP_S.load(Ordering::SeqCst), 0);
|
|
|
|
drop(task);
|
|
assert_eq!(POLL.load(Ordering::SeqCst), 1);
|
|
assert_eq!(SCHEDULE.load(Ordering::SeqCst), 0);
|
|
assert_eq!(DROP_F.load(Ordering::SeqCst), 1);
|
|
assert_eq!(DROP_S.load(Ordering::SeqCst), 1);
|
|
}
|
|
|
|
#[test]
|
|
fn schedule() {
|
|
let (s, r) = flume::unbounded();
|
|
let schedule = move |runnable| s.send(runnable).unwrap();
|
|
let (runnable, _task) = async_task::spawn(future::poll_fn(|_| Poll::<()>::Pending), schedule);
|
|
|
|
assert!(r.is_empty());
|
|
runnable.schedule();
|
|
|
|
let runnable = r.recv().unwrap();
|
|
assert!(r.is_empty());
|
|
runnable.schedule();
|
|
|
|
let runnable = r.recv().unwrap();
|
|
assert!(r.is_empty());
|
|
runnable.schedule();
|
|
|
|
r.recv().unwrap();
|
|
}
|
|
|
|
#[test]
|
|
fn schedule_counter() {
|
|
static COUNT: AtomicUsize = AtomicUsize::new(0);
|
|
|
|
let (s, r) = flume::unbounded();
|
|
let schedule = move |runnable: Runnable| {
|
|
COUNT.fetch_add(1, Ordering::SeqCst);
|
|
s.send(runnable).unwrap();
|
|
};
|
|
let (runnable, _task) = async_task::spawn(future::poll_fn(|_| Poll::<()>::Pending), schedule);
|
|
runnable.schedule();
|
|
|
|
r.recv().unwrap().schedule();
|
|
r.recv().unwrap().schedule();
|
|
assert_eq!(COUNT.load(Ordering::SeqCst), 3);
|
|
r.recv().unwrap();
|
|
}
|
|
|
|
#[test]
|
|
fn drop_inside_schedule() {
|
|
struct DropGuard(AtomicUsize);
|
|
impl Drop for DropGuard {
|
|
fn drop(&mut self) {
|
|
self.0.fetch_add(1, Ordering::SeqCst);
|
|
}
|
|
}
|
|
let guard = DropGuard(AtomicUsize::new(0));
|
|
|
|
let (runnable, _) = async_task::spawn(async {}, move |runnable| {
|
|
assert_eq!(guard.0.load(Ordering::SeqCst), 0);
|
|
drop(runnable);
|
|
assert_eq!(guard.0.load(Ordering::SeqCst), 0);
|
|
});
|
|
runnable.schedule();
|
|
}
|
|
|
|
#[test]
|
|
fn waker() {
|
|
let (s, r) = flume::unbounded();
|
|
let schedule = move |runnable| s.send(runnable).unwrap();
|
|
let (runnable, _task) = async_task::spawn(future::poll_fn(|_| Poll::<()>::Pending), schedule);
|
|
|
|
assert!(r.is_empty());
|
|
let waker = runnable.waker();
|
|
runnable.run();
|
|
waker.wake_by_ref();
|
|
|
|
let runnable = r.recv().unwrap();
|
|
runnable.run();
|
|
waker.wake();
|
|
r.recv().unwrap();
|
|
}
|