diff options
Diffstat (limited to 'tests')
| -rw-r--r-- | tests/basic.rs | 72 | ||||
| -rw-r--r-- | tests/cancel.rs | 18 | ||||
| -rw-r--r-- | tests/join.rs | 54 | ||||
| -rw-r--r-- | tests/panic.rs | 28 | ||||
| -rw-r--r-- | tests/ready.rs | 20 | ||||
| -rw-r--r-- | tests/waker_panic.rs | 46 | ||||
| -rw-r--r-- | tests/waker_pending.rs | 50 | ||||
| -rw-r--r-- | tests/waker_ready.rs | 38 |
8 files changed, 163 insertions, 163 deletions
diff --git a/tests/basic.rs b/tests/basic.rs index 81311bf..b012b57 100644 --- a/tests/basic.rs +++ b/tests/basic.rs @@ -3,7 +3,7 @@ use std::pin::Pin; use std::sync::atomic::{AtomicUsize, Ordering}; use std::task::{Context, Poll}; -use async_task::Task; +use async_task::Runnable; use futures_lite::future; // Creates a future with event counters. @@ -63,7 +63,7 @@ macro_rules! schedule { } let guard = Guard(Box::new(0)); - move |_task| { + move |_runnable| { &guard; $sched.fetch_add(1, Ordering::SeqCst); } @@ -79,14 +79,14 @@ fn try_await<T>(f: impl Future<Output = T>) -> Option<T> { fn drop_and_detach() { future!(f, POLL, DROP_F); schedule!(s, SCHEDULE, DROP_S); - let (task, handle) = async_task::spawn(f, s); + let (runnable, handle) = 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(task); + drop(runnable); assert_eq!(POLL.load(Ordering::SeqCst), 0); assert_eq!(SCHEDULE.load(Ordering::SeqCst), 0); assert_eq!(DROP_F.load(Ordering::SeqCst), 1); @@ -103,7 +103,7 @@ fn drop_and_detach() { fn detach_and_drop() { future!(f, POLL, DROP_F); schedule!(s, SCHEDULE, DROP_S); - let (task, handle) = async_task::spawn(f, s); + let (runnable, handle) = async_task::spawn(f, s); handle.detach(); assert_eq!(POLL.load(Ordering::SeqCst), 0); @@ -111,7 +111,7 @@ fn detach_and_drop() { assert_eq!(DROP_F.load(Ordering::SeqCst), 0); assert_eq!(DROP_S.load(Ordering::SeqCst), 0); - drop(task); + drop(runnable); assert_eq!(POLL.load(Ordering::SeqCst), 0); assert_eq!(SCHEDULE.load(Ordering::SeqCst), 0); assert_eq!(DROP_F.load(Ordering::SeqCst), 1); @@ -122,7 +122,7 @@ fn detach_and_drop() { fn detach_and_run() { future!(f, POLL, DROP_F); schedule!(s, SCHEDULE, DROP_S); - let (task, handle) = async_task::spawn(f, s); + let (runnable, handle) = async_task::spawn(f, s); handle.detach(); assert_eq!(POLL.load(Ordering::SeqCst), 0); @@ -130,7 +130,7 @@ fn detach_and_run() { assert_eq!(DROP_F.load(Ordering::SeqCst), 0); assert_eq!(DROP_S.load(Ordering::SeqCst), 0); - task.run(); + runnable.run(); assert_eq!(POLL.load(Ordering::SeqCst), 1); assert_eq!(SCHEDULE.load(Ordering::SeqCst), 0); assert_eq!(DROP_F.load(Ordering::SeqCst), 1); @@ -141,9 +141,9 @@ fn detach_and_run() { fn run_and_detach() { future!(f, POLL, DROP_F); schedule!(s, SCHEDULE, DROP_S); - let (task, handle) = async_task::spawn(f, s); + let (runnable, handle) = async_task::spawn(f, s); - task.run(); + runnable.run(); assert_eq!(POLL.load(Ordering::SeqCst), 1); assert_eq!(SCHEDULE.load(Ordering::SeqCst), 0); assert_eq!(DROP_F.load(Ordering::SeqCst), 1); @@ -160,7 +160,7 @@ fn run_and_detach() { fn cancel_and_run() { future!(f, POLL, DROP_F); schedule!(s, SCHEDULE, DROP_S); - let (task, handle) = async_task::spawn(f, s); + let (runnable, handle) = async_task::spawn(f, s); drop(handle); assert_eq!(POLL.load(Ordering::SeqCst), 0); @@ -168,7 +168,7 @@ fn cancel_and_run() { assert_eq!(DROP_F.load(Ordering::SeqCst), 0); assert_eq!(DROP_S.load(Ordering::SeqCst), 0); - task.run(); + runnable.run(); assert_eq!(POLL.load(Ordering::SeqCst), 0); assert_eq!(SCHEDULE.load(Ordering::SeqCst), 0); assert_eq!(DROP_F.load(Ordering::SeqCst), 1); @@ -179,9 +179,9 @@ fn cancel_and_run() { fn run_and_cancel() { future!(f, POLL, DROP_F); schedule!(s, SCHEDULE, DROP_S); - let (task, handle) = async_task::spawn(f, s); + let (runnable, handle) = async_task::spawn(f, s); - task.run(); + runnable.run(); assert_eq!(POLL.load(Ordering::SeqCst), 1); assert_eq!(SCHEDULE.load(Ordering::SeqCst), 0); assert_eq!(DROP_F.load(Ordering::SeqCst), 1); @@ -198,7 +198,7 @@ fn run_and_cancel() { fn cancel_join() { future!(f, POLL, DROP_F); schedule!(s, SCHEDULE, DROP_S); - let (task, mut handle) = async_task::spawn(f, s); + let (runnable, mut handle) = async_task::spawn(f, s); assert!(try_await(&mut handle).is_none()); assert_eq!(POLL.load(Ordering::SeqCst), 0); @@ -206,7 +206,7 @@ fn cancel_join() { assert_eq!(DROP_F.load(Ordering::SeqCst), 0); assert_eq!(DROP_S.load(Ordering::SeqCst), 0); - task.run(); + runnable.run(); assert_eq!(POLL.load(Ordering::SeqCst), 1); assert_eq!(SCHEDULE.load(Ordering::SeqCst), 0); assert_eq!(DROP_F.load(Ordering::SeqCst), 1); @@ -228,19 +228,19 @@ fn cancel_join() { #[test] fn schedule() { let (s, r) = flume::unbounded(); - let schedule = move |t| s.send(t).unwrap(); - let (task, _handle) = async_task::spawn(future::poll_fn(|_| Poll::<()>::Pending), schedule); + let schedule = move |runnable| s.send(runnable).unwrap(); + let (runnable, _handle) = async_task::spawn(future::poll_fn(|_| Poll::<()>::Pending), schedule); assert!(r.is_empty()); - task.schedule(); + runnable.schedule(); - let task = r.recv().unwrap(); + let runnable = r.recv().unwrap(); assert!(r.is_empty()); - task.schedule(); + runnable.schedule(); - let task = r.recv().unwrap(); + let runnable = r.recv().unwrap(); assert!(r.is_empty()); - task.schedule(); + runnable.schedule(); r.recv().unwrap(); } @@ -250,12 +250,12 @@ fn schedule_counter() { static COUNT: AtomicUsize = AtomicUsize::new(0); let (s, r) = flume::unbounded(); - let schedule = move |t: Task| { + let schedule = move |runnable: Runnable| { COUNT.fetch_add(1, Ordering::SeqCst); - s.send(t).unwrap(); + s.send(runnable).unwrap(); }; - let (task, _handle) = async_task::spawn(future::poll_fn(|_| Poll::<()>::Pending), schedule); - task.schedule(); + let (runnable, _handle) = async_task::spawn(future::poll_fn(|_| Poll::<()>::Pending), schedule); + runnable.schedule(); r.recv().unwrap().schedule(); r.recv().unwrap().schedule(); @@ -273,27 +273,27 @@ fn drop_inside_schedule() { } let guard = DropGuard(AtomicUsize::new(0)); - let (task, _) = async_task::spawn(async {}, move |task| { + let (runnable, _) = async_task::spawn(async {}, move |runnable| { assert_eq!(guard.0.load(Ordering::SeqCst), 0); - drop(task); + drop(runnable); assert_eq!(guard.0.load(Ordering::SeqCst), 0); }); - task.schedule(); + runnable.schedule(); } #[test] fn waker() { let (s, r) = flume::unbounded(); - let schedule = move |t| s.send(t).unwrap(); - let (task, _handle) = async_task::spawn(future::poll_fn(|_| Poll::<()>::Pending), schedule); + let schedule = move |runnable| s.send(runnable).unwrap(); + let (runnable, _handle) = async_task::spawn(future::poll_fn(|_| Poll::<()>::Pending), schedule); assert!(r.is_empty()); - let w = task.waker(); - task.run(); + let w = runnable.waker(); + runnable.run(); w.wake_by_ref(); - let task = r.recv().unwrap(); - task.run(); + let runnable = r.recv().unwrap(); + runnable.run(); w.wake(); r.recv().unwrap(); } diff --git a/tests/cancel.rs b/tests/cancel.rs index 3155876..4f6581a 100644 --- a/tests/cancel.rs +++ b/tests/cancel.rs @@ -5,7 +5,7 @@ use std::task::{Context, Poll}; use std::thread; use std::time::Duration; -use async_task::Task; +use async_task::Runnable; use easy_parallel::Parallel; use futures_lite::future; @@ -80,9 +80,9 @@ macro_rules! schedule { } let guard = Guard(Box::new(0)); - move |task: Task| { + move |runnable: Runnable| { &guard; - task.schedule(); + runnable.schedule(); $sched.fetch_add(1, Ordering::SeqCst); } }; @@ -97,9 +97,9 @@ fn ms(ms: u64) -> Duration { fn run_and_cancel() { future!(f, POLL, DROP_F, DROP_T); schedule!(s, SCHEDULE, DROP_S); - let (task, handle) = async_task::spawn(f, s); + let (runnable, handle) = async_task::spawn(f, s); - task.run(); + runnable.run(); assert_eq!(POLL.load(Ordering::SeqCst), 1); assert_eq!(SCHEDULE.load(Ordering::SeqCst), 0); assert_eq!(DROP_F.load(Ordering::SeqCst), 1); @@ -118,12 +118,12 @@ fn run_and_cancel() { fn cancel_and_run() { future!(f, POLL, DROP_F, DROP_T); schedule!(s, SCHEDULE, DROP_S); - let (task, handle) = async_task::spawn(f, s); + let (runnable, handle) = async_task::spawn(f, s); Parallel::new() .add(|| { thread::sleep(ms(200)); - task.run(); + runnable.run(); assert_eq!(POLL.load(Ordering::SeqCst), 0); assert_eq!(SCHEDULE.load(Ordering::SeqCst), 0); @@ -149,11 +149,11 @@ fn cancel_and_run() { fn cancel_during_run() { future!(f, POLL, DROP_F, DROP_T); schedule!(s, SCHEDULE, DROP_S); - let (task, handle) = async_task::spawn(f, s); + let (runnable, handle) = async_task::spawn(f, s); Parallel::new() .add(|| { - task.run(); + runnable.run(); thread::sleep(ms(200)); diff --git a/tests/join.rs b/tests/join.rs index 6a2505b..25bbf9a 100644 --- a/tests/join.rs +++ b/tests/join.rs @@ -7,7 +7,7 @@ use std::task::{Context, Poll}; use std::thread; use std::time::Duration; -use async_task::Task; +use async_task::Runnable; use easy_parallel::Parallel; use futures_lite::future; @@ -81,9 +81,9 @@ macro_rules! schedule { } let guard = Guard(Box::new(0)); - move |task: Task| { + move |runnable: Runnable| { &guard; - task.schedule(); + runnable.schedule(); $sched.fetch_add(1, Ordering::SeqCst); } }; @@ -98,11 +98,11 @@ fn ms(ms: u64) -> Duration { fn drop_and_join() { future!(f, POLL, DROP_F, DROP_T); schedule!(s, SCHEDULE, DROP_S); - let (task, handle) = async_task::spawn(f, s); + let (runnable, handle) = async_task::spawn(f, s); assert_eq!(DROP_T.load(Ordering::SeqCst), 0); - drop(task); + drop(runnable); assert_eq!(DROP_T.load(Ordering::SeqCst), 0); assert!(catch_unwind(|| future::block_on(handle)).is_err()); @@ -117,11 +117,11 @@ fn drop_and_join() { fn run_and_join() { future!(f, POLL, DROP_F, DROP_T); schedule!(s, SCHEDULE, DROP_S); - let (task, handle) = async_task::spawn(f, s); + let (runnable, handle) = async_task::spawn(f, s); assert_eq!(DROP_T.load(Ordering::SeqCst), 0); - task.run(); + runnable.run(); assert_eq!(DROP_T.load(Ordering::SeqCst), 0); assert!(catch_unwind(|| future::block_on(handle)).is_ok()); @@ -136,14 +136,14 @@ fn run_and_join() { fn detach_and_run() { future!(f, POLL, DROP_F, DROP_T); schedule!(s, SCHEDULE, DROP_S); - let (task, handle) = async_task::spawn(f, s); + let (runnable, handle) = async_task::spawn(f, s); assert_eq!(DROP_T.load(Ordering::SeqCst), 0); handle.detach(); assert_eq!(DROP_T.load(Ordering::SeqCst), 0); - task.run(); + runnable.run(); assert_eq!(POLL.load(Ordering::SeqCst), 1); assert_eq!(SCHEDULE.load(Ordering::SeqCst), 0); assert_eq!(DROP_F.load(Ordering::SeqCst), 1); @@ -155,11 +155,11 @@ fn detach_and_run() { fn join_twice() { future!(f, POLL, DROP_F, DROP_T); schedule!(s, SCHEDULE, DROP_S); - let (task, mut handle) = async_task::spawn(f, s); + let (runnable, mut handle) = async_task::spawn(f, s); assert_eq!(DROP_T.load(Ordering::SeqCst), 0); - task.run(); + runnable.run(); assert_eq!(DROP_T.load(Ordering::SeqCst), 0); future::block_on(&mut handle); @@ -184,12 +184,12 @@ fn join_twice() { fn join_and_cancel() { future!(f, POLL, DROP_F, DROP_T); schedule!(s, SCHEDULE, DROP_S); - let (task, handle) = async_task::spawn(f, s); + let (runnable, handle) = async_task::spawn(f, s); Parallel::new() .add(|| { thread::sleep(ms(200)); - drop(task); + drop(runnable); thread::sleep(ms(400)); assert_eq!(POLL.load(Ordering::SeqCst), 0); @@ -215,13 +215,13 @@ fn join_and_cancel() { fn join_and_run() { future!(f, POLL, DROP_F, DROP_T); schedule!(s, SCHEDULE, DROP_S); - let (task, handle) = async_task::spawn(f, s); + let (runnable, handle) = async_task::spawn(f, s); Parallel::new() .add(|| { thread::sleep(ms(400)); - task.run(); + runnable.run(); assert_eq!(POLL.load(Ordering::SeqCst), 1); assert_eq!(SCHEDULE.load(Ordering::SeqCst), 0); assert_eq!(DROP_F.load(Ordering::SeqCst), 1); @@ -246,13 +246,13 @@ fn join_and_run() { fn try_join_and_run_and_join() { future!(f, POLL, DROP_F, DROP_T); schedule!(s, SCHEDULE, DROP_S); - let (task, mut handle) = async_task::spawn(f, s); + let (runnable, mut handle) = async_task::spawn(f, s); Parallel::new() .add(|| { thread::sleep(ms(400)); - task.run(); + runnable.run(); assert_eq!(POLL.load(Ordering::SeqCst), 1); assert_eq!(SCHEDULE.load(Ordering::SeqCst), 0); assert_eq!(DROP_F.load(Ordering::SeqCst), 1); @@ -284,13 +284,13 @@ fn try_join_and_run_and_join() { fn try_join_and_cancel_and_run() { future!(f, POLL, DROP_F, DROP_T); schedule!(s, SCHEDULE, DROP_S); - let (task, mut handle) = async_task::spawn(f, s); + let (runnable, mut handle) = async_task::spawn(f, s); Parallel::new() .add(|| { thread::sleep(ms(200)); - task.run(); + runnable.run(); assert_eq!(POLL.load(Ordering::SeqCst), 0); assert_eq!(SCHEDULE.load(Ordering::SeqCst), 0); assert_eq!(DROP_F.load(Ordering::SeqCst), 1); @@ -318,13 +318,13 @@ fn try_join_and_cancel_and_run() { fn try_join_and_run_and_cancel() { future!(f, POLL, DROP_F, DROP_T); schedule!(s, SCHEDULE, DROP_S); - let (task, mut handle) = async_task::spawn(f, s); + let (runnable, mut handle) = async_task::spawn(f, s); Parallel::new() .add(|| { thread::sleep(ms(200)); - task.run(); + runnable.run(); assert_eq!(POLL.load(Ordering::SeqCst), 1); assert_eq!(SCHEDULE.load(Ordering::SeqCst), 0); assert_eq!(DROP_F.load(Ordering::SeqCst), 1); @@ -369,18 +369,18 @@ fn await_output() { } for i in 0..10 { - let (task, handle) = async_task::spawn(Fut::new(i), drop); - task.run(); + let (runnable, handle) = async_task::spawn(Fut::new(i), drop); + runnable.run(); assert_eq!(future::block_on(handle), i); } for i in 0..10 { - let (task, handle) = async_task::spawn(Fut::new(vec![7; i]), drop); - task.run(); + let (runnable, handle) = async_task::spawn(Fut::new(vec![7; i]), drop); + runnable.run(); assert_eq!(future::block_on(handle), vec![7; i]); } - let (task, handle) = async_task::spawn(Fut::new("foo".to_string()), drop); - task.run(); + let (runnable, handle) = async_task::spawn(Fut::new("foo".to_string()), drop); + runnable.run(); assert_eq!(future::block_on(handle), "foo"); } diff --git a/tests/panic.rs b/tests/panic.rs index b14581d..8a25e2e 100644 --- a/tests/panic.rs +++ b/tests/panic.rs @@ -6,7 +6,7 @@ use std::task::{Context, Poll}; use std::thread; use std::time::Duration; -use async_task::Task; +use async_task::Runnable; use easy_parallel::Parallel; use futures_lite::future; @@ -68,7 +68,7 @@ macro_rules! schedule { } let guard = Guard(Box::new(0)); - move |_task: Task| { + move |_runnable: Runnable| { &guard; $sched.fetch_add(1, Ordering::SeqCst); } @@ -84,11 +84,11 @@ fn ms(ms: u64) -> Duration { fn cancel_during_run() { future!(f, POLL, DROP_F); schedule!(s, SCHEDULE, DROP_S); - let (task, handle) = async_task::spawn(f, s); + let (runnable, handle) = async_task::spawn(f, s); Parallel::new() .add(|| { - assert!(catch_unwind(|| task.run()).is_err()); + assert!(catch_unwind(|| runnable.run()).is_err()); assert_eq!(POLL.load(Ordering::SeqCst), 1); assert_eq!(SCHEDULE.load(Ordering::SeqCst), 0); assert_eq!(DROP_F.load(Ordering::SeqCst), 1); @@ -110,9 +110,9 @@ fn cancel_during_run() { fn run_and_join() { future!(f, POLL, DROP_F); schedule!(s, SCHEDULE, DROP_S); - let (task, handle) = async_task::spawn(f, s); + let (runnable, handle) = async_task::spawn(f, s); - assert!(catch_unwind(|| task.run()).is_err()); + assert!(catch_unwind(|| runnable.run()).is_err()); assert_eq!(POLL.load(Ordering::SeqCst), 1); assert_eq!(SCHEDULE.load(Ordering::SeqCst), 0); assert_eq!(DROP_F.load(Ordering::SeqCst), 1); @@ -129,7 +129,7 @@ fn run_and_join() { fn try_join_and_run_and_join() { future!(f, POLL, DROP_F); schedule!(s, SCHEDULE, DROP_S); - let (task, mut handle) = async_task::spawn(f, s); + let (runnable, mut handle) = async_task::spawn(f, s); future::block_on(future::or(&mut handle, future::ready(Default::default()))); assert_eq!(POLL.load(Ordering::SeqCst), 0); @@ -137,7 +137,7 @@ fn try_join_and_run_and_join() { assert_eq!(DROP_F.load(Ordering::SeqCst), 0); assert_eq!(DROP_S.load(Ordering::SeqCst), 0); - assert!(catch_unwind(|| task.run()).is_err()); + assert!(catch_unwind(|| runnable.run()).is_err()); assert_eq!(POLL.load(Ordering::SeqCst), 1); assert_eq!(SCHEDULE.load(Ordering::SeqCst), 0); assert_eq!(DROP_F.load(Ordering::SeqCst), 1); @@ -154,11 +154,11 @@ fn try_join_and_run_and_join() { fn join_during_run() { future!(f, POLL, DROP_F); schedule!(s, SCHEDULE, DROP_S); - let (task, handle) = async_task::spawn(f, s); + let (runnable, handle) = async_task::spawn(f, s); Parallel::new() .add(|| { - assert!(catch_unwind(|| task.run()).is_err()); + assert!(catch_unwind(|| runnable.run()).is_err()); assert_eq!(POLL.load(Ordering::SeqCst), 1); assert_eq!(SCHEDULE.load(Ordering::SeqCst), 0); assert_eq!(DROP_F.load(Ordering::SeqCst), 1); @@ -184,11 +184,11 @@ fn join_during_run() { fn try_join_during_run() { future!(f, POLL, DROP_F); schedule!(s, SCHEDULE, DROP_S); - let (task, mut handle) = async_task::spawn(f, s); + let (runnable, mut handle) = async_task::spawn(f, s); Parallel::new() .add(|| { - assert!(catch_unwind(|| task.run()).is_err()); + assert!(catch_unwind(|| runnable.run()).is_err()); assert_eq!(POLL.load(Ordering::SeqCst), 1); assert_eq!(SCHEDULE.load(Ordering::SeqCst), 0); assert_eq!(DROP_F.load(Ordering::SeqCst), 1); @@ -211,11 +211,11 @@ fn try_join_during_run() { fn detach_during_run() { future!(f, POLL, DROP_F); schedule!(s, SCHEDULE, DROP_S); - let (task, handle) = async_task::spawn(f, s); + let (runnable, handle) = async_task::spawn(f, s); Parallel::new() .add(|| { - assert!(catch_unwind(|| task.run()).is_err()); + assert!(catch_unwind(|| runnable.run()).is_err()); assert_eq!(POLL.load(Ordering::SeqCst), 1); assert_eq!(SCHEDULE.load(Ordering::SeqCst), 0); assert_eq!(DROP_F.load(Ordering::SeqCst), 1); diff --git a/tests/ready.rs b/tests/ready.rs index 925f994..72a2b72 100644 --- a/tests/ready.rs +++ b/tests/ready.rs @@ -5,7 +5,7 @@ use std::task::{Context, Poll}; use std::thread; use std::time::Duration; -use async_task::Task; +use async_task::Runnable; use easy_parallel::Parallel; use futures_lite::future; @@ -80,7 +80,7 @@ macro_rules! schedule { } let guard = Guard(Box::new(0)); - move |_task: Task| { + move |_runnable: Runnable| { &guard; $sched.fetch_add(1, Ordering::SeqCst); } @@ -96,11 +96,11 @@ fn ms(ms: u64) -> Duration { fn cancel_during_run() { future!(f, POLL, DROP_F, DROP_T); schedule!(s, SCHEDULE, DROP_S); - let (task, handle) = async_task::spawn(f, s); + let (runnable, handle) = async_task::spawn(f, s); Parallel::new() .add(|| { - task.run(); + runnable.run(); assert_eq!(POLL.load(Ordering::SeqCst), 1); assert_eq!(SCHEDULE.load(Ordering::SeqCst), 0); assert_eq!(DROP_F.load(Ordering::SeqCst), 1); @@ -138,11 +138,11 @@ fn cancel_during_run() { fn join_during_run() { future!(f, POLL, DROP_F, DROP_T); schedule!(s, SCHEDULE, DROP_S); - let (task, handle) = async_task::spawn(f, s); + let (runnable, handle) = async_task::spawn(f, s); Parallel::new() .add(|| { - task.run(); + runnable.run(); assert_eq!(POLL.load(Ordering::SeqCst), 1); assert_eq!(SCHEDULE.load(Ordering::SeqCst), 0); assert_eq!(DROP_F.load(Ordering::SeqCst), 1); @@ -171,11 +171,11 @@ fn join_during_run() { fn try_join_during_run() { future!(f, POLL, DROP_F, DROP_T); schedule!(s, SCHEDULE, DROP_S); - let (task, mut handle) = async_task::spawn(f, s); + let (runnable, mut handle) = async_task::spawn(f, s); Parallel::new() .add(|| { - task.run(); + runnable.run(); assert_eq!(POLL.load(Ordering::SeqCst), 1); assert_eq!(SCHEDULE.load(Ordering::SeqCst), 0); assert_eq!(DROP_F.load(Ordering::SeqCst), 1); @@ -200,11 +200,11 @@ fn try_join_during_run() { fn detach_during_run() { future!(f, POLL, DROP_F, DROP_T); schedule!(s, SCHEDULE, DROP_S); - let (task, handle) = async_task::spawn(f, s); + let (runnable, handle) = async_task::spawn(f, s); Parallel::new() .add(|| { - task.run(); + runnable.run(); assert_eq!(POLL.load(Ordering::SeqCst), 1); assert_eq!(SCHEDULE.load(Ordering::SeqCst), 0); assert_eq!(DROP_F.load(Ordering::SeqCst), 1); diff --git a/tests/waker_panic.rs b/tests/waker_panic.rs index 571f8c8..5ff43fd 100644 --- a/tests/waker_panic.rs +++ b/tests/waker_panic.rs @@ -7,7 +7,7 @@ use std::task::{Context, Poll}; use std::thread; use std::time::Duration; -use async_task::Task; +use async_task::Runnable; use atomic_waker::AtomicWaker; use easy_parallel::Parallel; use futures_lite::future; @@ -85,10 +85,10 @@ macro_rules! schedule { } let guard = Guard(Box::new(0)); - let sched = move |task: Task| { + let sched = move |runnable: Runnable| { &guard; $sched.fetch_add(1, Ordering::SeqCst); - s.send(task).unwrap(); + s.send(runnable).unwrap(); }; (sched, r) @@ -108,16 +108,16 @@ fn try_await<T>(f: impl Future<Output = T>) -> Option<T> { fn wake_during_run() { future!(f, waker, POLL, DROP_F); schedule!(s, chan, SCHEDULE, DROP_S); - let (task, handle) = async_task::spawn(f, s); + let (runnable, handle) = async_task::spawn(f, s); - task.run(); + runnable.run(); let w = waker(); w.wake_by_ref(); - let task = chan.recv().unwrap(); + let runnable = chan.recv().unwrap(); Parallel::new() .add(|| { - assert!(catch_unwind(|| task.run()).is_err()); + assert!(catch_unwind(|| runnable.run()).is_err()); drop(waker()); assert_eq!(POLL.load(Ordering::SeqCst), 2); assert_eq!(SCHEDULE.load(Ordering::SeqCst), 1); @@ -151,16 +151,16 @@ fn wake_during_run() { fn cancel_during_run() { future!(f, waker, POLL, DROP_F); schedule!(s, chan, SCHEDULE, DROP_S); - let (task, handle) = async_task::spawn(f, s); + let (runnable, handle) = async_task::spawn(f, s); - task.run(); + runnable.run(); let w = waker(); w.wake(); - let task = chan.recv().unwrap(); + let runnable = chan.recv().unwrap(); Parallel::new() .add(|| { - assert!(catch_unwind(|| task.run()).is_err()); + assert!(catch_unwind(|| runnable.run()).is_err()); drop(waker()); assert_eq!(POLL.load(Ordering::SeqCst), 2); assert_eq!(SCHEDULE.load(Ordering::SeqCst), 1); @@ -193,16 +193,16 @@ fn cancel_during_run() { fn wake_and_cancel_during_run() { future!(f, waker, POLL, DROP_F); schedule!(s, chan, SCHEDULE, DROP_S); - let (task, handle) = async_task::spawn(f, s); + let (runnable, handle) = async_task::spawn(f, s); - task.run(); + runnable.run(); let w = waker(); w.wake_by_ref(); - let task = chan.recv().unwrap(); + let runnable = chan.recv().unwrap(); Parallel::new() .add(|| { - assert!(catch_unwind(|| task.run()).is_err()); + assert!(catch_unwind(|| runnable.run()).is_err()); drop(waker()); assert_eq!(POLL.load(Ordering::SeqCst), 2); assert_eq!(SCHEDULE.load(Ordering::SeqCst), 1); @@ -242,16 +242,16 @@ fn wake_and_cancel_during_run() { fn cancel_and_wake_during_run() { future!(f, waker, POLL, DROP_F); schedule!(s, chan, SCHEDULE, DROP_S); - let (task, handle) = async_task::spawn(f, s); + let (runnable, handle) = async_task::spawn(f, s); - task.run(); + runnable.run(); let w = waker(); w.wake_by_ref(); - let task = chan.recv().unwrap(); + let runnable = chan.recv().unwrap(); Parallel::new() .add(|| { - assert!(catch_unwind(|| task.run()).is_err()); + assert!(catch_unwind(|| runnable.run()).is_err()); drop(waker()); assert_eq!(POLL.load(Ordering::SeqCst), 2); assert_eq!(SCHEDULE.load(Ordering::SeqCst), 1); @@ -291,9 +291,9 @@ fn cancel_and_wake_during_run() { fn panic_and_poll() { future!(f, waker, POLL, DROP_F); schedule!(s, chan, SCHEDULE, DROP_S); - let (task, handle) = async_task::spawn(f, s); + let (runnable, handle) = async_task::spawn(f, s); - task.run(); + runnable.run(); waker().wake(); assert_eq!(POLL.load(Ordering::SeqCst), 1); assert_eq!(SCHEDULE.load(Ordering::SeqCst), 1); @@ -303,8 +303,8 @@ fn panic_and_poll() { let mut handle = handle; assert!(try_await(&mut handle).is_none()); - let task = chan.recv().unwrap(); - assert!(catch_unwind(|| task.run()).is_err()); + let runnable = chan.recv().unwrap(); + assert!(catch_unwind(|| runnable.run()).is_err()); assert_eq!(POLL.load(Ordering::SeqCst), 2); assert_eq!(SCHEDULE.load(Ordering::SeqCst), 1); assert_eq!(DROP_F.load(Ordering::SeqCst), 1); diff --git a/tests/waker_pending.rs b/tests/waker_pending.rs index 829d3aa..edbffde 100644 --- a/tests/waker_pending.rs +++ b/tests/waker_pending.rs @@ -5,7 +5,7 @@ use std::task::{Context, Poll}; use std::thread; use std::time::Duration; -use async_task::Task; +use async_task::Runnable; use atomic_waker::AtomicWaker; use easy_parallel::Parallel; @@ -76,10 +76,10 @@ macro_rules! schedule { } let guard = Guard(Box::new(0)); - let sched = move |task: Task| { + let sched = move |runnable: Runnable| { &guard; $sched.fetch_add(1, Ordering::SeqCst); - s.send(task).unwrap(); + s.send(runnable).unwrap(); }; (sched, r) @@ -95,16 +95,16 @@ fn ms(ms: u64) -> Duration { fn wake_during_run() { future!(f, waker, POLL, DROP_F); schedule!(s, chan, SCHEDULE, DROP_S); - let (task, _handle) = async_task::spawn(f, s); + let (runnable, _handle) = async_task::spawn(f, s); - task.run(); + runnable.run(); let w = waker(); w.wake_by_ref(); - let task = chan.recv().unwrap(); + let runnable = chan.recv().unwrap(); Parallel::new() .add(|| { - task.run(); + runnable.run(); assert_eq!(POLL.load(Ordering::SeqCst), 2); assert_eq!(SCHEDULE.load(Ordering::SeqCst), 2); assert_eq!(DROP_F.load(Ordering::SeqCst), 0); @@ -139,16 +139,16 @@ fn wake_during_run() { fn cancel_during_run() { future!(f, waker, POLL, DROP_F); schedule!(s, chan, SCHEDULE, DROP_S); - let (task, handle) = async_task::spawn(f, s); + let (runnable, handle) = async_task::spawn(f, s); - task.run(); + runnable.run(); let w = waker(); w.wake(); - let task = chan.recv().unwrap(); + let runnable = chan.recv().unwrap(); Parallel::new() .add(|| { - task.run(); + runnable.run(); drop(waker()); assert_eq!(POLL.load(Ordering::SeqCst), 2); assert_eq!(SCHEDULE.load(Ordering::SeqCst), 1); @@ -181,16 +181,16 @@ fn cancel_during_run() { fn wake_and_cancel_during_run() { future!(f, waker, POLL, DROP_F); schedule!(s, chan, SCHEDULE, DROP_S); - let (task, handle) = async_task::spawn(f, s); + let (runnable, handle) = async_task::spawn(f, s); - task.run(); + runnable.run(); let w = waker(); w.wake_by_ref(); - let task = chan.recv().unwrap(); + let runnable = chan.recv().unwrap(); Parallel::new() .add(|| { - task.run(); + runnable.run(); drop(waker()); assert_eq!(POLL.load(Ordering::SeqCst), 2); assert_eq!(SCHEDULE.load(Ordering::SeqCst), 1); @@ -230,16 +230,16 @@ fn wake_and_cancel_during_run() { fn cancel_and_wake_during_run() { future!(f, waker, POLL, DROP_F); schedule!(s, chan, SCHEDULE, DROP_S); - let (task, handle) = async_task::spawn(f, s); + let (runnable, handle) = async_task::spawn(f, s); - task.run(); + runnable.run(); let w = waker(); w.wake_by_ref(); - let task = chan.recv().unwrap(); + let runnable = chan.recv().unwrap(); Parallel::new() .add(|| { - task.run(); + runnable.run(); drop(waker()); assert_eq!(POLL.load(Ordering::SeqCst), 2); assert_eq!(SCHEDULE.load(Ordering::SeqCst), 1); @@ -279,9 +279,9 @@ fn cancel_and_wake_during_run() { fn drop_last_waker() { future!(f, waker, POLL, DROP_F); schedule!(s, chan, SCHEDULE, DROP_S); - let (task, handle) = async_task::spawn(f, s); + let (runnable, handle) = async_task::spawn(f, s); - task.run(); + runnable.run(); let w = waker(); handle.detach(); @@ -310,9 +310,9 @@ fn drop_last_waker() { fn cancel_last_handle() { future!(f, waker, POLL, DROP_F); schedule!(s, chan, SCHEDULE, DROP_S); - let (task, handle) = async_task::spawn(f, s); + let (runnable, handle) = async_task::spawn(f, s); - task.run(); + runnable.run(); drop(waker()); assert_eq!(POLL.load(Ordering::SeqCst), 1); assert_eq!(SCHEDULE.load(Ordering::SeqCst), 0); @@ -339,9 +339,9 @@ fn cancel_last_handle() { fn drop_last_handle() { future!(f, waker, POLL, DROP_F); schedule!(s, chan, SCHEDULE, DROP_S); - let (task, handle) = async_task::spawn(f, s); + let (runnable, handle) = async_task::spawn(f, s); - task.run(); + runnable.run(); drop(waker()); assert_eq!(POLL.load(Ordering::SeqCst), 1); assert_eq!(SCHEDULE.load(Ordering::SeqCst), 0); diff --git a/tests/waker_ready.rs b/tests/waker_ready.rs index e7e8103..6acad29 100644 --- a/tests/waker_ready.rs +++ b/tests/waker_ready.rs @@ -6,7 +6,7 @@ use std::task::{Context, Poll}; use std::thread; use std::time::Duration; -use async_task::Task; +use async_task::Runnable; use atomic_waker::AtomicWaker; // Creates a future with event counters. @@ -82,10 +82,10 @@ macro_rules! schedule { } let guard = Guard(Box::new(0)); - let sched = move |task: Task| { + let sched = move |runnable: Runnable| { &guard; $sched.fetch_add(1, Ordering::SeqCst); - s.send(task).unwrap(); + s.send(runnable).unwrap(); }; (sched, r) @@ -101,12 +101,12 @@ fn ms(ms: u64) -> Duration { fn wake() { future!(f, waker, POLL, DROP_F); schedule!(s, chan, SCHEDULE, DROP_S); - let (mut task, handle) = async_task::spawn(f, s); + let (mut runnable, handle) = async_task::spawn(f, s); handle.detach(); assert!(chan.is_empty()); - task.run(); + runnable.run(); assert_eq!(POLL.load(Ordering::SeqCst), 1); assert_eq!(SCHEDULE.load(Ordering::SeqCst), 0); assert_eq!(DROP_F.load(Ordering::SeqCst), 0); @@ -114,14 +114,14 @@ fn wake() { assert_eq!(chan.len(), 0); waker().wake(); - task = chan.recv().unwrap(); + runnable = chan.recv().unwrap(); assert_eq!(POLL.load(Ordering::SeqCst), 1); assert_eq!(SCHEDULE.load(Ordering::SeqCst), 1); assert_eq!(DROP_F.load(Ordering::SeqCst), 0); assert_eq!(DROP_S.load(Ordering::SeqCst), 0); assert_eq!(chan.len(), 0); - task.run(); + runnable.run(); assert_eq!(POLL.load(Ordering::SeqCst), 2); assert_eq!(SCHEDULE.load(Ordering::SeqCst), 1); assert_eq!(DROP_F.load(Ordering::SeqCst), 1); @@ -140,12 +140,12 @@ fn wake() { fn wake_by_ref() { future!(f, waker, POLL, DROP_F); schedule!(s, chan, SCHEDULE, DROP_S); - let (mut task, handle) = async_task::spawn(f, s); + let (mut runnable, handle) = async_task::spawn(f, s); handle.detach(); assert!(chan.is_empty()); - task.run(); + runnable.run(); assert_eq!(POLL.load(Ordering::SeqCst), 1); assert_eq!(SCHEDULE.load(Ordering::SeqCst), 0); assert_eq!(DROP_F.load(Ordering::SeqCst), 0); @@ -153,14 +153,14 @@ fn wake_by_ref() { assert_eq!(chan.len(), 0); waker().wake_by_ref(); - task = chan.recv().unwrap(); + runnable = chan.recv().unwrap(); assert_eq!(POLL.load(Ordering::SeqCst), 1); assert_eq!(SCHEDULE.load(Ordering::SeqCst), 1); assert_eq!(DROP_F.load(Ordering::SeqCst), 0); assert_eq!(DROP_S.load(Ordering::SeqCst), 0); assert_eq!(chan.len(), 0); - task.run(); + runnable.run(); assert_eq!(POLL.load(Ordering::SeqCst), 2); assert_eq!(SCHEDULE.load(Ordering::SeqCst), 1); assert_eq!(DROP_F.load(Ordering::SeqCst), 1); @@ -179,10 +179,10 @@ fn wake_by_ref() { fn clone() { future!(f, waker, POLL, DROP_F); schedule!(s, chan, SCHEDULE, DROP_S); - let (mut task, handle) = async_task::spawn(f, s); + let (mut runnable, handle) = async_task::spawn(f, s); handle.detach(); - task.run(); + runnable.run(); assert_eq!(POLL.load(Ordering::SeqCst), 1); assert_eq!(SCHEDULE.load(Ordering::SeqCst), 0); assert_eq!(DROP_F.load(Ordering::SeqCst), 0); @@ -194,8 +194,8 @@ fn clone() { let w4 = w3.clone(); w4.wake(); - task = chan.recv().unwrap(); - task.run(); + runnable = chan.recv().unwrap(); + runnable.run(); assert_eq!(POLL.load(Ordering::SeqCst), 2); assert_eq!(SCHEDULE.load(Ordering::SeqCst), 1); assert_eq!(DROP_F.load(Ordering::SeqCst), 1); @@ -218,10 +218,10 @@ fn clone() { fn wake_dropped() { future!(f, waker, POLL, DROP_F); schedule!(s, chan, SCHEDULE, DROP_S); - let (task, handle) = async_task::spawn(f, s); + let (runnable, handle) = async_task::spawn(f, s); handle.detach(); - task.run(); + runnable.run(); assert_eq!(POLL.load(Ordering::SeqCst), 1); assert_eq!(SCHEDULE.load(Ordering::SeqCst), 0); assert_eq!(DROP_F.load(Ordering::SeqCst), 0); @@ -250,10 +250,10 @@ fn wake_dropped() { fn wake_completed() { future!(f, waker, POLL, DROP_F); schedule!(s, chan, SCHEDULE, DROP_S); - let (task, handle) = async_task::spawn(f, s); + let (runnable, handle) = async_task::spawn(f, s); handle.detach(); - task.run(); + runnable.run(); let w = waker(); assert_eq!(POLL.load(Ordering::SeqCst), 1); assert_eq!(SCHEDULE.load(Ordering::SeqCst), 0); |