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

sync: polish and update API doc examples (#1398)

Browse Source 
- Remove `poll_*` fns from some of the sync types.
- Move `AtomicWaker` and `Lock` to the root of the `sync` crate.
This commit is contained in:
Carl Lerche
2019-08-06 13:54:56 -07:00
committed by GitHub
parent 05d00aebb7
commit 2f43b0a023
19 changed files with 408 additions and 313 deletions
Download Patch File Download Diff File Expand all files Collapse all files
tokio-sync/tests/atomic_waker.rs
+1 -1
View File
@@ -1,7 +1,7 @@
#![deny(warnings, rust_2018_idioms)]
use std::task::Waker;
use tokio_sync::task::AtomicWaker;
use tokio_sync::AtomicWaker;
use tokio_test::task::MockTask;
trait AssertSend: Send {}
tokio-sync/tests/fuzz_atomic_waker.rs
+1 -1
View File
@@ -8,7 +8,7 @@ extern crate loom;
mod atomic_waker;
use crate::atomic_waker::AtomicWaker;
use async_util::future::poll_fn;
use futures_util::future::poll_fn;
use loom::futures::block_on;
use loom::sync::atomic::AtomicUsize;
use loom::thread;
tokio-sync/tests/fuzz_mpsc.rs
+1 -2
View File
@@ -18,8 +18,7 @@ mod mpsc;
#[allow(warnings)]
mod semaphore;
// use futures::{future::poll_fn, Stream};
use async_util::future::poll_fn;
use futures_util::future::poll_fn;
use loom::futures::block_on;
use loom::thread;
tokio-sync/tests/fuzz_semaphore.rs
+1 -1
View File
@@ -9,8 +9,8 @@ mod semaphore;
use crate::semaphore::*;
use async_util::future::poll_fn;
use futures_core::ready;
use futures_util::future::poll_fn;
use loom::futures::block_on;
use loom::thread;
use std::future::Future;
tokio-sync/tests/lock.rs
+24 -21
View File
@@ -1,55 +1,57 @@
#![deny(warnings, rust_2018_idioms)]
use pin_utils::pin_mut;
use tokio_sync::lock::Lock;
use tokio_test::task::MockTask;
use tokio_sync::Lock;
use tokio_test::task::spawn;
use tokio_test::{assert_pending, assert_ready};
#[test]
fn straight_execution() {
let mut task = MockTask::new();
let mut l = Lock::new(100);
// We can immediately acquire the lock and take the value
task.enter(|cx| {
let mut g = assert_ready!(l.poll_lock(cx));
{
let mut t = spawn(l.lock());
let mut g = assert_ready!(t.poll());
assert_eq!(&*g, &100);
*g = 99;
drop(g);
let mut g = assert_ready!(l.poll_lock(cx));
}
{
let mut t = spawn(l.lock());
let mut g = assert_ready!(t.poll());
assert_eq!(&*g, &99);
*g = 98;
drop(g);
let mut g = assert_ready!(l.poll_lock(cx));
}
{
let mut t = spawn(l.lock());
let mut g = assert_ready!(t.poll());
assert_eq!(&*g, &98);
// We can continue to access the guard even if the lock is dropped
drop(t);
drop(l);
*g = 97;
assert_eq!(&*g, &97);
});
}
}
#[test]
fn readiness() {
let mut t1 = MockTask::new();
let mut t2 = MockTask::new();
let mut l1 = Lock::new(100);
let mut l2 = l1.clone();
let mut t1 = spawn(l1.lock());
let mut t2 = spawn(l2.lock());
let mut l = Lock::new(100);
let g = assert_ready!(t1.enter(|cx| l.poll_lock(cx)));
let g = assert_ready!(t1.poll());
// We can't now acquire the lease since it's already held in g
assert_pending!(t2.enter(|cx| l.poll_lock(cx)));
assert_pending!(t2.poll());
// But once g unlocks, we can acquire it
drop(g);
assert!(t2.is_woken());
assert_ready!(t2.enter(|cx| l.poll_lock(cx)));
assert_ready!(t2.poll());
}
/*
#[test]
#[ignore]
fn lock() {
@@ -79,3 +81,4 @@ fn lock() {
let result = assert_ready!(task.poll(&mut l));
assert!(*result);
}
*/
tokio-sync/tests/watch.rs
+153 -138
View File
@@ -1,7 +1,7 @@
#![deny(warnings, rust_2018_idioms)]
use tokio_sync::watch;
use tokio_test::task::MockTask;
use tokio_test::task::spawn;
use tokio_test::{assert_pending, assert_ready};
/*
@@ -27,110 +27,111 @@ macro_rules! assert_not_ready {
*/
#[test]
fn single_rx_poll_ref() {
fn single_rx_recv_ref() {
let (tx, mut rx) = watch::channel("one");
let mut task = MockTask::new();
task.enter(|cx| {
{
let v = assert_ready!(rx.poll_ref(cx)).unwrap();
assert_eq!(*v, "one");
}
assert_pending!(rx.poll_ref(cx));
});
{
let mut t = spawn(rx.recv_ref());
let v = assert_ready!(t.poll()).unwrap();
assert_eq!(*v, "one");
}
tx.broadcast("two").unwrap();
{
let mut t = spawn(rx.recv_ref());
assert!(task.is_woken());
assert_pending!(t.poll());
task.enter(|cx| {
{
let v = assert_ready!(rx.poll_ref(cx)).unwrap();
assert_eq!(*v, "two");
}
assert_pending!(rx.poll_ref(cx));
});
tx.broadcast("two").unwrap();
drop(tx);
assert!(t.is_woken());
assert!(task.is_woken());
let v = assert_ready!(t.poll()).unwrap();
assert_eq!(*v, "two");
}
task.enter(|cx| {
let res = assert_ready!(rx.poll_ref(cx));
{
let mut t = spawn(rx.recv_ref());
assert_pending!(t.poll());
drop(tx);
let res = assert_ready!(t.poll());
assert!(res.is_none());
});
}
}
#[test]
fn single_rx_poll_next() {
fn single_rx_recv() {
let (tx, mut rx) = watch::channel("one");
let mut task = MockTask::new();
task.enter(|cx| {
let v = assert_ready!(rx.poll_next(cx)).unwrap();
{
let mut t = spawn(rx.recv());
let v = assert_ready!(t.poll()).unwrap();
assert_eq!(v, "one");
assert_pending!(rx.poll_ref(cx));
});
}
tx.broadcast("two").unwrap();
{
let mut t = spawn(rx.recv());
assert!(task.is_woken());
assert_pending!(t.poll());
task.enter(|cx| {
let v = assert_ready!(rx.poll_next(cx)).unwrap();
tx.broadcast("two").unwrap();
assert!(t.is_woken());
let v = assert_ready!(t.poll()).unwrap();
assert_eq!(v, "two");
assert_pending!(rx.poll_ref(cx));
});
}
drop(tx);
{
let mut t = spawn(rx.recv());
assert!(task.is_woken());
assert_pending!(t.poll());
task.enter(|cx| {
let res = assert_ready!(rx.poll_next(cx));
drop(tx);
let res = assert_ready!(t.poll());
assert!(res.is_none());
});
}
}
#[test]
#[cfg(feature = "async-traits")]
fn stream_impl() {
use futures_core::Stream;
use pin_utils::pin_mut;
use tokio::prelude::*;
let (tx, rx) = watch::channel("one");
let mut task = MockTask::new();
let (tx, mut rx) = watch::channel("one");
pin_mut!(rx);
{
let mut t = spawn(rx.next());
let v = assert_ready!(t.poll()).unwrap();
assert_eq!(v, "one");
}
task.enter(|cx| {
{
let v = assert_ready!(Stream::poll_next(rx.as_mut(), cx)).unwrap();
assert_eq!(v, "one");
}
assert_pending!(rx.poll_ref(cx));
});
{
let mut t = spawn(rx.next());
tx.broadcast("two").unwrap();
assert_pending!(t.poll());
assert!(task.is_woken());
tx.broadcast("two").unwrap();
task.enter(|cx| {
{
let v = assert_ready!(Stream::poll_next(rx.as_mut(), cx)).unwrap();
assert_eq!(v, "two");
}
assert_pending!(rx.poll_ref(cx));
});
assert!(t.is_woken());
drop(tx);
let v = assert_ready!(t.poll()).unwrap();
assert_eq!(v, "two");
}
assert!(task.is_woken());
{
let mut t = spawn(rx.next());
task.enter(|cx| {
let res = assert_ready!(Stream::poll_next(rx, cx));
assert_pending!(t.poll());
drop(tx);
let res = assert_ready!(t.poll());
assert!(res.is_none());
});
}
}
#[test]
@@ -138,67 +139,83 @@ fn multi_rx() {
let (tx, mut rx1) = watch::channel("one");
let mut rx2 = rx1.clone();
let mut task1 = MockTask::new();
let mut task2 = MockTask::new();
{
let mut t1 = spawn(rx1.recv_ref());
let mut t2 = spawn(rx2.recv_ref());
task1.enter(|cx| {
let res = assert_ready!(rx1.poll_ref(cx));
let res = assert_ready!(t1.poll());
assert_eq!(*res.unwrap(), "one");
});
task2.enter(|cx| {
let res = assert_ready!(rx2.poll_ref(cx));
let res = assert_ready!(t2.poll());
assert_eq!(*res.unwrap(), "one");
});
}
tx.broadcast("two").unwrap();
let mut t2 = spawn(rx2.recv_ref());
assert!(task1.is_woken());
assert!(task2.is_woken());
{
let mut t1 = spawn(rx1.recv_ref());
task1.enter(|cx| {
let res = assert_ready!(rx1.poll_ref(cx));
assert_pending!(t1.poll());
assert_pending!(t2.poll());
tx.broadcast("two").unwrap();
assert!(t1.is_woken());
assert!(t2.is_woken());
let res = assert_ready!(t1.poll());
assert_eq!(*res.unwrap(), "two");
});
}
tx.broadcast("three").unwrap();
{
let mut t1 = spawn(rx1.recv_ref());
assert!(task1.is_woken());
assert!(task2.is_woken());
assert_pending!(t1.poll());
task1.enter(|cx| {
let res = assert_ready!(rx1.poll_ref(cx));
tx.broadcast("three").unwrap();
assert!(t1.is_woken());
assert!(t2.is_woken());
let res = assert_ready!(t1.poll());
assert_eq!(*res.unwrap(), "three");
});
task2.enter(|cx| {
let res = assert_ready!(rx2.poll_ref(cx));
let res = assert_ready!(t2.poll());
assert_eq!(*res.unwrap(), "three");
});
}
tx.broadcast("four").unwrap();
drop(t2);
task1.enter(|cx| {
let res = assert_ready!(rx1.poll_ref(cx));
{
let mut t1 = spawn(rx1.recv_ref());
let mut t2 = spawn(rx2.recv_ref());
assert_pending!(t1.poll());
assert_pending!(t2.poll());
tx.broadcast("four").unwrap();
let res = assert_ready!(t1.poll());
assert_eq!(*res.unwrap(), "four");
});
drop(t1);
drop(tx);
let mut t1 = spawn(rx1.recv_ref());
assert_pending!(t1.poll());
task1.enter(|cx| {
let res = assert_ready!(rx1.poll_ref(cx));
drop(tx);
assert!(t1.is_woken());
let res = assert_ready!(t1.poll());
assert!(res.is_none());
});
task2.enter(|cx| {
let res = assert_ready!(rx2.poll_ref(cx));
let res = assert_ready!(t2.poll());
assert_eq!(*res.unwrap(), "four");
});
task2.enter(|cx| {
let res = assert_ready!(rx2.poll_ref(cx));
drop(t2);
let mut t2 = spawn(rx2.recv_ref());
let res = assert_ready!(t2.poll());
assert!(res.is_none());
});
}
}
#[test]
@@ -206,67 +223,65 @@ fn rx_observes_final_value() {
// Initial value
let (tx, mut rx) = watch::channel("one");
let mut task = MockTask::new();
drop(tx);
task.enter(|cx| {
let res = assert_ready!(rx.poll_ref(cx));
assert!(res.is_some());
{
let mut t1 = spawn(rx.recv_ref());
let res = assert_ready!(t1.poll());
assert_eq!(*res.unwrap(), "one");
});
}
task.enter(|cx| {
let res = assert_ready!(rx.poll_ref(cx));
{
let mut t1 = spawn(rx.recv_ref());
let res = assert_ready!(t1.poll());
assert!(res.is_none());
});
}
// Sending a value
let (tx, mut rx) = watch::channel("one");
let mut task = MockTask::new();
tx.broadcast("two").unwrap();
task.enter(|cx| {
{
let res = assert_ready!(rx.poll_ref(cx));
assert!(res.is_some());
assert_eq!(*res.unwrap(), "two");
}
{
let mut t1 = spawn(rx.recv_ref());
let res = assert_ready!(t1.poll());
assert_eq!(*res.unwrap(), "two");
}
assert_pending!(rx.poll_ref(cx));
});
{
let mut t1 = spawn(rx.recv_ref());
assert_pending!(t1.poll());
tx.broadcast("three").unwrap();
drop(tx);
tx.broadcast("three").unwrap();
drop(tx);
assert!(task.is_woken());
assert!(t1.is_woken());
task.enter(|cx| {
let res = assert_ready!(rx.poll_ref(cx));
assert!(res.is_some());
let res = assert_ready!(t1.poll());
assert_eq!(*res.unwrap(), "three");
});
}
task.enter(|cx| {
let res = assert_ready!(rx.poll_ref(cx));
{
let mut t1 = spawn(rx.recv_ref());
let res = assert_ready!(t1.poll());
assert!(res.is_none());
});
}
}
#[test]
fn poll_close() {
let (mut tx, rx) = watch::channel("one");
let mut task = MockTask::new();
assert_pending!(task.enter(|cx| tx.poll_close(cx)));
{
let mut t = spawn(tx.closed());
assert_pending!(t.poll());
drop(rx);
drop(rx);
assert!(task.is_woken());
assert_ready!(task.enter(|cx| tx.poll_close(cx)));
assert!(t.is_woken());
assert_ready!(t.poll());
}
assert!(tx.broadcast("two").is_err());
}