Rename Task to Runnable
diff --git a/benches/spawn.rs b/benches/spawn.rs
index e9f93ce..9d74110 100644
--- a/benches/spawn.rs
+++ b/benches/spawn.rs
@@ -17,8 +17,8 @@
#[bench]
fn task_run(b: &mut Bencher) {
b.iter(|| {
- let (task, handle) = async_task::spawn(async {}, drop);
- task.run();
+ let (runnable, handle) = async_task::spawn(async {}, drop);
+ runnable.run();
executor::block_on(handle).unwrap();
});
}
@@ -35,9 +35,9 @@
fn oneshot_run(b: &mut Bencher) {
b.iter(|| {
let (tx, rx) = oneshot::channel::<()>();
- let task = Box::new(async move { tx.send(()).map_err(|_| ()) });
+ let runnable = Box::new(async move { tx.send(()).map_err(|_| ()) });
- let future = task.and_then(|_| rx.map_err(|_| ()));
+ let future = runnable.and_then(|_| rx.map_err(|_| ()));
executor::block_on(future).unwrap();
});
}
diff --git a/examples/spawn-local.rs b/examples/spawn-local.rs
index 1e1180c..2693aec 100644
--- a/examples/spawn-local.rs
+++ b/examples/spawn-local.rs
@@ -4,11 +4,11 @@
use std::future::Future;
use std::rc::Rc;
-use async_task::{JoinHandle, Task};
+use async_task::{JoinHandle, Runnable};
thread_local! {
// A channel that holds scheduled tasks.
- static QUEUE: (flume::Sender<Task>, flume::Receiver<Task>) = flume::unbounded();
+ static QUEUE: (flume::Sender<Runnable>, flume::Receiver<Runnable>) = flume::unbounded();
}
/// Spawns a future on the executor.
@@ -19,10 +19,10 @@
{
// Create a task that is scheduled by sending itself into the channel.
let schedule = |t| QUEUE.with(|(s, _)| s.send(t).unwrap());
- let (task, handle) = async_task::spawn_local(future, schedule);
+ let (runnable, handle) = async_task::spawn_local(future, schedule);
// Schedule the task by sending it into the queue.
- task.schedule();
+ runnable.schedule();
handle
}
diff --git a/examples/spawn-on-thread.rs b/examples/spawn-on-thread.rs
index 3b7e522..a3da7be 100644
--- a/examples/spawn-on-thread.rs
+++ b/examples/spawn-on-thread.rs
@@ -29,16 +29,16 @@
// Create a task that is scheduled by sending itself into the channel.
let schedule = move |t| s.upgrade().unwrap().send(t).unwrap();
- let (task, handle) = async_task::spawn(future, schedule);
+ let (runnable, handle) = async_task::spawn(future, schedule);
// Schedule the task by sending it into the channel.
- task.schedule();
+ runnable.schedule();
// Spawn a thread running the task to completion.
thread::spawn(move || {
// Keep taking the task from the channel and running it until completion.
- for task in receiver {
- task.run();
+ for runnable in receiver {
+ runnable.run();
}
});
diff --git a/examples/spawn.rs b/examples/spawn.rs
index 63e84b6..07d6acd 100644
--- a/examples/spawn.rs
+++ b/examples/spawn.rs
@@ -4,7 +4,7 @@
use std::panic::catch_unwind;
use std::thread;
-use async_task::{JoinHandle, Task};
+use async_task::{JoinHandle, Runnable};
use futures_lite::future;
use once_cell::sync::Lazy;
@@ -15,14 +15,14 @@
T: Send + 'static,
{
// A channel that holds scheduled tasks.
- static QUEUE: Lazy<flume::Sender<Task>> = Lazy::new(|| {
- let (sender, receiver) = flume::unbounded::<Task>();
+ static QUEUE: Lazy<flume::Sender<Runnable>> = Lazy::new(|| {
+ let (sender, receiver) = flume::unbounded::<Runnable>();
// Start the executor thread.
thread::spawn(|| {
- for task in receiver {
+ for runnable in receiver {
// Ignore panics for simplicity.
- let _ignore_panic = catch_unwind(|| task.run());
+ let _ignore_panic = catch_unwind(|| runnable.run());
}
});
@@ -31,10 +31,10 @@
// Create a task that is scheduled by sending itself into the channel.
let schedule = |t| QUEUE.send(t).unwrap();
- let (task, handle) = async_task::spawn(future, schedule);
+ let (runnable, handle) = async_task::spawn(future, schedule);
// Schedule the task by sending it into the channel.
- task.schedule();
+ runnable.schedule();
handle
}
diff --git a/src/lib.rs b/src/lib.rs
index 63ca99c..194a421 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -15,10 +15,10 @@
//! # let future = async { 1 + 2 };
//! #
//! # // A function that schedules the task when it gets woken up.
-//! # let schedule = move |task| sender.send(task).unwrap();
+//! # let schedule = move |runnable| sender.send(runnable).unwrap();
//! #
//! # // Construct a task.
-//! # let (task, handle) = async_task::spawn(future, schedule);
+//! # let (runnable, handle) = async_task::spawn(future, schedule);
//! ```
//!
//! A task is constructed using either [`spawn`] or [`spawn_local`]:
@@ -30,16 +30,16 @@
//! let future = async { 1 + 2 };
//!
//! // A function that schedules the task when it gets woken up.
-//! let schedule = move |task| sender.send(task).unwrap();
+//! let schedule = move |runnable| sender.send(runnable).unwrap();
//!
//! // Construct a task.
-//! let (task, handle) = async_task::spawn(future, schedule);
+//! let (runnable, handle) = async_task::spawn(future, schedule);
//!
//! // Push the task into the queue by invoking its schedule function.
-//! task.schedule();
+//! runnable.schedule();
//! ```
//!
-//! The function returns a runnable [`Task`] and a [`JoinHandle`] that can await the result.
+//! The function returns a runnable [`Runnable`] and a [`JoinHandle`] that can await the result.
//!
//! # Execution
//!
@@ -53,16 +53,16 @@
//! # let future = async { 1 + 2 };
//! #
//! # // A function that schedules the task when it gets woken up.
-//! # let schedule = move |task| sender.send(task).unwrap();
+//! # let schedule = move |runnable| sender.send(runnable).unwrap();
//! #
//! # // Construct a task.
-//! # let (task, handle) = async_task::spawn(future, schedule);
+//! # let (runnable, handle) = async_task::spawn(future, schedule);
//! #
//! # // Push the task into the queue by invoking its schedule function.
-//! # task.schedule();
+//! # runnable.schedule();
//! #
-//! for task in receiver {
-//! task.run();
+//! for runnable in receiver {
+//! runnable.run();
//! }
//! ```
//!
@@ -72,10 +72,10 @@
//!
//! # Cancellation
//!
-//! Both [`Task`] and [`JoinHandle`] have methods that cancel the task. When canceled, the task's
-//! future will not be polled again and will get dropped instead.
+//! Both [`Runnable`] and [`JoinHandle`] have methods that cancel the task. When canceled, the
+//! task's future will not be polled again and will get dropped instead.
//!
-//! If canceled by the [`Task`] instance, the task is destroyed immediately. If canceled by the
+//! If canceled by the [`Runnable`] instance, the task is destroyed immediately. If canceled by the
//! [`JoinHandle`] instance, it will be scheduled one more time and the next attempt to run it will
//! simply destroy it.
//!
@@ -90,12 +90,7 @@
//! The layout of a task is equivalent to 4 `usize`s followed by the schedule function, and then by
//! a union of the future and its output.
//!
-//! [`spawn`]: fn.spawn.html
-//! [`spawn_local`]: fn.spawn_local.html
-//! [`Task`]: struct.Task.html
-//! [`JoinHandle`]: struct.JoinHandle.html
-//! [`Waker`]: https://doc.rust-lang.org/std/task/struct.Waker.html
-//! [`block_on`]: https://github.com/async-rs/async-task/blob/master/examples/block.rs
+//! [`block_on`]: https://github.com/stjepang/async-task/blob/master/examples/block.rs
#![cfg_attr(not(feature = "std"), no_std)]
#![warn(missing_docs, missing_debug_implementations, rust_2018_idioms)]
@@ -108,11 +103,11 @@
mod join_handle;
mod raw;
mod state;
-mod task;
+mod runnable;
mod utils;
pub use crate::join_handle::JoinHandle;
-pub use crate::task::{spawn, Task};
+pub use crate::runnable::{spawn, Runnable};
#[cfg(feature = "std")]
-pub use crate::task::spawn_local;
+pub use crate::runnable::spawn_local;
diff --git a/src/raw.rs b/src/raw.rs
index 7144aca..51dddd7 100644
--- a/src/raw.rs
+++ b/src/raw.rs
@@ -10,7 +10,7 @@
use crate::header::Header;
use crate::state::*;
use crate::utils::{abort, abort_on_panic, extend};
-use crate::Task;
+use crate::Runnable;
/// The vtable for a task.
pub(crate) struct TaskVTable {
@@ -83,7 +83,7 @@
impl<F, T, S> RawTask<F, T, S>
where
F: Future<Output = T> + 'static,
- S: Fn(Task) + Send + Sync + 'static,
+ S: Fn(Runnable) + Send + Sync + 'static,
{
const RAW_WAKER_VTABLE: RawWakerVTable = RawWakerVTable::new(
Self::clone_waker,
@@ -94,7 +94,7 @@
/// Allocates a task with the given `future` and `schedule` function.
///
- /// It is assumed that initially only the `Task` reference and the `JoinHandle` exist.
+ /// It is assumed that initially only the `Runnable` reference and the `JoinHandle` exist.
pub(crate) fn allocate(future: F, schedule: S) -> NonNull<()> {
// Compute the layout of the task for allocation. Abort if the computation fails.
let task_layout = abort_on_panic(|| Self::task_layout());
@@ -295,7 +295,7 @@
// Schedule the task. There is no need to call `Self::schedule(ptr)`
// because the schedule function cannot be destroyed while the waker is
// still alive.
- let task = Task {
+ let task = Runnable {
raw_task: NonNull::new_unchecked(ptr as *mut ()),
};
(*raw.schedule)(task);
@@ -386,7 +386,7 @@
_waker = Waker::from_raw(Self::clone_waker(ptr));
}
- let task = Task {
+ let task = Runnable {
raw_task: NonNull::new_unchecked(ptr as *mut ()),
};
(*raw.schedule)(task);
@@ -593,12 +593,12 @@
struct Guard<F, T, S>(RawTask<F, T, S>)
where
F: Future<Output = T> + 'static,
- S: Fn(Task) + Send + Sync + 'static;
+ S: Fn(Runnable) + Send + Sync + 'static;
impl<F, T, S> Drop for Guard<F, T, S>
where
F: Future<Output = T> + 'static,
- S: Fn(Task) + Send + Sync + 'static,
+ S: Fn(Runnable) + Send + Sync + 'static,
{
fn drop(&mut self) {
let raw = self.0;
diff --git a/src/task.rs b/src/runnable.rs
similarity index 72%
rename from src/task.rs
rename to src/runnable.rs
index 02ef126..12f9619 100644
--- a/src/task.rs
+++ b/src/runnable.rs
@@ -13,8 +13,8 @@
/// Creates a new task.
///
-/// This constructor returns a [`Task`] reference that runs the future and a [`JoinHandle`] that
-/// awaits its result.
+/// This constructor returns a [`Runnable`] reference that runs the future and a [`JoinHandle`]
+/// that awaits its result.
///
/// When run, the task polls `future`. When woken up, it gets scheduled for running by the
/// `schedule` function.
@@ -25,11 +25,6 @@
/// If you need to spawn a future that does not implement [`Send`], consider using the
/// [`spawn_local`] function instead.
///
-/// [`Task`]: struct.Task.html
-/// [`JoinHandle`]: struct.JoinHandle.html
-/// [`Send`]: https://doc.rust-lang.org/std/marker/trait.Send.html
-/// [`spawn_local`]: fn.spawn_local.html
-///
/// # Examples
///
/// ```
@@ -40,16 +35,16 @@
///
/// // If the task gets woken up, it will be sent into this channel.
/// let (s, r) = flume::unbounded();
-/// let schedule = move |task| s.send(task).unwrap();
+/// let schedule = move |runnable| s.send(runnable).unwrap();
///
/// // Create a task with the future and the schedule function.
-/// let (task, handle) = async_task::spawn(future, schedule);
+/// let (runnable, handle) = async_task::spawn(future, schedule);
/// ```
-pub fn spawn<F, T, S>(future: F, schedule: S) -> (Task, JoinHandle<T>)
+pub fn spawn<F, T, S>(future: F, schedule: S) -> (Runnable, JoinHandle<T>)
where
F: Future<Output = T> + Send + 'static,
T: Send + 'static,
- S: Fn(Task) + Send + Sync + 'static,
+ S: Fn(Runnable) + Send + Sync + 'static,
{
// Allocate large futures on the heap.
let raw_task = if mem::size_of::<F>() >= 2048 {
@@ -59,7 +54,7 @@
RawTask::<F, T, S>::allocate(future, schedule)
};
- let task = Task { raw_task };
+ let task = Runnable { raw_task };
let handle = JoinHandle {
raw_task,
_marker: PhantomData,
@@ -69,8 +64,8 @@
/// Creates a new local task.
///
-/// This constructor returns a [`Task`] reference that runs the future and a [`JoinHandle`] that
-/// awaits its result.
+/// This constructor returns a [`Runnable`] reference that runs the future and a [`JoinHandle`]
+/// that awaits its result.
///
/// When run, the task polls `future`. When woken up, it gets scheduled for running by the
/// `schedule` function.
@@ -79,16 +74,11 @@
/// push the task into some kind of queue so that it can be processed later.
///
/// Unlike [`spawn`], this function does not require the future to implement [`Send`]. If the
-/// [`Task`] reference is run or dropped on a thread it was not created on, a panic will occur.
+/// [`Runnable`] reference is run or dropped on a thread it was not created on, a panic will occur.
///
/// **NOTE:** This function is only available when the `std` feature for this crate is enabled (it
/// is by default).
///
-/// [`Task`]: struct.Task.html
-/// [`JoinHandle`]: struct.JoinHandle.html
-/// [`spawn`]: fn.spawn.html
-/// [`Send`]: https://doc.rust-lang.org/std/marker/trait.Send.html
-///
/// # Examples
///
/// ```
@@ -99,17 +89,17 @@
///
/// // If the task gets woken up, it will be sent into this channel.
/// let (s, r) = flume::unbounded();
-/// let schedule = move |task| s.send(task).unwrap();
+/// let schedule = move |runnable| s.send(runnable).unwrap();
///
/// // Create a task with the future and the schedule function.
-/// let (task, handle) = async_task::spawn_local(future, schedule);
+/// let (runnable, handle) = async_task::spawn_local(future, schedule);
/// ```
#[cfg(feature = "std")]
-pub fn spawn_local<F, T, S>(future: F, schedule: S) -> (Task, JoinHandle<T>)
+pub fn spawn_local<F, T, S>(future: F, schedule: S) -> (Runnable, JoinHandle<T>)
where
F: Future<Output = T> + 'static,
T: 'static,
- S: Fn(Task) + Send + Sync + 'static,
+ S: Fn(Runnable) + Send + Sync + 'static,
{
use std::mem::ManuallyDrop;
use std::pin::Pin;
@@ -168,7 +158,7 @@
RawTask::<_, T, S>::allocate(future, schedule)
};
- let task = Task { raw_task };
+ let task = Runnable { raw_task };
let handle = JoinHandle {
raw_task,
_marker: PhantomData,
@@ -178,38 +168,34 @@
/// A task reference that runs its future.
///
-/// At any moment in time, there is at most one [`Task`] reference associated with a particular
-/// task. Running consumes the [`Task`] reference and polls its internal future. If the future is
-/// still pending after getting polled, the [`Task`] reference simply won't exist until a [`Waker`]
-/// notifies the task. If the future completes, its result becomes available to the [`JoinHandle`].
+/// At any moment in time, there is at most one [`Runnable`] reference associated with a particular
+/// task. Running consumes the [`Runnable`] reference and polls its internal future. If the future
+/// is still pending after getting polled, the [`Runnable`] reference simply won't exist until a
+/// [`Waker`] notifies the task. If the future completes, its result becomes available to the
+/// [`JoinHandle`].
///
-/// When a task is woken up, its [`Task`] reference is recreated and passed to the schedule
-/// function. In most executors, scheduling simply pushes the [`Task`] reference into a queue of
-/// runnable tasks.
+/// When a task is woken up, its [`Runnable`] reference is recreated and passed to the schedule
+/// function. In most executors, scheduling simply pushes the [`Runnable`] reference into a queue
+/// of runnable tasks.
///
-/// If the [`Task`] reference is dropped without getting run, the task is automatically canceled.
-/// When canceled, the task won't be scheduled again even if a [`Waker`] wakes it. It is possible
-/// for the [`JoinHandle`] to cancel while the [`Task`] reference exists, in which case an attempt
-/// to run the task won't do anything.
-///
-/// [`run()`]: struct.Task.html#method.run
-/// [`JoinHandle`]: struct.JoinHandle.html
-/// [`Task`]: struct.Task.html
-/// [`Waker`]: https://doc.rust-lang.org/std/task/struct.Waker.html
-pub struct Task {
+/// If the [`Runnable`] reference is dropped without getting run, the task is automatically
+/// canceled. When canceled, the task won't be scheduled again even if a [`Waker`] wakes it. It is
+/// possible for the [`JoinHandle`] to cancel while the [`Runnable`] reference exists, in which
+/// case an attempt to run the task won't do anything.
+pub struct Runnable {
/// A pointer to the heap-allocated task.
pub(crate) raw_task: NonNull<()>,
}
-unsafe impl Send for Task {}
-unsafe impl Sync for Task {}
+unsafe impl Send for Runnable {}
+unsafe impl Sync for Runnable {}
#[cfg(feature = "std")]
-impl std::panic::UnwindSafe for Task {}
+impl std::panic::UnwindSafe for Runnable {}
#[cfg(feature = "std")]
-impl std::panic::RefUnwindSafe for Task {}
+impl std::panic::RefUnwindSafe for Runnable {}
-impl Task {
+impl Runnable {
/// Schedules the task.
///
/// This is a convenience method that simply reschedules the task by passing it to its schedule
@@ -241,9 +227,6 @@
/// It is possible that polling the future panics, in which case the panic will be propagated
/// into the caller. It is advised that invocations of this method are wrapped inside
/// [`catch_unwind`]. If a panic occurs, the task is automatically canceled.
- ///
- /// [`JoinHandle`]: struct.JoinHandle.html
- /// [`catch_unwind`]: https://doc.rust-lang.org/std/panic/fn.catch_unwind.html
pub fn run(self) -> bool {
let ptr = self.raw_task.as_ptr();
let header = ptr as *const Header;
@@ -264,7 +247,7 @@
}
}
-impl Drop for Task {
+impl Drop for Runnable {
fn drop(&mut self) {
let ptr = self.raw_task.as_ptr();
let header = ptr as *const Header;
@@ -290,12 +273,12 @@
}
}
-impl fmt::Debug for Task {
+impl fmt::Debug for Runnable {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
let ptr = self.raw_task.as_ptr();
let header = ptr as *const Header;
- f.debug_struct("Task")
+ f.debug_struct("Runnable")
.field("header", unsafe { &(*header) })
.finish()
}
diff --git a/src/state.rs b/src/state.rs
index 099e6bc..343cc4d 100644
--- a/src/state.rs
+++ b/src/state.rs
@@ -1,7 +1,7 @@
/// Set if the task is scheduled for running.
///
-/// A task is considered to be scheduled whenever its `Task` reference exists. It therefore also
-/// begins in scheduled state at the moment of creation.
+/// A task is considered to be scheduled whenever its `Runnable` reference exists. It therefore
+/// also begins in scheduled state at the moment of creation.
///
/// This flag can't be set when the task is completed. However, it can be set while the task is
/// running, in which case it will be rescheduled as soon as polling finishes.
@@ -29,7 +29,7 @@
/// If a task is closed, that means it's either canceled or its output has been consumed by the
/// `JoinHandle`. A task becomes closed when:
///
-/// 1. It gets canceled by `Task::cancel()`, `Task::drop()`, or `JoinHandle::cancel()`.
+/// 1. It gets canceled by `Runnable::drop()`, `Task::drop()`, or `Task::cancel()`.
/// 2. Its output gets awaited by the `JoinHandle`.
/// 3. It panics while polling the future.
/// 4. It is completed and the `JoinHandle` gets dropped.
@@ -38,7 +38,7 @@
/// Set if the `JoinHandle` still exists.
///
/// The `JoinHandle` is a special case in that it is only tracked by this flag, while all other
-/// task references (`Task` and `Waker`s) are tracked by the reference count.
+/// task references (`Runnable` and `Waker`s) are tracked by the reference count.
pub(crate) const HANDLE: usize = 1 << 4;
/// Set if the `JoinHandle` is awaiting the output.
@@ -65,6 +65,6 @@
/// bits contain the reference count. The value of `REFERENCE` represents a single reference in the
/// total reference count.
///
-/// Note that the reference counter only tracks the `Task` and `Waker`s. The `JoinHandle` is
+/// Note that the reference counter only tracks the `Runnable` and `Waker`s. The `JoinHandle` is
/// tracked separately by the `HANDLE` flag.
pub(crate) const REFERENCE: usize = 1 << 8;
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::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 @@
}
let guard = Guard(Box::new(0));
- move |_task| {
+ move |_runnable| {
&guard;
$sched.fetch_add(1, Ordering::SeqCst);
}
@@ -79,14 +79,14 @@
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 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 @@
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_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 @@
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 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 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 @@
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 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 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 @@
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 @@
#[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 @@
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 @@
}
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::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 @@
}
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 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 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_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::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 @@
}
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 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 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 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 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_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_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 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_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_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 @@
}
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::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 @@
}
let guard = Guard(Box::new(0));
- move |_task: Task| {
+ move |_runnable: Runnable| {
&guard;
$sched.fetch_add(1, Ordering::SeqCst);
}
@@ -84,11 +84,11 @@
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 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 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 @@
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 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 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 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::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 @@
}
let guard = Guard(Box::new(0));
- move |_task: Task| {
+ move |_runnable: Runnable| {
&guard;
$sched.fetch_add(1, Ordering::SeqCst);
}
@@ -96,11 +96,11 @@
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 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 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 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::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 @@
}
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 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 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 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 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 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 @@
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::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 @@
}
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 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 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 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 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 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 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 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::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 @@
}
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 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 @@
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_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 @@
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 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 @@
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 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_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);
