chore: checkpoint before Python removal

vendor/tokio/tests/_require_full.rs

@@ -0,0 +1,8 @@
+#[cfg(not(any(feature = "full", target_family = "wasm")))]
+compile_error!("run main Tokio tests with `--features full`");
+
+// CI sets `--cfg tokio_no_parking_lot` when trying to run tests with
+// `parking_lot` disabled. This check prevents "silent failure" if `parking_lot`
+// accidentally gets enabled.
+#[cfg(all(tokio_no_parking_lot, feature = "parking_lot"))]
+compile_error!("parking_lot feature enabled when it should not be");

vendor/tokio/tests/async_send_sync.rs

@@ -0,0 +1,778 @@
+#![warn(rust_2018_idioms)]
+#![cfg(feature = "full")]
+#![allow(clippy::type_complexity, clippy::diverging_sub_expression)]
+
+use std::cell::Cell;
+use std::future::Future;
+use std::io::SeekFrom;
+use std::net::SocketAddr;
+use std::pin::Pin;
+use std::rc::Rc;
+use tokio::net::TcpStream;
+use tokio::time::{Duration, Instant};
+
+// The names of these structs behaves better when sorted.
+// Send: Yes, Sync: Yes
+#[derive(Clone)]
+#[allow(unused)]
+struct YY {}
+
+// Send: Yes, Sync: No
+#[derive(Clone)]
+#[allow(unused)]
+struct YN {
+    _value: Cell<u8>,
+}
+
+// Send: No, Sync: No
+#[derive(Clone)]
+#[allow(unused)]
+struct NN {
+    _value: Rc<u8>,
+}
+
+#[allow(dead_code)]
+type BoxFutureSync<T> = std::pin::Pin<Box<dyn std::future::Future<Output = T> + Send + Sync>>;
+#[allow(dead_code)]
+type BoxFutureSend<T> = std::pin::Pin<Box<dyn std::future::Future<Output = T> + Send>>;
+#[allow(dead_code)]
+type BoxFuture<T> = std::pin::Pin<Box<dyn std::future::Future<Output = T>>>;
+
+#[allow(dead_code)]
+type BoxAsyncRead = std::pin::Pin<Box<dyn tokio::io::AsyncBufRead + Send + Sync>>;
+#[allow(dead_code)]
+type BoxAsyncSeek = std::pin::Pin<Box<dyn tokio::io::AsyncSeek + Send + Sync>>;
+#[allow(dead_code)]
+type BoxAsyncWrite = std::pin::Pin<Box<dyn tokio::io::AsyncWrite + Send + Sync>>;
+
+#[allow(dead_code)]
+fn require_send<T: Send>(_t: &T) {}
+#[allow(dead_code)]
+fn require_sync<T: Sync>(_t: &T) {}
+#[allow(dead_code)]
+fn require_unpin<T: Unpin>(_t: &T) {}
+
+#[allow(dead_code)]
+struct Invalid;
+
+#[allow(unused)]
+trait AmbiguousIfSend<A> {
+    fn some_item(&self) {}
+}
+impl<T: ?Sized> AmbiguousIfSend<()> for T {}
+impl<T: ?Sized + Send> AmbiguousIfSend<Invalid> for T {}
+
+#[allow(unused)]
+trait AmbiguousIfSync<A> {
+    fn some_item(&self) {}
+}
+impl<T: ?Sized> AmbiguousIfSync<()> for T {}
+impl<T: ?Sized + Sync> AmbiguousIfSync<Invalid> for T {}
+
+#[allow(unused)]
+trait AmbiguousIfUnpin<A> {
+    fn some_item(&self) {}
+}
+impl<T: ?Sized> AmbiguousIfUnpin<()> for T {}
+impl<T: ?Sized + Unpin> AmbiguousIfUnpin<Invalid> for T {}
+
+macro_rules! into_todo {
+    ($typ:ty) => {{
+        let x: $typ = todo!();
+        x
+    }};
+}
+
+macro_rules! async_assert_fn_send {
+    (Send & $(!)?Sync & $(!)?Unpin, $value:expr) => {
+        require_send(&$value);
+    };
+    (!Send & $(!)?Sync & $(!)?Unpin, $value:expr) => {
+        AmbiguousIfSend::some_item(&$value);
+    };
+}
+macro_rules! async_assert_fn_sync {
+    ($(!)?Send & Sync & $(!)?Unpin, $value:expr) => {
+        require_sync(&$value);
+    };
+    ($(!)?Send & !Sync & $(!)?Unpin, $value:expr) => {
+        AmbiguousIfSync::some_item(&$value);
+    };
+}
+macro_rules! async_assert_fn_unpin {
+    ($(!)?Send & $(!)?Sync & Unpin, $value:expr) => {
+        require_unpin(&$value);
+    };
+    ($(!)?Send & $(!)?Sync & !Unpin, $value:expr) => {
+        AmbiguousIfUnpin::some_item(&$value);
+    };
+}
+
+macro_rules! async_assert_fn {
+    ($($f:ident $(< $($generic:ty),* > )? )::+($($arg:ty),*): $($tok:tt)*) => {
+        #[allow(unreachable_code)]
+        #[allow(unused_variables)]
+        const _: fn() = || {
+            let f = $($f $(::<$($generic),*>)? )::+( $( into_todo!($arg) ),* );
+            async_assert_fn_send!($($tok)*, f);
+            async_assert_fn_sync!($($tok)*, f);
+            async_assert_fn_unpin!($($tok)*, f);
+        };
+    };
+}
+macro_rules! assert_value {
+    ($type:ty: $($tok:tt)*) => {
+        #[allow(unreachable_code)]
+        #[allow(unused_variables)]
+        const _: fn() = || {
+            let f: $type = todo!();
+            async_assert_fn_send!($($tok)*, f);
+            async_assert_fn_sync!($($tok)*, f);
+            async_assert_fn_unpin!($($tok)*, f);
+        };
+    };
+}
+
+macro_rules! cfg_not_wasi {
+    ($($item:item)*) => {
+        $(
+            #[cfg(not(target_os = "wasi"))]
+            $item
+        )*
+    }
+}
+
+// Manually re-implementation of `async_assert_fn` for `poll_fn`. The macro
+// doesn't work for this particular case because constructing the closure
+// is too complicated.
+const _: fn() = || {
+    let pinned = std::marker::PhantomPinned;
+    let f = tokio::macros::support::poll_fn(move |_| {
+        // Use `pinned` to take ownership of it.
+        let _ = &pinned;
+        std::task::Poll::Pending::<()>
+    });
+    require_send(&f);
+    require_sync(&f);
+    AmbiguousIfUnpin::some_item(&f);
+};
+
+cfg_not_wasi! {
+    mod fs {
+        use super::*;
+        assert_value!(tokio::fs::DirBuilder: Send & Sync & Unpin);
+        assert_value!(tokio::fs::DirEntry: Send & Sync & Unpin);
+        assert_value!(tokio::fs::File: Send & Sync & Unpin);
+        assert_value!(tokio::fs::OpenOptions: Send & Sync & Unpin);
+        assert_value!(tokio::fs::ReadDir: Send & Sync & Unpin);
+
+        async_assert_fn!(tokio::fs::canonicalize(&str): Send & Sync & !Unpin);
+        async_assert_fn!(tokio::fs::copy(&str, &str): Send & Sync & !Unpin);
+        async_assert_fn!(tokio::fs::create_dir(&str): Send & Sync & !Unpin);
+        async_assert_fn!(tokio::fs::create_dir_all(&str): Send & Sync & !Unpin);
+        async_assert_fn!(tokio::fs::hard_link(&str, &str): Send & Sync & !Unpin);
+        async_assert_fn!(tokio::fs::metadata(&str): Send & Sync & !Unpin);
+        async_assert_fn!(tokio::fs::read(&str): Send & Sync & !Unpin);
+        async_assert_fn!(tokio::fs::read_dir(&str): Send & Sync & !Unpin);
+        async_assert_fn!(tokio::fs::read_link(&str): Send & Sync & !Unpin);
+        async_assert_fn!(tokio::fs::read_to_string(&str): Send & Sync & !Unpin);
+        async_assert_fn!(tokio::fs::remove_dir(&str): Send & Sync & !Unpin);
+        async_assert_fn!(tokio::fs::remove_dir_all(&str): Send & Sync & !Unpin);
+        async_assert_fn!(tokio::fs::remove_file(&str): Send & Sync & !Unpin);
+        async_assert_fn!(tokio::fs::rename(&str, &str): Send & Sync & !Unpin);
+        async_assert_fn!(tokio::fs::set_permissions(&str, std::fs::Permissions): Send & Sync & !Unpin);
+        async_assert_fn!(tokio::fs::symlink_metadata(&str): Send & Sync & !Unpin);
+        async_assert_fn!(tokio::fs::write(&str, Vec<u8>): Send & Sync & !Unpin);
+        async_assert_fn!(tokio::fs::ReadDir::next_entry(_): Send & Sync & !Unpin);
+        async_assert_fn!(tokio::fs::OpenOptions::open(_, &str): Send & Sync & !Unpin);
+        async_assert_fn!(tokio::fs::DirBuilder::create(_, &str): Send & Sync & !Unpin);
+        async_assert_fn!(tokio::fs::DirEntry::metadata(_): Send & Sync & !Unpin);
+        async_assert_fn!(tokio::fs::DirEntry::file_type(_): Send & Sync & !Unpin);
+        async_assert_fn!(tokio::fs::File::open(&str): Send & Sync & !Unpin);
+        async_assert_fn!(tokio::fs::File::create(&str): Send & Sync & !Unpin);
+        async_assert_fn!(tokio::fs::File::sync_all(_): Send & Sync & !Unpin);
+        async_assert_fn!(tokio::fs::File::sync_data(_): Send & Sync & !Unpin);
+        async_assert_fn!(tokio::fs::File::set_len(_, u64): Send & Sync & !Unpin);
+        async_assert_fn!(tokio::fs::File::metadata(_): Send & Sync & !Unpin);
+        async_assert_fn!(tokio::fs::File::try_clone(_): Send & Sync & !Unpin);
+        async_assert_fn!(tokio::fs::File::into_std(_): Send & Sync & !Unpin);
+        async_assert_fn!(
+            tokio::fs::File::set_permissions(_, std::fs::Permissions): Send & Sync & !Unpin
+        );
+    }
+}
+
+cfg_not_wasi! {
+    assert_value!(tokio::net::TcpSocket: Send & Sync & Unpin);
+    async_assert_fn!(tokio::net::TcpListener::bind(SocketAddr): Send & Sync & !Unpin);
+    async_assert_fn!(tokio::net::TcpStream::connect(SocketAddr): Send & Sync & !Unpin);
+}
+
+assert_value!(tokio::net::TcpListener: Send & Sync & Unpin);
+assert_value!(tokio::net::TcpStream: Send & Sync & Unpin);
+assert_value!(tokio::net::tcp::OwnedReadHalf: Send & Sync & Unpin);
+assert_value!(tokio::net::tcp::OwnedWriteHalf: Send & Sync & Unpin);
+assert_value!(tokio::net::tcp::ReadHalf<'_>: Send & Sync & Unpin);
+assert_value!(tokio::net::tcp::ReuniteError: Send & Sync & Unpin);
+assert_value!(tokio::net::tcp::WriteHalf<'_>: Send & Sync & Unpin);
+async_assert_fn!(tokio::net::TcpListener::accept(_): Send & Sync & !Unpin);
+async_assert_fn!(tokio::net::TcpStream::peek(_, &mut [u8]): Send & Sync & !Unpin);
+async_assert_fn!(tokio::net::TcpStream::readable(_): Send & Sync & !Unpin);
+async_assert_fn!(tokio::net::TcpStream::ready(_, tokio::io::Interest): Send & Sync & !Unpin);
+async_assert_fn!(tokio::net::TcpStream::writable(_): Send & Sync & !Unpin);
+
+// Wasi does not support UDP
+cfg_not_wasi! {
+    mod udp_socket {
+        use super::*;
+        assert_value!(tokio::net::UdpSocket: Send & Sync & Unpin);
+        async_assert_fn!(tokio::net::UdpSocket::bind(SocketAddr): Send & Sync & !Unpin);
+        async_assert_fn!(tokio::net::UdpSocket::connect(_, SocketAddr): Send & Sync & !Unpin);
+        async_assert_fn!(tokio::net::UdpSocket::peek_from(_, &mut [u8]): Send & Sync & !Unpin);
+        async_assert_fn!(tokio::net::UdpSocket::readable(_): Send & Sync & !Unpin);
+        async_assert_fn!(tokio::net::UdpSocket::ready(_, tokio::io::Interest): Send & Sync & !Unpin);
+        async_assert_fn!(tokio::net::UdpSocket::recv(_, &mut [u8]): Send & Sync & !Unpin);
+        async_assert_fn!(tokio::net::UdpSocket::recv_from(_, &mut [u8]): Send & Sync & !Unpin);
+        async_assert_fn!(tokio::net::UdpSocket::send(_, &[u8]): Send & Sync & !Unpin);
+        async_assert_fn!(tokio::net::UdpSocket::send_to(_, &[u8], SocketAddr): Send & Sync & !Unpin);
+        async_assert_fn!(tokio::net::UdpSocket::writable(_): Send & Sync & !Unpin);
+    }
+}
+async_assert_fn!(tokio::net::lookup_host(SocketAddr): Send & Sync & !Unpin);
+async_assert_fn!(tokio::net::tcp::ReadHalf::peek(_, &mut [u8]): Send & Sync & !Unpin);
+
+#[cfg(unix)]
+mod unix_datagram {
+    use super::*;
+    use tokio::net::*;
+    assert_value!(UnixDatagram: Send & Sync & Unpin);
+    assert_value!(UnixListener: Send & Sync & Unpin);
+    assert_value!(UnixStream: Send & Sync & Unpin);
+    assert_value!(unix::OwnedReadHalf: Send & Sync & Unpin);
+    assert_value!(unix::OwnedWriteHalf: Send & Sync & Unpin);
+    assert_value!(unix::ReadHalf<'_>: Send & Sync & Unpin);
+    assert_value!(unix::ReuniteError: Send & Sync & Unpin);
+    assert_value!(unix::SocketAddr: Send & Sync & Unpin);
+    assert_value!(unix::UCred: Send & Sync & Unpin);
+    assert_value!(unix::WriteHalf<'_>: Send & Sync & Unpin);
+    async_assert_fn!(UnixDatagram::readable(_): Send & Sync & !Unpin);
+    async_assert_fn!(UnixDatagram::ready(_, tokio::io::Interest): Send & Sync & !Unpin);
+    async_assert_fn!(UnixDatagram::recv(_, &mut [u8]): Send & Sync & !Unpin);
+    async_assert_fn!(UnixDatagram::recv_from(_, &mut [u8]): Send & Sync & !Unpin);
+    async_assert_fn!(UnixDatagram::send(_, &[u8]): Send & Sync & !Unpin);
+    async_assert_fn!(UnixDatagram::send_to(_, &[u8], &str): Send & Sync & !Unpin);
+    async_assert_fn!(UnixDatagram::writable(_): Send & Sync & !Unpin);
+    async_assert_fn!(UnixListener::accept(_): Send & Sync & !Unpin);
+    async_assert_fn!(UnixStream::connect(&str): Send & Sync & !Unpin);
+    async_assert_fn!(UnixStream::readable(_): Send & Sync & !Unpin);
+    async_assert_fn!(UnixStream::ready(_, tokio::io::Interest): Send & Sync & !Unpin);
+    async_assert_fn!(UnixStream::writable(_): Send & Sync & !Unpin);
+}
+
+#[cfg(unix)]
+mod unix_pipe {
+    use super::*;
+    use tokio::net::unix::pipe::*;
+    assert_value!(OpenOptions: Send & Sync & Unpin);
+    assert_value!(Receiver: Send & Sync & Unpin);
+    assert_value!(Sender: Send & Sync & Unpin);
+    async_assert_fn!(Receiver::readable(_): Send & Sync & !Unpin);
+    async_assert_fn!(Receiver::ready(_, tokio::io::Interest): Send & Sync & !Unpin);
+    async_assert_fn!(Sender::ready(_, tokio::io::Interest): Send & Sync & !Unpin);
+    async_assert_fn!(Sender::writable(_): Send & Sync & !Unpin);
+}
+
+#[cfg(windows)]
+mod windows_named_pipe {
+    use super::*;
+    use tokio::net::windows::named_pipe::*;
+    assert_value!(ClientOptions: Send & Sync & Unpin);
+    assert_value!(NamedPipeClient: Send & Sync & Unpin);
+    assert_value!(NamedPipeServer: Send & Sync & Unpin);
+    assert_value!(PipeEnd: Send & Sync & Unpin);
+    assert_value!(PipeInfo: Send & Sync & Unpin);
+    assert_value!(PipeMode: Send & Sync & Unpin);
+    assert_value!(ServerOptions: Send & Sync & Unpin);
+    async_assert_fn!(NamedPipeClient::readable(_): Send & Sync & !Unpin);
+    async_assert_fn!(NamedPipeClient::ready(_, tokio::io::Interest): Send & Sync & !Unpin);
+    async_assert_fn!(NamedPipeClient::writable(_): Send & Sync & !Unpin);
+    async_assert_fn!(NamedPipeServer::connect(_): Send & Sync & !Unpin);
+    async_assert_fn!(NamedPipeServer::readable(_): Send & Sync & !Unpin);
+    async_assert_fn!(NamedPipeServer::ready(_, tokio::io::Interest): Send & Sync & !Unpin);
+    async_assert_fn!(NamedPipeServer::writable(_): Send & Sync & !Unpin);
+}
+
+cfg_not_wasi! {
+    mod test_process {
+        use super::*;
+        assert_value!(tokio::process::Child: Send & Sync & Unpin);
+        assert_value!(tokio::process::ChildStderr: Send & Sync & Unpin);
+        assert_value!(tokio::process::ChildStdin: Send & Sync & Unpin);
+        assert_value!(tokio::process::ChildStdout: Send & Sync & Unpin);
+        assert_value!(tokio::process::Command: Send & Sync & Unpin);
+        async_assert_fn!(tokio::process::Child::kill(_): Send & Sync & !Unpin);
+        async_assert_fn!(tokio::process::Child::wait(_): Send & Sync & !Unpin);
+        async_assert_fn!(tokio::process::Child::wait_with_output(_): Send & Sync & !Unpin);
+    }
+
+    async_assert_fn!(tokio::signal::ctrl_c(): Send & Sync & !Unpin);
+}
+
+#[cfg(unix)]
+mod unix_signal {
+    use super::*;
+    assert_value!(tokio::signal::unix::Signal: Send & Sync & Unpin);
+    assert_value!(tokio::signal::unix::SignalKind: Send & Sync & Unpin);
+    async_assert_fn!(tokio::signal::unix::Signal::recv(_): Send & Sync & !Unpin);
+}
+#[cfg(windows)]
+mod windows_signal {
+    use super::*;
+    assert_value!(tokio::signal::windows::CtrlC: Send & Sync & Unpin);
+    assert_value!(tokio::signal::windows::CtrlBreak: Send & Sync & Unpin);
+    async_assert_fn!(tokio::signal::windows::CtrlC::recv(_): Send & Sync & !Unpin);
+    async_assert_fn!(tokio::signal::windows::CtrlBreak::recv(_): Send & Sync & !Unpin);
+}
+
+assert_value!(tokio::sync::AcquireError: Send & Sync & Unpin);
+assert_value!(tokio::sync::Barrier: Send & Sync & Unpin);
+assert_value!(tokio::sync::BarrierWaitResult: Send & Sync & Unpin);
+assert_value!(tokio::sync::MappedMutexGuard<'_, NN>: !Send & !Sync & Unpin);
+assert_value!(tokio::sync::MappedMutexGuard<'_, YN>: Send & !Sync & Unpin);
+assert_value!(tokio::sync::MappedMutexGuard<'_, YY>: Send & Sync & Unpin);
+assert_value!(tokio::sync::Mutex<NN>: !Send & !Sync & Unpin);
+assert_value!(tokio::sync::Mutex<YN>: Send & Sync & Unpin);
+assert_value!(tokio::sync::Mutex<YY>: Send & Sync & Unpin);
+assert_value!(tokio::sync::MutexGuard<'_, NN>: !Send & !Sync & Unpin);
+assert_value!(tokio::sync::MutexGuard<'_, YN>: Send & !Sync & Unpin);
+assert_value!(tokio::sync::MutexGuard<'_, YY>: Send & Sync & Unpin);
+assert_value!(tokio::sync::Notify: Send & Sync & Unpin);
+assert_value!(tokio::sync::OnceCell<NN>: !Send & !Sync & Unpin);
+assert_value!(tokio::sync::OnceCell<YN>: Send & !Sync & Unpin);
+assert_value!(tokio::sync::OnceCell<YY>: Send & Sync & Unpin);
+assert_value!(tokio::sync::SetOnce<NN>: !Send & !Sync & Unpin);
+assert_value!(tokio::sync::SetOnce<YN>: Send & !Sync & Unpin);
+assert_value!(tokio::sync::SetOnce<YY>: Send & Sync & Unpin);
+assert_value!(tokio::sync::OwnedMutexGuard<NN>: !Send & !Sync & Unpin);
+assert_value!(tokio::sync::OwnedMutexGuard<YN>: Send & !Sync & Unpin);
+assert_value!(tokio::sync::OwnedMutexGuard<YY>: Send & Sync & Unpin);
+assert_value!(tokio::sync::OwnedMappedMutexGuard<NN,NN>: !Send & !Sync & Unpin);
+assert_value!(tokio::sync::OwnedMappedMutexGuard<NN,YN>: !Send & !Sync & Unpin);
+assert_value!(tokio::sync::OwnedMappedMutexGuard<NN,YY>: !Send & !Sync & Unpin);
+assert_value!(tokio::sync::OwnedMappedMutexGuard<YN,NN>: !Send & !Sync & Unpin);
+assert_value!(tokio::sync::OwnedMappedMutexGuard<YN,YN>: Send & !Sync & Unpin);
+assert_value!(tokio::sync::OwnedMappedMutexGuard<YN,YY>: Send & !Sync & Unpin);
+assert_value!(tokio::sync::OwnedMappedMutexGuard<YY,NN>: !Send & !Sync & Unpin);
+assert_value!(tokio::sync::OwnedMappedMutexGuard<YY,YN>: Send & !Sync & Unpin);
+assert_value!(tokio::sync::OwnedMappedMutexGuard<YY,YY>: Send & Sync & Unpin);
+assert_value!(tokio::sync::OwnedRwLockMappedWriteGuard<NN>: !Send & !Sync & Unpin);
+assert_value!(tokio::sync::OwnedRwLockMappedWriteGuard<YN>: !Send & !Sync & Unpin);
+assert_value!(tokio::sync::OwnedRwLockMappedWriteGuard<YY>: Send & Sync & Unpin);
+assert_value!(tokio::sync::OwnedRwLockReadGuard<NN>: !Send & !Sync & Unpin);
+assert_value!(tokio::sync::OwnedRwLockReadGuard<YN>: !Send & !Sync & Unpin);
+assert_value!(tokio::sync::OwnedRwLockReadGuard<YY>: Send & Sync & Unpin);
+assert_value!(tokio::sync::OwnedRwLockWriteGuard<NN>: !Send & !Sync & Unpin);
+assert_value!(tokio::sync::OwnedRwLockWriteGuard<YN>: !Send & !Sync & Unpin);
+assert_value!(tokio::sync::OwnedRwLockWriteGuard<YY>: Send & Sync & Unpin);
+assert_value!(tokio::sync::OwnedSemaphorePermit: Send & Sync & Unpin);
+assert_value!(tokio::sync::RwLock<NN>: !Send & !Sync & Unpin);
+assert_value!(tokio::sync::RwLock<YN>: Send & !Sync & Unpin);
+assert_value!(tokio::sync::RwLock<YY>: Send & Sync & Unpin);
+assert_value!(tokio::sync::RwLockMappedWriteGuard<'_, NN>: !Send & !Sync & Unpin);
+assert_value!(tokio::sync::RwLockMappedWriteGuard<'_, YN>: !Send & !Sync & Unpin);
+assert_value!(tokio::sync::RwLockMappedWriteGuard<'_, YY>: Send & Sync & Unpin);
+assert_value!(tokio::sync::RwLockReadGuard<'_, NN>: !Send & !Sync & Unpin);
+assert_value!(tokio::sync::RwLockReadGuard<'_, YN>: !Send & !Sync & Unpin);
+assert_value!(tokio::sync::RwLockReadGuard<'_, YY>: Send & Sync & Unpin);
+assert_value!(tokio::sync::RwLockWriteGuard<'_, NN>: !Send & !Sync & Unpin);
+assert_value!(tokio::sync::RwLockWriteGuard<'_, YN>: !Send & !Sync & Unpin);
+assert_value!(tokio::sync::RwLockWriteGuard<'_, YY>: Send & Sync & Unpin);
+assert_value!(tokio::sync::Semaphore: Send & Sync & Unpin);
+assert_value!(tokio::sync::SemaphorePermit<'_>: Send & Sync & Unpin);
+assert_value!(tokio::sync::TryAcquireError: Send & Sync & Unpin);
+assert_value!(tokio::sync::TryLockError: Send & Sync & Unpin);
+assert_value!(tokio::sync::broadcast::Receiver<NN>: !Send & !Sync & Unpin);
+assert_value!(tokio::sync::broadcast::Receiver<YN>: Send & Sync & Unpin);
+assert_value!(tokio::sync::broadcast::Receiver<YY>: Send & Sync & Unpin);
+assert_value!(tokio::sync::broadcast::Sender<NN>: !Send & !Sync & Unpin);
+assert_value!(tokio::sync::broadcast::Sender<YN>: Send & Sync & Unpin);
+assert_value!(tokio::sync::broadcast::Sender<YY>: Send & Sync & Unpin);
+assert_value!(tokio::sync::broadcast::WeakSender<NN>: !Send & !Sync & Unpin);
+assert_value!(tokio::sync::broadcast::WeakSender<YN>: Send & Sync & Unpin);
+assert_value!(tokio::sync::broadcast::WeakSender<YY>: Send & Sync & Unpin);
+assert_value!(tokio::sync::futures::Notified<'_>: Send & Sync & !Unpin);
+assert_value!(tokio::sync::futures::OwnedNotified: Send & Sync & !Unpin);
+assert_value!(tokio::sync::mpsc::OwnedPermit<NN>: !Send & !Sync & Unpin);
+assert_value!(tokio::sync::mpsc::OwnedPermit<YN>: Send & Sync & Unpin);
+assert_value!(tokio::sync::mpsc::OwnedPermit<YY>: Send & Sync & Unpin);
+assert_value!(tokio::sync::mpsc::Permit<'_, NN>: !Send & !Sync & Unpin);
+assert_value!(tokio::sync::mpsc::Permit<'_, YN>: Send & Sync & Unpin);
+assert_value!(tokio::sync::mpsc::Permit<'_, YY>: Send & Sync & Unpin);
+assert_value!(tokio::sync::mpsc::Receiver<NN>: !Send & !Sync & Unpin);
+assert_value!(tokio::sync::mpsc::Receiver<YN>: Send & Sync & Unpin);
+assert_value!(tokio::sync::mpsc::Receiver<YY>: Send & Sync & Unpin);
+assert_value!(tokio::sync::mpsc::Sender<NN>: !Send & !Sync & Unpin);
+assert_value!(tokio::sync::mpsc::Sender<YN>: Send & Sync & Unpin);
+assert_value!(tokio::sync::mpsc::Sender<YY>: Send & Sync & Unpin);
+assert_value!(tokio::sync::mpsc::UnboundedReceiver<NN>: !Send & !Sync & Unpin);
+assert_value!(tokio::sync::mpsc::UnboundedReceiver<YN>: Send & Sync & Unpin);
+assert_value!(tokio::sync::mpsc::UnboundedReceiver<YY>: Send & Sync & Unpin);
+assert_value!(tokio::sync::mpsc::UnboundedSender<NN>: !Send & !Sync & Unpin);
+assert_value!(tokio::sync::mpsc::UnboundedSender<YN>: Send & Sync & Unpin);
+assert_value!(tokio::sync::mpsc::UnboundedSender<YY>: Send & Sync & Unpin);
+assert_value!(tokio::sync::mpsc::WeakSender<NN>: !Send & !Sync & Unpin);
+assert_value!(tokio::sync::mpsc::WeakSender<YN>: Send & Sync & Unpin);
+assert_value!(tokio::sync::mpsc::WeakSender<YY>: Send & Sync & Unpin);
+assert_value!(tokio::sync::mpsc::WeakUnboundedSender<NN>: !Send & !Sync & Unpin);
+assert_value!(tokio::sync::mpsc::WeakUnboundedSender<YN>: Send & Sync & Unpin);
+assert_value!(tokio::sync::mpsc::WeakUnboundedSender<YY>: Send & Sync & Unpin);
+assert_value!(tokio::sync::mpsc::error::SendError<NN>: !Send & !Sync & Unpin);
+assert_value!(tokio::sync::mpsc::error::SendError<YN>: Send & !Sync & Unpin);
+assert_value!(tokio::sync::mpsc::error::SendError<YY>: Send & Sync & Unpin);
+assert_value!(tokio::sync::mpsc::error::SendTimeoutError<NN>: !Send & !Sync & Unpin);
+assert_value!(tokio::sync::mpsc::error::SendTimeoutError<YN>: Send & !Sync & Unpin);
+assert_value!(tokio::sync::mpsc::error::SendTimeoutError<YY>: Send & Sync & Unpin);
+assert_value!(tokio::sync::mpsc::error::TrySendError<NN>: !Send & !Sync & Unpin);
+assert_value!(tokio::sync::mpsc::error::TrySendError<YN>: Send & !Sync & Unpin);
+assert_value!(tokio::sync::mpsc::error::TrySendError<YY>: Send & Sync & Unpin);
+assert_value!(tokio::sync::oneshot::Receiver<NN>: !Send & !Sync & Unpin);
+assert_value!(tokio::sync::oneshot::Receiver<YN>: Send & Sync & Unpin);
+assert_value!(tokio::sync::oneshot::Receiver<YY>: Send & Sync & Unpin);
+assert_value!(tokio::sync::oneshot::Sender<NN>: !Send & !Sync & Unpin);
+assert_value!(tokio::sync::oneshot::Sender<YN>: Send & Sync & Unpin);
+assert_value!(tokio::sync::oneshot::Sender<YY>: Send & Sync & Unpin);
+assert_value!(tokio::sync::watch::Receiver<NN>: !Send & !Sync & Unpin);
+assert_value!(tokio::sync::watch::Receiver<YN>: !Send & !Sync & Unpin);
+assert_value!(tokio::sync::watch::Receiver<YY>: Send & Sync & Unpin);
+assert_value!(tokio::sync::watch::Ref<'_, NN>: !Send & !Sync & Unpin);
+assert_value!(tokio::sync::watch::Ref<'_, YN>: !Send & !Sync & Unpin);
+assert_value!(tokio::sync::watch::Ref<'_, YY>: !Send & Sync & Unpin);
+assert_value!(tokio::sync::watch::Sender<NN>: !Send & !Sync & Unpin);
+assert_value!(tokio::sync::watch::Sender<YN>: !Send & !Sync & Unpin);
+assert_value!(tokio::sync::watch::Sender<YY>: Send & Sync & Unpin);
+assert_value!(tokio::task::JoinError: Send & Sync & Unpin);
+assert_value!(tokio::task::JoinHandle<NN>: !Send & !Sync & Unpin);
+assert_value!(tokio::task::JoinHandle<YN>: Send & Sync & Unpin);
+assert_value!(tokio::task::JoinHandle<YY>: Send & Sync & Unpin);
+assert_value!(tokio::task::JoinSet<NN>: !Send & !Sync & Unpin);
+assert_value!(tokio::task::JoinSet<YN>: Send & Sync & Unpin);
+assert_value!(tokio::task::JoinSet<YY>: Send & Sync & Unpin);
+assert_value!(tokio::task::LocalSet: !Send & !Sync & Unpin);
+assert_value!(tokio::task::coop::RestoreOnPending: !Send & !Sync & Unpin);
+async_assert_fn!(tokio::sync::Barrier::wait(_): Send & Sync & !Unpin);
+async_assert_fn!(tokio::sync::Mutex<NN>::lock(_): !Send & !Sync & !Unpin);
+async_assert_fn!(tokio::sync::Mutex<NN>::lock_owned(_): !Send & !Sync & !Unpin);
+async_assert_fn!(tokio::sync::Mutex<YN>::lock(_): Send & Sync & !Unpin);
+async_assert_fn!(tokio::sync::Mutex<YN>::lock_owned(_): Send & Sync & !Unpin);
+async_assert_fn!(tokio::sync::Mutex<YY>::lock(_): Send & Sync & !Unpin);
+async_assert_fn!(tokio::sync::Mutex<YY>::lock_owned(_): Send & Sync & !Unpin);
+async_assert_fn!(tokio::sync::Notify::notified(_): Send & Sync & !Unpin);
+async_assert_fn!(tokio::sync::OnceCell<NN>::get_or_init( _, fn() -> Pin<Box<dyn Future<Output = NN> + Send + Sync>>): !Send & !Sync & !Unpin);
+async_assert_fn!(tokio::sync::OnceCell<NN>::get_or_init( _, fn() -> Pin<Box<dyn Future<Output = NN> + Send>>): !Send & !Sync & !Unpin);
+async_assert_fn!(tokio::sync::OnceCell<NN>::get_or_init( _, fn() -> Pin<Box<dyn Future<Output = NN>>>): !Send & !Sync & !Unpin);
+async_assert_fn!(tokio::sync::OnceCell<NN>::get_or_try_init( _, fn() -> Pin<Box<dyn Future<Output = std::io::Result<NN>> + Send + Sync>>): !Send & !Sync & !Unpin);
+async_assert_fn!(tokio::sync::OnceCell<NN>::get_or_try_init( _, fn() -> Pin<Box<dyn Future<Output = std::io::Result<NN>> + Send>>): !Send & !Sync & !Unpin);
+async_assert_fn!(tokio::sync::OnceCell<NN>::get_or_try_init( _, fn() -> Pin<Box<dyn Future<Output = std::io::Result<NN>>>>): !Send & !Sync & !Unpin);
+async_assert_fn!(tokio::sync::OnceCell<YN>::get_or_init( _, fn() -> Pin<Box<dyn Future<Output = YN> + Send + Sync>>): !Send & !Sync & !Unpin);
+async_assert_fn!(tokio::sync::OnceCell<YN>::get_or_init( _, fn() -> Pin<Box<dyn Future<Output = YN> + Send>>): !Send & !Sync & !Unpin);
+async_assert_fn!(tokio::sync::OnceCell<YN>::get_or_init( _, fn() -> Pin<Box<dyn Future<Output = YN>>>): !Send & !Sync & !Unpin);
+async_assert_fn!(tokio::sync::OnceCell<YN>::get_or_try_init( _, fn() -> Pin<Box<dyn Future<Output = std::io::Result<YN>> + Send + Sync>>): !Send & !Sync & !Unpin);
+async_assert_fn!(tokio::sync::OnceCell<YN>::get_or_try_init( _, fn() -> Pin<Box<dyn Future<Output = std::io::Result<YN>> + Send>>): !Send & !Sync & !Unpin);
+async_assert_fn!(tokio::sync::OnceCell<YN>::get_or_try_init( _, fn() -> Pin<Box<dyn Future<Output = std::io::Result<YN>>>>): !Send & !Sync & !Unpin);
+async_assert_fn!(tokio::sync::OnceCell<YY>::get_or_init( _, fn() -> Pin<Box<dyn Future<Output = YY> + Send + Sync>>): Send & Sync & !Unpin);
+async_assert_fn!(tokio::sync::OnceCell<YY>::get_or_init( _, fn() -> Pin<Box<dyn Future<Output = YY> + Send>>): Send & !Sync & !Unpin);
+async_assert_fn!(tokio::sync::OnceCell<YY>::get_or_init( _, fn() -> Pin<Box<dyn Future<Output = YY>>>): !Send & !Sync & !Unpin);
+async_assert_fn!(tokio::sync::OnceCell<YY>::get_or_try_init( _, fn() -> Pin<Box<dyn Future<Output = std::io::Result<YY>> + Send + Sync>>): Send & Sync & !Unpin);
+async_assert_fn!(tokio::sync::OnceCell<YY>::get_or_try_init( _, fn() -> Pin<Box<dyn Future<Output = std::io::Result<YY>> + Send>>): Send & !Sync & !Unpin);
+async_assert_fn!(tokio::sync::OnceCell<YY>::get_or_try_init( _, fn() -> Pin<Box<dyn Future<Output = std::io::Result<YY>>>>): !Send & !Sync & !Unpin);
+async_assert_fn!(tokio::sync::SetOnce<NN>::wait(_): !Send & !Sync & !Unpin);
+async_assert_fn!(tokio::sync::SetOnce<YN>::wait(_): !Send & !Sync & !Unpin);
+async_assert_fn!(tokio::sync::SetOnce<YY>::wait(_): Send & Sync & !Unpin);
+async_assert_fn!(tokio::sync::RwLock<NN>::read(_): !Send & !Sync & !Unpin);
+async_assert_fn!(tokio::sync::RwLock<NN>::write(_): !Send & !Sync & !Unpin);
+async_assert_fn!(tokio::sync::RwLock<YN>::read(_): !Send & !Sync & !Unpin);
+async_assert_fn!(tokio::sync::RwLock<YN>::write(_): !Send & !Sync & !Unpin);
+async_assert_fn!(tokio::sync::RwLock<YY>::read(_): Send & Sync & !Unpin);
+async_assert_fn!(tokio::sync::RwLock<YY>::write(_): Send & Sync & !Unpin);
+async_assert_fn!(tokio::sync::Semaphore::acquire(_): Send & Sync & !Unpin);
+async_assert_fn!(tokio::sync::Semaphore::acquire_many(_, u32): Send & Sync & !Unpin);
+async_assert_fn!(tokio::sync::Semaphore::acquire_many_owned(_, u32): Send & Sync & !Unpin);
+async_assert_fn!(tokio::sync::Semaphore::acquire_owned(_): Send & Sync & !Unpin);
+async_assert_fn!(tokio::sync::broadcast::Receiver<NN>::recv(_): !Send & !Sync & !Unpin);
+async_assert_fn!(tokio::sync::broadcast::Receiver<YN>::recv(_): Send & Sync & !Unpin);
+async_assert_fn!(tokio::sync::broadcast::Receiver<YY>::recv(_): Send & Sync & !Unpin);
+async_assert_fn!(tokio::sync::mpsc::Receiver<NN>::recv(_): !Send & !Sync & !Unpin);
+async_assert_fn!(tokio::sync::mpsc::Receiver<YN>::recv(_): Send & Sync & !Unpin);
+async_assert_fn!(tokio::sync::mpsc::Receiver<YY>::recv(_): Send & Sync & !Unpin);
+async_assert_fn!(tokio::sync::mpsc::Sender<NN>::closed(_): !Send & !Sync & !Unpin);
+async_assert_fn!(tokio::sync::mpsc::Sender<NN>::reserve(_): !Send & !Sync & !Unpin);
+async_assert_fn!(tokio::sync::mpsc::Sender<NN>::reserve_owned(_): !Send & !Sync & !Unpin);
+async_assert_fn!(tokio::sync::mpsc::Sender<NN>::send(_, NN): !Send & !Sync & !Unpin);
+async_assert_fn!(tokio::sync::mpsc::Sender<NN>::send_timeout(_, NN, Duration): !Send & !Sync & !Unpin);
+async_assert_fn!(tokio::sync::mpsc::Sender<YN>::closed(_): Send & Sync & !Unpin);
+async_assert_fn!(tokio::sync::mpsc::Sender<YN>::reserve(_): Send & Sync & !Unpin);
+async_assert_fn!(tokio::sync::mpsc::Sender<YN>::reserve_owned(_): Send & Sync & !Unpin);
+async_assert_fn!(tokio::sync::mpsc::Sender<YN>::send(_, YN): Send & !Sync & !Unpin);
+async_assert_fn!(tokio::sync::mpsc::Sender<YN>::send_timeout(_, YN, Duration): Send & !Sync & !Unpin);
+async_assert_fn!(tokio::sync::mpsc::Sender<YY>::closed(_): Send & Sync & !Unpin);
+async_assert_fn!(tokio::sync::mpsc::Sender<YY>::reserve(_): Send & Sync & !Unpin);
+async_assert_fn!(tokio::sync::mpsc::Sender<YY>::reserve_owned(_): Send & Sync & !Unpin);
+async_assert_fn!(tokio::sync::mpsc::Sender<YY>::send(_, YY): Send & Sync & !Unpin);
+async_assert_fn!(tokio::sync::mpsc::Sender<YY>::send_timeout(_, YY, Duration): Send & Sync & !Unpin);
+async_assert_fn!(tokio::sync::mpsc::UnboundedReceiver<NN>::recv(_): !Send & !Sync & !Unpin);
+async_assert_fn!(tokio::sync::mpsc::UnboundedReceiver<YN>::recv(_): Send & Sync & !Unpin);
+async_assert_fn!(tokio::sync::mpsc::UnboundedReceiver<YY>::recv(_): Send & Sync & !Unpin);
+async_assert_fn!(tokio::sync::mpsc::UnboundedSender<NN>::closed(_): !Send & !Sync & !Unpin);
+async_assert_fn!(tokio::sync::mpsc::UnboundedSender<YN>::closed(_): Send & Sync & !Unpin);
+async_assert_fn!(tokio::sync::mpsc::UnboundedSender<YY>::closed(_): Send & Sync & !Unpin);
+async_assert_fn!(tokio::sync::oneshot::Sender<NN>::closed(_): !Send & !Sync & !Unpin);
+async_assert_fn!(tokio::sync::oneshot::Sender<YN>::closed(_): Send & Sync & !Unpin);
+async_assert_fn!(tokio::sync::oneshot::Sender<YY>::closed(_): Send & Sync & !Unpin);
+async_assert_fn!(tokio::sync::watch::Receiver<NN>::changed(_): !Send & !Sync & !Unpin);
+async_assert_fn!(tokio::sync::watch::Receiver<YN>::changed(_): !Send & !Sync & !Unpin);
+async_assert_fn!(tokio::sync::watch::Receiver<YY>::changed(_): Send & Sync & !Unpin);
+async_assert_fn!(tokio::sync::watch::Sender<NN>::closed(_): !Send & !Sync & !Unpin);
+async_assert_fn!(tokio::sync::watch::Sender<YN>::closed(_): !Send & !Sync & !Unpin);
+async_assert_fn!(tokio::sync::watch::Sender<YY>::closed(_): Send & Sync & !Unpin);
+async_assert_fn!(tokio::task::JoinSet<Cell<u32>>::join_next(_): Send & Sync & !Unpin);
+async_assert_fn!(tokio::task::JoinSet<Cell<u32>>::shutdown(_): Send & Sync & !Unpin);
+async_assert_fn!(tokio::task::JoinSet<Rc<u32>>::join_next(_): !Send & !Sync & !Unpin);
+async_assert_fn!(tokio::task::JoinSet<Rc<u32>>::shutdown(_): !Send & !Sync & !Unpin);
+async_assert_fn!(tokio::task::JoinSet<u32>::join_next(_): Send & Sync & !Unpin);
+async_assert_fn!(tokio::task::JoinSet<u32>::shutdown(_): Send & Sync & !Unpin);
+async_assert_fn!(tokio::task::LocalKey<Cell<u32>>::scope(_, Cell<u32>, BoxFuture<()>): !Send & !Sync & !Unpin);
+async_assert_fn!(tokio::task::LocalKey<Cell<u32>>::scope(_, Cell<u32>, BoxFutureSend<()>): Send & !Sync & !Unpin);
+async_assert_fn!(tokio::task::LocalKey<Cell<u32>>::scope(_, Cell<u32>, BoxFutureSync<()>): Send & !Sync & !Unpin);
+async_assert_fn!(tokio::task::LocalKey<Rc<u32>>::scope(_, Rc<u32>, BoxFuture<()>): !Send & !Sync & !Unpin);
+async_assert_fn!(tokio::task::LocalKey<Rc<u32>>::scope(_, Rc<u32>, BoxFutureSend<()>): !Send & !Sync & !Unpin);
+async_assert_fn!(tokio::task::LocalKey<Rc<u32>>::scope(_, Rc<u32>, BoxFutureSync<()>): !Send & !Sync & !Unpin);
+async_assert_fn!(tokio::task::LocalKey<u32>::scope(_, u32, BoxFuture<()>): !Send & !Sync & !Unpin);
+async_assert_fn!(tokio::task::LocalKey<u32>::scope(_, u32, BoxFutureSend<()>): Send & !Sync & !Unpin);
+async_assert_fn!(tokio::task::LocalKey<u32>::scope(_, u32, BoxFutureSync<()>): Send & Sync & !Unpin);
+async_assert_fn!(tokio::task::LocalSet::run_until(_, BoxFutureSync<()>): !Send & !Sync & !Unpin);
+async_assert_fn!(tokio::task::unconstrained(BoxFuture<()>): !Send & !Sync & Unpin);
+async_assert_fn!(tokio::task::unconstrained(BoxFutureSend<()>): Send & !Sync & Unpin);
+async_assert_fn!(tokio::task::unconstrained(BoxFutureSync<()>): Send & Sync & Unpin);
+
+assert_value!(tokio::runtime::Builder: Send & Sync & Unpin);
+assert_value!(tokio::runtime::EnterGuard<'_>: !Send & Sync & Unpin);
+assert_value!(tokio::runtime::Handle: Send & Sync & Unpin);
+assert_value!(tokio::runtime::Runtime: Send & Sync & Unpin);
+
+assert_value!(tokio::time::Interval: Send & Sync & Unpin);
+assert_value!(tokio::time::Instant: Send & Sync & Unpin);
+assert_value!(tokio::time::Sleep: Send & Sync & !Unpin);
+assert_value!(tokio::time::Timeout<BoxFutureSync<()>>: Send & Sync & !Unpin);
+assert_value!(tokio::time::Timeout<BoxFutureSend<()>>: Send & !Sync & !Unpin);
+assert_value!(tokio::time::Timeout<BoxFuture<()>>: !Send & !Sync & !Unpin);
+assert_value!(tokio::time::error::Elapsed: Send & Sync & Unpin);
+assert_value!(tokio::time::error::Error: Send & Sync & Unpin);
+async_assert_fn!(tokio::time::advance(Duration): Send & Sync & !Unpin);
+async_assert_fn!(tokio::time::sleep(Duration): Send & Sync & !Unpin);
+async_assert_fn!(tokio::time::sleep_until(Instant): Send & Sync & !Unpin);
+async_assert_fn!(tokio::time::timeout(Duration, BoxFutureSync<()>): Send & Sync & !Unpin);
+async_assert_fn!(tokio::time::timeout(Duration, BoxFutureSend<()>): Send & !Sync & !Unpin);
+async_assert_fn!(tokio::time::timeout(Duration, BoxFuture<()>): !Send & !Sync & !Unpin);
+async_assert_fn!(tokio::time::timeout_at(Instant, BoxFutureSync<()>): Send & Sync & !Unpin);
+async_assert_fn!(tokio::time::timeout_at(Instant, BoxFutureSend<()>): Send & !Sync & !Unpin);
+async_assert_fn!(tokio::time::timeout_at(Instant, BoxFuture<()>): !Send & !Sync & !Unpin);
+async_assert_fn!(tokio::time::Interval::tick(_): Send & Sync & !Unpin);
+
+assert_value!(tokio::io::BufReader<TcpStream>: Send & Sync & Unpin);
+assert_value!(tokio::io::BufStream<TcpStream>: Send & Sync & Unpin);
+assert_value!(tokio::io::BufWriter<TcpStream>: Send & Sync & Unpin);
+assert_value!(tokio::io::DuplexStream: Send & Sync & Unpin);
+assert_value!(tokio::io::Empty: Send & Sync & Unpin);
+assert_value!(tokio::io::Interest: Send & Sync & Unpin);
+assert_value!(tokio::io::Lines<TcpStream>: Send & Sync & Unpin);
+assert_value!(tokio::io::ReadBuf<'_>: Send & Sync & Unpin);
+assert_value!(tokio::io::ReadHalf<TcpStream>: Send & Sync & Unpin);
+assert_value!(tokio::io::Ready: Send & Sync & Unpin);
+assert_value!(tokio::io::Repeat: Send & Sync & Unpin);
+assert_value!(tokio::io::Sink: Send & Sync & Unpin);
+assert_value!(tokio::io::Split<TcpStream>: Send & Sync & Unpin);
+assert_value!(tokio::io::Stderr: Send & Sync & Unpin);
+assert_value!(tokio::io::Stdin: Send & Sync & Unpin);
+assert_value!(tokio::io::Stdout: Send & Sync & Unpin);
+assert_value!(tokio::io::Take<TcpStream>: Send & Sync & Unpin);
+assert_value!(tokio::io::WriteHalf<TcpStream>: Send & Sync & Unpin);
+async_assert_fn!(tokio::io::copy(&mut TcpStream, &mut TcpStream): Send & Sync & !Unpin);
+async_assert_fn!(
+    tokio::io::copy_bidirectional(&mut TcpStream, &mut TcpStream): Send & Sync & !Unpin
+);
+async_assert_fn!(tokio::io::copy_buf(&mut tokio::io::BufReader<TcpStream>, &mut TcpStream): Send & Sync & !Unpin);
+async_assert_fn!(tokio::io::empty(): Send & Sync & Unpin);
+async_assert_fn!(tokio::io::repeat(u8): Send & Sync & Unpin);
+async_assert_fn!(tokio::io::sink(): Send & Sync & Unpin);
+async_assert_fn!(tokio::io::split(TcpStream): Send & Sync & Unpin);
+async_assert_fn!(tokio::io::stderr(): Send & Sync & Unpin);
+async_assert_fn!(tokio::io::stdin(): Send & Sync & Unpin);
+async_assert_fn!(tokio::io::stdout(): Send & Sync & Unpin);
+async_assert_fn!(tokio::io::Split<tokio::io::BufReader<TcpStream>>::next_segment(_): Send & Sync & !Unpin);
+async_assert_fn!(tokio::io::Lines<tokio::io::BufReader<TcpStream>>::next_line(_): Send & Sync & !Unpin);
+async_assert_fn!(tokio::io::AsyncBufReadExt::read_until(&mut BoxAsyncRead, u8, &mut Vec<u8>): Send & Sync & !Unpin);
+async_assert_fn!(
+    tokio::io::AsyncBufReadExt::read_line(&mut BoxAsyncRead, &mut String): Send & Sync & !Unpin
+);
+async_assert_fn!(tokio::io::AsyncBufReadExt::fill_buf(&mut BoxAsyncRead): Send & Sync & !Unpin);
+async_assert_fn!(tokio::io::AsyncReadExt::read(&mut BoxAsyncRead, &mut [u8]): Send & Sync & !Unpin);
+async_assert_fn!(tokio::io::AsyncReadExt::read_buf(&mut BoxAsyncRead, &mut Vec<u8>): Send & Sync & !Unpin);
+async_assert_fn!(
+    tokio::io::AsyncReadExt::read_exact(&mut BoxAsyncRead, &mut [u8]): Send & Sync & !Unpin
+);
+async_assert_fn!(tokio::io::AsyncReadExt::read_u8(&mut BoxAsyncRead): Send & Sync & !Unpin);
+async_assert_fn!(tokio::io::AsyncReadExt::read_i8(&mut BoxAsyncRead): Send & Sync & !Unpin);
+async_assert_fn!(tokio::io::AsyncReadExt::read_u16(&mut BoxAsyncRead): Send & Sync & !Unpin);
+async_assert_fn!(tokio::io::AsyncReadExt::read_i16(&mut BoxAsyncRead): Send & Sync & !Unpin);
+async_assert_fn!(tokio::io::AsyncReadExt::read_u32(&mut BoxAsyncRead): Send & Sync & !Unpin);
+async_assert_fn!(tokio::io::AsyncReadExt::read_i32(&mut BoxAsyncRead): Send & Sync & !Unpin);
+async_assert_fn!(tokio::io::AsyncReadExt::read_u64(&mut BoxAsyncRead): Send & Sync & !Unpin);
+async_assert_fn!(tokio::io::AsyncReadExt::read_i64(&mut BoxAsyncRead): Send & Sync & !Unpin);
+async_assert_fn!(tokio::io::AsyncReadExt::read_u128(&mut BoxAsyncRead): Send & Sync & !Unpin);
+async_assert_fn!(tokio::io::AsyncReadExt::read_i128(&mut BoxAsyncRead): Send & Sync & !Unpin);
+async_assert_fn!(tokio::io::AsyncReadExt::read_f32(&mut BoxAsyncRead): Send & Sync & !Unpin);
+async_assert_fn!(tokio::io::AsyncReadExt::read_f64(&mut BoxAsyncRead): Send & Sync & !Unpin);
+async_assert_fn!(tokio::io::AsyncReadExt::read_u16_le(&mut BoxAsyncRead): Send & Sync & !Unpin);
+async_assert_fn!(tokio::io::AsyncReadExt::read_i16_le(&mut BoxAsyncRead): Send & Sync & !Unpin);
+async_assert_fn!(tokio::io::AsyncReadExt::read_u32_le(&mut BoxAsyncRead): Send & Sync & !Unpin);
+async_assert_fn!(tokio::io::AsyncReadExt::read_i32_le(&mut BoxAsyncRead): Send & Sync & !Unpin);
+async_assert_fn!(tokio::io::AsyncReadExt::read_u64_le(&mut BoxAsyncRead): Send & Sync & !Unpin);
+async_assert_fn!(tokio::io::AsyncReadExt::read_i64_le(&mut BoxAsyncRead): Send & Sync & !Unpin);
+async_assert_fn!(tokio::io::AsyncReadExt::read_u128_le(&mut BoxAsyncRead): Send & Sync & !Unpin);
+async_assert_fn!(tokio::io::AsyncReadExt::read_i128_le(&mut BoxAsyncRead): Send & Sync & !Unpin);
+async_assert_fn!(tokio::io::AsyncReadExt::read_f32_le(&mut BoxAsyncRead): Send & Sync & !Unpin);
+async_assert_fn!(tokio::io::AsyncReadExt::read_f64_le(&mut BoxAsyncRead): Send & Sync & !Unpin);
+async_assert_fn!(tokio::io::AsyncReadExt::read_to_end(&mut BoxAsyncRead, &mut Vec<u8>): Send & Sync & !Unpin);
+async_assert_fn!(
+    tokio::io::AsyncReadExt::read_to_string(&mut BoxAsyncRead, &mut String): Send & Sync & !Unpin
+);
+async_assert_fn!(tokio::io::AsyncSeekExt::seek(&mut BoxAsyncSeek, SeekFrom): Send & Sync & !Unpin);
+async_assert_fn!(tokio::io::AsyncSeekExt::stream_position(&mut BoxAsyncSeek): Send & Sync & !Unpin);
+async_assert_fn!(tokio::io::AsyncWriteExt::write(&mut BoxAsyncWrite, &[u8]): Send & Sync & !Unpin);
+async_assert_fn!(
+    tokio::io::AsyncWriteExt::write_vectored(&mut BoxAsyncWrite, _): Send & Sync & !Unpin
+);
+async_assert_fn!(
+    tokio::io::AsyncWriteExt::write_buf(&mut BoxAsyncWrite, &mut bytes::Bytes): Send
+        & Sync
+        & !Unpin
+);
+async_assert_fn!(
+    tokio::io::AsyncWriteExt::write_all_buf(&mut BoxAsyncWrite, &mut bytes::Bytes): Send
+        & Sync
+        & !Unpin
+);
+async_assert_fn!(
+    tokio::io::AsyncWriteExt::write_all(&mut BoxAsyncWrite, &[u8]): Send & Sync & !Unpin
+);
+async_assert_fn!(tokio::io::AsyncWriteExt::write_u8(&mut BoxAsyncWrite, u8): Send & Sync & !Unpin);
+async_assert_fn!(tokio::io::AsyncWriteExt::write_i8(&mut BoxAsyncWrite, i8): Send & Sync & !Unpin);
+async_assert_fn!(
+    tokio::io::AsyncWriteExt::write_u16(&mut BoxAsyncWrite, u16): Send & Sync & !Unpin
+);
+async_assert_fn!(
+    tokio::io::AsyncWriteExt::write_i16(&mut BoxAsyncWrite, i16): Send & Sync & !Unpin
+);
+async_assert_fn!(
+    tokio::io::AsyncWriteExt::write_u32(&mut BoxAsyncWrite, u32): Send & Sync & !Unpin
+);
+async_assert_fn!(
+    tokio::io::AsyncWriteExt::write_i32(&mut BoxAsyncWrite, i32): Send & Sync & !Unpin
+);
+async_assert_fn!(
+    tokio::io::AsyncWriteExt::write_u64(&mut BoxAsyncWrite, u64): Send & Sync & !Unpin
+);
+async_assert_fn!(
+    tokio::io::AsyncWriteExt::write_i64(&mut BoxAsyncWrite, i64): Send & Sync & !Unpin
+);
+async_assert_fn!(
+    tokio::io::AsyncWriteExt::write_u128(&mut BoxAsyncWrite, u128): Send & Sync & !Unpin
+);
+async_assert_fn!(
+    tokio::io::AsyncWriteExt::write_i128(&mut BoxAsyncWrite, i128): Send & Sync & !Unpin
+);
+async_assert_fn!(
+    tokio::io::AsyncWriteExt::write_f32(&mut BoxAsyncWrite, f32): Send & Sync & !Unpin
+);
+async_assert_fn!(
+    tokio::io::AsyncWriteExt::write_f64(&mut BoxAsyncWrite, f64): Send & Sync & !Unpin
+);
+async_assert_fn!(
+    tokio::io::AsyncWriteExt::write_u16_le(&mut BoxAsyncWrite, u16): Send & Sync & !Unpin
+);
+async_assert_fn!(
+    tokio::io::AsyncWriteExt::write_i16_le(&mut BoxAsyncWrite, i16): Send & Sync & !Unpin
+);
+async_assert_fn!(
+    tokio::io::AsyncWriteExt::write_u32_le(&mut BoxAsyncWrite, u32): Send & Sync & !Unpin
+);
+async_assert_fn!(
+    tokio::io::AsyncWriteExt::write_i32_le(&mut BoxAsyncWrite, i32): Send & Sync & !Unpin
+);
+async_assert_fn!(
+    tokio::io::AsyncWriteExt::write_u64_le(&mut BoxAsyncWrite, u64): Send & Sync & !Unpin
+);
+async_assert_fn!(
+    tokio::io::AsyncWriteExt::write_i64_le(&mut BoxAsyncWrite, i64): Send & Sync & !Unpin
+);
+async_assert_fn!(
+    tokio::io::AsyncWriteExt::write_u128_le(&mut BoxAsyncWrite, u128): Send & Sync & !Unpin
+);
+async_assert_fn!(
+    tokio::io::AsyncWriteExt::write_i128_le(&mut BoxAsyncWrite, i128): Send & Sync & !Unpin
+);
+async_assert_fn!(
+    tokio::io::AsyncWriteExt::write_f32_le(&mut BoxAsyncWrite, f32): Send & Sync & !Unpin
+);
+async_assert_fn!(
+    tokio::io::AsyncWriteExt::write_f64_le(&mut BoxAsyncWrite, f64): Send & Sync & !Unpin
+);
+async_assert_fn!(tokio::io::AsyncWriteExt::flush(&mut BoxAsyncWrite): Send & Sync & !Unpin);
+async_assert_fn!(tokio::io::AsyncWriteExt::shutdown(&mut BoxAsyncWrite): Send & Sync & !Unpin);
+
+#[cfg(unix)]
+mod unix_asyncfd {
+    use super::*;
+    use tokio::io::unix::*;
+
+    #[allow(unused)]
+    struct ImplsFd<T> {
+        _t: T,
+    }
+    impl<T> std::os::unix::io::AsRawFd for ImplsFd<T> {
+        fn as_raw_fd(&self) -> std::os::unix::io::RawFd {
+            unreachable!()
+        }
+    }
+
+    assert_value!(AsyncFd<ImplsFd<YY>>: Send & Sync & Unpin);
+    assert_value!(AsyncFd<ImplsFd<YN>>: Send & !Sync & Unpin);
+    assert_value!(AsyncFd<ImplsFd<NN>>: !Send & !Sync & Unpin);
+    assert_value!(AsyncFdReadyGuard<'_, ImplsFd<YY>>: Send & Sync & Unpin);
+    assert_value!(AsyncFdReadyGuard<'_, ImplsFd<YN>>: !Send & !Sync & Unpin);
+    assert_value!(AsyncFdReadyGuard<'_, ImplsFd<NN>>: !Send & !Sync & Unpin);
+    assert_value!(AsyncFdReadyMutGuard<'_, ImplsFd<YY>>: Send & Sync & Unpin);
+    assert_value!(AsyncFdReadyMutGuard<'_, ImplsFd<YN>>: Send & !Sync & Unpin);
+    assert_value!(AsyncFdReadyMutGuard<'_, ImplsFd<NN>>: !Send & !Sync & Unpin);
+    assert_value!(TryIoError: Send & Sync & Unpin);
+    async_assert_fn!(AsyncFd<ImplsFd<YY>>::readable(_): Send & Sync & !Unpin);
+    async_assert_fn!(AsyncFd<ImplsFd<YY>>::readable_mut(_): Send & Sync & !Unpin);
+    async_assert_fn!(AsyncFd<ImplsFd<YY>>::writable(_): Send & Sync & !Unpin);
+    async_assert_fn!(AsyncFd<ImplsFd<YY>>::writable_mut(_): Send & Sync & !Unpin);
+    async_assert_fn!(AsyncFd<ImplsFd<YN>>::readable(_): !Send & !Sync & !Unpin);
+    async_assert_fn!(AsyncFd<ImplsFd<YN>>::readable_mut(_): Send & !Sync & !Unpin);
+    async_assert_fn!(AsyncFd<ImplsFd<YN>>::writable(_): !Send & !Sync & !Unpin);
+    async_assert_fn!(AsyncFd<ImplsFd<YN>>::writable_mut(_): Send & !Sync & !Unpin);
+    async_assert_fn!(AsyncFd<ImplsFd<NN>>::readable(_): !Send & !Sync & !Unpin);
+    async_assert_fn!(AsyncFd<ImplsFd<NN>>::readable_mut(_): !Send & !Sync & !Unpin);
+    async_assert_fn!(AsyncFd<ImplsFd<NN>>::writable(_): !Send & !Sync & !Unpin);
+    async_assert_fn!(AsyncFd<ImplsFd<NN>>::writable_mut(_): !Send & !Sync & !Unpin);
+}
+
+#[cfg(tokio_unstable)]
+mod unstable {
+    use super::*;
+
+    assert_value!(tokio::runtime::LocalRuntime: !Send & !Sync & Unpin);
+    assert_value!(tokio::runtime::LocalOptions: !Send & !Sync & Unpin);
+}

vendor/tokio/tests/buffered.rs

@@ -0,0 +1,51 @@
+#![warn(rust_2018_idioms)]
+#![cfg(all(feature = "full", not(target_os = "wasi")))] // Wasi does not support bind()
+
+use tokio::net::TcpListener;
+use tokio_test::assert_ok;
+
+use std::io::prelude::*;
+use std::net::TcpStream;
+use std::thread;
+
+#[tokio::test]
+#[cfg_attr(miri, ignore)] // No `socket` on miri.
+async fn echo_server() {
+    const N: usize = 1024;
+
+    let srv = assert_ok!(TcpListener::bind("127.0.0.1:0").await);
+    let addr = assert_ok!(srv.local_addr());
+
+    let msg = "foo bar baz";
+
+    let t = thread::spawn(move || {
+        let mut s = assert_ok!(TcpStream::connect(addr));
+
+        let t2 = thread::spawn(move || {
+            let mut s = assert_ok!(TcpStream::connect(addr));
+            let mut b = vec![0; msg.len() * N];
+            assert_ok!(s.read_exact(&mut b));
+            b
+        });
+
+        let mut expected = Vec::<u8>::new();
+        for _i in 0..N {
+            expected.extend(msg.as_bytes());
+            let res = assert_ok!(s.write(msg.as_bytes()));
+            assert_eq!(res, msg.len());
+        }
+
+        (expected, t2)
+    });
+
+    let (mut a, _) = assert_ok!(srv.accept().await);
+    let (mut b, _) = assert_ok!(srv.accept().await);
+
+    let n = assert_ok!(tokio::io::copy(&mut a, &mut b).await);
+
+    let (expected, t2) = t.join().unwrap();
+    let actual = t2.join().unwrap();
+
+    assert!(expected == actual);
+    assert_eq!(n, msg.len() as u64 * 1024);
+}

vendor/tokio/tests/coop_budget.rs

@@ -0,0 +1,93 @@
+#![warn(rust_2018_idioms)]
+#![cfg(all(feature = "full", target_os = "linux"))]
+
+use std::sync::atomic::{AtomicUsize, Ordering};
+use std::sync::Arc;
+use tokio::net::UdpSocket;
+use tokio::task::coop::{consume_budget, has_budget_remaining};
+
+const BUDGET: usize = 128;
+
+/// Ensure that UDP sockets have functional budgeting
+///
+/// # Design
+/// Two sockets communicate by spamming packets from one to the other.
+///
+/// In Linux, this packet will be slammed through the entire network stack and into the receiver's buffer during the
+/// send system call because we are using the loopback interface.
+/// This happens because the softirq chain invoked on send when using the loopback interface covers virtually the
+/// entirety of the lifecycle of a packet within the kernel network stack.
+///
+/// As a result, neither socket will ever encounter an EWOULDBLOCK, and the only way for these to yield during the loop
+/// is through budgeting.
+///
+/// A second task runs in the background and increments a counter before yielding, allowing us to know how many times sockets yielded.
+/// Since we are both sending and receiving, that should happen once per 64 packets, because budgets are of size 128
+/// and there are two budget events per packet, a send and a recv.
+#[tokio::test]
+#[cfg_attr(miri, ignore)] // No `socket` on miri.
+async fn coop_budget_udp_send_recv() {
+    const N_ITERATIONS: usize = 1024;
+
+    const PACKET: &[u8] = b"Hello, world";
+    const PACKET_LEN: usize = 12;
+
+    assert_eq!(
+        PACKET_LEN,
+        PACKET.len(),
+        "Defect in test, programmer can't do math"
+    );
+
+    // bind each socket to a dynamic port, forcing IPv4 addressing on the localhost interface
+    let tx = UdpSocket::bind("127.0.0.1:0").await.unwrap();
+    let rx = UdpSocket::bind("127.0.0.1:0").await.unwrap();
+
+    tx.connect(rx.local_addr().unwrap()).await.unwrap();
+    rx.connect(tx.local_addr().unwrap()).await.unwrap();
+
+    let tracker = Arc::new(AtomicUsize::default());
+
+    let tracker_clone = Arc::clone(&tracker);
+
+    tokio::task::yield_now().await;
+
+    tokio::spawn(async move {
+        loop {
+            tracker_clone.fetch_add(1, Ordering::SeqCst);
+
+            tokio::task::yield_now().await;
+        }
+    });
+
+    for _ in 0..N_ITERATIONS {
+        tx.send(PACKET).await.unwrap();
+
+        let mut tmp = [0; PACKET_LEN];
+
+        // ensure that we aren't somehow accumulating other
+        assert_eq!(
+            PACKET_LEN,
+            rx.recv(&mut tmp).await.unwrap(),
+            "Defect in test case, received unexpected result from socket"
+        );
+        assert_eq!(
+            PACKET, &tmp,
+            "Defect in test case, received unexpected result from socket"
+        );
+    }
+
+    assert_eq!(N_ITERATIONS / (BUDGET / 2), tracker.load(Ordering::SeqCst));
+}
+
+#[tokio::test]
+async fn test_has_budget_remaining() {
+    // At the beginning, budget should be available.
+    assert!(has_budget_remaining());
+
+    // Deplete the budget
+    for _ in 0..BUDGET {
+        consume_budget().await;
+    }
+
+    assert!(!has_budget_remaining());
+}

vendor/tokio/tests/dump.rs

@@ -0,0 +1,199 @@
+#![cfg(all(
+    tokio_unstable,
+    feature = "taskdump",
+    target_os = "linux",
+    any(target_arch = "aarch64", target_arch = "x86", target_arch = "x86_64")
+))]
+
+use std::hint::black_box;
+use tokio::runtime::{self, Handle};
+
+#[inline(never)]
+async fn a() {
+    black_box(b()).await
+}
+
+#[inline(never)]
+async fn b() {
+    black_box(c()).await
+}
+
+#[inline(never)]
+async fn c() {
+    loop {
+        black_box(tokio::task::yield_now()).await
+    }
+}
+
+#[test]
+fn current_thread() {
+    let rt = runtime::Builder::new_current_thread()
+        .enable_all()
+        .build()
+        .unwrap();
+
+    async fn dump() {
+        let handle = Handle::current();
+        let dump = handle.dump().await;
+
+        let tasks: Vec<_> = dump.tasks().iter().collect();
+
+        assert_eq!(tasks.len(), 3);
+
+        for task in tasks {
+            let id = task.id();
+            let trace = task.trace().to_string();
+            eprintln!("\n\n{id}:\n{trace}\n\n");
+            assert!(trace.contains("dump::a"));
+            assert!(trace.contains("dump::b"));
+            assert!(trace.contains("dump::c"));
+            assert!(trace.contains("tokio::task::yield_now"));
+        }
+    }
+
+    rt.block_on(async {
+        tokio::select!(
+            biased;
+            _ = tokio::spawn(a()) => {},
+            _ = tokio::spawn(a()) => {},
+            _ = tokio::spawn(a()) => {},
+            _ = dump() => {},
+        );
+    });
+}
+
+#[test]
+fn multi_thread() {
+    let rt = runtime::Builder::new_multi_thread()
+        .enable_all()
+        .worker_threads(3)
+        .build()
+        .unwrap();
+
+    async fn dump() {
+        let handle = Handle::current();
+        let dump = handle.dump().await;
+
+        let tasks: Vec<_> = dump.tasks().iter().collect();
+
+        assert_eq!(tasks.len(), 3);
+
+        for task in tasks {
+            let id = task.id();
+            let trace = task.trace().to_string();
+            eprintln!("\n\n{id}:\n{trace}\n\n");
+            assert!(trace.contains("dump::a"));
+            assert!(trace.contains("dump::b"));
+            assert!(trace.contains("dump::c"));
+            assert!(trace.contains("tokio::task::yield_now"));
+        }
+    }
+
+    rt.block_on(async {
+        tokio::select!(
+            biased;
+            _ = tokio::spawn(a()) => {},
+            _ = tokio::spawn(a()) => {},
+            _ = tokio::spawn(a()) => {},
+            _ = dump() => {},
+        );
+    });
+}
+
+/// Regression tests for #6035.
+///
+/// These tests ensure that dumping will not deadlock if a future completes
+/// during a trace.
+mod future_completes_during_trace {
+    use super::*;
+
+    use core::future::{poll_fn, Future};
+
+    /// A future that completes only during a trace.
+    fn complete_during_trace() -> impl Future<Output = ()> + Send {
+        use std::task::Poll;
+        poll_fn(|cx| {
+            if Handle::is_tracing() {
+                Poll::Ready(())
+            } else {
+                cx.waker().wake_by_ref();
+                Poll::Pending
+            }
+        })
+    }
+
+    #[test]
+    fn current_thread() {
+        let rt = runtime::Builder::new_current_thread()
+            .enable_all()
+            .build()
+            .unwrap();
+
+        async fn dump() {
+            let handle = Handle::current();
+            let _dump = handle.dump().await;
+        }
+
+        rt.block_on(async {
+            let _ = tokio::join!(tokio::spawn(complete_during_trace()), dump());
+        });
+    }
+
+    #[test]
+    fn multi_thread() {
+        let rt = runtime::Builder::new_multi_thread()
+            .enable_all()
+            .build()
+            .unwrap();
+
+        async fn dump() {
+            let handle = Handle::current();
+            let _dump = handle.dump().await;
+            tokio::task::yield_now().await;
+        }
+
+        rt.block_on(async {
+            let _ = tokio::join!(tokio::spawn(complete_during_trace()), dump());
+        });
+    }
+}
+
+/// Regression test for #6051.
+///
+/// This test ensures that tasks notified outside of a worker will not be
+/// traced, since doing so will un-set their notified bit prior to them being
+/// run and panic.
+#[test]
+fn notified_during_tracing() {
+    let rt = runtime::Builder::new_multi_thread()
+        .enable_all()
+        .worker_threads(3)
+        .build()
+        .unwrap();
+
+    let timeout = async {
+        tokio::time::sleep(tokio::time::Duration::from_secs(1)).await;
+    };
+
+    let timer = rt.spawn(async {
+        loop {
+            tokio::time::sleep(tokio::time::Duration::from_nanos(1)).await;
+        }
+    });
+
+    let dump = async {
+        loop {
+            let handle = Handle::current();
+            let _dump = handle.dump().await;
+        }
+    };
+
+    rt.block_on(async {
+        tokio::select!(
+            biased;
+            _ = timeout => {},
+            _ = timer => {},
+            _ = dump => {},
+        );
+    });
+}

vendor/tokio/tests/duplex_stream.rs

@@ -0,0 +1,47 @@
+#![warn(rust_2018_idioms)]
+#![cfg(feature = "full")]
+
+use std::io::IoSlice;
+use tokio::io::{AsyncReadExt, AsyncWriteExt};
+
+const HELLO: &[u8] = b"hello world...";
+
+#[tokio::test]
+async fn write_vectored() {
+    let (mut client, mut server) = tokio::io::duplex(64);
+
+    let ret = client
+        .write_vectored(&[IoSlice::new(HELLO), IoSlice::new(HELLO)])
+        .await
+        .unwrap();
+    assert_eq!(ret, HELLO.len() * 2);
+
+    client.flush().await.unwrap();
+    drop(client);
+
+    let mut buf = Vec::with_capacity(HELLO.len() * 2);
+    let bytes_read = server.read_to_end(&mut buf).await.unwrap();
+
+    assert_eq!(bytes_read, HELLO.len() * 2);
+    assert_eq!(buf, [HELLO, HELLO].concat());
+}
+
+#[tokio::test]
+async fn write_vectored_and_shutdown() {
+    let (mut client, mut server) = tokio::io::duplex(64);
+
+    let ret = client
+        .write_vectored(&[IoSlice::new(HELLO), IoSlice::new(HELLO)])
+        .await
+        .unwrap();
+    assert_eq!(ret, HELLO.len() * 2);
+
+    client.shutdown().await.unwrap();
+    drop(client);
+
+    let mut buf = Vec::with_capacity(HELLO.len() * 2);
+    let bytes_read = server.read_to_end(&mut buf).await.unwrap();
+
+    assert_eq!(bytes_read, HELLO.len() * 2);
+    assert_eq!(buf, [HELLO, HELLO].concat());
+}

vendor/tokio/tests/fs.rs

@@ -0,0 +1,36 @@
+#![warn(rust_2018_idioms)]
+#![cfg(all(feature = "full", not(target_os = "wasi")))] // Wasi does not support file operations
+
+use tokio::fs;
+use tokio_test::assert_ok;
+
+#[tokio::test]
+async fn path_read_write() {
+    let temp = tempdir();
+    let dir = temp.path();
+
+    assert_ok!(fs::write(dir.join("bar"), b"bytes").await);
+    let out = assert_ok!(fs::read(dir.join("bar")).await);
+
+    assert_eq!(out, b"bytes");
+}
+
+#[tokio::test]
+async fn try_clone_should_preserve_max_buf_size() {
+    let buf_size = 128;
+    let temp = tempdir();
+    let dir = temp.path();
+
+    let mut file = fs::File::create(dir.join("try_clone_should_preserve_max_buf_size"))
+        .await
+        .unwrap();
+    file.set_max_buf_size(buf_size);
+
+    let cloned = file.try_clone().await.unwrap();
+
+    assert_eq!(cloned.max_buf_size(), buf_size);
+}
+
+fn tempdir() -> tempfile::TempDir {
+    tempfile::tempdir().unwrap()
+}

vendor/tokio/tests/fs_canonicalize_dir.rs

@@ -0,0 +1,22 @@
+#![warn(rust_2018_idioms)]
+#![cfg(all(feature = "full", not(target_os = "wasi")))] // WASI does not support all fs operations
+
+use tokio::fs;
+
+#[tokio::test]
+#[cfg(unix)]
+async fn canonicalize_root_dir_unix() {
+    assert_eq!(fs::canonicalize("/.").await.unwrap().to_str().unwrap(), "/");
+}
+
+#[tokio::test]
+#[cfg(windows)]
+async fn canonicalize_root_dir_windows() {
+    // 2-step let bindings due to Rust memory semantics
+    let dir_path = fs::canonicalize("C:\\.\\").await.unwrap();
+
+    let dir_name = dir_path.to_str().unwrap();
+
+    assert!(dir_name.starts_with("\\\\"));
+    assert!(dir_name.ends_with("C:\\"));
+}

vendor/tokio/tests/fs_copy.rs

@@ -0,0 +1,41 @@
+#![warn(rust_2018_idioms)]
+#![cfg(all(feature = "full", not(target_os = "wasi")))] // WASI does not support all fs operations
+
+use tempfile::tempdir;
+use tokio::fs;
+
+#[tokio::test]
+#[cfg_attr(miri, ignore)] // No `fchmod` in miri.
+async fn copy() {
+    let dir = tempdir().unwrap();
+
+    let source_path = dir.path().join("foo.txt");
+    let dest_path = dir.path().join("bar.txt");
+
+    fs::write(&source_path, b"Hello File!").await.unwrap();
+    fs::copy(&source_path, &dest_path).await.unwrap();
+
+    let from = fs::read(&source_path).await.unwrap();
+    let to = fs::read(&dest_path).await.unwrap();
+
+    assert_eq!(from, to);
+}
+
+#[tokio::test]
+#[cfg_attr(miri, ignore)] // No `fchmod` in miri.
+async fn copy_permissions() {
+    let dir = tempdir().unwrap();
+    let from_path = dir.path().join("foo.txt");
+    let to_path = dir.path().join("bar.txt");
+
+    let from = tokio::fs::File::create(&from_path).await.unwrap();
+    let mut from_perms = from.metadata().await.unwrap().permissions();
+    from_perms.set_readonly(true);
+    from.set_permissions(from_perms.clone()).await.unwrap();
+
+    tokio::fs::copy(from_path, &to_path).await.unwrap();
+
+    let to_perms = tokio::fs::metadata(to_path).await.unwrap().permissions();
+
+    assert_eq!(from_perms, to_perms);
+}

vendor/tokio/tests/fs_dir.rs

@@ -0,0 +1,126 @@
+#![warn(rust_2018_idioms)]
+#![cfg(all(feature = "full", not(target_os = "wasi")))] // WASI does not support all fs operations
+
+use tokio::fs;
+use tokio_test::{assert_err, assert_ok};
+
+use std::sync::{Arc, Mutex};
+use tempfile::tempdir;
+
+#[tokio::test]
+async fn create_dir() {
+    let base_dir = tempdir().unwrap();
+    let new_dir = base_dir.path().join("foo");
+    let new_dir_2 = new_dir.clone();
+
+    assert_ok!(fs::create_dir(new_dir).await);
+
+    assert!(new_dir_2.is_dir());
+}
+
+#[tokio::test]
+async fn create_all() {
+    let base_dir = tempdir().unwrap();
+    let new_dir = base_dir.path().join("foo").join("bar");
+    let new_dir_2 = new_dir.clone();
+
+    assert_ok!(fs::create_dir_all(new_dir).await);
+    assert!(new_dir_2.is_dir());
+}
+
+#[tokio::test]
+async fn build_dir() {
+    let base_dir = tempdir().unwrap();
+    let new_dir = base_dir.path().join("foo").join("bar");
+    let new_dir_2 = new_dir.clone();
+
+    assert_ok!(fs::DirBuilder::new().recursive(true).create(new_dir).await);
+
+    assert!(new_dir_2.is_dir());
+    assert_err!(
+        fs::DirBuilder::new()
+            .recursive(false)
+            .create(new_dir_2)
+            .await
+    );
+}
+
+#[tokio::test]
+#[cfg(unix)]
+async fn build_dir_mode_read_only() {
+    let base_dir = tempdir().unwrap();
+    let new_dir = base_dir.path().join("abc");
+
+    assert_ok!(
+        fs::DirBuilder::new()
+            .recursive(true)
+            .mode(0o444)
+            .create(&new_dir)
+            .await
+    );
+
+    assert!(fs::metadata(new_dir)
+        .await
+        .expect("metadata result")
+        .permissions()
+        .readonly());
+}
+
+#[tokio::test]
+async fn remove() {
+    let base_dir = tempdir().unwrap();
+    let new_dir = base_dir.path().join("foo");
+    let new_dir_2 = new_dir.clone();
+
+    std::fs::create_dir(new_dir.clone()).unwrap();
+
+    assert_ok!(fs::remove_dir(new_dir).await);
+    assert!(!new_dir_2.exists());
+}
+
+#[tokio::test]
+async fn read_inherent() {
+    let base_dir = tempdir().unwrap();
+
+    let p = base_dir.path();
+    std::fs::create_dir(p.join("aa")).unwrap();
+    std::fs::create_dir(p.join("bb")).unwrap();
+    std::fs::create_dir(p.join("cc")).unwrap();
+
+    let files = Arc::new(Mutex::new(Vec::new()));
+
+    let f = files.clone();
+    let p = p.to_path_buf();
+
+    let mut entries = fs::read_dir(p).await.unwrap();
+
+    while let Some(e) = assert_ok!(entries.next_entry().await) {
+        let s = e.file_name().to_str().unwrap().to_string();
+        f.lock().unwrap().push(s);
+    }
+
+    let mut files = files.lock().unwrap();
+    files.sort(); // because the order is not guaranteed
+    assert_eq!(
+        *files,
+        vec!["aa".to_string(), "bb".to_string(), "cc".to_string()]
+    );
+}
+
+#[tokio::test]
+async fn read_dir_entry_info() {
+    let temp_dir = tempdir().unwrap();
+
+    let file_path = temp_dir.path().join("a.txt");
+
+    fs::write(&file_path, b"Hello File!").await.unwrap();
+
+    let mut dir = fs::read_dir(temp_dir.path()).await.unwrap();
+
+    let first_entry = dir.next_entry().await.unwrap().unwrap();
+
+    assert_eq!(first_entry.path(), file_path);
+    assert_eq!(first_entry.file_name(), "a.txt");
+    assert!(first_entry.metadata().await.unwrap().is_file());
+    assert!(first_entry.file_type().await.unwrap().is_file());
+}

vendor/tokio/tests/fs_file.rs

@@ -0,0 +1,289 @@
+#![warn(rust_2018_idioms)]
+#![cfg(all(feature = "full", not(target_os = "wasi")))] // WASI does not support all fs operations
+
+use futures::future::FutureExt;
+use std::io::prelude::*;
+use std::io::IoSlice;
+use tempfile::NamedTempFile;
+use tokio::fs::File;
+use tokio::io::{AsyncReadExt, AsyncSeekExt, AsyncWriteExt, SeekFrom};
+use tokio_test::task;
+
+const HELLO: &[u8] = b"hello world...";
+
+#[tokio::test]
+async fn basic_read() {
+    let mut tempfile = tempfile();
+    tempfile.write_all(HELLO).unwrap();
+
+    let mut file = File::open(tempfile.path()).await.unwrap();
+
+    let mut buf = [0; 1024];
+    let n = file.read(&mut buf).await.unwrap();
+
+    assert_eq!(n, HELLO.len());
+    assert_eq!(&buf[..n], HELLO);
+}
+
+#[tokio::test]
+async fn basic_write() {
+    let tempfile = tempfile();
+
+    let mut file = File::create(tempfile.path()).await.unwrap();
+
+    file.write_all(HELLO).await.unwrap();
+    file.flush().await.unwrap();
+
+    let file = std::fs::read(tempfile.path()).unwrap();
+    assert_eq!(file, HELLO);
+}
+
+#[tokio::test]
+async fn basic_write_and_shutdown() {
+    let tempfile = tempfile();
+
+    let mut file = File::create(tempfile.path()).await.unwrap();
+
+    file.write_all(HELLO).await.unwrap();
+    file.shutdown().await.unwrap();
+
+    let file = std::fs::read(tempfile.path()).unwrap();
+    assert_eq!(file, HELLO);
+}
+
+#[tokio::test]
+async fn write_vectored() {
+    let tempfile = tempfile();
+
+    let mut file = File::create(tempfile.path()).await.unwrap();
+
+    let ret = file
+        .write_vectored(&[IoSlice::new(HELLO), IoSlice::new(HELLO)])
+        .await
+        .unwrap();
+    assert_eq!(ret, HELLO.len() * 2);
+    file.flush().await.unwrap();
+
+    let file = std::fs::read(tempfile.path()).unwrap();
+    assert_eq!(file, [HELLO, HELLO].concat());
+}
+
+#[tokio::test]
+async fn write_vectored_and_shutdown() {
+    let tempfile = tempfile();
+
+    let mut file = File::create(tempfile.path()).await.unwrap();
+
+    let ret = file
+        .write_vectored(&[IoSlice::new(HELLO), IoSlice::new(HELLO)])
+        .await
+        .unwrap();
+    assert_eq!(ret, HELLO.len() * 2);
+    file.shutdown().await.unwrap();
+
+    let file = std::fs::read(tempfile.path()).unwrap();
+    assert_eq!(file, [HELLO, HELLO].concat());
+}
+
+#[tokio::test]
+async fn rewind_seek_position() {
+    let tempfile = tempfile();
+
+    let mut file = File::create(tempfile.path()).await.unwrap();
+
+    file.seek(SeekFrom::Current(10)).await.unwrap();
+
+    file.rewind().await.unwrap();
+
+    assert_eq!(file.stream_position().await.unwrap(), 0);
+}
+
+#[tokio::test]
+async fn coop() {
+    let mut tempfile = tempfile();
+    tempfile.write_all(HELLO).unwrap();
+
+    let mut task = task::spawn(async {
+        let mut file = File::open(tempfile.path()).await.unwrap();
+
+        let mut buf = [0; 1024];
+
+        loop {
+            let _ = file.read(&mut buf).await.unwrap();
+            file.seek(std::io::SeekFrom::Start(0)).await.unwrap();
+        }
+    });
+
+    for _ in 0..1_000 {
+        if task.poll().is_pending() {
+            return;
+        }
+    }
+
+    panic!("did not yield");
+}
+
+#[tokio::test]
+async fn write_to_clone() {
+    let tempfile = tempfile();
+
+    let file = File::create(tempfile.path()).await.unwrap();
+    let mut clone = file.try_clone().await.unwrap();
+
+    clone.write_all(HELLO).await.unwrap();
+    clone.flush().await.unwrap();
+
+    let contents = std::fs::read(tempfile.path()).unwrap();
+    assert_eq!(contents, HELLO);
+}
+
+#[tokio::test]
+async fn write_into_std() {
+    let tempfile = tempfile();
+
+    let file = File::create(tempfile.path()).await.unwrap();
+    let mut std_file = file.into_std().await;
+
+    std_file.write_all(HELLO).unwrap();
+
+    let contents = std::fs::read(tempfile.path()).unwrap();
+    assert_eq!(contents, HELLO);
+}
+
+#[tokio::test]
+async fn write_into_std_immediate() {
+    let tempfile = tempfile();
+
+    let file = File::create(tempfile.path()).await.unwrap();
+    let mut std_file = file.try_into_std().unwrap();
+
+    std_file.write_all(HELLO).unwrap();
+
+    let contents = std::fs::read(tempfile.path()).unwrap();
+    assert_eq!(contents, HELLO);
+}
+
+#[tokio::test]
+async fn read_file_from_std() {
+    let mut tempfile = tempfile();
+    tempfile.write_all(HELLO).unwrap();
+
+    let std_file = std::fs::File::open(tempfile.path()).unwrap();
+    let mut file = File::from(std_file);
+
+    let mut buf = [0; 1024];
+    let n = file.read(&mut buf).await.unwrap();
+    assert_eq!(n, HELLO.len());
+    assert_eq!(&buf[..n], HELLO);
+}
+
+#[tokio::test]
+async fn empty_read() {
+    let mut tempfile = tempfile();
+    tempfile.write_all(HELLO).unwrap();
+
+    let mut file = File::open(tempfile.path()).await.unwrap();
+
+    // Perform an empty read and get a length of zero.
+    assert!(matches!(file.read(&mut []).now_or_never(), Some(Ok(0))));
+
+    // Check that we don't get EOF on the next read.
+    let mut buf = [0; 1024];
+    let n = file.read(&mut buf).await.unwrap();
+
+    assert_eq!(n, HELLO.len());
+    assert_eq!(&buf[..n], HELLO);
+}
+
+fn tempfile() -> NamedTempFile {
+    NamedTempFile::new().unwrap()
+}
+
+#[tokio::test]
+async fn set_max_buf_size_read() {
+    let mut tempfile = tempfile();
+    tempfile.write_all(HELLO).unwrap();
+    let mut file = File::open(tempfile.path()).await.unwrap();
+    let mut buf = [0; 1024];
+    file.set_max_buf_size(1);
+
+    // A single read operation reads a maximum of 1 byte.
+    assert_eq!(file.read(&mut buf).await.unwrap(), 1);
+}
+
+#[tokio::test]
+async fn set_max_buf_size_write() {
+    let tempfile = tempfile();
+    let mut file = File::create(tempfile.path()).await.unwrap();
+    file.set_max_buf_size(1);
+
+    // A single write operation writes a maximum of 1 byte.
+    assert_eq!(file.write(HELLO).await.unwrap(), 1);
+}
+
+#[tokio::test]
+#[cfg_attr(miri, ignore)]
+#[cfg(unix)]
+async fn file_debug_fmt() {
+    let tempfile = tempfile();
+
+    let file = File::open(tempfile.path()).await.unwrap();
+
+    assert_eq!(
+        &format!("{file:?}")[0..33],
+        "tokio::fs::File { std: File { fd:"
+    );
+}
+
+#[tokio::test]
+#[cfg(windows)]
+async fn file_debug_fmt() {
+    let tempfile = tempfile();
+
+    let file = File::open(tempfile.path()).await.unwrap();
+
+    assert_eq!(
+        &format!("{:?}", file)[0..37],
+        "tokio::fs::File { std: File { handle:"
+    );
+}
+
+#[tokio::test]
+#[cfg(unix)]
+async fn unix_fd_is_valid() {
+    use std::os::unix::io::AsRawFd;
+    let tempfile = tempfile();
+
+    let file = File::create(tempfile.path()).await.unwrap();
+    assert!(file.as_raw_fd() as u64 > 0);
+}
+
+#[tokio::test]
+#[cfg(unix)]
+async fn read_file_from_unix_fd() {
+    use std::os::unix::io::{FromRawFd, IntoRawFd};
+
+    let mut tempfile = tempfile();
+    tempfile.write_all(HELLO).unwrap();
+
+    let file1 = File::open(tempfile.path()).await.unwrap();
+    let raw_fd = file1.into_std().await.into_raw_fd();
+    assert!(raw_fd > 0);
+
+    let mut file2 = unsafe { File::from_raw_fd(raw_fd) };
+
+    let mut buf = [0; 1024];
+    let n = file2.read(&mut buf).await.unwrap();
+    assert_eq!(n, HELLO.len());
+    assert_eq!(&buf[..n], HELLO);
+}
+
+#[tokio::test]
+#[cfg(windows)]
+async fn windows_handle() {
+    use std::os::windows::io::AsRawHandle;
+    let tempfile = tempfile();
+
+    let file = File::create(tempfile.path()).await.unwrap();
+    assert!(file.as_raw_handle() as u64 > 0);
+}

vendor/tokio/tests/fs_link.rs

@@ -0,0 +1,116 @@
+#![warn(rust_2018_idioms)]
+#![cfg(all(feature = "full", not(target_os = "wasi")))] // WASI does not support all fs operations
+
+use tokio::fs;
+
+use std::io::Write;
+use tempfile::tempdir;
+
+#[tokio::test]
+#[cfg_attr(miri, ignore)] // No `linkat` in miri.
+async fn test_hard_link() {
+    let dir = tempdir().unwrap();
+    let src = dir.path().join("src.txt");
+    let dst = dir.path().join("dst.txt");
+
+    std::fs::File::create(&src)
+        .unwrap()
+        .write_all(b"hello")
+        .unwrap();
+
+    fs::hard_link(&src, &dst).await.unwrap();
+
+    std::fs::File::create(&src)
+        .unwrap()
+        .write_all(b"new-data")
+        .unwrap();
+
+    let content = fs::read(&dst).await.unwrap();
+    assert_eq!(content, b"new-data");
+
+    // test that this is not a symlink:
+    assert!(fs::read_link(&dst).await.is_err());
+}
+
+#[cfg(unix)]
+#[tokio::test]
+async fn test_symlink() {
+    let dir = tempdir().unwrap();
+    let src = dir.path().join("src.txt");
+    let dst = dir.path().join("dst.txt");
+
+    std::fs::File::create(&src)
+        .unwrap()
+        .write_all(b"hello")
+        .unwrap();
+
+    fs::symlink(&src, &dst).await.unwrap();
+
+    std::fs::File::create(&src)
+        .unwrap()
+        .write_all(b"new-data")
+        .unwrap();
+
+    let content = fs::read(&dst).await.unwrap();
+    assert_eq!(content, b"new-data");
+
+    let read = fs::read_link(dst.clone()).await.unwrap();
+    assert!(read == src);
+
+    let symlink_meta = fs::symlink_metadata(dst.clone()).await.unwrap();
+    assert!(symlink_meta.file_type().is_symlink());
+}
+
+#[tokio::test]
+#[cfg_attr(miri, ignore)] // No `linkat` in miri.
+async fn test_hard_link_error_source_not_found() {
+    let dir = tempdir().unwrap();
+    let src = dir.path().join("nonexistent.txt");
+    let dst = dir.path().join("dst.txt");
+
+    let err = fs::hard_link(&src, &dst).await.unwrap_err();
+    assert_eq!(err.kind(), std::io::ErrorKind::NotFound);
+}
+
+#[tokio::test]
+#[cfg_attr(miri, ignore)] // No `linkat` in miri.
+async fn test_hard_link_error_destination_already_exists() {
+    let dir = tempdir().unwrap();
+    let src = dir.path().join("src.txt");
+    let dst = dir.path().join("dst.txt");
+
+    // Create source file
+    std::fs::write(&src, b"source content").unwrap();
+
+    // Create destination file
+    std::fs::write(&dst, b"destination content").unwrap();
+
+    // Attempt to create hard link when destination already exists
+    let err = fs::hard_link(&src, &dst).await.unwrap_err();
+    assert_eq!(err.kind(), std::io::ErrorKind::AlreadyExists);
+}
+
+#[tokio::test]
+#[cfg_attr(miri, ignore)] // No `linkat` in miri.
+async fn test_hard_link_error_source_is_directory() {
+    let dir = tempdir().unwrap();
+    let src_dir = dir.path().join("src_directory");
+    let dst = dir.path().join("dst.txt");
+
+    // Create source directory
+    fs::create_dir(&src_dir).await.unwrap();
+
+    // Attempt to create hard link from a directory
+    // On most systems, hard linking directories is not allowed
+    let err = fs::hard_link(&src_dir, &dst).await.unwrap_err();
+
+    // Different platforms return different error kinds
+    #[cfg(unix)]
+    assert!(
+        err.kind() == std::io::ErrorKind::PermissionDenied
+            || err.kind() == std::io::ErrorKind::Other
+    );
+
+    #[cfg(windows)]
+    assert_eq!(err.kind(), std::io::ErrorKind::PermissionDenied);
+}

vendor/tokio/tests/fs_open_options.rs

@@ -0,0 +1,84 @@
+#![warn(rust_2018_idioms)]
+#![cfg(all(feature = "full", not(target_os = "wasi")))] // WASI does not support all fs operations
+
+use std::io::Write;
+use tempfile::NamedTempFile;
+use tokio::fs::OpenOptions;
+use tokio::io::AsyncReadExt;
+
+const HELLO: &[u8] = b"hello world...";
+
+#[tokio::test]
+async fn open_with_open_options_and_read() {
+    let mut tempfile = NamedTempFile::new().unwrap();
+    tempfile.write_all(HELLO).unwrap();
+
+    let mut file = OpenOptions::new().read(true).open(tempfile).await.unwrap();
+
+    let mut buf = [0; 1024];
+    let n = file.read(&mut buf).await.unwrap();
+
+    assert_eq!(n, HELLO.len());
+    assert_eq!(&buf[..n], HELLO);
+}
+
+#[tokio::test]
+async fn open_options_write() {
+    // TESTING HACK: use Debug output to check the stored data
+    assert!(format!("{:?}", OpenOptions::new().write(true)).contains("write: true"));
+}
+
+#[tokio::test]
+async fn open_options_append() {
+    // TESTING HACK: use Debug output to check the stored data
+    assert!(format!("{:?}", OpenOptions::new().append(true)).contains("append: true"));
+}
+
+#[tokio::test]
+async fn open_options_truncate() {
+    // TESTING HACK: use Debug output to check the stored data
+    assert!(format!("{:?}", OpenOptions::new().truncate(true)).contains("truncate: true"));
+}
+
+#[tokio::test]
+async fn open_options_create() {
+    // TESTING HACK: use Debug output to check the stored data
+    assert!(format!("{:?}", OpenOptions::new().create(true)).contains("create: true"));
+}
+
+#[tokio::test]
+async fn open_options_create_new() {
+    // TESTING HACK: use Debug output to check the stored data
+    assert!(format!("{:?}", OpenOptions::new().create_new(true)).contains("create_new: true"));
+}
+
+#[tokio::test]
+#[cfg(unix)]
+async fn open_options_mode() {
+    let mode = format!("{:?}", OpenOptions::new().mode(0o644));
+    // TESTING HACK: use Debug output to check the stored data
+    assert!(
+        mode.contains("mode: 420") || mode.contains("mode: 0o000644"),
+        "mode is: {mode}"
+    );
+}
+
+#[tokio::test]
+#[cfg(target_os = "linux")]
+async fn open_options_custom_flags_linux() {
+    // TESTING HACK: use Debug output to check the stored data
+    assert!(
+        format!("{:?}", OpenOptions::new().custom_flags(libc::O_TRUNC))
+            .contains("custom_flags: 512")
+    );
+}
+
+#[tokio::test]
+#[cfg(any(target_os = "freebsd", target_os = "macos"))]
+async fn open_options_custom_flags_bsd_family() {
+    // TESTING HACK: use Debug output to check the stored data
+    assert!(
+        format!("{:?}", OpenOptions::new().custom_flags(libc::O_NOFOLLOW))
+            .contains("custom_flags: 256,")
+    );
+}

vendor/tokio/tests/fs_open_options_windows.rs

@@ -0,0 +1,51 @@
+#![warn(rust_2018_idioms)]
+#![cfg(all(feature = "full", not(target_os = "wasi")))] // WASI does not support all fs operations
+#![cfg(windows)]
+
+use tokio::fs::OpenOptions;
+use windows_sys::Win32::Storage::FileSystem;
+
+#[tokio::test]
+#[cfg(windows)]
+async fn open_options_windows_access_mode() {
+    // TESTING HACK: use Debug output to check the stored data
+    assert!(format!("{:?}", OpenOptions::new().access_mode(0)).contains("access_mode: Some(0)"));
+}
+
+#[tokio::test]
+#[cfg(windows)]
+async fn open_options_windows_share_mode() {
+    // TESTING HACK: use Debug output to check the stored data
+    assert!(format!("{:?}", OpenOptions::new().share_mode(0)).contains("share_mode: 0,"));
+}
+
+#[tokio::test]
+#[cfg(windows)]
+async fn open_options_windows_custom_flags() {
+    // TESTING HACK: use Debug output to check the stored data
+    assert!(format!(
+        "{:?}",
+        OpenOptions::new().custom_flags(FileSystem::FILE_FLAG_DELETE_ON_CLOSE)
+    )
+    .contains("custom_flags: 67108864,"));
+}
+
+#[tokio::test]
+#[cfg(windows)]
+async fn open_options_windows_attributes() {
+    assert!(format!(
+        "{:?}",
+        OpenOptions::new().attributes(FileSystem::FILE_ATTRIBUTE_HIDDEN)
+    )
+    .contains("attributes: 2,"));
+}
+
+#[tokio::test]
+#[cfg(windows)]
+async fn open_options_windows_security_qos_flags() {
+    assert!(format!(
+        "{:?}",
+        OpenOptions::new().security_qos_flags(FileSystem::SECURITY_IDENTIFICATION)
+    )
+    .contains("security_qos_flags: 1114112,"));
+}

vendor/tokio/tests/fs_remove_dir_all.rs

@@ -0,0 +1,31 @@
+#![warn(rust_2018_idioms)]
+#![cfg(all(feature = "full", not(target_os = "wasi")))] // WASI does not support all fs operations
+
+use tempfile::tempdir;
+use tokio::fs;
+
+#[tokio::test]
+async fn remove_dir_all() {
+    let temp_dir = tempdir().unwrap();
+
+    let test_dir = temp_dir.path().join("test");
+    fs::create_dir(&test_dir).await.unwrap();
+
+    let file_path = test_dir.as_path().join("a.txt");
+
+    fs::write(&file_path, b"Hello File!").await.unwrap();
+
+    fs::remove_dir_all(test_dir.as_path()).await.unwrap();
+
+    // test dir should no longer exist
+    match fs::try_exists(test_dir).await {
+        Ok(exists) => assert!(!exists),
+        Err(_) => println!("ignored try_exists error after remove_dir_all"),
+    };
+
+    // contents should no longer exist
+    match fs::try_exists(file_path).await {
+        Ok(exists) => assert!(!exists),
+        Err(_) => println!("ignored try_exists error after remove_dir_all"),
+    };
+}

vendor/tokio/tests/fs_remove_file.rs

@@ -0,0 +1,24 @@
+#![warn(rust_2018_idioms)]
+#![cfg(all(feature = "full", not(target_os = "wasi")))] // WASI does not support all fs operations
+
+use tempfile::tempdir;
+use tokio::fs;
+
+#[tokio::test]
+async fn remove_file() {
+    let temp_dir = tempdir().unwrap();
+
+    let file_path = temp_dir.path().join("a.txt");
+
+    fs::write(&file_path, b"Hello File!").await.unwrap();
+
+    assert!(fs::try_exists(&file_path).await.unwrap());
+
+    fs::remove_file(&file_path).await.unwrap();
+
+    // should no longer exist
+    match fs::try_exists(file_path).await {
+        Ok(exists) => assert!(!exists),
+        Err(_) => println!("ignored try_exists error after remove_file"),
+    };
+}

vendor/tokio/tests/fs_rename.rs

@@ -0,0 +1,28 @@
+#![warn(rust_2018_idioms)]
+#![cfg(all(feature = "full", not(target_os = "wasi")))] // WASI does not support all fs operations
+
+use tempfile::tempdir;
+use tokio::fs;
+
+#[tokio::test]
+async fn rename_file() {
+    let temp_dir = tempdir().unwrap();
+
+    let file_path = temp_dir.path().join("a.txt");
+
+    fs::write(&file_path, b"Hello File!").await.unwrap();
+
+    assert!(fs::try_exists(&file_path).await.unwrap());
+
+    let new_file_path = temp_dir.path().join("b.txt");
+
+    fs::rename(&file_path, &new_file_path).await.unwrap();
+
+    assert!(fs::try_exists(new_file_path).await.unwrap());
+
+    // original file should no longer exist
+    match fs::try_exists(file_path).await {
+        Ok(exists) => assert!(!exists),
+        Err(_) => println!("ignored try_exists error after rename"),
+    };
+}

vendor/tokio/tests/fs_symlink_dir_windows.rs

@@ -0,0 +1,31 @@
+#![warn(rust_2018_idioms)]
+#![cfg(all(feature = "full", not(target_os = "wasi")))] // WASI does not support all fs operations
+#![cfg(windows)]
+
+use tempfile::tempdir;
+use tokio::fs;
+
+#[tokio::test]
+async fn symlink_file_windows() {
+    const FILE_NAME: &str = "abc.txt";
+
+    let temp_dir = tempdir().unwrap();
+
+    let dir1 = temp_dir.path().join("a");
+    fs::create_dir(&dir1).await.unwrap();
+
+    let file1 = dir1.as_path().join(FILE_NAME);
+    fs::write(&file1, b"Hello File!").await.unwrap();
+
+    let dir2 = temp_dir.path().join("b");
+    fs::symlink_dir(&dir1, &dir2).await.unwrap();
+
+    fs::write(&file1, b"new data!").await.unwrap();
+
+    let file2 = dir2.as_path().join(FILE_NAME);
+
+    let from = fs::read(&file1).await.unwrap();
+    let to = fs::read(&file2).await.unwrap();
+
+    assert_eq!(from, to);
+}

vendor/tokio/tests/fs_symlink_file_windows.rs

@@ -0,0 +1,24 @@
+#![warn(rust_2018_idioms)]
+#![cfg(all(feature = "full", not(target_os = "wasi")))] // WASI does not support all fs operations
+#![cfg(windows)]
+
+use tempfile::tempdir;
+use tokio::fs;
+
+#[tokio::test]
+async fn symlink_file_windows() {
+    let dir = tempdir().unwrap();
+
+    let source_path = dir.path().join("foo.txt");
+    let dest_path = dir.path().join("bar.txt");
+
+    fs::write(&source_path, b"Hello File!").await.unwrap();
+    fs::symlink_file(&source_path, &dest_path).await.unwrap();
+
+    fs::write(&source_path, b"new data!").await.unwrap();
+
+    let from = fs::read(&source_path).await.unwrap();
+    let to = fs::read(&dest_path).await.unwrap();
+
+    assert_eq!(from, to);
+}

vendor/tokio/tests/fs_try_exists.rs

@@ -0,0 +1,48 @@
+#![warn(rust_2018_idioms)]
+#![cfg(all(feature = "full", not(target_os = "wasi")))] // WASI does not support all fs operations
+
+use tempfile::tempdir;
+use tokio::fs;
+
+#[tokio::test]
+#[cfg_attr(miri, ignore)] // No `chmod` in miri.
+async fn try_exists() {
+    let dir = tempdir().unwrap();
+
+    let existing_path = dir.path().join("foo.txt");
+    fs::write(&existing_path, b"Hello File!").await.unwrap();
+    let nonexisting_path = dir.path().join("bar.txt");
+
+    assert!(fs::try_exists(existing_path).await.unwrap());
+    assert!(!fs::try_exists(nonexisting_path).await.unwrap());
+    // FreeBSD root user always has permission to stat.
+    #[cfg(all(
+        unix,
+        not(any(target_os = "freebsd", all(tokio_unstable, feature = "io-uring")))
+    ))]
+    {
+        use std::os::unix::prelude::PermissionsExt;
+        let permission_denied_directory_path = dir.path().join("baz");
+        fs::create_dir(&permission_denied_directory_path)
+            .await
+            .unwrap();
+        let permission_denied_file_path = permission_denied_directory_path.join("baz.txt");
+        fs::write(&permission_denied_file_path, b"Hello File!")
+            .await
+            .unwrap();
+        let mut perms = tokio::fs::metadata(&permission_denied_directory_path)
+            .await
+            .unwrap()
+            .permissions();
+
+        perms.set_mode(0o244);
+        fs::set_permissions(&permission_denied_directory_path, perms)
+            .await
+            .unwrap();
+        let permission_denied_result = fs::try_exists(permission_denied_file_path).await;
+        assert_eq!(
+            permission_denied_result.err().unwrap().kind(),
+            std::io::ErrorKind::PermissionDenied
+        );
+    }
+}

vendor/tokio/tests/fs_uring.rs

@@ -0,0 +1,157 @@
+//! Uring file operations tests.
+
+#![cfg(all(
+    tokio_unstable,
+    feature = "io-uring",
+    feature = "rt",
+    feature = "fs",
+    target_os = "linux"
+))]
+
+use futures::future::FutureExt;
+use std::sync::mpsc;
+use std::task::Poll;
+use std::time::Duration;
+use std::{future::poll_fn, path::PathBuf};
+use tempfile::NamedTempFile;
+use tokio::{
+    fs::OpenOptions,
+    runtime::{Builder, Runtime},
+};
+use tokio_util::task::TaskTracker;
+
+fn multi_rt(n: usize) -> Box<dyn Fn() -> Runtime> {
+    Box::new(move || {
+        Builder::new_multi_thread()
+            .worker_threads(n)
+            .enable_all()
+            .build()
+            .unwrap()
+    })
+}
+
+fn current_rt() -> Box<dyn Fn() -> Runtime> {
+    Box::new(|| Builder::new_current_thread().enable_all().build().unwrap())
+}
+
+fn rt_combinations() -> Vec<Box<dyn Fn() -> Runtime>> {
+    vec![
+        current_rt(),
+        multi_rt(1),
+        multi_rt(2),
+        multi_rt(8),
+        multi_rt(64),
+        multi_rt(256),
+    ]
+}
+
+#[test]
+fn shutdown_runtime_while_performing_io_uring_ops() {
+    fn run(rt: Runtime) {
+        let (tx, rx) = mpsc::channel();
+        let (done_tx, done_rx) = mpsc::channel();
+
+        let (_tmp, path) = create_tmp_files(1);
+        rt.spawn(async move {
+            let path = path[0].clone();
+
+            // spawning a bunch of uring operations.
+            loop {
+                let path = path.clone();
+                tokio::spawn(async move {
+                    let mut opt = OpenOptions::new();
+                    opt.read(true);
+                    opt.open(&path).await.unwrap();
+                });
+
+                // Avoid busy looping.
+                tokio::task::yield_now().await;
+            }
+        });
+
+        std::thread::spawn(move || {
+            let rt: Runtime = rx.recv().unwrap();
+            rt.shutdown_timeout(Duration::from_millis(300));
+            done_tx.send(()).unwrap();
+        });
+
+        tx.send(rt).unwrap();
+        done_rx.recv().unwrap();
+    }
+
+    for rt in rt_combinations() {
+        run(rt());
+    }
+}
+
+#[test]
+fn open_many_files() {
+    fn run(rt: Runtime) {
+        const NUM_FILES: usize = 512;
+
+        let (_tmp_files, paths): (Vec<NamedTempFile>, Vec<PathBuf>) = create_tmp_files(NUM_FILES);
+
+        rt.block_on(async move {
+            let tracker = TaskTracker::new();
+
+            for i in 0..10_000 {
+                let path = paths.get(i % NUM_FILES).unwrap().clone();
+                tracker.spawn(async move {
+                    let _file = OpenOptions::new().read(true).open(path).await.unwrap();
+                });
+            }
+            tracker.close();
+            tracker.wait().await;
+        });
+    }
+
+    for rt in rt_combinations() {
+        run(rt());
+    }
+}
+
+#[tokio::test]
+async fn cancel_op_future() {
+    let (_tmp_file, path): (Vec<NamedTempFile>, Vec<PathBuf>) = create_tmp_files(1);
+
+    let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel();
+    let handle = tokio::spawn(async move {
+        poll_fn(|cx| {
+            let opt = {
+                let mut opt = tokio::fs::OpenOptions::new();
+                opt.read(true);
+                opt
+            };
+
+            let fut = opt.open(&path[0]);
+
+            // If io_uring is enabled (and not falling back to the thread pool),
+            // the first poll should return Pending.
+            let _pending = Box::pin(fut).poll_unpin(cx);
+
+            tx.send(()).unwrap();
+
+            Poll::<()>::Pending
+        })
+        .await;
+    });
+
+    // Wait for the first poll
+    rx.recv().await.unwrap();
+
+    handle.abort();
+
+    let res = handle.await.unwrap_err();
+    assert!(res.is_cancelled());
+}
+
+fn create_tmp_files(num_files: usize) -> (Vec<NamedTempFile>, Vec<PathBuf>) {
+    let mut files = Vec::with_capacity(num_files);
+    for _ in 0..num_files {
+        let tmp = NamedTempFile::new().unwrap();
+        let path = tmp.path().to_path_buf();
+        files.push((tmp, path));
+    }
+
+    files.into_iter().unzip()
+}

vendor/tokio/tests/fs_uring_read.rs

@@ -0,0 +1,202 @@
+//! Uring file operations tests.
+
+#![cfg(all(
+    tokio_unstable,
+    feature = "io-uring",
+    feature = "rt",
+    feature = "fs",
+    target_os = "linux"
+))]
+
+use futures::future::Future;
+use std::future::poll_fn;
+use std::io::Write;
+use std::path::PathBuf;
+use std::sync::mpsc;
+use std::task::{Context, Poll, Waker};
+use std::time::Duration;
+use tempfile::NamedTempFile;
+use tokio::fs::read;
+use tokio::runtime::{Builder, Runtime};
+use tokio_test::assert_pending;
+use tokio_util::task::TaskTracker;
+
+fn multi_rt(n: usize) -> Box<dyn Fn() -> Runtime> {
+    Box::new(move || {
+        Builder::new_multi_thread()
+            .worker_threads(n)
+            .enable_all()
+            .build()
+            .unwrap()
+    })
+}
+
+fn current_rt() -> Box<dyn Fn() -> Runtime> {
+    Box::new(|| Builder::new_current_thread().enable_all().build().unwrap())
+}
+
+fn rt_combinations() -> Vec<Box<dyn Fn() -> Runtime>> {
+    vec![
+        current_rt(),
+        multi_rt(1),
+        multi_rt(2),
+        multi_rt(8),
+        multi_rt(64),
+        multi_rt(256),
+    ]
+}
+
+#[test]
+fn shutdown_runtime_while_performing_io_uring_ops() {
+    fn run(rt: Runtime) {
+        let (done_tx, done_rx) = mpsc::channel();
+        let (_tmp, path) = create_tmp_files(1);
+        // keep 100 permits
+        const N: i32 = 100;
+        rt.spawn(async move {
+            let path = path[0].clone();
+
+            // spawning a bunch of uring operations.
+            let mut futs = vec![];
+
+            // spawning a bunch of uring operations.
+            for _ in 0..N {
+                let path = path.clone();
+                let mut fut = Box::pin(read(path));
+
+                poll_fn(|cx| {
+                    assert_pending!(fut.as_mut().poll(cx));
+                    Poll::<()>::Pending
+                })
+                .await;
+
+                futs.push(fut);
+            }
+
+            tokio::task::yield_now().await;
+        });
+
+        std::thread::spawn(move || {
+            rt.shutdown_timeout(Duration::from_millis(300));
+            done_tx.send(()).unwrap();
+        });
+
+        done_rx.recv().unwrap();
+    }
+
+    for rt in rt_combinations() {
+        run(rt());
+    }
+}
+
+#[test]
+fn read_many_files() {
+    fn run(rt: Runtime) {
+        const NUM_FILES: usize = 512;
+
+        let (_tmp_files, paths): (Vec<NamedTempFile>, Vec<PathBuf>) = create_tmp_files(NUM_FILES);
+
+        rt.block_on(async move {
+            let tracker = TaskTracker::new();
+
+            for i in 0..10_000 {
+                let path = paths.get(i % NUM_FILES).unwrap().clone();
+                tracker.spawn(async move {
+                    let bytes = read(path).await.unwrap();
+                    assert_eq!(bytes, vec![20; 1023]);
+                });
+            }
+            tracker.close();
+            tracker.wait().await;
+        });
+    }
+
+    for rt in rt_combinations() {
+        run(rt());
+    }
+}
+
+#[tokio::test]
+async fn read_small_large_files() {
+    let (_tmp, path) = create_large_temp_file();
+
+    let bytes = read(path).await.unwrap();
+
+    assert_eq!(bytes, create_buf(5000));
+
+    let (_tmp, path) = create_small_temp_file();
+
+    let bytes = read(path).await.unwrap();
+
+    assert_eq!(bytes, create_buf(20));
+}
+
+#[tokio::test]
+async fn cancel_op_future() {
+    let (_tmp_file, path): (Vec<NamedTempFile>, Vec<PathBuf>) = create_tmp_files(1);
+    let path = path[0].clone();
+
+    let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel();
+
+    let handle = tokio::spawn(async move {
+        let fut = read(path.clone());
+        tokio::pin!(fut);
+
+        poll_fn(move |_| {
+            // If io_uring is enabled (and not falling back to the thread pool),
+            // the first poll should return Pending.
+            assert_pending!(fut.as_mut().poll(&mut Context::from_waker(Waker::noop())));
+            tx.send(true).unwrap();
+
+            Poll::<()>::Pending
+        })
+        .await;
+    });
+
+    // Wait for the first poll
+
+    let val = rx.recv().await;
+    assert!(val.unwrap());
+
+    handle.abort();
+
+    let res = handle.await.unwrap_err();
+    assert!(res.is_cancelled());
+}
+
+fn create_tmp_files(num_files: usize) -> (Vec<NamedTempFile>, Vec<PathBuf>) {
+    let mut files = Vec::with_capacity(num_files);
+    for _ in 0..num_files {
+        let mut tmp = NamedTempFile::new().unwrap();
+        let buf = vec![20; 1023];
+        tmp.write_all(&buf).unwrap();
+        let path = tmp.path().to_path_buf();
+        files.push((tmp, path));
+    }
+
+    files.into_iter().unzip()
+}
+
+fn create_large_temp_file() -> (NamedTempFile, PathBuf) {
+    let mut tmp = NamedTempFile::new().unwrap();
+    let buf = create_buf(5000);
+
+    tmp.write_all(&buf).unwrap();
+    let path = tmp.path().to_path_buf();
+
+    (tmp, path)
+}
+
+fn create_small_temp_file() -> (NamedTempFile, PathBuf) {
+    let mut tmp = NamedTempFile::new().unwrap();
+    let buf = create_buf(20);
+
+    tmp.write_all(&buf).unwrap();
+    let path = tmp.path().to_path_buf();
+
+    (tmp, path)
+}
+
+fn create_buf(length: usize) -> Vec<u8> {
+    (0..length).map(|i| i as u8).collect()
+}

vendor/tokio/tests/fs_write.rs

@@ -0,0 +1,16 @@
+#![warn(rust_2018_idioms)]
+#![cfg(all(feature = "full", not(target_os = "wasi")))] // WASI does not support all fs operations
+
+use tempfile::tempdir;
+use tokio::fs;
+
+#[tokio::test]
+async fn write() {
+    let dir = tempdir().unwrap();
+    let path = dir.path().join("test.txt");
+
+    fs::write(&path, "Hello, World!").await.unwrap();
+
+    let contents = fs::read_to_string(&path).await.unwrap();
+    assert_eq!(contents, "Hello, World!");
+}

vendor/tokio/tests/io_async_fd.rs

@@ -0,0 +1,958 @@
+#![warn(rust_2018_idioms)]
+#![cfg(all(unix, feature = "full"))]
+
+use std::os::unix::io::{AsRawFd, RawFd};
+use std::sync::{
+    atomic::{AtomicBool, Ordering},
+    Arc,
+};
+use std::time::Duration;
+use std::{
+    future::Future,
+    io::{self, ErrorKind, Read, Write},
+    task::{Context, Waker},
+};
+
+use nix::unistd::{read, write};
+
+use futures::poll;
+
+use tokio::io::unix::{AsyncFd, AsyncFdReadyGuard};
+use tokio::io::Interest;
+use tokio_test::{assert_err, assert_pending};
+
+struct TestWaker {
+    inner: Arc<TestWakerInner>,
+    waker: Waker,
+}
+
+#[derive(Default)]
+struct TestWakerInner {
+    awoken: AtomicBool,
+}
+
+impl futures::task::ArcWake for TestWakerInner {
+    fn wake_by_ref(arc_self: &Arc<Self>) {
+        arc_self.awoken.store(true, Ordering::SeqCst);
+    }
+}
+
+impl TestWaker {
+    fn new() -> Self {
+        let inner: Arc<TestWakerInner> = Default::default();
+
+        Self {
+            inner: inner.clone(),
+            waker: futures::task::waker(inner),
+        }
+    }
+
+    fn awoken(&self) -> bool {
+        self.inner.awoken.swap(false, Ordering::SeqCst)
+    }
+
+    fn context(&self) -> Context<'_> {
+        Context::from_waker(&self.waker)
+    }
+}
+
+#[derive(Debug)]
+struct FileDescriptor {
+    fd: std::os::fd::OwnedFd,
+}
+
+impl AsRawFd for FileDescriptor {
+    fn as_raw_fd(&self) -> RawFd {
+        self.fd.as_raw_fd()
+    }
+}
+
+impl Read for &FileDescriptor {
+    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
+        read(self.fd.as_raw_fd(), buf).map_err(io::Error::from)
+    }
+}
+
+impl Read for FileDescriptor {
+    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
+        (self as &Self).read(buf)
+    }
+}
+
+impl Write for &FileDescriptor {
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        write(&self.fd, buf).map_err(io::Error::from)
+    }
+
+    fn flush(&mut self) -> io::Result<()> {
+        Ok(())
+    }
+}
+
+impl Write for FileDescriptor {
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        (self as &Self).write(buf)
+    }
+
+    fn flush(&mut self) -> io::Result<()> {
+        (self as &Self).flush()
+    }
+}
+
+fn set_nonblocking(fd: RawFd) {
+    use nix::fcntl::{OFlag, F_GETFL, F_SETFL};
+
+    let flags = nix::fcntl::fcntl(fd, F_GETFL).expect("fcntl(F_GETFD)");
+
+    if flags < 0 {
+        panic!(
+            "bad return value from fcntl(F_GETFL): {} ({:?})",
+            flags,
+            nix::Error::last()
+        );
+    }
+
+    let flags = OFlag::from_bits_truncate(flags) | OFlag::O_NONBLOCK;
+
+    nix::fcntl::fcntl(fd, F_SETFL(flags)).expect("fcntl(F_SETFD)");
+}
+
+fn socketpair() -> (FileDescriptor, FileDescriptor) {
+    use nix::sys::socket::{self, AddressFamily, SockFlag, SockType};
+
+    let (fd_a, fd_b) = socket::socketpair(
+        AddressFamily::Unix,
+        SockType::Stream,
+        None,
+        SockFlag::empty(),
+    )
+    .expect("socketpair");
+    let fds = (FileDescriptor { fd: fd_a }, FileDescriptor { fd: fd_b });
+
+    set_nonblocking(fds.0.fd.as_raw_fd());
+    set_nonblocking(fds.1.fd.as_raw_fd());
+
+    fds
+}
+
+fn drain(mut fd: &FileDescriptor, mut amt: usize) {
+    let mut buf = [0u8; 512];
+    while amt > 0 {
+        match fd.read(&mut buf[..]) {
+            Err(e) if e.kind() == ErrorKind::WouldBlock => {}
+            Ok(0) => panic!("unexpected EOF"),
+            Err(e) => panic!("unexpected error: {e:?}"),
+            Ok(x) => amt -= x,
+        }
+    }
+}
+
+#[tokio::test]
+async fn initially_writable() {
+    let (a, b) = socketpair();
+
+    let afd_a = AsyncFd::new(a).unwrap();
+    let afd_b = AsyncFd::new(b).unwrap();
+
+    afd_a.writable().await.unwrap().clear_ready();
+    afd_b.writable().await.unwrap().clear_ready();
+
+    tokio::select! {
+        biased;
+        _ = tokio::time::sleep(Duration::from_millis(10)) => {},
+        _ = afd_a.readable() => panic!("Unexpected readable state"),
+        _ = afd_b.readable() => panic!("Unexpected readable state"),
+    }
+}
+
+#[tokio::test]
+async fn reset_readable() {
+    let (a, mut b) = socketpair();
+
+    let afd_a = AsyncFd::new(a).unwrap();
+
+    let readable = afd_a.readable();
+    tokio::pin!(readable);
+
+    tokio::select! {
+        _ = readable.as_mut() => panic!(),
+        _ = tokio::time::sleep(Duration::from_millis(10)) => {}
+    }
+
+    b.write_all(b"0").unwrap();
+
+    let mut guard = readable.await.unwrap();
+
+    guard
+        .try_io(|_| afd_a.get_ref().read(&mut [0]))
+        .unwrap()
+        .unwrap();
+
+    // `a` is not readable, but the reactor still thinks it is
+    // (because we have not observed a not-ready error yet)
+    afd_a.readable().await.unwrap().retain_ready();
+
+    // Explicitly clear the ready state
+    guard.clear_ready();
+
+    let readable = afd_a.readable();
+    tokio::pin!(readable);
+
+    tokio::select! {
+        _ = readable.as_mut() => panic!(),
+        _ = tokio::time::sleep(Duration::from_millis(10)) => {}
+    }
+
+    b.write_all(b"0").unwrap();
+
+    // We can observe the new readable event
+    afd_a.readable().await.unwrap().clear_ready();
+}
+
+#[tokio::test]
+async fn reset_writable() {
+    let (a, b) = socketpair();
+
+    let afd_a = AsyncFd::new(a).unwrap();
+
+    let mut guard = afd_a.writable().await.unwrap();
+
+    // Write until we get a WouldBlock. This also clears the ready state.
+    let mut bytes = 0;
+    while let Ok(Ok(amt)) = guard.try_io(|_| afd_a.get_ref().write(&[0; 512][..])) {
+        bytes += amt;
+    }
+
+    // Writable state should be cleared now.
+    let writable = afd_a.writable();
+    tokio::pin!(writable);
+
+    tokio::select! {
+        _ = writable.as_mut() => panic!(),
+        _ = tokio::time::sleep(Duration::from_millis(10)) => {}
+    }
+
+    // Read from the other side; we should become writable now.
+    drain(&b, bytes);
+
+    let _ = writable.await.unwrap();
+}
+
+#[derive(Debug)]
+struct ArcFd<T>(Arc<T>);
+impl<T: AsRawFd> AsRawFd for ArcFd<T> {
+    fn as_raw_fd(&self) -> RawFd {
+        self.0.as_raw_fd()
+    }
+}
+
+#[tokio::test]
+async fn drop_closes() {
+    let (a, mut b) = socketpair();
+
+    let afd_a = AsyncFd::new(a).unwrap();
+
+    assert_eq!(
+        ErrorKind::WouldBlock,
+        b.read(&mut [0]).err().unwrap().kind()
+    );
+
+    std::mem::drop(afd_a);
+
+    assert_eq!(0, b.read(&mut [0]).unwrap());
+
+    // into_inner does not close the fd
+
+    let (a, mut b) = socketpair();
+    let afd_a = AsyncFd::new(a).unwrap();
+    let _a: FileDescriptor = afd_a.into_inner();
+
+    assert_eq!(
+        ErrorKind::WouldBlock,
+        b.read(&mut [0]).err().unwrap().kind()
+    );
+
+    // Drop closure behavior is delegated to the inner object
+    let (a, mut b) = socketpair();
+    let arc_fd = Arc::new(a);
+    let afd_a = AsyncFd::new(ArcFd(arc_fd.clone())).unwrap();
+    std::mem::drop(afd_a);
+
+    assert_eq!(
+        ErrorKind::WouldBlock,
+        b.read(&mut [0]).err().unwrap().kind()
+    );
+
+    std::mem::drop(arc_fd); // suppress unnecessary clone clippy warning
+}
+
+#[tokio::test]
+async fn reregister() {
+    let (a, _b) = socketpair();
+
+    let afd_a = AsyncFd::new(a).unwrap();
+    let a = afd_a.into_inner();
+    AsyncFd::new(a).unwrap();
+}
+
+#[tokio::test]
+async fn guard_try_io() {
+    let (a, mut b) = socketpair();
+
+    b.write_all(b"0").unwrap();
+
+    let afd_a = AsyncFd::new(a).unwrap();
+
+    let mut guard = afd_a.readable().await.unwrap();
+
+    afd_a.get_ref().read_exact(&mut [0]).unwrap();
+
+    // Should not clear the readable state
+    let _ = guard.try_io(|_| Ok(()));
+
+    // Still readable...
+    let _ = afd_a.readable().await.unwrap();
+
+    // Should clear the readable state
+    let _ = guard.try_io(|_| io::Result::<()>::Err(ErrorKind::WouldBlock.into()));
+
+    // Assert not readable
+    let readable = afd_a.readable();
+    tokio::pin!(readable);
+
+    tokio::select! {
+        _ = readable.as_mut() => panic!(),
+        _ = tokio::time::sleep(Duration::from_millis(10)) => {}
+    }
+
+    // Write something down b again and make sure we're reawoken
+    b.write_all(b"0").unwrap();
+    let _ = readable.await.unwrap();
+}
+
+#[tokio::test]
+async fn try_io_readable() {
+    let (a, mut b) = socketpair();
+    let mut afd_a = AsyncFd::new(a).unwrap();
+
+    // Give the runtime some time to update bookkeeping.
+    tokio::task::yield_now().await;
+
+    {
+        let mut called = false;
+        let _ = afd_a.try_io_mut(Interest::READABLE, |_| {
+            called = true;
+            Ok(())
+        });
+        assert!(
+            !called,
+            "closure should not have been called, since socket should not be readable"
+        );
+    }
+
+    // Make `a` readable by writing to `b`.
+    // Give the runtime some time to update bookkeeping.
+    b.write_all(&[0]).unwrap();
+    tokio::task::yield_now().await;
+
+    {
+        let mut called = false;
+        let _ = afd_a.try_io(Interest::READABLE, |_| {
+            called = true;
+            Ok(())
+        });
+        assert!(
+            called,
+            "closure should have been called, since socket should have data available to read"
+        );
+    }
+
+    {
+        let mut called = false;
+        let _ = afd_a.try_io(Interest::READABLE, |_| {
+            called = true;
+            io::Result::<()>::Err(ErrorKind::WouldBlock.into())
+        });
+        assert!(
+            called,
+            "closure should have been called, since socket should have data available to read"
+        );
+    }
+
+    {
+        let mut called = false;
+        let _ = afd_a.try_io(Interest::READABLE, |_| {
+            called = true;
+            Ok(())
+        });
+        assert!(!called, "closure should not have been called, since socket readable state should have been cleared");
+    }
+}
+
+#[tokio::test]
+async fn try_io_writable() {
+    let (a, _b) = socketpair();
+    let afd_a = AsyncFd::new(a).unwrap();
+
+    // Give the runtime some time to update bookkeeping.
+    tokio::task::yield_now().await;
+
+    {
+        let mut called = false;
+        let _ = afd_a.try_io(Interest::WRITABLE, |_| {
+            called = true;
+            Ok(())
+        });
+        assert!(
+            called,
+            "closure should have been called, since socket should still be marked as writable"
+        );
+    }
+    {
+        let mut called = false;
+        let _ = afd_a.try_io(Interest::WRITABLE, |_| {
+            called = true;
+            io::Result::<()>::Err(ErrorKind::WouldBlock.into())
+        });
+        assert!(
+            called,
+            "closure should have been called, since socket should still be marked as writable"
+        );
+    }
+
+    {
+        let mut called = false;
+        let _ = afd_a.try_io(Interest::WRITABLE, |_| {
+            called = true;
+            Ok(())
+        });
+        assert!(!called, "closure should not have been called, since socket writable state should have been cleared");
+    }
+}
+
+#[tokio::test]
+async fn multiple_waiters() {
+    let (a, mut b) = socketpair();
+    let afd_a = Arc::new(AsyncFd::new(a).unwrap());
+
+    let barrier = Arc::new(tokio::sync::Barrier::new(11));
+
+    let mut tasks = Vec::new();
+    for _ in 0..10 {
+        let afd_a = afd_a.clone();
+        let barrier = barrier.clone();
+
+        let f = async move {
+            let notify_barrier = async {
+                barrier.wait().await;
+                futures::future::pending::<()>().await;
+            };
+
+            tokio::select! {
+                biased;
+                guard = afd_a.readable() => {
+                    tokio::task::yield_now().await;
+                    guard.unwrap().clear_ready()
+                },
+                _ = notify_barrier => unreachable!(),
+            }
+
+            std::mem::drop(afd_a);
+        };
+
+        tasks.push(tokio::spawn(f));
+    }
+
+    let mut all_tasks = futures::future::try_join_all(tasks);
+
+    tokio::select! {
+        r = std::pin::Pin::new(&mut all_tasks) => {
+            r.unwrap(); // propagate panic
+            panic!("Tasks exited unexpectedly")
+        },
+        _ = barrier.wait() => {}
+    }
+
+    b.write_all(b"0").unwrap();
+
+    all_tasks.await.unwrap();
+}
+
+#[tokio::test]
+async fn poll_fns() {
+    let (a, b) = socketpair();
+    let afd_a = Arc::new(AsyncFd::new(a).unwrap());
+    let afd_b = Arc::new(AsyncFd::new(b).unwrap());
+
+    // Fill up the write side of A
+    let mut bytes = 0;
+    while let Ok(amt) = afd_a.get_ref().write(&[0; 512]) {
+        bytes += amt;
+    }
+
+    let waker = TestWaker::new();
+
+    assert_pending!(afd_a.as_ref().poll_read_ready(&mut waker.context()));
+
+    let afd_a_2 = afd_a.clone();
+    let r_barrier = Arc::new(tokio::sync::Barrier::new(2));
+    let barrier_clone = r_barrier.clone();
+
+    let read_fut = tokio::spawn(async move {
+        // Move waker onto this task first
+        assert_pending!(poll!(std::future::poll_fn(|cx| afd_a_2
+            .as_ref()
+            .poll_read_ready(cx))));
+        barrier_clone.wait().await;
+
+        let _ = std::future::poll_fn(|cx| afd_a_2.as_ref().poll_read_ready(cx)).await;
+    });
+
+    let afd_a_2 = afd_a.clone();
+    let w_barrier = Arc::new(tokio::sync::Barrier::new(2));
+    let barrier_clone = w_barrier.clone();
+
+    let mut write_fut = tokio::spawn(async move {
+        // Move waker onto this task first
+        assert_pending!(poll!(std::future::poll_fn(|cx| afd_a_2
+            .as_ref()
+            .poll_write_ready(cx))));
+        barrier_clone.wait().await;
+
+        let _ = std::future::poll_fn(|cx| afd_a_2.as_ref().poll_write_ready(cx)).await;
+    });
+
+    r_barrier.wait().await;
+    w_barrier.wait().await;
+
+    let readable = afd_a.readable();
+    tokio::pin!(readable);
+
+    tokio::select! {
+        _ = &mut readable => unreachable!(),
+        _ = tokio::task::yield_now() => {}
+    }
+
+    // Make A readable. We expect that 'readable' and 'read_fut' will both complete quickly
+    afd_b.get_ref().write_all(b"0").unwrap();
+
+    let _ = tokio::join!(readable, read_fut);
+
+    // Our original waker should _not_ be awoken (poll_read_ready retains only the last context)
+    assert!(!waker.awoken());
+
+    // The writable side should not be awoken
+    tokio::select! {
+        _ = &mut write_fut => unreachable!(),
+        _ = tokio::time::sleep(Duration::from_millis(5)) => {}
+    }
+
+    // Make it writable now
+    drain(afd_b.get_ref(), bytes);
+
+    // now we should be writable (ie - the waker for poll_write should still be registered after we wake the read side)
+    let _ = write_fut.await;
+}
+
+fn assert_pending<T: std::fmt::Debug, F: Future<Output = T>>(f: F) -> std::pin::Pin<Box<F>> {
+    let mut pinned = Box::pin(f);
+
+    assert_pending!(pinned
+        .as_mut()
+        .poll(&mut Context::from_waker(futures::task::noop_waker_ref())));
+
+    pinned
+}
+
+fn rt() -> tokio::runtime::Runtime {
+    tokio::runtime::Builder::new_current_thread()
+        .enable_all()
+        .build()
+        .unwrap()
+}
+
+#[test]
+fn driver_shutdown_wakes_currently_pending() {
+    let rt = rt();
+
+    let (a, _b) = socketpair();
+    let afd_a = {
+        let _enter = rt.enter();
+        AsyncFd::new(a).unwrap()
+    };
+
+    let readable = assert_pending(afd_a.readable());
+
+    std::mem::drop(rt);
+
+    // The future was initialized **before** dropping the rt
+    assert_err!(futures::executor::block_on(readable));
+
+    // The future is initialized **after** dropping the rt.
+    assert_err!(futures::executor::block_on(afd_a.readable()));
+}
+
+#[test]
+fn driver_shutdown_wakes_future_pending() {
+    let rt = rt();
+
+    let (a, _b) = socketpair();
+    let afd_a = {
+        let _enter = rt.enter();
+        AsyncFd::new(a).unwrap()
+    };
+
+    std::mem::drop(rt);
+
+    assert_err!(futures::executor::block_on(afd_a.readable()));
+}
+
+#[test]
+fn driver_shutdown_wakes_pending_race() {
+    // TODO: make this a loom test
+    for _ in 0..100 {
+        let rt = rt();
+
+        let (a, _b) = socketpair();
+        let afd_a = {
+            let _enter = rt.enter();
+            AsyncFd::new(a).unwrap()
+        };
+
+        let _ = std::thread::spawn(move || std::mem::drop(rt));
+
+        // This may or may not return an error (but will be awoken)
+        let _ = futures::executor::block_on(afd_a.readable());
+
+        // However retrying will always return an error
+        assert_err!(futures::executor::block_on(afd_a.readable()));
+    }
+}
+
+async fn poll_readable<T: AsRawFd>(fd: &AsyncFd<T>) -> std::io::Result<AsyncFdReadyGuard<'_, T>> {
+    std::future::poll_fn(|cx| fd.poll_read_ready(cx)).await
+}
+
+async fn poll_writable<T: AsRawFd>(fd: &AsyncFd<T>) -> std::io::Result<AsyncFdReadyGuard<'_, T>> {
+    std::future::poll_fn(|cx| fd.poll_write_ready(cx)).await
+}
+
+#[test]
+fn driver_shutdown_wakes_currently_pending_polls() {
+    let rt = rt();
+
+    let (a, _b) = socketpair();
+    let afd_a = {
+        let _enter = rt.enter();
+        AsyncFd::new(a).unwrap()
+    };
+
+    while afd_a.get_ref().write(&[0; 512]).is_ok() {} // make not writable
+
+    let readable = assert_pending(poll_readable(&afd_a));
+    let writable = assert_pending(poll_writable(&afd_a));
+
+    std::mem::drop(rt);
+
+    // Attempting to poll readiness when the rt is dropped is an error
+    assert_err!(futures::executor::block_on(readable));
+    assert_err!(futures::executor::block_on(writable));
+}
+
+#[test]
+fn driver_shutdown_wakes_poll() {
+    let rt = rt();
+
+    let (a, _b) = socketpair();
+    let afd_a = {
+        let _enter = rt.enter();
+        AsyncFd::new(a).unwrap()
+    };
+
+    std::mem::drop(rt);
+
+    assert_err!(futures::executor::block_on(poll_readable(&afd_a)));
+    assert_err!(futures::executor::block_on(poll_writable(&afd_a)));
+}
+
+#[test]
+fn driver_shutdown_then_clear_readiness() {
+    let rt = rt();
+
+    let (a, _b) = socketpair();
+    let afd_a = {
+        let _enter = rt.enter();
+        AsyncFd::new(a).unwrap()
+    };
+
+    let mut write_ready = rt.block_on(afd_a.writable()).unwrap();
+
+    std::mem::drop(rt);
+
+    write_ready.clear_ready();
+}
+
+#[test]
+fn driver_shutdown_wakes_poll_race() {
+    // TODO: make this a loom test
+    for _ in 0..100 {
+        let rt = rt();
+
+        let (a, _b) = socketpair();
+        let afd_a = {
+            let _enter = rt.enter();
+            AsyncFd::new(a).unwrap()
+        };
+
+        while afd_a.get_ref().write(&[0; 512]).is_ok() {} // make not writable
+
+        let _ = std::thread::spawn(move || std::mem::drop(rt));
+
+        // The poll variants will always return an error in this case
+        assert_err!(futures::executor::block_on(poll_readable(&afd_a)));
+        assert_err!(futures::executor::block_on(poll_writable(&afd_a)));
+    }
+}
+
+#[tokio::test]
+#[cfg_attr(miri, ignore)] // No socket in miri.
+#[cfg(any(target_os = "linux", target_os = "android"))]
+async fn priority_event_on_oob_data() {
+    use std::net::SocketAddr;
+
+    use tokio::io::Interest;
+
+    let addr: SocketAddr = "127.0.0.1:0".parse().unwrap();
+
+    let listener = std::net::TcpListener::bind(addr).unwrap();
+    let addr = listener.local_addr().unwrap();
+
+    let client = std::net::TcpStream::connect(addr).unwrap();
+    let client = AsyncFd::with_interest(client, Interest::PRIORITY).unwrap();
+
+    let (stream, _) = listener.accept().unwrap();
+
+    // Sending out of band data should trigger priority event.
+    send_oob_data(&stream, b"hello").unwrap();
+
+    let _ = client.ready(Interest::PRIORITY).await.unwrap();
+}
+
+#[cfg(any(target_os = "linux", target_os = "android"))]
+fn send_oob_data<S: AsRawFd>(stream: &S, data: &[u8]) -> io::Result<usize> {
+    unsafe {
+        let res = libc::send(
+            stream.as_raw_fd(),
+            data.as_ptr().cast(),
+            data.len(),
+            libc::MSG_OOB,
+        );
+        if res == -1 {
+            Err(io::Error::last_os_error())
+        } else {
+            Ok(res as usize)
+        }
+    }
+}
+
+#[tokio::test]
+async fn clear_ready_matching_clears_ready() {
+    use tokio::io::{Interest, Ready};
+
+    let (a, mut b) = socketpair();
+
+    let afd_a = AsyncFd::new(a).unwrap();
+    b.write_all(b"0").unwrap();
+
+    let mut guard = afd_a
+        .ready(Interest::READABLE | Interest::WRITABLE)
+        .await
+        .unwrap();
+
+    assert_eq!(guard.ready(), Ready::READABLE | Ready::WRITABLE);
+
+    guard.clear_ready_matching(Ready::READABLE);
+    assert_eq!(guard.ready(), Ready::WRITABLE);
+
+    guard.clear_ready_matching(Ready::WRITABLE);
+    assert_eq!(guard.ready(), Ready::EMPTY);
+}
+
+#[tokio::test]
+async fn clear_ready_matching_clears_ready_mut() {
+    use tokio::io::{Interest, Ready};
+
+    let (a, mut b) = socketpair();
+
+    let mut afd_a = AsyncFd::new(a).unwrap();
+    b.write_all(b"0").unwrap();
+
+    let mut guard = afd_a
+        .ready_mut(Interest::READABLE | Interest::WRITABLE)
+        .await
+        .unwrap();
+
+    assert_eq!(guard.ready(), Ready::READABLE | Ready::WRITABLE);
+
+    guard.clear_ready_matching(Ready::READABLE);
+    assert_eq!(guard.ready(), Ready::WRITABLE);
+
+    guard.clear_ready_matching(Ready::WRITABLE);
+    assert_eq!(guard.ready(), Ready::EMPTY);
+}
+
+#[tokio::test]
+#[cfg_attr(miri, ignore)] // No socket in miri.
+#[cfg(target_os = "linux")]
+async fn await_error_readiness_timestamping() {
+    use std::net::{Ipv4Addr, SocketAddr};
+
+    use tokio::io::{Interest, Ready};
+
+    let address_a = SocketAddr::from((Ipv4Addr::LOCALHOST, 0));
+    let address_b = SocketAddr::from((Ipv4Addr::LOCALHOST, 0));
+
+    let socket = std::net::UdpSocket::bind(address_a).unwrap();
+
+    socket.set_nonblocking(true).unwrap();
+
+    // configure send timestamps
+    configure_timestamping_socket(&socket).unwrap();
+
+    socket.connect(address_b).unwrap();
+
+    let fd = AsyncFd::new(socket).unwrap();
+
+    tokio::select! {
+        _ = fd.ready(Interest::ERROR) => panic!(),
+        _ = tokio::time::sleep(Duration::from_millis(10)) => {}
+    }
+
+    let buf = b"hello there";
+    fd.get_ref().send(buf).unwrap();
+
+    // the send timestamp should now be in the error queue
+    let guard = fd.ready(Interest::ERROR).await.unwrap();
+    assert_eq!(guard.ready(), Ready::ERROR);
+}
+
+#[cfg(target_os = "linux")]
+fn configure_timestamping_socket(udp_socket: &std::net::UdpSocket) -> std::io::Result<libc::c_int> {
+    // enable software timestamping, and specifically software send timestamping
+    let options = libc::SOF_TIMESTAMPING_SOFTWARE | libc::SOF_TIMESTAMPING_TX_SOFTWARE;
+
+    let res = unsafe {
+        libc::setsockopt(
+            udp_socket.as_raw_fd(),
+            libc::SOL_SOCKET,
+            libc::SO_TIMESTAMP,
+            &options as *const _ as *const libc::c_void,
+            std::mem::size_of_val(&options) as libc::socklen_t,
+        )
+    };
+
+    if res == -1 {
+        Err(std::io::Error::last_os_error())
+    } else {
+        Ok(res)
+    }
+}
+
+#[tokio::test]
+#[cfg_attr(miri, ignore)] // No socket in miri.
+#[cfg(target_os = "linux")]
+async fn await_error_readiness_invalid_address() {
+    use std::net::{Ipv4Addr, SocketAddr};
+    use tokio::io::{Interest, Ready};
+
+    let socket_addr = SocketAddr::from((Ipv4Addr::LOCALHOST, 0));
+    let socket = std::net::UdpSocket::bind(socket_addr).unwrap();
+    let socket_fd = socket.as_raw_fd();
+
+    // Enable IP_RECVERR option to receive error messages
+    // https://man7.org/linux/man-pages/man7/ip.7.html has some extra information
+    let recv_err: libc::c_int = 1;
+    unsafe {
+        let res = libc::setsockopt(
+            socket.as_raw_fd(),
+            libc::SOL_IP,
+            libc::IP_RECVERR,
+            &recv_err as *const _ as *const libc::c_void,
+            std::mem::size_of_val(&recv_err) as libc::socklen_t,
+        );
+        if res == -1 {
+            panic!("{:?}", std::io::Error::last_os_error());
+        }
+    }
+
+    // Spawn a separate thread for sending messages
+    tokio::spawn(async move {
+        // Set the destination address. This address is invalid in this context. the OS will notice
+        // that nobody is listening on port this port. Normally this is ignored (UDP is "fire and forget"),
+        // but because IP_RECVERR is enabled, the error will actually be reported to the sending socket
+        let mut dest_addr =
+            unsafe { std::mem::MaybeUninit::<libc::sockaddr_in>::zeroed().assume_init() };
+        dest_addr.sin_family = libc::AF_INET as _;
+        // based on https://en.wikipedia.org/wiki/Ephemeral_port, we should pick a port number
+        // below 1024 to guarantee that other tests don't select this port by accident when they
+        // use port 0 to select an ephemeral port.
+        dest_addr.sin_port = 512u16.to_be(); // Destination port
+
+        // Prepare the message data
+        let message = "Hello, Socket!";
+
+        // Prepare the message structure for sendmsg
+        let mut iov = libc::iovec {
+            iov_base: message.as_ptr() as *mut libc::c_void,
+            iov_len: message.len(),
+        };
+
+        // Prepare the destination address for the sendmsg call
+        let dest_sockaddr: *const libc::sockaddr = &dest_addr as *const _ as *const libc::sockaddr;
+        let dest_addrlen: libc::socklen_t = std::mem::size_of_val(&dest_addr) as libc::socklen_t;
+
+        let mut msg: libc::msghdr = unsafe { std::mem::MaybeUninit::zeroed().assume_init() };
+        msg.msg_name = dest_sockaddr as *mut libc::c_void;
+        msg.msg_namelen = dest_addrlen;
+        msg.msg_iov = &mut iov;
+        msg.msg_iovlen = 1;
+
+        if unsafe { libc::sendmsg(socket_fd, &msg, 0) } == -1 {
+            panic!("{:?}", std::io::Error::last_os_error())
+        }
+    });
+
+    let fd = AsyncFd::new(socket).unwrap();
+
+    let guard = fd.ready(Interest::ERROR).await.unwrap();
+    assert_eq!(guard.ready(), Ready::ERROR);
+}
+
+#[derive(Debug, PartialEq, Eq)]
+struct InvalidSource;
+
+impl AsRawFd for InvalidSource {
+    fn as_raw_fd(&self) -> RawFd {
+        -1
+    }
+}
+
+#[tokio::test]
+async fn try_new() {
+    let original = Arc::new(InvalidSource);
+
+    let error = AsyncFd::try_new(original.clone()).unwrap_err();
+    let (returned, _cause) = error.into_parts();
+
+    assert!(Arc::ptr_eq(&original, &returned));
+}
+
+#[tokio::test]
+async fn try_with_interest() {
+    let original = Arc::new(InvalidSource);
+
+    let error = AsyncFd::try_with_interest(original.clone(), Interest::READABLE).unwrap_err();
+    let (returned, _cause) = error.into_parts();
+
+    assert!(Arc::ptr_eq(&original, &returned));
+}

vendor/tokio/tests/io_async_fd_memory_leak.rs

@@ -0,0 +1,209 @@
+//! Regression test for issue #7563 - Memory leak when fd closed before AsyncFd drop
+//!
+//! This test uses a custom global allocator to track actual memory usage,
+//! avoiding false positives from RSS measurements which include freed-but-retained memory.
+
+#![cfg(all(unix, target_os = "linux", feature = "full"))]
+
+use std::alloc::{GlobalAlloc, Layout, System};
+use std::sync::atomic::{AtomicUsize, Ordering};
+
+/// A tracking allocator that counts bytes currently allocated
+struct TrackingAllocator {
+    allocated: AtomicUsize,
+}
+
+impl TrackingAllocator {
+    const fn new() -> Self {
+        Self {
+            allocated: AtomicUsize::new(0),
+        }
+    }
+}
+
+unsafe impl GlobalAlloc for TrackingAllocator {
+    unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
+        let ptr = unsafe { System.alloc(layout) };
+        if !ptr.is_null() {
+            self.allocated.fetch_add(layout.size(), Ordering::Relaxed);
+        }
+        ptr
+    }
+
+    unsafe fn dealloc(&self, ptr: *mut u8, layout: Layout) {
+        unsafe { System.dealloc(ptr, layout) };
+        self.allocated.fetch_sub(layout.size(), Ordering::Relaxed);
+    }
+
+    unsafe fn realloc(&self, ptr: *mut u8, layout: Layout, new_size: usize) -> *mut u8 {
+        let new_ptr = unsafe { System.realloc(ptr, layout, new_size) };
+        if !new_ptr.is_null() {
+            // Subtract old size, add new size
+            if new_size > layout.size() {
+                self.allocated
+                    .fetch_add(new_size - layout.size(), Ordering::Relaxed);
+            } else {
+                self.allocated
+                    .fetch_sub(layout.size() - new_size, Ordering::Relaxed);
+            }
+        }
+        new_ptr
+    }
+}
+
+#[global_allocator]
+static GLOBAL: TrackingAllocator = TrackingAllocator::new();
+
+fn allocated_bytes() -> usize {
+    GLOBAL.allocated.load(Ordering::Relaxed)
+}
+
+#[tokio::test]
+async fn memory_leak_when_fd_closed_before_drop() {
+    use nix::sys::socket::{self, AddressFamily, SockFlag, SockType};
+    use std::os::unix::io::{AsRawFd, RawFd};
+    use std::sync::Arc;
+    use tokio::io::unix::AsyncFd;
+
+    struct RawFdWrapper {
+        fd: RawFd,
+    }
+
+    impl AsRawFd for RawFdWrapper {
+        fn as_raw_fd(&self) -> RawFd {
+            self.fd
+        }
+    }
+
+    struct ArcFd(Arc<RawFdWrapper>);
+
+    impl AsRawFd for ArcFd {
+        fn as_raw_fd(&self) -> RawFd {
+            self.0.as_raw_fd()
+        }
+    }
+
+    fn set_nonblocking(fd: RawFd) {
+        use nix::fcntl::{OFlag, F_GETFL, F_SETFL};
+
+        let flags = nix::fcntl::fcntl(fd, F_GETFL).expect("fcntl(F_GETFL)");
+
+        if flags < 0 {
+            panic!(
+                "bad return value from fcntl(F_GETFL): {} ({:?})",
+                flags,
+                nix::Error::last()
+            );
+        }
+
+        let flags = OFlag::from_bits_truncate(flags) | OFlag::O_NONBLOCK;
+
+        nix::fcntl::fcntl(fd, F_SETFL(flags)).expect("fcntl(F_SETFL)");
+    }
+
+    // Warm up - let runtime and allocator stabilize
+    for _ in 0..100 {
+        tokio::task::yield_now().await;
+    }
+
+    const ITERATIONS: usize = 1000;
+
+    // Phase 1: Warm up allocations
+    for _ in 0..ITERATIONS {
+        let (fd_a, _fd_b) = socket::socketpair(
+            AddressFamily::Unix,
+            SockType::Stream,
+            None,
+            SockFlag::empty(),
+        )
+        .unwrap();
+
+        let raw_fd = fd_a.as_raw_fd();
+        set_nonblocking(raw_fd);
+        std::mem::forget(fd_a);
+
+        let wrapper = Arc::new(RawFdWrapper { fd: raw_fd });
+        let async_fd = AsyncFd::new(ArcFd(wrapper)).unwrap();
+
+        // Close fd before dropping AsyncFd - this triggers the bug
+        unsafe {
+            libc::close(raw_fd);
+        }
+
+        drop(async_fd);
+    }
+
+    // Let things settle
+    tokio::task::yield_now().await;
+    let baseline = allocated_bytes();
+
+    // Phase 2: Run more iterations and check for growth
+    for _ in 0..ITERATIONS {
+        let (fd_a, _fd_b) = socket::socketpair(
+            AddressFamily::Unix,
+            SockType::Stream,
+            None,
+            SockFlag::empty(),
+        )
+        .unwrap();
+
+        let raw_fd = fd_a.as_raw_fd();
+        set_nonblocking(raw_fd);
+        std::mem::forget(fd_a);
+
+        let wrapper = Arc::new(RawFdWrapper { fd: raw_fd });
+        let async_fd = AsyncFd::new(ArcFd(wrapper)).unwrap();
+
+        unsafe {
+            libc::close(raw_fd);
+        }
+
+        drop(async_fd);
+    }
+
+    tokio::task::yield_now().await;
+    let after_phase2 = allocated_bytes();
+
+    // Phase 3: Run even more iterations
+    for _ in 0..ITERATIONS {
+        let (fd_a, _fd_b) = socket::socketpair(
+            AddressFamily::Unix,
+            SockType::Stream,
+            None,
+            SockFlag::empty(),
+        )
+        .unwrap();
+
+        let raw_fd = fd_a.as_raw_fd();
+        set_nonblocking(raw_fd);
+        std::mem::forget(fd_a);
+
+        let wrapper = Arc::new(RawFdWrapper { fd: raw_fd });
+        let async_fd = AsyncFd::new(ArcFd(wrapper)).unwrap();
+
+        unsafe {
+            libc::close(raw_fd);
+        }
+
+        drop(async_fd);
+    }
+
+    tokio::task::yield_now().await;
+    let after_phase3 = allocated_bytes();
+
+    let growth_phase2 = after_phase2.saturating_sub(baseline);
+    let growth_phase3 = after_phase3.saturating_sub(after_phase2);
+
+    // If there's a leak, each phase adds ~250KB (1000 * ~256 bytes per ScheduledIo)
+    // If fixed, memory should stabilize (minimal growth between phases)
+    // Allow 64KB tolerance for normal allocation variance
+    let threshold = 64 * 1024; // 64KB
+
+    assert!(
+        growth_phase2 < threshold || growth_phase3 < threshold,
+        "Memory leak detected: allocations keep growing without stabilizing. \
+         Phase 1->2: +{growth_phase2} bytes, Phase 2->3: +{growth_phase3} bytes. \
+         (baseline: {baseline} bytes, phase2: {after_phase2} bytes, phase3: {after_phase3} bytes). \
+         Expected at least one phase with <{threshold} bytes growth.",
+    );
+}

vendor/tokio/tests/io_async_read.rs

@@ -0,0 +1,10 @@
+#![warn(rust_2018_idioms)]
+#![cfg(feature = "full")]
+
+use tokio::io::AsyncRead;
+
+#[test]
+fn assert_obj_safe() {
+    fn _assert<T>() {}
+    _assert::<Box<dyn AsyncRead>>();
+}

vendor/tokio/tests/io_buf_reader.rs

@@ -0,0 +1,379 @@
+#![warn(rust_2018_idioms)]
+#![cfg(feature = "full")]
+
+// https://github.com/rust-lang/futures-rs/blob/1803948ff091b4eabf7f3bf39e16bbbdefca5cc8/futures/tests/io_buf_reader.rs
+
+use futures::task::{noop_waker_ref, Context, Poll};
+use std::cmp;
+use std::io::{self, Cursor};
+use std::pin::Pin;
+use tokio::io::{
+    AsyncBufRead, AsyncBufReadExt, AsyncRead, AsyncReadExt, AsyncSeek, AsyncSeekExt, AsyncWriteExt,
+    BufReader, ReadBuf, SeekFrom,
+};
+use tokio_test::task::spawn;
+use tokio_test::{assert_pending, assert_ready};
+
+macro_rules! run_fill_buf {
+    ($reader:expr) => {{
+        let mut cx = Context::from_waker(noop_waker_ref());
+        loop {
+            if let Poll::Ready(x) = Pin::new(&mut $reader).poll_fill_buf(&mut cx) {
+                break x;
+            }
+        }
+    }};
+}
+
+struct MaybePending<'a> {
+    inner: &'a [u8],
+    ready_read: bool,
+    ready_fill_buf: bool,
+}
+
+impl<'a> MaybePending<'a> {
+    fn new(inner: &'a [u8]) -> Self {
+        Self {
+            inner,
+            ready_read: false,
+            ready_fill_buf: false,
+        }
+    }
+}
+
+impl AsyncRead for MaybePending<'_> {
+    fn poll_read(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+        buf: &mut ReadBuf<'_>,
+    ) -> Poll<io::Result<()>> {
+        if self.ready_read {
+            self.ready_read = false;
+            Pin::new(&mut self.inner).poll_read(cx, buf)
+        } else {
+            self.ready_read = true;
+            cx.waker().wake_by_ref();
+            Poll::Pending
+        }
+    }
+}
+
+impl AsyncBufRead for MaybePending<'_> {
+    fn poll_fill_buf(mut self: Pin<&mut Self>, _: &mut Context<'_>) -> Poll<io::Result<&[u8]>> {
+        if self.ready_fill_buf {
+            self.ready_fill_buf = false;
+            if self.inner.is_empty() {
+                return Poll::Ready(Ok(&[]));
+            }
+            let len = cmp::min(2, self.inner.len());
+            Poll::Ready(Ok(&self.inner[0..len]))
+        } else {
+            self.ready_fill_buf = true;
+            Poll::Pending
+        }
+    }
+
+    fn consume(mut self: Pin<&mut Self>, amt: usize) {
+        self.inner = &self.inner[amt..];
+    }
+}
+
+#[tokio::test]
+async fn test_buffered_reader() {
+    let inner: &[u8] = &[5, 6, 7, 0, 1, 2, 3, 4];
+    let mut reader = BufReader::with_capacity(2, inner);
+
+    let mut buf = [0, 0, 0];
+    let nread = reader.read(&mut buf).await.unwrap();
+    assert_eq!(nread, 3);
+    assert_eq!(buf, [5, 6, 7]);
+    assert_eq!(reader.buffer(), []);
+
+    let mut buf = [0, 0];
+    let nread = reader.read(&mut buf).await.unwrap();
+    assert_eq!(nread, 2);
+    assert_eq!(buf, [0, 1]);
+    assert_eq!(reader.buffer(), []);
+
+    let mut buf = [0];
+    let nread = reader.read(&mut buf).await.unwrap();
+    assert_eq!(nread, 1);
+    assert_eq!(buf, [2]);
+    assert_eq!(reader.buffer(), [3]);
+
+    let mut buf = [0, 0, 0];
+    let nread = reader.read(&mut buf).await.unwrap();
+    assert_eq!(nread, 1);
+    assert_eq!(buf, [3, 0, 0]);
+    assert_eq!(reader.buffer(), []);
+
+    let nread = reader.read(&mut buf).await.unwrap();
+    assert_eq!(nread, 1);
+    assert_eq!(buf, [4, 0, 0]);
+    assert_eq!(reader.buffer(), []);
+
+    assert_eq!(reader.read(&mut buf).await.unwrap(), 0);
+}
+
+#[tokio::test]
+async fn test_buffered_reader_seek() {
+    let inner: &[u8] = &[5, 6, 7, 0, 1, 2, 3, 4];
+    let mut reader = BufReader::with_capacity(2, Cursor::new(inner));
+
+    assert_eq!(reader.seek(SeekFrom::Start(3)).await.unwrap(), 3);
+    assert_eq!(run_fill_buf!(reader).unwrap(), &[0, 1][..]);
+    assert!(reader.seek(SeekFrom::Current(i64::MIN)).await.is_err());
+    assert_eq!(run_fill_buf!(reader).unwrap(), &[0, 1][..]);
+    assert_eq!(reader.seek(SeekFrom::Current(1)).await.unwrap(), 4);
+    assert_eq!(run_fill_buf!(reader).unwrap(), &[1, 2][..]);
+    Pin::new(&mut reader).consume(1);
+    assert_eq!(reader.seek(SeekFrom::Current(-2)).await.unwrap(), 3);
+}
+
+#[tokio::test]
+async fn test_buffered_reader_seek_underflow() {
+    // gimmick reader that yields its position modulo 256 for each byte
+    struct PositionReader {
+        pos: u64,
+    }
+    impl AsyncRead for PositionReader {
+        fn poll_read(
+            mut self: Pin<&mut Self>,
+            _: &mut Context<'_>,
+            buf: &mut ReadBuf<'_>,
+        ) -> Poll<io::Result<()>> {
+            let b = buf.initialize_unfilled();
+            let len = b.len();
+            for x in b {
+                *x = self.pos as u8;
+                self.pos = self.pos.wrapping_add(1);
+            }
+            buf.advance(len);
+            Poll::Ready(Ok(()))
+        }
+    }
+    impl AsyncSeek for PositionReader {
+        fn start_seek(mut self: Pin<&mut Self>, pos: SeekFrom) -> io::Result<()> {
+            match pos {
+                SeekFrom::Start(n) => {
+                    self.pos = n;
+                }
+                SeekFrom::Current(n) => {
+                    self.pos = self.pos.wrapping_add(n as u64);
+                }
+                SeekFrom::End(n) => {
+                    self.pos = u64::MAX.wrapping_add(n as u64);
+                }
+            }
+            Ok(())
+        }
+        fn poll_complete(self: Pin<&mut Self>, _: &mut Context<'_>) -> Poll<io::Result<u64>> {
+            Poll::Ready(Ok(self.pos))
+        }
+    }
+
+    let mut reader = BufReader::with_capacity(5, PositionReader { pos: 0 });
+    assert_eq!(run_fill_buf!(reader).unwrap(), &[0, 1, 2, 3, 4][..]);
+    assert_eq!(reader.seek(SeekFrom::End(-5)).await.unwrap(), u64::MAX - 5);
+    assert_eq!(run_fill_buf!(reader).unwrap().len(), 5);
+    // the following seek will require two underlying seeks
+    let expected = 9_223_372_036_854_775_802;
+    assert_eq!(
+        reader.seek(SeekFrom::Current(i64::MIN)).await.unwrap(),
+        expected
+    );
+    assert_eq!(run_fill_buf!(reader).unwrap().len(), 5);
+    // seeking to 0 should empty the buffer.
+    assert_eq!(reader.seek(SeekFrom::Current(0)).await.unwrap(), expected);
+    assert_eq!(reader.get_ref().pos, expected);
+}
+
+#[tokio::test]
+async fn test_short_reads() {
+    /// A dummy reader intended at testing short-reads propagation.
+    struct ShortReader {
+        lengths: Vec<usize>,
+    }
+
+    impl AsyncRead for ShortReader {
+        fn poll_read(
+            mut self: Pin<&mut Self>,
+            _: &mut Context<'_>,
+            buf: &mut ReadBuf<'_>,
+        ) -> Poll<io::Result<()>> {
+            if !self.lengths.is_empty() {
+                buf.advance(self.lengths.remove(0));
+            }
+            Poll::Ready(Ok(()))
+        }
+    }
+
+    let inner = ShortReader {
+        lengths: vec![0, 1, 2, 0, 1, 0],
+    };
+    let mut reader = BufReader::new(inner);
+    let mut buf = [0, 0];
+    assert_eq!(reader.read(&mut buf).await.unwrap(), 0);
+    assert_eq!(reader.read(&mut buf).await.unwrap(), 1);
+    assert_eq!(reader.read(&mut buf).await.unwrap(), 2);
+    assert_eq!(reader.read(&mut buf).await.unwrap(), 0);
+    assert_eq!(reader.read(&mut buf).await.unwrap(), 1);
+    assert_eq!(reader.read(&mut buf).await.unwrap(), 0);
+    assert_eq!(reader.read(&mut buf).await.unwrap(), 0);
+}
+
+#[tokio::test]
+async fn maybe_pending() {
+    let inner: &[u8] = &[5, 6, 7, 0, 1, 2, 3, 4];
+    let mut reader = BufReader::with_capacity(2, MaybePending::new(inner));
+
+    let mut buf = [0, 0, 0];
+    let nread = reader.read(&mut buf).await.unwrap();
+    assert_eq!(nread, 3);
+    assert_eq!(buf, [5, 6, 7]);
+    assert_eq!(reader.buffer(), []);
+
+    let mut buf = [0, 0];
+    let nread = reader.read(&mut buf).await.unwrap();
+    assert_eq!(nread, 2);
+    assert_eq!(buf, [0, 1]);
+    assert_eq!(reader.buffer(), []);
+
+    let mut buf = [0];
+    let nread = reader.read(&mut buf).await.unwrap();
+    assert_eq!(nread, 1);
+    assert_eq!(buf, [2]);
+    assert_eq!(reader.buffer(), [3]);
+
+    let mut buf = [0, 0, 0];
+    let nread = reader.read(&mut buf).await.unwrap();
+    assert_eq!(nread, 1);
+    assert_eq!(buf, [3, 0, 0]);
+    assert_eq!(reader.buffer(), []);
+
+    let nread = reader.read(&mut buf).await.unwrap();
+    assert_eq!(nread, 1);
+    assert_eq!(buf, [4, 0, 0]);
+    assert_eq!(reader.buffer(), []);
+
+    assert_eq!(reader.read(&mut buf).await.unwrap(), 0);
+}
+
+#[tokio::test]
+async fn maybe_pending_buf_read() {
+    let inner = MaybePending::new(&[0, 1, 2, 3, 1, 0]);
+    let mut reader = BufReader::with_capacity(2, inner);
+    let mut v = Vec::new();
+    reader.read_until(3, &mut v).await.unwrap();
+    assert_eq!(v, [0, 1, 2, 3]);
+    v.clear();
+    reader.read_until(1, &mut v).await.unwrap();
+    assert_eq!(v, [1]);
+    v.clear();
+    reader.read_until(8, &mut v).await.unwrap();
+    assert_eq!(v, [0]);
+    v.clear();
+    reader.read_until(9, &mut v).await.unwrap();
+    assert_eq!(v, []);
+}
+
+// https://github.com/rust-lang/futures-rs/pull/1573#discussion_r281162309
+#[tokio::test]
+async fn maybe_pending_seek() {
+    struct MaybePendingSeek<'a> {
+        inner: Cursor<&'a [u8]>,
+        ready: bool,
+        seek_res: Option<io::Result<()>>,
+    }
+
+    impl<'a> MaybePendingSeek<'a> {
+        fn new(inner: &'a [u8]) -> Self {
+            Self {
+                inner: Cursor::new(inner),
+                ready: true,
+                seek_res: None,
+            }
+        }
+    }
+
+    impl AsyncRead for MaybePendingSeek<'_> {
+        fn poll_read(
+            mut self: Pin<&mut Self>,
+            cx: &mut Context<'_>,
+            buf: &mut ReadBuf<'_>,
+        ) -> Poll<io::Result<()>> {
+            Pin::new(&mut self.inner).poll_read(cx, buf)
+        }
+    }
+
+    impl AsyncBufRead for MaybePendingSeek<'_> {
+        fn poll_fill_buf(
+            mut self: Pin<&mut Self>,
+            cx: &mut Context<'_>,
+        ) -> Poll<io::Result<&[u8]>> {
+            let this: *mut Self = &mut *self as *mut _;
+            Pin::new(&mut unsafe { &mut *this }.inner).poll_fill_buf(cx)
+        }
+
+        fn consume(mut self: Pin<&mut Self>, amt: usize) {
+            Pin::new(&mut self.inner).consume(amt)
+        }
+    }
+
+    impl AsyncSeek for MaybePendingSeek<'_> {
+        fn start_seek(mut self: Pin<&mut Self>, pos: SeekFrom) -> io::Result<()> {
+            self.seek_res = Some(Pin::new(&mut self.inner).start_seek(pos));
+            Ok(())
+        }
+        fn poll_complete(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<u64>> {
+            if self.ready {
+                self.ready = false;
+                self.seek_res.take().unwrap_or(Ok(()))?;
+                Pin::new(&mut self.inner).poll_complete(cx)
+            } else {
+                self.ready = true;
+                cx.waker().wake_by_ref();
+                Poll::Pending
+            }
+        }
+    }
+
+    let inner: &[u8] = &[5, 6, 7, 0, 1, 2, 3, 4];
+    let mut reader = BufReader::with_capacity(2, MaybePendingSeek::new(inner));
+
+    assert_eq!(reader.seek(SeekFrom::Current(3)).await.unwrap(), 3);
+    assert_eq!(run_fill_buf!(reader).unwrap(), &[0, 1][..]);
+    assert!(reader.seek(SeekFrom::Current(i64::MIN)).await.is_err());
+    assert_eq!(run_fill_buf!(reader).unwrap(), &[0, 1][..]);
+    assert_eq!(reader.seek(SeekFrom::Current(1)).await.unwrap(), 4);
+    assert_eq!(run_fill_buf!(reader).unwrap(), &[1, 2][..]);
+    Pin::new(&mut reader).consume(1);
+    assert_eq!(reader.seek(SeekFrom::Current(-2)).await.unwrap(), 3);
+}
+
+// This tests the AsyncBufReadExt::fill_buf wrapper.
+#[tokio::test]
+async fn test_fill_buf_wrapper() {
+    let (mut write, read) = tokio::io::duplex(16);
+
+    let mut read = BufReader::new(read);
+    write.write_all(b"hello world").await.unwrap();
+
+    assert_eq!(read.fill_buf().await.unwrap(), b"hello world");
+    read.consume(b"hello ".len());
+    assert_eq!(read.fill_buf().await.unwrap(), b"world");
+    assert_eq!(read.fill_buf().await.unwrap(), b"world");
+    read.consume(b"world".len());
+
+    let mut fill = spawn(read.fill_buf());
+    assert_pending!(fill.poll());
+
+    write.write_all(b"foo bar").await.unwrap();
+    assert_eq!(assert_ready!(fill.poll()).unwrap(), b"foo bar");
+    drop(fill);
+
+    drop(write);
+    assert_eq!(read.fill_buf().await.unwrap(), b"foo bar");
+    read.consume(b"foo bar".len());
+    assert_eq!(read.fill_buf().await.unwrap(), b"");
+}

vendor/tokio/tests/io_buf_writer.rs

@@ -0,0 +1,537 @@
+#![warn(rust_2018_idioms)]
+#![cfg(feature = "full")]
+
+// https://github.com/rust-lang/futures-rs/blob/1803948ff091b4eabf7f3bf39e16bbbdefca5cc8/futures/tests/io_buf_writer.rs
+
+use futures::task::{Context, Poll};
+use std::io::{self, Cursor};
+use std::pin::Pin;
+use tokio::io::{AsyncSeek, AsyncSeekExt, AsyncWrite, AsyncWriteExt, BufWriter, SeekFrom};
+
+use futures::future;
+use tokio_test::assert_ok;
+
+use std::cmp;
+use std::io::IoSlice;
+
+mod support {
+    pub(crate) mod io_vec;
+}
+use support::io_vec::IoBufs;
+
+struct MaybePending {
+    inner: Vec<u8>,
+    ready: bool,
+}
+
+impl MaybePending {
+    fn new(inner: Vec<u8>) -> Self {
+        Self {
+            inner,
+            ready: false,
+        }
+    }
+}
+
+impl AsyncWrite for MaybePending {
+    fn poll_write(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+        buf: &[u8],
+    ) -> Poll<io::Result<usize>> {
+        if self.ready {
+            self.ready = false;
+            Pin::new(&mut self.inner).poll_write(cx, buf)
+        } else {
+            self.ready = true;
+            cx.waker().wake_by_ref();
+            Poll::Pending
+        }
+    }
+
+    fn poll_flush(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+        Pin::new(&mut self.inner).poll_flush(cx)
+    }
+
+    fn poll_shutdown(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+        Pin::new(&mut self.inner).poll_shutdown(cx)
+    }
+}
+
+async fn write_vectored<W>(writer: &mut W, bufs: &[IoSlice<'_>]) -> io::Result<usize>
+where
+    W: AsyncWrite + Unpin,
+{
+    let mut writer = Pin::new(writer);
+    future::poll_fn(|cx| writer.as_mut().poll_write_vectored(cx, bufs)).await
+}
+
+#[tokio::test]
+async fn buf_writer() {
+    let mut writer = BufWriter::with_capacity(2, Vec::new());
+
+    assert_eq!(writer.write(&[0, 1]).await.unwrap(), 2);
+    assert_eq!(writer.buffer(), []);
+    assert_eq!(*writer.get_ref(), [0, 1]);
+
+    assert_eq!(writer.write(&[2]).await.unwrap(), 1);
+    assert_eq!(writer.buffer(), [2]);
+    assert_eq!(*writer.get_ref(), [0, 1]);
+
+    assert_eq!(writer.write(&[3]).await.unwrap(), 1);
+    assert_eq!(writer.buffer(), [2, 3]);
+    assert_eq!(*writer.get_ref(), [0, 1]);
+
+    writer.flush().await.unwrap();
+    assert_eq!(writer.buffer(), []);
+    assert_eq!(*writer.get_ref(), [0, 1, 2, 3]);
+
+    assert_eq!(writer.write(&[4]).await.unwrap(), 1);
+    assert_eq!(writer.write(&[5]).await.unwrap(), 1);
+    assert_eq!(writer.buffer(), [4, 5]);
+    assert_eq!(*writer.get_ref(), [0, 1, 2, 3]);
+
+    assert_eq!(writer.write(&[6]).await.unwrap(), 1);
+    assert_eq!(writer.buffer(), [6]);
+    assert_eq!(*writer.get_ref(), [0, 1, 2, 3, 4, 5]);
+
+    assert_eq!(writer.write(&[7, 8]).await.unwrap(), 2);
+    assert_eq!(writer.buffer(), []);
+    assert_eq!(*writer.get_ref(), [0, 1, 2, 3, 4, 5, 6, 7, 8]);
+
+    assert_eq!(writer.write(&[9, 10, 11]).await.unwrap(), 3);
+    assert_eq!(writer.buffer(), []);
+    assert_eq!(*writer.get_ref(), [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]);
+
+    writer.flush().await.unwrap();
+    assert_eq!(writer.buffer(), []);
+    assert_eq!(*writer.get_ref(), [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]);
+}
+
+#[tokio::test]
+async fn buf_writer_inner_flushes() {
+    let mut w = BufWriter::with_capacity(3, Vec::new());
+    assert_eq!(w.write(&[0, 1]).await.unwrap(), 2);
+    assert_eq!(*w.get_ref(), []);
+    w.flush().await.unwrap();
+    let w = w.into_inner();
+    assert_eq!(w, [0, 1]);
+}
+
+#[tokio::test]
+async fn buf_writer_seek() {
+    let mut w = BufWriter::with_capacity(3, Cursor::new(Vec::new()));
+    w.write_all(&[0, 1, 2, 3, 4, 5]).await.unwrap();
+    w.write_all(&[6, 7]).await.unwrap();
+    assert_eq!(w.seek(SeekFrom::Current(0)).await.unwrap(), 8);
+    assert_eq!(&w.get_ref().get_ref()[..], &[0, 1, 2, 3, 4, 5, 6, 7][..]);
+    assert_eq!(w.seek(SeekFrom::Start(2)).await.unwrap(), 2);
+    w.write_all(&[8, 9]).await.unwrap();
+    w.flush().await.unwrap();
+    assert_eq!(&w.into_inner().into_inner()[..], &[0, 1, 8, 9, 4, 5, 6, 7]);
+}
+
+#[tokio::test]
+async fn maybe_pending_buf_writer() {
+    let mut writer = BufWriter::with_capacity(2, MaybePending::new(Vec::new()));
+
+    assert_eq!(writer.write(&[0, 1]).await.unwrap(), 2);
+    assert_eq!(writer.buffer(), []);
+    assert_eq!(&writer.get_ref().inner, &[0, 1]);
+
+    assert_eq!(writer.write(&[2]).await.unwrap(), 1);
+    assert_eq!(writer.buffer(), [2]);
+    assert_eq!(&writer.get_ref().inner, &[0, 1]);
+
+    assert_eq!(writer.write(&[3]).await.unwrap(), 1);
+    assert_eq!(writer.buffer(), [2, 3]);
+    assert_eq!(&writer.get_ref().inner, &[0, 1]);
+
+    writer.flush().await.unwrap();
+    assert_eq!(writer.buffer(), []);
+    assert_eq!(&writer.get_ref().inner, &[0, 1, 2, 3]);
+
+    assert_eq!(writer.write(&[4]).await.unwrap(), 1);
+    assert_eq!(writer.write(&[5]).await.unwrap(), 1);
+    assert_eq!(writer.buffer(), [4, 5]);
+    assert_eq!(&writer.get_ref().inner, &[0, 1, 2, 3]);
+
+    assert_eq!(writer.write(&[6]).await.unwrap(), 1);
+    assert_eq!(writer.buffer(), [6]);
+    assert_eq!(writer.get_ref().inner, &[0, 1, 2, 3, 4, 5]);
+
+    assert_eq!(writer.write(&[7, 8]).await.unwrap(), 2);
+    assert_eq!(writer.buffer(), []);
+    assert_eq!(writer.get_ref().inner, &[0, 1, 2, 3, 4, 5, 6, 7, 8]);
+
+    assert_eq!(writer.write(&[9, 10, 11]).await.unwrap(), 3);
+    assert_eq!(writer.buffer(), []);
+    assert_eq!(
+        writer.get_ref().inner,
+        &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
+    );
+
+    writer.flush().await.unwrap();
+    assert_eq!(writer.buffer(), []);
+    assert_eq!(
+        &writer.get_ref().inner,
+        &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
+    );
+}
+
+#[tokio::test]
+async fn maybe_pending_buf_writer_inner_flushes() {
+    let mut w = BufWriter::with_capacity(3, MaybePending::new(Vec::new()));
+    assert_eq!(w.write(&[0, 1]).await.unwrap(), 2);
+    assert_eq!(&w.get_ref().inner, &[]);
+    w.flush().await.unwrap();
+    let w = w.into_inner().inner;
+    assert_eq!(w, [0, 1]);
+}
+
+#[tokio::test]
+async fn maybe_pending_buf_writer_seek() {
+    struct MaybePendingSeek {
+        inner: Cursor<Vec<u8>>,
+        ready_write: bool,
+        ready_seek: bool,
+        seek_res: Option<io::Result<()>>,
+    }
+
+    impl MaybePendingSeek {
+        fn new(inner: Vec<u8>) -> Self {
+            Self {
+                inner: Cursor::new(inner),
+                ready_write: false,
+                ready_seek: false,
+                seek_res: None,
+            }
+        }
+    }
+
+    impl AsyncWrite for MaybePendingSeek {
+        fn poll_write(
+            mut self: Pin<&mut Self>,
+            cx: &mut Context<'_>,
+            buf: &[u8],
+        ) -> Poll<io::Result<usize>> {
+            if self.ready_write {
+                self.ready_write = false;
+                Pin::new(&mut self.inner).poll_write(cx, buf)
+            } else {
+                self.ready_write = true;
+                cx.waker().wake_by_ref();
+                Poll::Pending
+            }
+        }
+
+        fn poll_flush(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+            Pin::new(&mut self.inner).poll_flush(cx)
+        }
+
+        fn poll_shutdown(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+            Pin::new(&mut self.inner).poll_shutdown(cx)
+        }
+    }
+
+    impl AsyncSeek for MaybePendingSeek {
+        fn start_seek(mut self: Pin<&mut Self>, pos: SeekFrom) -> io::Result<()> {
+            self.seek_res = Some(Pin::new(&mut self.inner).start_seek(pos));
+            Ok(())
+        }
+        fn poll_complete(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<u64>> {
+            if self.ready_seek {
+                self.ready_seek = false;
+                self.seek_res.take().unwrap_or(Ok(()))?;
+                Pin::new(&mut self.inner).poll_complete(cx)
+            } else {
+                self.ready_seek = true;
+                cx.waker().wake_by_ref();
+                Poll::Pending
+            }
+        }
+    }
+
+    let mut w = BufWriter::with_capacity(3, MaybePendingSeek::new(Vec::new()));
+    w.write_all(&[0, 1, 2, 3, 4, 5]).await.unwrap();
+    w.write_all(&[6, 7]).await.unwrap();
+    assert_eq!(w.seek(SeekFrom::Current(0)).await.unwrap(), 8);
+    assert_eq!(
+        &w.get_ref().inner.get_ref()[..],
+        &[0, 1, 2, 3, 4, 5, 6, 7][..]
+    );
+    assert_eq!(w.seek(SeekFrom::Start(2)).await.unwrap(), 2);
+    w.write_all(&[8, 9]).await.unwrap();
+    w.flush().await.unwrap();
+    assert_eq!(
+        &w.into_inner().inner.into_inner()[..],
+        &[0, 1, 8, 9, 4, 5, 6, 7]
+    );
+}
+
+struct MockWriter {
+    data: Vec<u8>,
+    write_len: usize,
+    vectored: bool,
+}
+
+impl MockWriter {
+    fn new(write_len: usize) -> Self {
+        MockWriter {
+            data: Vec::new(),
+            write_len,
+            vectored: false,
+        }
+    }
+
+    fn vectored(write_len: usize) -> Self {
+        MockWriter {
+            data: Vec::new(),
+            write_len,
+            vectored: true,
+        }
+    }
+
+    fn write_up_to(&mut self, buf: &[u8], limit: usize) -> usize {
+        let len = cmp::min(buf.len(), limit);
+        self.data.extend_from_slice(&buf[..len]);
+        len
+    }
+}
+
+impl AsyncWrite for MockWriter {
+    fn poll_write(
+        self: Pin<&mut Self>,
+        _: &mut Context<'_>,
+        buf: &[u8],
+    ) -> Poll<Result<usize, io::Error>> {
+        let this = self.get_mut();
+        let n = this.write_up_to(buf, this.write_len);
+        Ok(n).into()
+    }
+
+    fn poll_write_vectored(
+        self: Pin<&mut Self>,
+        _: &mut Context<'_>,
+        bufs: &[IoSlice<'_>],
+    ) -> Poll<Result<usize, io::Error>> {
+        let this = self.get_mut();
+        let mut total_written = 0;
+        for buf in bufs {
+            let n = this.write_up_to(buf, this.write_len - total_written);
+            total_written += n;
+            if total_written == this.write_len {
+                break;
+            }
+        }
+        Ok(total_written).into()
+    }
+
+    fn is_write_vectored(&self) -> bool {
+        self.vectored
+    }
+
+    fn poll_flush(self: Pin<&mut Self>, _: &mut Context<'_>) -> Poll<Result<(), io::Error>> {
+        Ok(()).into()
+    }
+
+    fn poll_shutdown(self: Pin<&mut Self>, _: &mut Context<'_>) -> Poll<Result<(), io::Error>> {
+        Ok(()).into()
+    }
+}
+
+#[tokio::test]
+async fn write_vectored_empty_on_non_vectored() {
+    let mut w = BufWriter::new(MockWriter::new(4));
+    let n = assert_ok!(write_vectored(&mut w, &[]).await);
+    assert_eq!(n, 0);
+
+    let io_vec = [IoSlice::new(&[]); 3];
+    let n = assert_ok!(write_vectored(&mut w, &io_vec).await);
+    assert_eq!(n, 0);
+
+    assert_ok!(w.flush().await);
+    assert!(w.get_ref().data.is_empty());
+}
+
+#[tokio::test]
+async fn write_vectored_empty_on_vectored() {
+    let mut w = BufWriter::new(MockWriter::vectored(4));
+    let n = assert_ok!(write_vectored(&mut w, &[]).await);
+    assert_eq!(n, 0);
+
+    let io_vec = [IoSlice::new(&[]); 3];
+    let n = assert_ok!(write_vectored(&mut w, &io_vec).await);
+    assert_eq!(n, 0);
+
+    assert_ok!(w.flush().await);
+    assert!(w.get_ref().data.is_empty());
+}
+
+#[tokio::test]
+async fn write_vectored_basic_on_non_vectored() {
+    let msg = b"foo bar baz";
+    let bufs = [
+        IoSlice::new(&msg[0..4]),
+        IoSlice::new(&msg[4..8]),
+        IoSlice::new(&msg[8..]),
+    ];
+    let mut w = BufWriter::new(MockWriter::new(4));
+    let n = assert_ok!(write_vectored(&mut w, &bufs).await);
+    assert_eq!(n, msg.len());
+    assert!(w.buffer() == &msg[..]);
+    assert_ok!(w.flush().await);
+    assert_eq!(w.get_ref().data, msg);
+}
+
+#[tokio::test]
+async fn write_vectored_basic_on_vectored() {
+    let msg = b"foo bar baz";
+    let bufs = [
+        IoSlice::new(&msg[0..4]),
+        IoSlice::new(&msg[4..8]),
+        IoSlice::new(&msg[8..]),
+    ];
+    let mut w = BufWriter::new(MockWriter::vectored(4));
+    let n = assert_ok!(write_vectored(&mut w, &bufs).await);
+    assert_eq!(n, msg.len());
+    assert!(w.buffer() == &msg[..]);
+    assert_ok!(w.flush().await);
+    assert_eq!(w.get_ref().data, msg);
+}
+
+#[tokio::test]
+async fn write_vectored_large_total_on_non_vectored() {
+    let msg = b"foo bar baz";
+    let mut bufs = [
+        IoSlice::new(&msg[0..4]),
+        IoSlice::new(&msg[4..8]),
+        IoSlice::new(&msg[8..]),
+    ];
+    let io_vec = IoBufs::new(&mut bufs);
+    let mut w = BufWriter::with_capacity(8, MockWriter::new(4));
+    let n = assert_ok!(write_vectored(&mut w, &io_vec).await);
+    assert_eq!(n, 8);
+    assert!(w.buffer() == &msg[..8]);
+    let io_vec = io_vec.advance(n);
+    let n = assert_ok!(write_vectored(&mut w, &io_vec).await);
+    assert_eq!(n, 3);
+    assert!(w.get_ref().data.as_slice() == &msg[..8]);
+    assert!(w.buffer() == &msg[8..]);
+}
+
+#[tokio::test]
+async fn write_vectored_large_total_on_vectored() {
+    let msg = b"foo bar baz";
+    let mut bufs = [
+        IoSlice::new(&msg[0..4]),
+        IoSlice::new(&msg[4..8]),
+        IoSlice::new(&msg[8..]),
+    ];
+    let io_vec = IoBufs::new(&mut bufs);
+    let mut w = BufWriter::with_capacity(8, MockWriter::vectored(10));
+    let n = assert_ok!(write_vectored(&mut w, &io_vec).await);
+    assert_eq!(n, 10);
+    assert!(w.buffer().is_empty());
+    let io_vec = io_vec.advance(n);
+    let n = assert_ok!(write_vectored(&mut w, &io_vec).await);
+    assert_eq!(n, 1);
+    assert!(w.get_ref().data.as_slice() == &msg[..10]);
+    assert!(w.buffer() == &msg[10..]);
+}
+
+struct VectoredWriteHarness {
+    writer: BufWriter<MockWriter>,
+    buf_capacity: usize,
+}
+
+impl VectoredWriteHarness {
+    fn new(buf_capacity: usize) -> Self {
+        VectoredWriteHarness {
+            writer: BufWriter::with_capacity(buf_capacity, MockWriter::new(4)),
+            buf_capacity,
+        }
+    }
+
+    fn with_vectored_backend(buf_capacity: usize) -> Self {
+        VectoredWriteHarness {
+            writer: BufWriter::with_capacity(buf_capacity, MockWriter::vectored(4)),
+            buf_capacity,
+        }
+    }
+
+    async fn write_all<'a, 'b>(&mut self, mut io_vec: IoBufs<'a, 'b>) -> usize {
+        let mut total_written = 0;
+        while !io_vec.is_empty() {
+            let n = assert_ok!(write_vectored(&mut self.writer, &io_vec).await);
+            assert!(n != 0);
+            assert!(self.writer.buffer().len() <= self.buf_capacity);
+            total_written += n;
+            io_vec = io_vec.advance(n);
+        }
+        total_written
+    }
+
+    async fn flush(&mut self) -> &[u8] {
+        assert_ok!(self.writer.flush().await);
+        &self.writer.get_ref().data
+    }
+}
+
+#[tokio::test]
+async fn write_vectored_odd_on_non_vectored() {
+    let msg = b"foo bar baz";
+    let mut bufs = [
+        IoSlice::new(&msg[0..4]),
+        IoSlice::new(&[]),
+        IoSlice::new(&msg[4..9]),
+        IoSlice::new(&msg[9..]),
+    ];
+    let mut h = VectoredWriteHarness::new(8);
+    let bytes_written = h.write_all(IoBufs::new(&mut bufs)).await;
+    assert_eq!(bytes_written, msg.len());
+    assert_eq!(h.flush().await, msg);
+}
+
+#[tokio::test]
+async fn write_vectored_odd_on_vectored() {
+    let msg = b"foo bar baz";
+    let mut bufs = [
+        IoSlice::new(&msg[0..4]),
+        IoSlice::new(&[]),
+        IoSlice::new(&msg[4..9]),
+        IoSlice::new(&msg[9..]),
+    ];
+    let mut h = VectoredWriteHarness::with_vectored_backend(8);
+    let bytes_written = h.write_all(IoBufs::new(&mut bufs)).await;
+    assert_eq!(bytes_written, msg.len());
+    assert_eq!(h.flush().await, msg);
+}
+
+#[tokio::test]
+async fn write_vectored_large_slice_on_non_vectored() {
+    let msg = b"foo bar baz";
+    let mut bufs = [
+        IoSlice::new(&[]),
+        IoSlice::new(&msg[..9]),
+        IoSlice::new(&msg[9..]),
+    ];
+    let mut h = VectoredWriteHarness::new(8);
+    let bytes_written = h.write_all(IoBufs::new(&mut bufs)).await;
+    assert_eq!(bytes_written, msg.len());
+    assert_eq!(h.flush().await, msg);
+}
+
+#[tokio::test]
+async fn write_vectored_large_slice_on_vectored() {
+    let msg = b"foo bar baz";
+    let mut bufs = [
+        IoSlice::new(&[]),
+        IoSlice::new(&msg[..9]),
+        IoSlice::new(&msg[9..]),
+    ];
+    let mut h = VectoredWriteHarness::with_vectored_backend(8);
+    let bytes_written = h.write_all(IoBufs::new(&mut bufs)).await;
+    assert_eq!(bytes_written, msg.len());
+    assert_eq!(h.flush().await, msg);
+}

vendor/tokio/tests/io_chain.rs

@@ -0,0 +1,16 @@
+#![warn(rust_2018_idioms)]
+#![cfg(feature = "full")]
+
+use tokio::io::AsyncReadExt;
+use tokio_test::assert_ok;
+
+#[tokio::test]
+async fn chain() {
+    let mut buf = Vec::new();
+    let rd1: &[u8] = b"hello ";
+    let rd2: &[u8] = b"world";
+
+    let mut rd = rd1.chain(rd2);
+    assert_ok!(rd.read_to_end(&mut buf).await);
+    assert_eq!(buf, b"hello world");
+}

vendor/tokio/tests/io_copy.rs

@@ -0,0 +1,101 @@
+#![warn(rust_2018_idioms)]
+#![cfg(feature = "full")]
+
+use bytes::BytesMut;
+use tokio::io::{self, AsyncRead, AsyncReadExt, AsyncWrite, AsyncWriteExt, ReadBuf};
+use tokio_test::assert_ok;
+
+use std::pin::Pin;
+use std::task::{ready, Context, Poll};
+
+#[tokio::test]
+async fn copy() {
+    struct Rd(bool);
+
+    impl AsyncRead for Rd {
+        fn poll_read(
+            mut self: Pin<&mut Self>,
+            _cx: &mut Context<'_>,
+            buf: &mut ReadBuf<'_>,
+        ) -> Poll<io::Result<()>> {
+            if self.0 {
+                buf.put_slice(b"hello world");
+                self.0 = false;
+                Poll::Ready(Ok(()))
+            } else {
+                Poll::Ready(Ok(()))
+            }
+        }
+    }
+
+    let mut rd = Rd(true);
+    let mut wr = Vec::new();
+
+    let n = assert_ok!(io::copy(&mut rd, &mut wr).await);
+    assert_eq!(n, 11);
+    assert_eq!(wr, b"hello world");
+}
+
+#[tokio::test]
+async fn proxy() {
+    struct BufferedWd {
+        buf: BytesMut,
+        writer: io::DuplexStream,
+    }
+
+    impl AsyncWrite for BufferedWd {
+        fn poll_write(
+            self: Pin<&mut Self>,
+            _cx: &mut Context<'_>,
+            buf: &[u8],
+        ) -> Poll<io::Result<usize>> {
+            self.get_mut().buf.extend_from_slice(buf);
+            Poll::Ready(Ok(buf.len()))
+        }
+
+        fn poll_flush(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+            let this = self.get_mut();
+
+            while !this.buf.is_empty() {
+                let n = ready!(Pin::new(&mut this.writer).poll_write(cx, &this.buf))?;
+                let _ = this.buf.split_to(n);
+            }
+
+            Pin::new(&mut this.writer).poll_flush(cx)
+        }
+
+        fn poll_shutdown(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+            Pin::new(&mut self.writer).poll_shutdown(cx)
+        }
+    }
+
+    let (rd, wd) = io::duplex(1024);
+    let mut rd = rd.take(1024);
+    let mut wd = BufferedWd {
+        buf: BytesMut::new(),
+        writer: wd,
+    };
+
+    // write start bytes
+    assert_ok!(wd.write_all(&[0x42; 512]).await);
+    assert_ok!(wd.flush().await);
+
+    let n = assert_ok!(io::copy(&mut rd, &mut wd).await);
+
+    assert_eq!(n, 1024);
+}
+
+#[tokio::test]
+async fn copy_is_cooperative() {
+    tokio::select! {
+        biased;
+        _ = async {
+            loop {
+                let mut reader: &[u8] = b"hello";
+                let mut writer: Vec<u8> = vec![];
+                let _ = io::copy(&mut reader, &mut writer).await;
+            }
+        } => {},
+        _ = tokio::task::yield_now() => {}
+    }
+}

vendor/tokio/tests/io_copy_bidirectional.rs

@@ -0,0 +1,168 @@
+#![warn(rust_2018_idioms)]
+#![cfg(all(feature = "full", not(target_os = "wasi")))] // Wasi does not support bind()
+
+use std::time::Duration;
+use tokio::io::{self, copy_bidirectional, AsyncReadExt, AsyncWriteExt};
+use tokio::net::TcpStream;
+use tokio::task::JoinHandle;
+
+async fn make_socketpair() -> (TcpStream, TcpStream) {
+    let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
+    let addr = listener.local_addr().unwrap();
+    let connector = TcpStream::connect(addr);
+    let acceptor = listener.accept();
+
+    let (c1, c2) = tokio::join!(connector, acceptor);
+
+    (c1.unwrap(), c2.unwrap().0)
+}
+
+async fn block_write(s: &mut TcpStream) -> usize {
+    static BUF: [u8; 2048] = [0; 2048];
+
+    let mut copied = 0;
+    loop {
+        tokio::select! {
+            result = s.write(&BUF) => {
+                copied += result.expect("write error")
+            },
+            _ = tokio::time::sleep(Duration::from_millis(10)) => {
+                break;
+            }
+        }
+    }
+
+    copied
+}
+
+async fn symmetric<F, Fut>(mut cb: F)
+where
+    F: FnMut(JoinHandle<io::Result<(u64, u64)>>, TcpStream, TcpStream) -> Fut,
+    Fut: std::future::Future<Output = ()>,
+{
+    // We run the test twice, with streams passed to copy_bidirectional in
+    // different orders, in order to ensure that the two arguments are
+    // interchangeable.
+
+    let (a, mut a1) = make_socketpair().await;
+    let (b, mut b1) = make_socketpair().await;
+
+    let handle = tokio::spawn(async move { copy_bidirectional(&mut a1, &mut b1).await });
+    cb(handle, a, b).await;
+
+    let (a, mut a1) = make_socketpair().await;
+    let (b, mut b1) = make_socketpair().await;
+
+    let handle = tokio::spawn(async move { copy_bidirectional(&mut b1, &mut a1).await });
+
+    cb(handle, b, a).await;
+}
+
+#[tokio::test]
+#[cfg_attr(miri, ignore)] // No `socket` in miri.
+async fn test_basic_transfer() {
+    symmetric(|_handle, mut a, mut b| async move {
+        a.write_all(b"test").await.unwrap();
+        let mut tmp = [0; 4];
+        b.read_exact(&mut tmp).await.unwrap();
+        assert_eq!(&tmp[..], b"test");
+    })
+    .await
+}
+
+#[tokio::test]
+#[cfg_attr(miri, ignore)] // No `socket` in miri.
+async fn test_transfer_after_close() {
+    symmetric(|handle, mut a, mut b| async move {
+        AsyncWriteExt::shutdown(&mut a).await.unwrap();
+        b.read_to_end(&mut Vec::new()).await.unwrap();
+
+        b.write_all(b"quux").await.unwrap();
+        let mut tmp = [0; 4];
+        a.read_exact(&mut tmp).await.unwrap();
+        assert_eq!(&tmp[..], b"quux");
+
+        // Once both are closed, we should have our handle back
+        drop(b);
+
+        assert_eq!(handle.await.unwrap().unwrap(), (0, 4));
+    })
+    .await
+}
+
+#[tokio::test]
+#[cfg_attr(miri, ignore)] // No `socket` in miri.
+async fn blocking_one_side_does_not_block_other() {
+    symmetric(|handle, mut a, mut b| async move {
+        block_write(&mut a).await;
+
+        b.write_all(b"quux").await.unwrap();
+        let mut tmp = [0; 4];
+        a.read_exact(&mut tmp).await.unwrap();
+        assert_eq!(&tmp[..], b"quux");
+
+        AsyncWriteExt::shutdown(&mut a).await.unwrap();
+
+        let mut buf = Vec::new();
+        b.read_to_end(&mut buf).await.unwrap();
+
+        drop(b);
+
+        assert_eq!(handle.await.unwrap().unwrap(), (buf.len() as u64, 4));
+    })
+    .await
+}
+
+#[tokio::test]
+async fn immediate_exit_on_write_error() {
+    let payload = b"here, take this";
+    let error = || io::Error::new(io::ErrorKind::Other, "no thanks!");
+
+    let mut a = tokio_test::io::Builder::new()
+        .read(payload)
+        .write_error(error())
+        .build();
+
+    let mut b = tokio_test::io::Builder::new()
+        .read(payload)
+        .write_error(error())
+        .build();
+
+    assert!(copy_bidirectional(&mut a, &mut b).await.is_err());
+}
+
+#[tokio::test]
+async fn immediate_exit_on_read_error() {
+    let error = || io::Error::new(io::ErrorKind::Other, "got nothing!");
+
+    let mut a = tokio_test::io::Builder::new().read_error(error()).build();
+
+    let mut b = tokio_test::io::Builder::new().read_error(error()).build();
+
+    assert!(copy_bidirectional(&mut a, &mut b).await.is_err());
+}
+
+#[tokio::test]
+async fn copy_bidirectional_is_cooperative() {
+    tokio::select! {
+        biased;
+        _ = async {
+            loop {
+                let payload = b"here, take this";
+
+                let mut a = tokio_test::io::Builder::new()
+                    .read(payload)
+                    .write(payload)
+                    .build();
+
+                let mut b = tokio_test::io::Builder::new()
+                    .read(payload)
+                    .write(payload)
+                    .build();
+
+                let _ = copy_bidirectional(&mut a, &mut b).await;
+            }
+        } => {},
+        _ = tokio::task::yield_now() => {}
+    }
+}

vendor/tokio/tests/io_driver.rs

@@ -0,0 +1,105 @@
+#![warn(rust_2018_idioms)]
+// Wasi does not support panic recovery or threading
+#![cfg(all(feature = "full", not(target_os = "wasi")))]
+
+use tokio::net::TcpListener;
+use tokio::runtime;
+use tokio_test::{assert_ok, assert_pending};
+
+use futures::task::{waker_ref, ArcWake};
+use std::future::Future;
+use std::net::TcpStream;
+use std::pin::Pin;
+use std::sync::{mpsc, Arc, Mutex};
+use std::task::Context;
+
+struct Task<T> {
+    future: Mutex<Pin<Box<T>>>,
+}
+
+impl<T: Send> ArcWake for Task<T> {
+    fn wake_by_ref(_: &Arc<Self>) {
+        // Do nothing...
+    }
+}
+
+impl<T> Task<T> {
+    fn new(future: T) -> Task<T> {
+        Task {
+            future: Mutex::new(Box::pin(future)),
+        }
+    }
+}
+
+#[test]
+#[cfg_attr(miri, ignore)] // No `socket` in miri.
+fn test_drop_on_notify() {
+    // When the reactor receives a kernel notification, it notifies the
+    // task that holds the associated socket. If this notification results in
+    // the task being dropped, the socket will also be dropped.
+    //
+    // Previously, there was a deadlock scenario where the reactor, while
+    // notifying, held a lock and the task being dropped attempted to acquire
+    // that same lock in order to clean up state.
+    //
+    // To simulate this case, we create a fake executor that does nothing when
+    // the task is notified. This simulates an executor in the process of
+    // shutting down. Then, when the task handle is dropped, the task itself is
+    // dropped.
+
+    let rt = runtime::Builder::new_current_thread()
+        .enable_all()
+        .build()
+        .unwrap();
+
+    let (addr_tx, addr_rx) = mpsc::channel();
+
+    // Define a task that just drains the listener
+    let task = Arc::new(Task::new(async move {
+        // Create a listener
+        let listener = assert_ok!(TcpListener::bind("127.0.0.1:0").await);
+
+        // Send the address
+        let addr = listener.local_addr().unwrap();
+        addr_tx.send(addr).unwrap();
+
+        loop {
+            let _ = listener.accept().await;
+        }
+    }));
+
+    {
+        let _enter = rt.enter();
+        let waker = waker_ref(&task);
+        let mut cx = Context::from_waker(&waker);
+        assert_pending!(task.future.lock().unwrap().as_mut().poll(&mut cx));
+    }
+
+    // Get the address
+    let addr = addr_rx.recv().unwrap();
+
+    drop(task);
+
+    // Establish a connection to the acceptor
+    let _s = TcpStream::connect(addr).unwrap();
+
+    // Force the reactor to turn
+    rt.block_on(async {});
+}
+
+#[test]
+#[should_panic(
+    expected = "A Tokio 1.x context was found, but IO is disabled. Call `enable_io` on the runtime builder to enable IO."
+)]
+#[cfg_attr(miri, ignore)] // No `socket` in miri.
+fn panics_when_io_disabled() {
+    let rt = runtime::Builder::new_current_thread().build().unwrap();
+
+    rt.block_on(async {
+        let listener = std::net::TcpListener::bind("127.0.0.1:0").unwrap();
+
+        listener.set_nonblocking(true).unwrap();
+
+        let _ = tokio::net::TcpListener::from_std(listener);
+    });
+}

vendor/tokio/tests/io_driver_drop.rs

@@ -0,0 +1,62 @@
+#![warn(rust_2018_idioms)]
+#![cfg(all(feature = "full", not(target_os = "wasi")))] // Wasi does not support bind
+
+use tokio::net::TcpListener;
+use tokio::runtime;
+use tokio_test::{assert_err, assert_pending, assert_ready, task};
+
+#[test]
+#[cfg_attr(miri, ignore)] // No `socket` in miri.
+fn tcp_doesnt_block() {
+    let rt = rt();
+
+    let listener = {
+        let _enter = rt.enter();
+        let listener = std::net::TcpListener::bind("127.0.0.1:0").unwrap();
+
+        listener.set_nonblocking(true).unwrap();
+
+        TcpListener::from_std(listener).unwrap()
+    };
+
+    drop(rt);
+
+    let mut task = task::spawn(async move {
+        assert_err!(listener.accept().await);
+    });
+
+    assert_ready!(task.poll());
+}
+
+#[test]
+#[cfg_attr(miri, ignore)] // No `socket` in miri.
+fn drop_wakes() {
+    let rt = rt();
+
+    let listener = {
+        let _enter = rt.enter();
+        let listener = std::net::TcpListener::bind("127.0.0.1:0").unwrap();
+
+        listener.set_nonblocking(true).unwrap();
+
+        TcpListener::from_std(listener).unwrap()
+    };
+
+    let mut task = task::spawn(async move {
+        assert_err!(listener.accept().await);
+    });
+
+    assert_pending!(task.poll());
+
+    drop(rt);
+
+    assert!(task.is_woken());
+    assert_ready!(task.poll());
+}
+
+fn rt() -> runtime::Runtime {
+    runtime::Builder::new_current_thread()
+        .enable_all()
+        .build()
+        .unwrap()
+}

vendor/tokio/tests/io_fill_buf.rs

@@ -0,0 +1,34 @@
+#![warn(rust_2018_idioms)]
+#![cfg(all(feature = "full", not(target_os = "wasi")))] // Wasi does not support file operations
+
+use tempfile::NamedTempFile;
+use tokio::fs::File;
+use tokio::io::{AsyncBufReadExt, BufReader};
+use tokio_test::assert_ok;
+
+#[tokio::test]
+async fn fill_buf_file() {
+    let file = NamedTempFile::new().unwrap();
+
+    assert_ok!(std::fs::write(file.path(), b"hello"));
+
+    let file = assert_ok!(File::open(file.path()).await);
+    let mut file = BufReader::new(file);
+
+    let mut contents = Vec::new();
+
+    loop {
+        let consumed = {
+            let buffer = assert_ok!(file.fill_buf().await);
+            if buffer.is_empty() {
+                break;
+            }
+            contents.extend_from_slice(buffer);
+            buffer.len()
+        };
+
+        file.consume(consumed);
+    }
+
+    assert_eq!(contents, b"hello");
+}

vendor/tokio/tests/io_join.rs

@@ -0,0 +1,81 @@
+#![warn(rust_2018_idioms)]
+#![cfg(feature = "full")]
+
+use tokio::io::{join, AsyncRead, AsyncReadExt, AsyncWrite, AsyncWriteExt, Join, ReadBuf};
+
+use std::io;
+use std::pin::Pin;
+use std::task::{Context, Poll};
+
+struct R;
+
+impl AsyncRead for R {
+    fn poll_read(
+        self: Pin<&mut Self>,
+        _cx: &mut Context<'_>,
+        buf: &mut ReadBuf<'_>,
+    ) -> Poll<io::Result<()>> {
+        buf.put_slice(b"z");
+        Poll::Ready(Ok(()))
+    }
+}
+
+struct W;
+
+impl AsyncWrite for W {
+    fn poll_write(
+        self: Pin<&mut Self>,
+        _cx: &mut Context<'_>,
+        _buf: &[u8],
+    ) -> Poll<Result<usize, io::Error>> {
+        Poll::Ready(Ok(1))
+    }
+
+    fn poll_flush(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<Result<(), io::Error>> {
+        Poll::Ready(Ok(()))
+    }
+
+    fn poll_shutdown(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<Result<(), io::Error>> {
+        Poll::Ready(Ok(()))
+    }
+
+    fn poll_write_vectored(
+        self: Pin<&mut Self>,
+        _cx: &mut Context<'_>,
+        _bufs: &[io::IoSlice<'_>],
+    ) -> Poll<Result<usize, io::Error>> {
+        Poll::Ready(Ok(2))
+    }
+
+    fn is_write_vectored(&self) -> bool {
+        true
+    }
+}
+
+#[test]
+fn is_send_and_sync() {
+    fn assert_bound<T: Send + Sync>() {}
+
+    assert_bound::<Join<W, R>>();
+}
+
+#[test]
+fn method_delegation() {
+    let mut rw = join(R, W);
+    let mut buf = [0; 1];
+
+    tokio_test::block_on(async move {
+        assert_eq!(1, rw.read(&mut buf).await.unwrap());
+        assert_eq!(b'z', buf[0]);
+
+        assert_eq!(1, rw.write(b"x").await.unwrap());
+        assert_eq!(
+            2,
+            rw.write_vectored(&[io::IoSlice::new(b"x")]).await.unwrap()
+        );
+        assert!(rw.is_write_vectored());
+
+        assert!(rw.flush().await.is_ok());
+        assert!(rw.shutdown().await.is_ok());
+    });
+}

vendor/tokio/tests/io_lines.rs

@@ -0,0 +1,19 @@
+#![warn(rust_2018_idioms)]
+#![cfg(feature = "full")]
+
+use tokio::io::AsyncBufReadExt;
+use tokio_test::assert_ok;
+
+#[tokio::test]
+async fn lines_inherent() {
+    let rd: &[u8] = b"hello\r\nworld\n\n";
+    let mut st = rd.lines();
+
+    let b = assert_ok!(st.next_line().await).unwrap();
+    assert_eq!(b, "hello");
+    let b = assert_ok!(st.next_line().await).unwrap();
+    assert_eq!(b, "world");
+    let b = assert_ok!(st.next_line().await).unwrap();
+    assert_eq!(b, "");
+    assert!(assert_ok!(st.next_line().await).is_none());
+}

vendor/tokio/tests/io_mem_stream.rs

@@ -0,0 +1,121 @@
+#![warn(rust_2018_idioms)]
+#![cfg(feature = "full")]
+
+use tokio::io::{duplex, AsyncReadExt, AsyncWriteExt};
+
+#[tokio::test]
+async fn ping_pong() {
+    let (mut a, mut b) = duplex(32);
+
+    let mut buf = [0u8; 4];
+
+    a.write_all(b"ping").await.unwrap();
+    b.read_exact(&mut buf).await.unwrap();
+    assert_eq!(&buf, b"ping");
+
+    b.write_all(b"pong").await.unwrap();
+    a.read_exact(&mut buf).await.unwrap();
+    assert_eq!(&buf, b"pong");
+}
+
+#[tokio::test]
+async fn across_tasks() {
+    let (mut a, mut b) = duplex(32);
+
+    let t1 = tokio::spawn(async move {
+        a.write_all(b"ping").await.unwrap();
+        let mut buf = [0u8; 4];
+        a.read_exact(&mut buf).await.unwrap();
+        assert_eq!(&buf, b"pong");
+    });
+
+    let t2 = tokio::spawn(async move {
+        let mut buf = [0u8; 4];
+        b.read_exact(&mut buf).await.unwrap();
+        assert_eq!(&buf, b"ping");
+        b.write_all(b"pong").await.unwrap();
+    });
+
+    t1.await.unwrap();
+    t2.await.unwrap();
+}
+
+#[tokio::test]
+async fn disconnect() {
+    let (mut a, mut b) = duplex(32);
+
+    let t1 = tokio::spawn(async move {
+        a.write_all(b"ping").await.unwrap();
+        // and dropped
+    });
+
+    let t2 = tokio::spawn(async move {
+        let mut buf = [0u8; 32];
+        let n = b.read(&mut buf).await.unwrap();
+        assert_eq!(&buf[..n], b"ping");
+
+        let n = b.read(&mut buf).await.unwrap();
+        assert_eq!(n, 0);
+    });
+
+    t1.await.unwrap();
+    t2.await.unwrap();
+}
+
+#[tokio::test]
+async fn disconnect_reader() {
+    let (a, mut b) = duplex(2);
+
+    let t1 = tokio::spawn(async move {
+        // this will block, as not all data fits into duplex
+        b.write_all(b"ping").await.unwrap_err();
+    });
+
+    let t2 = tokio::spawn(async move {
+        // here we drop the reader side, and we expect the writer in the other
+        // task to exit with an error
+        drop(a);
+    });
+
+    t2.await.unwrap();
+    t1.await.unwrap();
+}
+
+#[tokio::test]
+async fn max_write_size() {
+    let (mut a, mut b) = duplex(32);
+
+    let t1 = tokio::spawn(async move {
+        let n = a.write(&[0u8; 64]).await.unwrap();
+        assert_eq!(n, 32);
+        let n = a.write(&[0u8; 64]).await.unwrap();
+        assert_eq!(n, 4);
+    });
+
+    let mut buf = [0u8; 4];
+    b.read_exact(&mut buf).await.unwrap();
+
+    t1.await.unwrap();
+
+    // drop b only after task t1 finishes writing
+    drop(b);
+}
+
+#[tokio::test]
+async fn duplex_is_cooperative() {
+    let (mut tx, mut rx) = tokio::io::duplex(1024 * 8);
+
+    tokio::select! {
+        biased;
+
+        _ = async {
+            loop {
+                let buf = [3u8; 4096];
+                tx.write_all(&buf).await.unwrap();
+                let mut buf = [0u8; 4096];
+                let _ = rx.read(&mut buf).await.unwrap();
+            }
+        } => {},
+        _ = tokio::task::yield_now() => {}
+    }
+}

vendor/tokio/tests/io_panic.rs

@@ -0,0 +1,222 @@
+#![warn(rust_2018_idioms)]
+#![cfg(all(feature = "full", not(target_os = "wasi")))] // Wasi does not support panic recovery
+#![cfg(panic = "unwind")]
+
+use std::task::{Context, Poll};
+use std::{error::Error, pin::Pin};
+use tokio::io::{self, split, AsyncRead, AsyncWrite, ReadBuf};
+
+mod support {
+    pub mod panic;
+}
+use support::panic::test_panic;
+
+struct RW;
+
+impl AsyncRead for RW {
+    fn poll_read(
+        self: Pin<&mut Self>,
+        _cx: &mut Context<'_>,
+        buf: &mut ReadBuf<'_>,
+    ) -> Poll<io::Result<()>> {
+        buf.put_slice(b"z");
+        Poll::Ready(Ok(()))
+    }
+}
+
+impl AsyncWrite for RW {
+    fn poll_write(
+        self: Pin<&mut Self>,
+        _cx: &mut Context<'_>,
+        _buf: &[u8],
+    ) -> Poll<Result<usize, io::Error>> {
+        Poll::Ready(Ok(1))
+    }
+
+    fn poll_flush(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<Result<(), io::Error>> {
+        Poll::Ready(Ok(()))
+    }
+
+    fn poll_shutdown(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<Result<(), io::Error>> {
+        Poll::Ready(Ok(()))
+    }
+}
+
+#[cfg(unix)]
+mod unix {
+    use std::os::unix::prelude::{AsRawFd, RawFd};
+
+    pub struct MockFd;
+
+    impl AsRawFd for MockFd {
+        fn as_raw_fd(&self) -> RawFd {
+            0
+        }
+    }
+}
+
+#[test]
+fn read_buf_initialize_unfilled_to_panic_caller() -> Result<(), Box<dyn Error>> {
+    let panic_location_file = test_panic(|| {
+        let mut buffer = Vec::<u8>::new();
+        let mut read_buf = ReadBuf::new(&mut buffer);
+
+        read_buf.initialize_unfilled_to(2);
+    });
+
+    // The panic location should be in this file
+    assert_eq!(&panic_location_file.unwrap(), file!());
+
+    Ok(())
+}
+
+#[test]
+fn read_buf_advance_panic_caller() -> Result<(), Box<dyn Error>> {
+    let panic_location_file = test_panic(|| {
+        let mut buffer = Vec::<u8>::new();
+        let mut read_buf = ReadBuf::new(&mut buffer);
+
+        read_buf.advance(2);
+    });
+
+    // The panic location should be in this file
+    assert_eq!(&panic_location_file.unwrap(), file!());
+
+    Ok(())
+}
+
+#[test]
+fn read_buf_set_filled_panic_caller() -> Result<(), Box<dyn Error>> {
+    let panic_location_file = test_panic(|| {
+        let mut buffer = Vec::<u8>::new();
+        let mut read_buf = ReadBuf::new(&mut buffer);
+
+        read_buf.set_filled(2);
+    });
+
+    // The panic location should be in this file
+    assert_eq!(&panic_location_file.unwrap(), file!());
+
+    Ok(())
+}
+
+#[test]
+fn read_buf_put_slice_panic_caller() -> Result<(), Box<dyn Error>> {
+    let panic_location_file = test_panic(|| {
+        let mut buffer = Vec::<u8>::new();
+        let mut read_buf = ReadBuf::new(&mut buffer);
+
+        let new_slice = [0x40_u8, 0x41_u8];
+
+        read_buf.put_slice(&new_slice);
+    });
+
+    // The panic location should be in this file
+    assert_eq!(&panic_location_file.unwrap(), file!());
+
+    Ok(())
+}
+
+#[test]
+fn unsplit_panic_caller() -> Result<(), Box<dyn Error>> {
+    let panic_location_file = test_panic(|| {
+        let (r1, _w1) = split(RW);
+        let (_r2, w2) = split(RW);
+        r1.unsplit(w2);
+    });
+
+    // The panic location should be in this file
+    assert_eq!(&panic_location_file.unwrap(), file!());
+
+    Ok(())
+}
+
+#[test]
+#[cfg(unix)]
+fn async_fd_new_panic_caller() -> Result<(), Box<dyn Error>> {
+    use tokio::io::unix::AsyncFd;
+    use tokio::runtime::Builder;
+
+    let panic_location_file = test_panic(|| {
+        // Runtime without `enable_io` so it has no IO driver set.
+        let rt = Builder::new_current_thread().build().unwrap();
+        rt.block_on(async {
+            let fd = unix::MockFd;
+
+            let _ = AsyncFd::new(fd);
+        });
+    });
+
+    // The panic location should be in this file
+    assert_eq!(&panic_location_file.unwrap(), file!());
+
+    Ok(())
+}
+
+#[test]
+#[cfg(unix)]
+fn async_fd_with_interest_panic_caller() -> Result<(), Box<dyn Error>> {
+    use tokio::io::unix::AsyncFd;
+    use tokio::io::Interest;
+    use tokio::runtime::Builder;
+
+    let panic_location_file = test_panic(|| {
+        // Runtime without `enable_io` so it has no IO driver set.
+        let rt = Builder::new_current_thread().build().unwrap();
+        rt.block_on(async {
+            let fd = unix::MockFd;
+
+            let _ = AsyncFd::with_interest(fd, Interest::READABLE);
+        });
+    });
+
+    // The panic location should be in this file
+    assert_eq!(&panic_location_file.unwrap(), file!());
+
+    Ok(())
+}
+
+#[test]
+#[cfg(unix)]
+fn async_fd_try_new_panic_caller() -> Result<(), Box<dyn Error>> {
+    use tokio::io::unix::AsyncFd;
+    use tokio::runtime::Builder;
+
+    let panic_location_file = test_panic(|| {
+        // Runtime without `enable_io` so it has no IO driver set.
+        let rt = Builder::new_current_thread().build().unwrap();
+        rt.block_on(async {
+            let fd = unix::MockFd;
+
+            let _ = AsyncFd::try_new(fd);
+        });
+    });
+
+    // The panic location should be in this file
+    assert_eq!(&panic_location_file.unwrap(), file!());
+
+    Ok(())
+}
+
+#[test]
+#[cfg(unix)]
+fn async_fd_try_with_interest_panic_caller() -> Result<(), Box<dyn Error>> {
+    use tokio::io::unix::AsyncFd;
+    use tokio::io::Interest;
+    use tokio::runtime::Builder;
+
+    let panic_location_file = test_panic(|| {
+        // Runtime without `enable_io` so it has no IO driver set.
+        let rt = Builder::new_current_thread().build().unwrap();
+        rt.block_on(async {
+            let fd = unix::MockFd;
+
+            let _ = AsyncFd::try_with_interest(fd, Interest::READABLE);
+        });
+    });
+
+    // The panic location should be in this file
+    assert_eq!(&panic_location_file.unwrap(), file!());
+
+    Ok(())
+}

vendor/tokio/tests/io_poll_aio.rs

@@ -0,0 +1,339 @@
+#![warn(rust_2018_idioms)]
+#![cfg(all(target_os = "freebsd", feature = "net"))]
+
+use mio_aio::{AioFsyncMode, SourceApi};
+use std::{
+    future::Future,
+    io, mem,
+    os::fd::AsFd,
+    os::unix::io::{AsRawFd, RawFd},
+    pin::{pin, Pin},
+    task::{Context, Poll},
+};
+use tempfile::tempfile;
+use tokio::io::bsd::{Aio, AioSource};
+use tokio_test::assert_pending;
+
+mod aio {
+    use super::*;
+
+    #[derive(Debug)]
+    struct TokioSource<'fd>(mio_aio::Source<nix::sys::aio::AioFsync<'fd>>);
+
+    impl<'fd> AioSource for TokioSource<'fd> {
+        fn register(&mut self, kq: RawFd, token: usize) {
+            self.0.register_raw(kq, token)
+        }
+        fn deregister(&mut self) {
+            self.0.deregister_raw()
+        }
+    }
+
+    /// A very crude implementation of an AIO-based future
+    struct FsyncFut<'fd>(Aio<TokioSource<'fd>>);
+
+    impl<'fd> FsyncFut<'fd> {
+        pub fn submit(self: Pin<&mut Self>) -> io::Result<()> {
+            let p = unsafe { self.map_unchecked_mut(|s| &mut s.0 .0) };
+            match p.submit() {
+                Ok(()) => Ok(()),
+                Err(e) => Err(io::Error::from_raw_os_error(e as i32)),
+            }
+        }
+    }
+
+    impl<'fd> Future for FsyncFut<'fd> {
+        type Output = io::Result<()>;
+
+        fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+            let poll_result = self.0.poll_ready(cx);
+            match poll_result {
+                Poll::Pending => Poll::Pending,
+                Poll::Ready(Err(e)) => Poll::Ready(Err(e)),
+                Poll::Ready(Ok(_ev)) => {
+                    // At this point, we could clear readiness.  But there's no
+                    // point, since we're about to drop the Aio.
+                    let p = unsafe { self.map_unchecked_mut(|s| &mut s.0 .0) };
+                    let result = p.aio_return();
+                    match result {
+                        Ok(r) => Poll::Ready(Ok(r)),
+                        Err(e) => Poll::Ready(Err(io::Error::from_raw_os_error(e as i32))),
+                    }
+                }
+            }
+        }
+    }
+
+    /// Low-level AIO Source
+    ///
+    /// An example bypassing mio_aio and Nix to demonstrate how the kevent
+    /// registration actually works, under the hood.
+    struct LlSource(Pin<Box<libc::aiocb>>);
+
+    impl LlSource {
+        fn fsync(mut self: Pin<&mut Self>) {
+            let r = unsafe {
+                let p = self.0.as_mut().get_unchecked_mut();
+                libc::aio_fsync(libc::O_SYNC, p)
+            };
+            assert_eq!(0, r);
+        }
+    }
+
+    impl AioSource for LlSource {
+        fn register(&mut self, kq: RawFd, token: usize) {
+            let mut sev: libc::sigevent = unsafe { mem::MaybeUninit::zeroed().assume_init() };
+            sev.sigev_notify = libc::SIGEV_KEVENT;
+            sev.sigev_signo = kq;
+            sev.sigev_value = libc::sigval {
+                sival_ptr: token as *mut libc::c_void,
+            };
+            self.0.aio_sigevent = sev;
+        }
+
+        fn deregister(&mut self) {
+            unsafe {
+                self.0.aio_sigevent = mem::zeroed();
+            }
+        }
+    }
+
+    struct LlFut(Aio<LlSource>);
+
+    impl LlFut {
+        pub fn fsync(self: Pin<&mut Self>) {
+            let p = unsafe { self.map_unchecked_mut(|s| &mut *(s.0)) };
+            p.fsync();
+        }
+    }
+
+    impl Future for LlFut {
+        type Output = std::io::Result<usize>;
+
+        fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+            let poll_result = self.0.poll_ready(cx);
+            match poll_result {
+                Poll::Pending => Poll::Pending,
+                Poll::Ready(Err(e)) => Poll::Ready(Err(e)),
+                Poll::Ready(Ok(ev)) => {
+                    // Clearing readiness makes the future non-idempotent; the
+                    // caller can't poll it repeatedly after it has already
+                    // returned Ready.  But that's ok; most futures behave this
+                    // way.
+                    self.0.clear_ready(ev);
+                    let r = unsafe { libc::aio_return(self.0 .0.as_mut().get_unchecked_mut()) };
+                    if r >= 0 {
+                        Poll::Ready(Ok(r as usize))
+                    } else {
+                        Poll::Ready(Err(io::Error::last_os_error()))
+                    }
+                }
+            }
+        }
+    }
+
+    #[tokio::test]
+    async fn fsync() {
+        let f = tempfile().unwrap();
+        let fd = f.as_fd();
+        let mode = AioFsyncMode::O_SYNC;
+        let source = TokioSource(mio_aio::Fsync::fsync(fd, mode, 0));
+        let poll_aio = Aio::new_for_aio(source).unwrap();
+        let mut fut = pin!(FsyncFut(poll_aio));
+        fut.as_mut().submit().unwrap();
+        fut.await.unwrap();
+    }
+
+    #[tokio::test]
+    async fn ll_fsync() {
+        let f = tempfile().unwrap();
+        let fd = f.as_raw_fd();
+        let mut aiocb: libc::aiocb = unsafe { mem::MaybeUninit::zeroed().assume_init() };
+        aiocb.aio_fildes = fd;
+        let source = LlSource(Box::pin(aiocb));
+        let mut poll_aio = Aio::new_for_aio(source).unwrap();
+        let r = unsafe {
+            let p = poll_aio.0.as_mut().get_unchecked_mut();
+            libc::aio_fsync(libc::O_SYNC, p)
+        };
+        assert_eq!(0, r);
+        let fut = LlFut(poll_aio);
+        fut.await.unwrap();
+    }
+
+    /// A suitably crafted future type can reuse an Aio object
+    #[tokio::test]
+    async fn reuse() {
+        let f = tempfile().unwrap();
+        let fd = f.as_raw_fd();
+        let mut aiocb: libc::aiocb = unsafe { mem::MaybeUninit::zeroed().assume_init() };
+        aiocb.aio_fildes = fd;
+        let source = LlSource(Box::pin(aiocb));
+        let poll_aio = Aio::new_for_aio(source).unwrap();
+
+        // Send the operation to the kernel the first time
+        let mut fut = LlFut(poll_aio);
+        {
+            let mut pfut = Pin::new(&mut fut);
+            pfut.as_mut().fsync();
+            pfut.as_mut().await.unwrap();
+        }
+
+        // Check that readiness was cleared
+        let mut ctx = Context::from_waker(futures::task::noop_waker_ref());
+        assert_pending!(fut.0.poll_ready(&mut ctx));
+
+        // and reuse the future and its Aio object
+        {
+            let mut pfut = Pin::new(&mut fut);
+            pfut.as_mut().fsync();
+            pfut.as_mut().await.unwrap();
+        }
+    }
+}
+
+mod lio {
+    use super::*;
+
+    /// Low-level source based on lio_listio
+    ///
+    /// An example demonstrating using AIO with `Interest::Lio`.  mio_aio 0.8
+    /// doesn't include any bindings for lio_listio, so we've got to go
+    /// low-level.
+    struct LioSource<'a> {
+        aiocb: Pin<&'a mut [&'a mut libc::aiocb; 1]>,
+        sev: libc::sigevent,
+    }
+
+    impl<'a> LioSource<'a> {
+        fn new(aiocb: Pin<&'a mut [&'a mut libc::aiocb; 1]>) -> Self {
+            LioSource {
+                aiocb,
+                sev: unsafe { mem::zeroed() },
+            }
+        }
+
+        fn submit(mut self: Pin<&mut Self>) {
+            let p: *const *mut libc::aiocb =
+                unsafe { self.aiocb.as_mut().get_unchecked_mut() } as *const _ as *const *mut _;
+            let r = unsafe { libc::lio_listio(libc::LIO_NOWAIT, p, 1, &mut self.sev) };
+            assert_eq!(r, 0);
+        }
+    }
+
+    impl<'a> AioSource for LioSource<'a> {
+        fn register(&mut self, kq: RawFd, token: usize) {
+            let mut sev: libc::sigevent = unsafe { mem::MaybeUninit::zeroed().assume_init() };
+            sev.sigev_notify = libc::SIGEV_KEVENT;
+            sev.sigev_signo = kq;
+            sev.sigev_value = libc::sigval {
+                sival_ptr: token as *mut libc::c_void,
+            };
+            self.sev = sev;
+        }
+
+        fn deregister(&mut self) {
+            unsafe {
+                self.sev = mem::zeroed();
+            }
+        }
+    }
+
+    struct LioFut<'a>(Aio<LioSource<'a>>);
+
+    impl<'a> LioFut<'a> {
+        pub fn submit(self: Pin<&mut Self>) {
+            let p = unsafe { self.map_unchecked_mut(|s| &mut *(s.0)) };
+            p.submit();
+        }
+    }
+
+    impl<'a> Future for LioFut<'a> {
+        type Output = std::io::Result<usize>;
+
+        fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+            let poll_result = self.0.poll_ready(cx);
+            match poll_result {
+                Poll::Pending => Poll::Pending,
+                Poll::Ready(Err(e)) => Poll::Ready(Err(e)),
+                Poll::Ready(Ok(ev)) => {
+                    // Clearing readiness makes the future non-idempotent; the
+                    // caller can't poll it repeatedly after it has already
+                    // returned Ready.  But that's ok; most futures behave this
+                    // way.  Clearing readiness is especially useful for
+                    // lio_listio, because sometimes some operations will be
+                    // ready but not all.
+                    self.0.clear_ready(ev);
+                    let r = unsafe {
+                        let p1 = self.get_unchecked_mut();
+                        let p2: &mut [&mut libc::aiocb; 1] =
+                            p1.0.aiocb.as_mut().get_unchecked_mut();
+                        let p3: &mut libc::aiocb = p2[0];
+                        libc::aio_return(p3)
+                    };
+                    if r >= 0 {
+                        Poll::Ready(Ok(r as usize))
+                    } else {
+                        Poll::Ready(Err(io::Error::last_os_error()))
+                    }
+                }
+            }
+        }
+    }
+
+    /// An lio_listio operation with one fsync element
+    #[tokio::test]
+    async fn onewrite() {
+        const WBUF: &[u8] = b"abcdef";
+        let f = tempfile().unwrap();
+
+        let mut aiocb: libc::aiocb = unsafe { mem::zeroed() };
+        aiocb.aio_fildes = f.as_raw_fd();
+        aiocb.aio_lio_opcode = libc::LIO_WRITE;
+        aiocb.aio_nbytes = WBUF.len();
+        aiocb.aio_buf = WBUF.as_ptr() as *mut _;
+        let aiocb = pin!([&mut aiocb]);
+        let source = LioSource::new(aiocb);
+        let poll_aio = Aio::new_for_lio(source).unwrap();
+
+        // Send the operation to the kernel
+        let mut fut = pin!(LioFut(poll_aio));
+        fut.as_mut().submit();
+        fut.await.unwrap();
+    }
+
+    /// A suitably crafted future type can reuse an Aio object
+    #[tokio::test]
+    async fn reuse() {
+        const WBUF: &[u8] = b"abcdef";
+        let f = tempfile().unwrap();
+
+        let mut aiocb: libc::aiocb = unsafe { mem::zeroed() };
+        aiocb.aio_fildes = f.as_raw_fd();
+        aiocb.aio_lio_opcode = libc::LIO_WRITE;
+        aiocb.aio_nbytes = WBUF.len();
+        aiocb.aio_buf = WBUF.as_ptr() as *mut _;
+        let aiocb = pin!([&mut aiocb]);
+        let source = LioSource::new(aiocb);
+        let poll_aio = Aio::new_for_lio(source).unwrap();
+
+        // Send the operation to the kernel the first time
+        let mut fut = LioFut(poll_aio);
+        {
+            let mut pfut = Pin::new(&mut fut);
+            pfut.as_mut().submit();
+            pfut.as_mut().await.unwrap();
+        }
+
+        // Check that readiness was cleared
+        let mut ctx = Context::from_waker(futures::task::noop_waker_ref());
+        assert_pending!(fut.0.poll_ready(&mut ctx));
+
+        // and reuse the future and its Aio object
+        {
+            let mut pfut = Pin::new(&mut fut);
+            pfut.as_mut().submit();
+            pfut.as_mut().await.unwrap();
+        }
+    }
+}

vendor/tokio/tests/io_read.rs

@@ -0,0 +1,75 @@
+#![warn(rust_2018_idioms)]
+#![cfg(all(feature = "full", not(target_os = "wasi")))] // Wasi does not support panic recovery
+
+use tokio::io::{AsyncRead, AsyncReadExt, ReadBuf};
+use tokio_test::assert_ok;
+
+use std::io;
+use std::pin::Pin;
+use std::task::{Context, Poll};
+
+mod support {
+    pub(crate) mod leaked_buffers;
+}
+use support::leaked_buffers::LeakedBuffers;
+
+#[tokio::test]
+async fn read() {
+    #[derive(Default)]
+    struct Rd {
+        poll_cnt: usize,
+    }
+
+    impl AsyncRead for Rd {
+        fn poll_read(
+            mut self: Pin<&mut Self>,
+            _cx: &mut Context<'_>,
+            buf: &mut ReadBuf<'_>,
+        ) -> Poll<io::Result<()>> {
+            assert_eq!(0, self.poll_cnt);
+            self.poll_cnt += 1;
+
+            buf.put_slice(b"hello world");
+            Poll::Ready(Ok(()))
+        }
+    }
+
+    let mut buf = Box::new([0; 11]);
+    let mut rd = Rd::default();
+
+    let n = assert_ok!(rd.read(&mut buf[..]).await);
+    assert_eq!(n, 11);
+    assert_eq!(buf[..], b"hello world"[..]);
+}
+
+struct BadAsyncRead {
+    leaked_buffers: LeakedBuffers,
+}
+
+impl BadAsyncRead {
+    fn new() -> Self {
+        Self {
+            leaked_buffers: LeakedBuffers::new(),
+        }
+    }
+}
+
+impl AsyncRead for BadAsyncRead {
+    fn poll_read(
+        mut self: Pin<&mut Self>,
+        _cx: &mut Context<'_>,
+        buf: &mut ReadBuf<'_>,
+    ) -> Poll<io::Result<()>> {
+        *buf = ReadBuf::new(unsafe { self.leaked_buffers.create(buf.capacity()) });
+        buf.advance(buf.capacity());
+
+        Poll::Ready(Ok(()))
+    }
+}
+
+#[tokio::test]
+#[should_panic]
+async fn read_buf_bad_async_read() {
+    let mut buf = Vec::with_capacity(10);
+    BadAsyncRead::new().read_buf(&mut buf).await.unwrap();
+}

vendor/tokio/tests/io_read_buf.rs

@@ -0,0 +1,94 @@
+#![warn(rust_2018_idioms)]
+#![cfg(feature = "full")]
+
+use tokio::io::{AsyncRead, AsyncReadExt, ReadBuf};
+use tokio_test::assert_ok;
+
+use std::io;
+use std::pin::Pin;
+use std::task::{Context, Poll};
+
+#[tokio::test]
+async fn read_buf() {
+    struct Rd {
+        cnt: usize,
+    }
+
+    impl AsyncRead for Rd {
+        fn poll_read(
+            mut self: Pin<&mut Self>,
+            _cx: &mut Context<'_>,
+            buf: &mut ReadBuf<'_>,
+        ) -> Poll<io::Result<()>> {
+            self.cnt += 1;
+            buf.put_slice(b"hello world");
+            Poll::Ready(Ok(()))
+        }
+    }
+
+    let mut buf = vec![];
+    let mut rd = Rd { cnt: 0 };
+
+    let n = assert_ok!(rd.read_buf(&mut buf).await);
+    assert_eq!(1, rd.cnt);
+    assert_eq!(n, 11);
+    assert_eq!(buf[..], b"hello world"[..]);
+}
+
+#[tokio::test]
+#[cfg(feature = "io-util")]
+async fn issue_5588() {
+    use bytes::BufMut;
+
+    // steps to zero
+    let mut buf = [0; 8];
+    let mut read_buf = ReadBuf::new(&mut buf);
+    assert_eq!(read_buf.remaining_mut(), 8);
+    assert_eq!(read_buf.chunk_mut().len(), 8);
+    unsafe {
+        read_buf.advance_mut(1);
+    }
+    assert_eq!(read_buf.remaining_mut(), 7);
+    assert_eq!(read_buf.chunk_mut().len(), 7);
+    unsafe {
+        read_buf.advance_mut(5);
+    }
+    assert_eq!(read_buf.remaining_mut(), 2);
+    assert_eq!(read_buf.chunk_mut().len(), 2);
+    unsafe {
+        read_buf.advance_mut(2);
+    }
+    assert_eq!(read_buf.remaining_mut(), 0);
+    assert_eq!(read_buf.chunk_mut().len(), 0);
+
+    // directly to zero
+    let mut buf = [0; 8];
+    let mut read_buf = ReadBuf::new(&mut buf);
+    assert_eq!(read_buf.remaining_mut(), 8);
+    assert_eq!(read_buf.chunk_mut().len(), 8);
+    unsafe {
+        read_buf.advance_mut(8);
+    }
+    assert_eq!(read_buf.remaining_mut(), 0);
+    assert_eq!(read_buf.chunk_mut().len(), 0);
+
+    // uninit
+    let mut buf = [std::mem::MaybeUninit::new(1); 8];
+    let mut uninit = ReadBuf::uninit(&mut buf);
+    assert_eq!(uninit.remaining_mut(), 8);
+    assert_eq!(uninit.chunk_mut().len(), 8);
+
+    let mut buf = [std::mem::MaybeUninit::uninit(); 8];
+    let mut uninit = ReadBuf::uninit(&mut buf);
+    unsafe {
+        uninit.advance_mut(4);
+    }
+    assert_eq!(uninit.remaining_mut(), 4);
+    assert_eq!(uninit.chunk_mut().len(), 4);
+    uninit.put_u8(1);
+    assert_eq!(uninit.remaining_mut(), 3);
+    assert_eq!(uninit.chunk_mut().len(), 3);
+    uninit.put_slice(&[1, 2, 3]);
+    assert_eq!(uninit.remaining_mut(), 0);
+    assert_eq!(uninit.chunk_mut().len(), 0);
+}

vendor/tokio/tests/io_read_exact.rs

@@ -0,0 +1,15 @@
+#![warn(rust_2018_idioms)]
+#![cfg(feature = "full")]
+
+use tokio::io::AsyncReadExt;
+use tokio_test::assert_ok;
+
+#[tokio::test]
+async fn read_exact() {
+    let mut buf = Box::new([0; 8]);
+    let mut rd: &[u8] = b"hello world";
+
+    let n = assert_ok!(rd.read_exact(&mut buf[..]).await);
+    assert_eq!(n, 8);
+    assert_eq!(buf[..], b"hello wo"[..]);
+}

vendor/tokio/tests/io_read_line.rs

@@ -0,0 +1,107 @@
+#![warn(rust_2018_idioms)]
+#![cfg(feature = "full")]
+
+use std::io::ErrorKind;
+use tokio::io::{AsyncBufReadExt, BufReader, Error};
+use tokio_test::{assert_ok, io::Builder};
+
+use std::io::Cursor;
+
+#[tokio::test]
+async fn read_line() {
+    let mut buf = String::new();
+    let mut rd = Cursor::new(b"hello\nworld\n\n");
+
+    let n = assert_ok!(rd.read_line(&mut buf).await);
+    assert_eq!(n, 6);
+    assert_eq!(buf, "hello\n");
+    buf.clear();
+    let n = assert_ok!(rd.read_line(&mut buf).await);
+    assert_eq!(n, 6);
+    assert_eq!(buf, "world\n");
+    buf.clear();
+    let n = assert_ok!(rd.read_line(&mut buf).await);
+    assert_eq!(n, 1);
+    assert_eq!(buf, "\n");
+    buf.clear();
+    let n = assert_ok!(rd.read_line(&mut buf).await);
+    assert_eq!(n, 0);
+    assert_eq!(buf, "");
+}
+
+#[tokio::test]
+async fn read_line_not_all_ready() {
+    let mock = Builder::new()
+        .read(b"Hello Wor")
+        .read(b"ld\nFizzBuz")
+        .read(b"z\n1\n2")
+        .build();
+
+    let mut read = BufReader::new(mock);
+
+    let mut line = "We say ".to_string();
+    let bytes = read.read_line(&mut line).await.unwrap();
+    assert_eq!(bytes, "Hello World\n".len());
+    assert_eq!(line.as_str(), "We say Hello World\n");
+
+    line = "I solve ".to_string();
+    let bytes = read.read_line(&mut line).await.unwrap();
+    assert_eq!(bytes, "FizzBuzz\n".len());
+    assert_eq!(line.as_str(), "I solve FizzBuzz\n");
+
+    line.clear();
+    let bytes = read.read_line(&mut line).await.unwrap();
+    assert_eq!(bytes, 2);
+    assert_eq!(line.as_str(), "1\n");
+
+    line.clear();
+    let bytes = read.read_line(&mut line).await.unwrap();
+    assert_eq!(bytes, 1);
+    assert_eq!(line.as_str(), "2");
+}
+
+#[tokio::test]
+async fn read_line_invalid_utf8() {
+    let mock = Builder::new().read(b"Hello Wor\xffld.\n").build();
+
+    let mut read = BufReader::new(mock);
+
+    let mut line = "Foo".to_string();
+    let err = read.read_line(&mut line).await.expect_err("Should fail");
+    assert_eq!(err.kind(), ErrorKind::InvalidData);
+    assert_eq!(err.to_string(), "stream did not contain valid UTF-8");
+    assert_eq!(line.as_str(), "Foo");
+}
+
+#[tokio::test]
+async fn read_line_fail() {
+    let mock = Builder::new()
+        .read(b"Hello Wor")
+        .read_error(Error::new(ErrorKind::Other, "The world has no end"))
+        .build();
+
+    let mut read = BufReader::new(mock);
+
+    let mut line = "Foo".to_string();
+    let err = read.read_line(&mut line).await.expect_err("Should fail");
+    assert_eq!(err.kind(), ErrorKind::Other);
+    assert_eq!(err.to_string(), "The world has no end");
+    assert_eq!(line.as_str(), "FooHello Wor");
+}
+
+#[tokio::test]
+async fn read_line_fail_and_utf8_fail() {
+    let mock = Builder::new()
+        .read(b"Hello Wor")
+        .read(b"\xff\xff\xff")
+        .read_error(Error::new(ErrorKind::Other, "The world has no end"))
+        .build();
+
+    let mut read = BufReader::new(mock);
+
+    let mut line = "Foo".to_string();
+    let err = read.read_line(&mut line).await.expect_err("Should fail");
+    assert_eq!(err.kind(), ErrorKind::Other);
+    assert_eq!(err.to_string(), "The world has no end");
+    assert_eq!(line.as_str(), "Foo");
+}

vendor/tokio/tests/io_read_to_end.rs

@@ -0,0 +1,125 @@
+#![warn(rust_2018_idioms)]
+#![cfg(feature = "full")]
+
+use std::pin::Pin;
+use std::task::{Context, Poll};
+use tokio::io::{AsyncRead, AsyncReadExt, ReadBuf};
+use tokio_test::assert_ok;
+use tokio_test::io::Builder;
+
+#[tokio::test]
+async fn read_to_end() {
+    let mut buf = vec![];
+    let mut rd: &[u8] = b"hello world";
+
+    let n = assert_ok!(rd.read_to_end(&mut buf).await);
+    assert_eq!(n, 11);
+    assert_eq!(buf[..], b"hello world"[..]);
+}
+
+#[derive(Copy, Clone, Debug)]
+enum State {
+    Initializing,
+    JustFilling,
+    Done,
+}
+
+struct UninitTest {
+    num_init: usize,
+    state: State,
+}
+
+impl AsyncRead for UninitTest {
+    fn poll_read(
+        self: Pin<&mut Self>,
+        _cx: &mut Context<'_>,
+        buf: &mut ReadBuf<'_>,
+    ) -> Poll<std::io::Result<()>> {
+        let me = Pin::into_inner(self);
+        let real_num_init = buf.initialized().len() - buf.filled().len();
+        assert_eq!(real_num_init, me.num_init, "{:?}", me.state);
+
+        match me.state {
+            State::Initializing => {
+                buf.initialize_unfilled_to(me.num_init + 2);
+                buf.advance(1);
+                me.num_init += 1;
+
+                if me.num_init == 24 {
+                    me.state = State::JustFilling;
+                }
+            }
+            State::JustFilling => {
+                buf.advance(1);
+                me.num_init -= 1;
+
+                if me.num_init == 15 {
+                    // The buffer is resized on next call.
+                    me.num_init = 0;
+                    me.state = State::Done;
+                }
+            }
+            State::Done => { /* .. do nothing .. */ }
+        }
+
+        Poll::Ready(Ok(()))
+    }
+}
+
+#[tokio::test]
+async fn read_to_end_uninit() {
+    let mut buf = Vec::with_capacity(64);
+    let mut test = UninitTest {
+        num_init: 0,
+        state: State::Initializing,
+    };
+
+    test.read_to_end(&mut buf).await.unwrap();
+    assert_eq!(buf.len(), 33);
+}
+
+#[tokio::test]
+#[cfg_attr(miri, ignore)] // too slow with miri
+async fn read_to_end_doesnt_grow_with_capacity() {
+    let arr: Vec<u8> = (0..100).collect();
+
+    // We only test from 32 since we allocate at least 32 bytes each time
+    for len in 32..100 {
+        let bytes = &arr[..len];
+        for split in 0..len {
+            for cap in 0..101 {
+                let mut mock = if split == 0 {
+                    Builder::new().read(bytes).build()
+                } else {
+                    Builder::new()
+                        .read(&bytes[..split])
+                        .read(&bytes[split..])
+                        .build()
+                };
+                let mut buf = Vec::with_capacity(cap);
+                AsyncReadExt::read_to_end(&mut mock, &mut buf)
+                    .await
+                    .unwrap();
+                // It has the right data.
+                assert_eq!(buf.as_slice(), bytes);
+                // Unless cap was smaller than length, then we did not reallocate.
+                if cap >= len {
+                    assert_eq!(buf.capacity(), cap);
+                }
+            }
+        }
+    }
+}
+
+#[tokio::test]
+async fn read_to_end_grows_capacity_if_unfit() {
+    let bytes = b"the_vector_startingcap_will_be_smaller";
+    let mut mock = Builder::new().read(bytes).build();
+    let initial_capacity = bytes.len() - 4;
+    let mut buf = Vec::with_capacity(initial_capacity);
+    AsyncReadExt::read_to_end(&mut mock, &mut buf)
+        .await
+        .unwrap();
+    // *4 since it doubles when it doesn't fit and again when reaching EOF
+    assert_eq!(buf.capacity(), initial_capacity * 4);
+}

vendor/tokio/tests/io_read_to_string.rs

@@ -0,0 +1,63 @@
+#![warn(rust_2018_idioms)]
+#![cfg(feature = "full")]
+
+use std::io;
+use tokio::io::AsyncReadExt;
+use tokio_test::assert_ok;
+use tokio_test::io::Builder;
+
+#[tokio::test]
+async fn read_to_string() {
+    let mut buf = String::new();
+    let mut rd: &[u8] = b"hello world";
+
+    let n = assert_ok!(rd.read_to_string(&mut buf).await);
+    assert_eq!(n, 11);
+    assert_eq!(buf[..], "hello world"[..]);
+}
+
+#[tokio::test]
+async fn to_string_does_not_truncate_on_utf8_error() {
+    let data = vec![0xff, 0xff, 0xff];
+
+    let mut s = "abc".to_string();
+
+    match AsyncReadExt::read_to_string(&mut data.as_slice(), &mut s).await {
+        Ok(len) => panic!("Should fail: {len} bytes."),
+        Err(err) if err.to_string() == "stream did not contain valid UTF-8" => {}
+        Err(err) => panic!("Fail: {err}."),
+    }
+
+    assert_eq!(s, "abc");
+}
+
+#[tokio::test]
+async fn to_string_does_not_truncate_on_io_error() {
+    let mut mock = Builder::new()
+        .read(b"def")
+        .read_error(io::Error::new(io::ErrorKind::Other, "whoops"))
+        .build();
+    let mut s = "abc".to_string();
+
+    match AsyncReadExt::read_to_string(&mut mock, &mut s).await {
+        Ok(len) => panic!("Should fail: {len} bytes."),
+        Err(err) if err.to_string() == "whoops" => {}
+        Err(err) => panic!("Fail: {err}."),
+    }
+
+    assert_eq!(s, "abc");
+}
+
+#[tokio::test]
+async fn to_string_appends() {
+    let data = b"def".to_vec();
+
+    let mut s = "abc".to_string();
+
+    let len = AsyncReadExt::read_to_string(&mut data.as_slice(), &mut s)
+        .await
+        .unwrap();
+
+    assert_eq!(len, 3);
+    assert_eq!(s, "abcdef");
+}

vendor/tokio/tests/io_read_until.rs

@@ -0,0 +1,74 @@
+#![warn(rust_2018_idioms)]
+#![cfg(feature = "full")]
+
+use std::io::ErrorKind;
+use tokio::io::{AsyncBufReadExt, BufReader, Error};
+use tokio_test::{assert_ok, io::Builder};
+
+#[tokio::test]
+async fn read_until() {
+    let mut buf = vec![];
+    let mut rd: &[u8] = b"hello world";
+
+    let n = assert_ok!(rd.read_until(b' ', &mut buf).await);
+    assert_eq!(n, 6);
+    assert_eq!(buf, b"hello ");
+    buf.clear();
+    let n = assert_ok!(rd.read_until(b' ', &mut buf).await);
+    assert_eq!(n, 5);
+    assert_eq!(buf, b"world");
+    buf.clear();
+    let n = assert_ok!(rd.read_until(b' ', &mut buf).await);
+    assert_eq!(n, 0);
+    assert_eq!(buf, []);
+}
+
+#[tokio::test]
+async fn read_until_not_all_ready() {
+    let mock = Builder::new()
+        .read(b"Hello Wor")
+        .read(b"ld#Fizz\xffBuz")
+        .read(b"z#1#2")
+        .build();
+
+    let mut read = BufReader::new(mock);
+
+    let mut chunk = b"We say ".to_vec();
+    let bytes = read.read_until(b'#', &mut chunk).await.unwrap();
+    assert_eq!(bytes, b"Hello World#".len());
+    assert_eq!(chunk, b"We say Hello World#");
+
+    chunk = b"I solve ".to_vec();
+    let bytes = read.read_until(b'#', &mut chunk).await.unwrap();
+    assert_eq!(bytes, b"Fizz\xffBuzz\n".len());
+    assert_eq!(chunk, b"I solve Fizz\xffBuzz#");
+
+    chunk.clear();
+    let bytes = read.read_until(b'#', &mut chunk).await.unwrap();
+    assert_eq!(bytes, 2);
+    assert_eq!(chunk, b"1#");
+
+    chunk.clear();
+    let bytes = read.read_until(b'#', &mut chunk).await.unwrap();
+    assert_eq!(bytes, 1);
+    assert_eq!(chunk, b"2");
+}
+
+#[tokio::test]
+async fn read_until_fail() {
+    let mock = Builder::new()
+        .read(b"Hello \xffWor")
+        .read_error(Error::new(ErrorKind::Other, "The world has no end"))
+        .build();
+
+    let mut read = BufReader::new(mock);
+
+    let mut chunk = b"Foo".to_vec();
+    let err = read
+        .read_until(b'#', &mut chunk)
+        .await
+        .expect_err("Should fail");
+    assert_eq!(err.kind(), ErrorKind::Other);
+    assert_eq!(err.to_string(), "The world has no end");
+    assert_eq!(chunk, b"FooHello \xffWor");
+}

vendor/tokio/tests/io_repeat.rs

@@ -0,0 +1,18 @@
+#![warn(rust_2018_idioms)]
+#![cfg(all(feature = "full", not(miri)))]
+
+use tokio::io::AsyncReadExt;
+
+#[tokio::test]
+async fn repeat_poll_read_is_cooperative() {
+    tokio::select! {
+        biased;
+        _ = async {
+            loop {
+                let mut buf = [0u8; 4096];
+                tokio::io::repeat(0b101).read_exact(&mut buf).await.unwrap();
+            }
+        } => {},
+        _ = tokio::task::yield_now() => {}
+    }
+}

vendor/tokio/tests/io_sink.rs

@@ -0,0 +1,44 @@
+#![warn(rust_2018_idioms)]
+#![cfg(feature = "full")]
+
+use tokio::io::AsyncWriteExt;
+
+#[tokio::test]
+async fn sink_poll_write_is_cooperative() {
+    tokio::select! {
+        biased;
+        _ = async {
+            loop {
+                let buf = vec![1, 2, 3];
+                tokio::io::sink().write_all(&buf).await.unwrap();
+            }
+        } => {},
+        _ = tokio::task::yield_now() => {}
+    }
+}
+
+#[tokio::test]
+async fn sink_poll_flush_is_cooperative() {
+    tokio::select! {
+        biased;
+        _ = async {
+            loop {
+                tokio::io::sink().flush().await.unwrap();
+            }
+        } => {},
+        _ = tokio::task::yield_now() => {}
+    }
+}
+
+#[tokio::test]
+async fn sink_poll_shutdown_is_cooperative() {
+    tokio::select! {
+        biased;
+        _ = async {
+            loop {
+                tokio::io::sink().shutdown().await.unwrap();
+            }
+        } => {},
+        _ = tokio::task::yield_now() => {}
+    }
+}

vendor/tokio/tests/io_split.rs

@@ -0,0 +1,114 @@
+#![warn(rust_2018_idioms)]
+#![cfg(all(feature = "full", not(target_os = "wasi")))] // Wasi does not support panic recovery
+
+use tokio::io::{
+    split, AsyncRead, AsyncReadExt, AsyncWrite, AsyncWriteExt, ReadBuf, ReadHalf, WriteHalf,
+};
+
+use std::io;
+use std::pin::Pin;
+use std::task::{Context, Poll};
+
+struct RW;
+
+impl AsyncRead for RW {
+    fn poll_read(
+        self: Pin<&mut Self>,
+        _cx: &mut Context<'_>,
+        buf: &mut ReadBuf<'_>,
+    ) -> Poll<io::Result<()>> {
+        buf.put_slice(b"z");
+        Poll::Ready(Ok(()))
+    }
+}
+
+impl AsyncWrite for RW {
+    fn poll_write(
+        self: Pin<&mut Self>,
+        _cx: &mut Context<'_>,
+        _buf: &[u8],
+    ) -> Poll<Result<usize, io::Error>> {
+        Poll::Ready(Ok(1))
+    }
+
+    fn poll_flush(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<Result<(), io::Error>> {
+        Poll::Ready(Ok(()))
+    }
+
+    fn poll_shutdown(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<Result<(), io::Error>> {
+        Poll::Ready(Ok(()))
+    }
+
+    fn poll_write_vectored(
+        self: Pin<&mut Self>,
+        _cx: &mut Context<'_>,
+        _bufs: &[io::IoSlice<'_>],
+    ) -> Poll<Result<usize, io::Error>> {
+        Poll::Ready(Ok(2))
+    }
+
+    fn is_write_vectored(&self) -> bool {
+        true
+    }
+}
+
+#[test]
+fn is_send_and_sync() {
+    fn assert_bound<T: Send + Sync>() {}
+
+    assert_bound::<ReadHalf<RW>>();
+    assert_bound::<WriteHalf<RW>>();
+}
+
+#[test]
+fn split_stream_id() {
+    let (r1, w1) = split(RW);
+    let (r2, w2) = split(RW);
+    assert!(r1.is_pair_of(&w1));
+    assert!(!r1.is_pair_of(&w2));
+    assert!(r2.is_pair_of(&w2));
+    assert!(!r2.is_pair_of(&w1));
+}
+
+#[test]
+fn unsplit_ok() {
+    let (r, w) = split(RW);
+    r.unsplit(w);
+}
+
+#[test]
+#[should_panic]
+fn unsplit_err1() {
+    let (r, _) = split(RW);
+    let (_, w) = split(RW);
+    r.unsplit(w);
+}
+
+#[test]
+#[should_panic]
+fn unsplit_err2() {
+    let (_, w) = split(RW);
+    let (r, _) = split(RW);
+    r.unsplit(w);
+}
+
+#[test]
+fn method_delegation() {
+    let (mut r, mut w) = split(RW);
+    let mut buf = [0; 1];
+
+    tokio_test::block_on(async move {
+        assert_eq!(1, r.read(&mut buf).await.unwrap());
+        assert_eq!(b'z', buf[0]);
+
+        assert_eq!(1, w.write(b"x").await.unwrap());
+        assert_eq!(
+            2,
+            w.write_vectored(&[io::IoSlice::new(b"x")]).await.unwrap()
+        );
+        assert!(w.is_write_vectored());
+
+        assert!(w.flush().await.is_ok());
+        assert!(w.shutdown().await.is_ok());
+    });
+}

vendor/tokio/tests/io_take.rs

@@ -0,0 +1,74 @@
+#![warn(rust_2018_idioms)]
+#![cfg(all(feature = "full", not(target_os = "wasi")))] // Wasi does not support panic recovery
+
+use std::pin::Pin;
+use std::task::{Context, Poll};
+use tokio::io::{self, AsyncRead, AsyncReadExt, ReadBuf};
+use tokio_test::assert_ok;
+
+mod support {
+    pub(crate) mod leaked_buffers;
+}
+use support::leaked_buffers::LeakedBuffers;
+
+#[tokio::test]
+async fn take() {
+    let mut buf = [0; 6];
+    let rd: &[u8] = b"hello world";
+
+    let mut rd = rd.take(4);
+    let n = assert_ok!(rd.read(&mut buf).await);
+    assert_eq!(n, 4);
+    assert_eq!(&buf, &b"hell\0\0"[..]);
+}
+
+#[tokio::test]
+async fn issue_4435() {
+    let mut buf = [0; 8];
+    let rd: &[u8] = b"hello world";
+
+    let rd = rd.take(4);
+    tokio::pin!(rd);
+
+    let mut read_buf = ReadBuf::new(&mut buf);
+    read_buf.put_slice(b"AB");
+
+    std::future::poll_fn(|cx| rd.as_mut().poll_read(cx, &mut read_buf))
+        .await
+        .unwrap();
+    assert_eq!(&buf, &b"ABhell\0\0"[..]);
+}
+
+struct BadReader {
+    leaked_buffers: LeakedBuffers,
+}
+
+impl BadReader {
+    fn new() -> Self {
+        Self {
+            leaked_buffers: LeakedBuffers::new(),
+        }
+    }
+}
+
+impl AsyncRead for BadReader {
+    fn poll_read(
+        mut self: Pin<&mut Self>,
+        _cx: &mut Context<'_>,
+        read_buf: &mut ReadBuf<'_>,
+    ) -> Poll<io::Result<()>> {
+        let mut buf = ReadBuf::new(unsafe { self.leaked_buffers.create(10) });
+        buf.put_slice(&[123; 10]);
+        *read_buf = buf;
+
+        Poll::Ready(Ok(()))
+    }
+}
+
+#[tokio::test]
+#[should_panic]
+async fn bad_reader_fails() {
+    let mut buf = Vec::with_capacity(10);
+
+    BadReader::new().take(10).read_buf(&mut buf).await.unwrap();
+}

vendor/tokio/tests/io_util_empty.rs

@@ -0,0 +1,61 @@
+#![cfg(feature = "full")]
+use tokio::io::{AsyncBufReadExt, AsyncReadExt, AsyncSeekExt};
+
+#[tokio::test]
+async fn empty_read_is_cooperative() {
+    tokio::select! {
+        biased;
+
+        _ = async {
+            loop {
+                let mut buf = [0u8; 4096];
+                let _ = tokio::io::empty().read(&mut buf).await;
+            }
+        } => {},
+        _ = tokio::task::yield_now() => {}
+    }
+}
+
+#[tokio::test]
+async fn empty_buf_reads_are_cooperative() {
+    tokio::select! {
+        biased;
+
+        _ = async {
+            loop {
+                let mut buf = String::new();
+                let _ = tokio::io::empty().read_line(&mut buf).await;
+            }
+        } => {},
+        _ = tokio::task::yield_now() => {}
+    }
+}
+
+#[tokio::test]
+async fn empty_seek() {
+    use std::io::SeekFrom;
+
+    let mut empty = tokio::io::empty();
+
+    assert!(matches!(empty.seek(SeekFrom::Start(0)).await, Ok(0)));
+    assert!(matches!(empty.seek(SeekFrom::Start(1)).await, Ok(0)));
+    assert!(matches!(empty.seek(SeekFrom::Start(u64::MAX)).await, Ok(0)));
+
+    assert!(matches!(empty.seek(SeekFrom::End(i64::MIN)).await, Ok(0)));
+    assert!(matches!(empty.seek(SeekFrom::End(-1)).await, Ok(0)));
+    assert!(matches!(empty.seek(SeekFrom::End(0)).await, Ok(0)));
+    assert!(matches!(empty.seek(SeekFrom::End(1)).await, Ok(0)));
+    assert!(matches!(empty.seek(SeekFrom::End(i64::MAX)).await, Ok(0)));
+
+    assert!(matches!(
+        empty.seek(SeekFrom::Current(i64::MIN)).await,
+        Ok(0)
+    ));
+    assert!(matches!(empty.seek(SeekFrom::Current(-1)).await, Ok(0)));
+    assert!(matches!(empty.seek(SeekFrom::Current(0)).await, Ok(0)));
+    assert!(matches!(empty.seek(SeekFrom::Current(1)).await, Ok(0)));
+    assert!(matches!(
+        empty.seek(SeekFrom::Current(i64::MAX)).await,
+        Ok(0)
+    ));
+}

vendor/tokio/tests/io_write.rs

@@ -0,0 +1,58 @@
+#![warn(rust_2018_idioms)]
+#![cfg(feature = "full")]
+
+use tokio::io::{AsyncWrite, AsyncWriteExt};
+use tokio_test::assert_ok;
+
+use bytes::BytesMut;
+use std::io;
+use std::pin::Pin;
+use std::task::{Context, Poll};
+
+#[tokio::test]
+async fn write() {
+    struct Wr {
+        buf: BytesMut,
+        cnt: usize,
+    }
+
+    impl AsyncWrite for Wr {
+        fn poll_write(
+            mut self: Pin<&mut Self>,
+            _cx: &mut Context<'_>,
+            buf: &[u8],
+        ) -> Poll<io::Result<usize>> {
+            assert_eq!(self.cnt, 0);
+            self.buf.extend(&buf[0..4]);
+            Ok(4).into()
+        }
+
+        fn poll_flush(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+            Ok(()).into()
+        }
+
+        fn poll_shutdown(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+            Ok(()).into()
+        }
+    }
+
+    let mut wr = Wr {
+        buf: BytesMut::with_capacity(64),
+        cnt: 0,
+    };
+
+    let n = assert_ok!(wr.write(b"hello world").await);
+    assert_eq!(n, 4);
+    assert_eq!(wr.buf, b"hell"[..]);
+}
+
+#[tokio::test]
+async fn write_cursor() {
+    use std::io::Cursor;
+
+    let mut wr = Cursor::new(Vec::new());
+
+    let n = assert_ok!(wr.write(b"hello world").await);
+    assert_eq!(n, 11);
+    assert_eq!(wr.get_ref().as_slice(), &b"hello world"[..]);
+}

vendor/tokio/tests/io_write_all.rs

@@ -0,0 +1,51 @@
+#![warn(rust_2018_idioms)]
+#![cfg(feature = "full")]
+
+use tokio::io::{AsyncWrite, AsyncWriteExt};
+use tokio_test::assert_ok;
+
+use bytes::BytesMut;
+use std::cmp;
+use std::io;
+use std::pin::Pin;
+use std::task::{Context, Poll};
+
+#[tokio::test]
+async fn write_all() {
+    struct Wr {
+        buf: BytesMut,
+        cnt: usize,
+    }
+
+    impl AsyncWrite for Wr {
+        fn poll_write(
+            mut self: Pin<&mut Self>,
+            _cx: &mut Context<'_>,
+            buf: &[u8],
+        ) -> Poll<io::Result<usize>> {
+            let n = cmp::min(4, buf.len());
+            let buf = &buf[0..n];
+
+            self.cnt += 1;
+            self.buf.extend(buf);
+            Ok(buf.len()).into()
+        }
+
+        fn poll_flush(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+            Ok(()).into()
+        }
+
+        fn poll_shutdown(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+            Ok(()).into()
+        }
+    }
+
+    let mut wr = Wr {
+        buf: BytesMut::with_capacity(64),
+        cnt: 0,
+    };
+
+    assert_ok!(wr.write_all(b"hello world").await);
+    assert_eq!(wr.buf, b"hello world"[..]);
+    assert_eq!(wr.cnt, 3);
+}

vendor/tokio/tests/io_write_all_buf.rs

@@ -0,0 +1,145 @@
+#![warn(rust_2018_idioms)]
+#![cfg(feature = "full")]
+
+use tokio::io::{AsyncWrite, AsyncWriteExt};
+use tokio_test::{assert_err, assert_ok};
+
+use bytes::{Buf, Bytes, BytesMut};
+use std::cmp;
+use std::io;
+use std::pin::Pin;
+use std::task::{Context, Poll};
+
+#[tokio::test]
+async fn write_all_buf() {
+    struct Wr {
+        buf: BytesMut,
+        cnt: usize,
+    }
+
+    impl AsyncWrite for Wr {
+        fn poll_write(
+            mut self: Pin<&mut Self>,
+            _cx: &mut Context<'_>,
+            buf: &[u8],
+        ) -> Poll<io::Result<usize>> {
+            let n = cmp::min(4, buf.len());
+            dbg!(buf);
+            let buf = &buf[0..n];
+
+            self.cnt += 1;
+            self.buf.extend(buf);
+            Ok(buf.len()).into()
+        }
+
+        fn poll_flush(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+            Ok(()).into()
+        }
+
+        fn poll_shutdown(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+            Ok(()).into()
+        }
+    }
+
+    let mut wr = Wr {
+        buf: BytesMut::with_capacity(64),
+        cnt: 0,
+    };
+
+    let mut buf = Bytes::from_static(b"hello").chain(Bytes::from_static(b"world"));
+
+    assert_ok!(wr.write_all_buf(&mut buf).await);
+    assert_eq!(wr.buf, b"helloworld"[..]);
+    // expect 4 writes, [hell],[o],[worl],[d]
+    assert_eq!(wr.cnt, 4);
+    assert!(!buf.has_remaining());
+}
+
+#[tokio::test]
+async fn write_buf_err() {
+    /// Error out after writing the first 4 bytes
+    struct Wr {
+        cnt: usize,
+    }
+
+    impl AsyncWrite for Wr {
+        fn poll_write(
+            mut self: Pin<&mut Self>,
+            _cx: &mut Context<'_>,
+            _buf: &[u8],
+        ) -> Poll<io::Result<usize>> {
+            self.cnt += 1;
+            if self.cnt == 2 {
+                return Poll::Ready(Err(io::Error::new(io::ErrorKind::Other, "whoops")));
+            }
+            Poll::Ready(Ok(4))
+        }
+
+        fn poll_flush(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+            Ok(()).into()
+        }
+
+        fn poll_shutdown(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+            Ok(()).into()
+        }
+    }
+
+    let mut wr = Wr { cnt: 0 };
+
+    let mut buf = Bytes::from_static(b"hello").chain(Bytes::from_static(b"world"));
+
+    assert_err!(wr.write_all_buf(&mut buf).await);
+    assert_eq!(
+        buf.copy_to_bytes(buf.remaining()),
+        Bytes::from_static(b"oworld")
+    );
+}
+
+#[tokio::test]
+async fn write_all_buf_vectored() {
+    struct Wr {
+        buf: BytesMut,
+    }
+    impl AsyncWrite for Wr {
+        fn poll_write(
+            self: Pin<&mut Self>,
+            _cx: &mut Context<'_>,
+            _buf: &[u8],
+        ) -> Poll<io::Result<usize>> {
+            // When executing `write_all_buf` with this writer,
+            // `poll_write` is not called.
+            panic!("shouldn't be called")
+        }
+        fn poll_flush(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+            Ok(()).into()
+        }
+        fn poll_shutdown(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+            Ok(()).into()
+        }
+        fn poll_write_vectored(
+            mut self: Pin<&mut Self>,
+            _cx: &mut Context<'_>,
+            bufs: &[io::IoSlice<'_>],
+        ) -> Poll<Result<usize, io::Error>> {
+            for buf in bufs {
+                self.buf.extend_from_slice(buf);
+            }
+            let n = self.buf.len();
+            Ok(n).into()
+        }
+        fn is_write_vectored(&self) -> bool {
+            // Enable vectored write.
+            true
+        }
+    }
+
+    let mut wr = Wr {
+        buf: BytesMut::with_capacity(64),
+    };
+    let mut buf = Bytes::from_static(b"hello")
+        .chain(Bytes::from_static(b" "))
+        .chain(Bytes::from_static(b"world"));
+
+    wr.write_all_buf(&mut buf).await.unwrap();
+    assert_eq!(&wr.buf[..], b"hello world");
+}

vendor/tokio/tests/io_write_buf.rs

@@ -0,0 +1,112 @@
+#![warn(rust_2018_idioms)]
+#![cfg(feature = "full")]
+
+use tokio::io::{AsyncWrite, AsyncWriteExt};
+use tokio_test::assert_ok;
+
+use bytes::BytesMut;
+use std::cmp;
+use std::io::{self, Cursor};
+use std::pin::Pin;
+use std::task::{Context, Poll};
+
+#[tokio::test]
+async fn write_all() {
+    struct Wr {
+        buf: BytesMut,
+        cnt: usize,
+    }
+
+    impl AsyncWrite for Wr {
+        fn poll_write(
+            mut self: Pin<&mut Self>,
+            _cx: &mut Context<'_>,
+            buf: &[u8],
+        ) -> Poll<io::Result<usize>> {
+            assert_eq!(self.cnt, 0);
+
+            let n = cmp::min(4, buf.len());
+            let buf = &buf[0..n];
+
+            self.cnt += 1;
+            self.buf.extend(buf);
+            Ok(buf.len()).into()
+        }
+
+        fn poll_flush(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+            Ok(()).into()
+        }
+
+        fn poll_shutdown(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+            Ok(()).into()
+        }
+    }
+
+    let mut wr = Wr {
+        buf: BytesMut::with_capacity(64),
+        cnt: 0,
+    };
+
+    let mut buf = Cursor::new(&b"hello world"[..]);
+
+    assert_ok!(wr.write_buf(&mut buf).await);
+    assert_eq!(wr.buf, b"hell"[..]);
+    assert_eq!(wr.cnt, 1);
+    assert_eq!(buf.position(), 4);
+}
+
+#[tokio::test]
+async fn write_buf_vectored() {
+    struct Wr {
+        buf: BytesMut,
+        cnt: usize,
+    }
+
+    impl AsyncWrite for Wr {
+        fn poll_write(
+            self: Pin<&mut Self>,
+            _cx: &mut Context<'_>,
+            _buf: &[u8],
+        ) -> Poll<io::Result<usize>> {
+            panic!("shouldn't be called")
+        }
+
+        fn poll_flush(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+            Ok(()).into()
+        }
+
+        fn poll_shutdown(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+            Ok(()).into()
+        }
+
+        fn poll_write_vectored(
+            mut self: Pin<&mut Self>,
+            _cx: &mut Context<'_>,
+            bufs: &[io::IoSlice<'_>],
+        ) -> Poll<Result<usize, io::Error>> {
+            let mut n = 0;
+            for buf in bufs {
+                self.buf.extend_from_slice(buf);
+                n += buf.len();
+            }
+            self.cnt += 1;
+            Ok(n).into()
+        }
+
+        fn is_write_vectored(&self) -> bool {
+            true
+        }
+    }
+
+    let mut wr = Wr {
+        buf: BytesMut::with_capacity(64),
+        cnt: 0,
+    };
+
+    let mut buf = Cursor::new(&b"hello world"[..]);
+
+    assert_ok!(wr.write_buf(&mut buf).await);
+    assert_eq!(wr.buf, b"hello world"[..]);
+    assert_eq!(wr.cnt, 1);
+    assert_eq!(buf.position(), 11);
+}

vendor/tokio/tests/io_write_int.rs

@@ -0,0 +1,37 @@
+#![warn(rust_2018_idioms)]
+#![cfg(feature = "full")]
+
+use tokio::io::{AsyncWrite, AsyncWriteExt};
+
+use std::io;
+use std::pin::Pin;
+use std::task::{Context, Poll};
+
+#[tokio::test]
+async fn write_int_should_err_if_write_count_0() {
+    struct Wr {}
+
+    impl AsyncWrite for Wr {
+        fn poll_write(
+            self: Pin<&mut Self>,
+            _cx: &mut Context<'_>,
+            _buf: &[u8],
+        ) -> Poll<io::Result<usize>> {
+            Ok(0).into()
+        }
+
+        fn poll_flush(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+            Ok(()).into()
+        }
+
+        fn poll_shutdown(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+            Ok(()).into()
+        }
+    }
+
+    let mut wr = Wr {};
+
+    // should be ok just to test these 2, other cases actually expanded by same macro.
+    assert!(wr.write_i8(0).await.is_err());
+    assert!(wr.write_i32(12).await.is_err());
+}

vendor/tokio/tests/join_handle_panic.rs

@@ -0,0 +1,21 @@
+#![warn(rust_2018_idioms)]
+#![cfg(all(feature = "full", not(target_os = "wasi")))] // Wasi doesn't support panic recovery
+#![cfg(panic = "unwind")]
+
+struct PanicsOnDrop;
+
+impl Drop for PanicsOnDrop {
+    fn drop(&mut self) {
+        panic!("I told you so");
+    }
+}
+
+#[tokio::test]
+async fn test_panics_do_not_propagate_when_dropping_join_handle() {
+    let join_handle = tokio::spawn(async move { PanicsOnDrop });
+
+    // only drop the JoinHandle when the task has completed
+    // (which is difficult to synchronize precisely)
+    tokio::time::sleep(std::time::Duration::from_millis(3)).await;
+    drop(join_handle);
+}

vendor/tokio/tests/macros_join.rs

@@ -0,0 +1,256 @@
+#![cfg(feature = "macros")]
+#![allow(clippy::disallowed_names)]
+use std::sync::Arc;
+
+#[cfg(all(target_family = "wasm", not(target_os = "wasi")))]
+#[cfg(target_pointer_width = "64")]
+use wasm_bindgen_test::wasm_bindgen_test as test;
+#[cfg(all(target_family = "wasm", not(target_os = "wasi")))]
+use wasm_bindgen_test::wasm_bindgen_test as maybe_tokio_test;
+
+#[cfg(not(all(target_family = "wasm", not(target_os = "wasi"))))]
+use tokio::test as maybe_tokio_test;
+
+use tokio::sync::{oneshot, Semaphore};
+use tokio_test::{assert_pending, assert_ready, task};
+
+#[maybe_tokio_test]
+async fn sync_one_lit_expr_comma() {
+    let foo = tokio::join!(async { 1 },);
+    assert_eq!(foo, (1,));
+
+    let foo = tokio::join!(biased; async { 1 },);
+    assert_eq!(foo, (1,));
+}
+
+#[maybe_tokio_test]
+async fn sync_one_lit_expr_no_comma() {
+    let foo = tokio::join!(async { 1 });
+    assert_eq!(foo, (1,));
+
+    let foo = tokio::join!(biased; async { 1 });
+    assert_eq!(foo, (1,));
+}
+
+#[maybe_tokio_test]
+async fn sync_two_lit_expr_comma() {
+    let foo = tokio::join!(async { 1 }, async { 2 },);
+    assert_eq!(foo, (1, 2));
+
+    let foo = tokio::join!(biased; async { 1 }, async { 2 },);
+    assert_eq!(foo, (1, 2));
+}
+
+#[maybe_tokio_test]
+async fn sync_two_lit_expr_no_comma() {
+    let foo = tokio::join!(async { 1 }, async { 2 });
+    assert_eq!(foo, (1, 2));
+
+    let foo = tokio::join!(biased; async { 1 }, async { 2 });
+    assert_eq!(foo, (1, 2));
+}
+
+#[maybe_tokio_test]
+async fn two_await() {
+    let (tx1, rx1) = oneshot::channel::<&str>();
+    let (tx2, rx2) = oneshot::channel::<u32>();
+
+    let mut join = task::spawn(async {
+        tokio::join!(async { rx1.await.unwrap() }, async { rx2.await.unwrap() })
+    });
+
+    assert_pending!(join.poll());
+
+    tx2.send(123).unwrap();
+    assert!(join.is_woken());
+    assert_pending!(join.poll());
+
+    tx1.send("hello").unwrap();
+    assert!(join.is_woken());
+    let res = assert_ready!(join.poll());
+
+    assert_eq!(("hello", 123), res);
+}
+
+#[test]
+#[cfg(target_pointer_width = "64")]
+fn join_size() {
+    use futures::future;
+    use std::mem;
+
+    let fut = async {
+        let ready = future::ready(0i32);
+        tokio::join!(ready)
+    };
+    assert_eq!(mem::size_of_val(&fut), 32);
+
+    let fut = async {
+        let ready1 = future::ready(0i32);
+        let ready2 = future::ready(0i32);
+        tokio::join!(ready1, ready2)
+    };
+    assert_eq!(mem::size_of_val(&fut), 48);
+}
+
+async fn non_cooperative_task(permits: Arc<Semaphore>) -> usize {
+    let mut exceeded_budget = 0;
+
+    for _ in 0..5 {
+        // Another task should run after this task uses its whole budget
+        for _ in 0..128 {
+            let _permit = permits.clone().acquire_owned().await.unwrap();
+        }
+
+        exceeded_budget += 1;
+    }
+
+    exceeded_budget
+}
+
+async fn poor_little_task(permits: Arc<Semaphore>) -> usize {
+    let mut how_many_times_i_got_to_run = 0;
+
+    for _ in 0..5 {
+        let _permit = permits.clone().acquire_owned().await.unwrap();
+        how_many_times_i_got_to_run += 1;
+    }
+
+    how_many_times_i_got_to_run
+}
+
+#[tokio::test]
+async fn join_does_not_allow_tasks_to_starve() {
+    let permits = Arc::new(Semaphore::new(1));
+
+    // non_cooperative_task should yield after its budget is exceeded and then poor_little_task should run.
+    let (non_cooperative_result, little_task_result) = tokio::join!(
+        non_cooperative_task(Arc::clone(&permits)),
+        poor_little_task(permits)
+    );
+
+    assert_eq!(5, non_cooperative_result);
+    assert_eq!(5, little_task_result);
+}
+
+#[tokio::test]
+async fn a_different_future_is_polled_first_every_time_poll_fn_is_polled() {
+    let poll_order = Arc::new(std::sync::Mutex::new(vec![]));
+
+    let fut = |x, poll_order: Arc<std::sync::Mutex<Vec<i32>>>| async move {
+        for _ in 0..4 {
+            {
+                let mut guard = poll_order.lock().unwrap();
+
+                guard.push(x);
+            }
+
+            tokio::task::yield_now().await;
+        }
+    };
+
+    tokio::join!(
+        fut(1, Arc::clone(&poll_order)),
+        fut(2, Arc::clone(&poll_order)),
+        fut(3, Arc::clone(&poll_order)),
+    );
+
+    // Each time the future created by join! is polled, it should start
+    // by polling a different future first.
+    assert_eq!(
+        vec![1, 2, 3, 2, 3, 1, 3, 1, 2, 1, 2, 3],
+        *poll_order.lock().unwrap()
+    );
+}
+
+#[tokio::test]
+async fn futures_are_polled_in_order_in_biased_mode() {
+    let poll_order = Arc::new(std::sync::Mutex::new(vec![]));
+
+    let fut = |x, poll_order: Arc<std::sync::Mutex<Vec<i32>>>| async move {
+        for _ in 0..4 {
+            {
+                let mut guard = poll_order.lock().unwrap();
+
+                guard.push(x);
+            }
+
+            tokio::task::yield_now().await;
+        }
+    };
+
+    tokio::join!(
+        biased;
+        fut(1, Arc::clone(&poll_order)),
+        fut(2, Arc::clone(&poll_order)),
+        fut(3, Arc::clone(&poll_order)),
+    );
+
+    // Each time the future created by join! is polled, it should start
+    // by polling in the order as declared in the macro inputs.
+    assert_eq!(
+        vec![1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3],
+        *poll_order.lock().unwrap()
+    );
+}
+
+#[test]
+#[cfg(target_pointer_width = "64")]
+fn join_size_biased() {
+    use futures::future;
+    use std::mem;
+
+    let fut = async {
+        let ready = future::ready(0i32);
+        tokio::join!(biased; ready)
+    };
+    assert_eq!(mem::size_of_val(&fut), 24);
+
+    let fut = async {
+        let ready1 = future::ready(0i32);
+        let ready2 = future::ready(0i32);
+        tokio::join!(biased; ready1, ready2)
+    };
+    assert_eq!(mem::size_of_val(&fut), 40);
+}
+
+#[tokio::test]
+#[allow(clippy::unit_cmp)]
+async fn empty_join() {
+    assert_eq!(tokio::join!(), ());
+    assert_eq!(tokio::join!(biased;), ());
+}
+
+#[tokio::test]
+async fn join_into_future() {
+    struct NotAFuture;
+    impl std::future::IntoFuture for NotAFuture {
+        type Output = ();
+        type IntoFuture = std::future::Ready<()>;
+
+        fn into_future(self) -> Self::IntoFuture {
+            std::future::ready(())
+        }
+    }
+
+    tokio::join!(NotAFuture);
+}
+
+// Regression test for: https://github.com/tokio-rs/tokio/issues/7637
+// We want to make sure that the `const COUNT: u32` declaration
+// inside the macro body doesn't leak to the caller to cause compiler failures
+// or variable shadowing.
+#[tokio::test]
+async fn caller_names_const_count() {
+    let (tx, rx) = oneshot::channel::<u32>();
+
+    const COUNT: u32 = 2;
+
+    let mut join = task::spawn(async { tokio::join!(async { tx.send(COUNT).unwrap() }) });
+    assert_ready!(join.poll());
+
+    let res = rx.await.unwrap();
+
+    // This passing demonstrates that the const in the macro is
+    // not shadowing the caller-specified COUNT value
+    assert_eq!(2, res);
+}

vendor/tokio/tests/macros_pin.rs

@@ -0,0 +1,21 @@
+#![cfg(feature = "macros")]
+
+#[cfg(all(target_family = "wasm", not(target_os = "wasi")))]
+use wasm_bindgen_test::wasm_bindgen_test as maybe_tokio_test;
+
+#[cfg(not(all(target_family = "wasm", not(target_os = "wasi"))))]
+use tokio::test as maybe_tokio_test;
+
+async fn one() {}
+async fn two() {}
+
+#[maybe_tokio_test]
+async fn multi_pin() {
+    tokio::pin! {
+        let f1 = one();
+        let f2 = two();
+    }
+
+    (&mut f1).await;
+    (&mut f2).await;
+}

vendor/tokio/tests/macros_rename_test.rs

@@ -0,0 +1,35 @@
+#![cfg(all(feature = "full", not(target_os = "wasi")))] // Wasi doesn't support threading
+
+#[allow(unused_imports)]
+use std as tokio;
+
+use ::tokio as tokio1;
+
+mod test {
+    pub use ::tokio;
+}
+
+async fn compute() -> usize {
+    let join = tokio1::spawn(async { 1 });
+    join.await.unwrap()
+}
+
+#[tokio1::main(crate = "tokio1")]
+async fn compute_main() -> usize {
+    compute().await
+}
+
+#[test]
+fn crate_rename_main() {
+    assert_eq!(1, compute_main());
+}
+
+#[tokio1::test(crate = "tokio1")]
+async fn crate_rename_test() {
+    assert_eq!(1, compute().await);
+}
+
+#[test::tokio::test(crate = "test::tokio")]
+async fn crate_path_test() {
+    assert_eq!(1, compute().await);
+}

vendor/tokio/tests/macros_select.rs

@@ -0,0 +1,760 @@
+#![cfg(feature = "macros")]
+#![allow(clippy::disallowed_names)]
+
+#[cfg(all(target_family = "wasm", not(target_os = "wasi")))]
+use wasm_bindgen_test::wasm_bindgen_test as maybe_tokio_test;
+
+#[cfg(not(all(target_family = "wasm", not(target_os = "wasi"))))]
+use tokio::test as maybe_tokio_test;
+
+use tokio::sync::oneshot;
+use tokio_test::{assert_ok, assert_pending, assert_ready};
+
+use std::future::poll_fn;
+use std::task::Poll::Ready;
+
+#[maybe_tokio_test]
+async fn sync_one_lit_expr_comma() {
+    let foo = tokio::select! {
+        foo = async { 1 } => foo,
+    };
+
+    assert_eq!(foo, 1);
+}
+
+#[maybe_tokio_test]
+async fn no_branch_else_only() {
+    let foo = tokio::select! {
+        else => 1,
+    };
+
+    assert_eq!(foo, 1);
+}
+
+#[maybe_tokio_test]
+async fn no_branch_else_only_biased() {
+    let foo = tokio::select! {
+        biased;
+        else => 1,
+    };
+
+    assert_eq!(foo, 1);
+}
+
+#[maybe_tokio_test]
+async fn nested_one() {
+    let foo = tokio::select! {
+        foo = async { 1 } => tokio::select! {
+            bar = async { foo } => bar,
+        },
+    };
+
+    assert_eq!(foo, 1);
+}
+
+#[maybe_tokio_test]
+async fn sync_one_lit_expr_no_comma() {
+    let foo = tokio::select! {
+        foo = async { 1 } => foo
+    };
+
+    assert_eq!(foo, 1);
+}
+
+#[maybe_tokio_test]
+async fn sync_one_lit_expr_block() {
+    let foo = tokio::select! {
+        foo = async { 1 } => { foo }
+    };
+
+    assert_eq!(foo, 1);
+}
+
+#[maybe_tokio_test]
+async fn sync_one_await() {
+    let foo = tokio::select! {
+        foo = one() => foo,
+    };
+
+    assert_eq!(foo, 1);
+}
+
+#[maybe_tokio_test]
+async fn sync_one_ident() {
+    let one = one();
+
+    let foo = tokio::select! {
+        foo = one => foo,
+    };
+
+    assert_eq!(foo, 1);
+}
+
+#[maybe_tokio_test]
+async fn sync_two() {
+    use std::cell::Cell;
+
+    let cnt = Cell::new(0);
+
+    let res = tokio::select! {
+        foo = async {
+            cnt.set(cnt.get() + 1);
+            1
+        } => foo,
+        bar = async {
+            cnt.set(cnt.get() + 1);
+            2
+        } => bar,
+    };
+
+    assert_eq!(1, cnt.get());
+    assert!(res == 1 || res == 2);
+}
+
+#[maybe_tokio_test]
+async fn drop_in_fut() {
+    let s = "hello".to_string();
+
+    let res = tokio::select! {
+        foo = async {
+            let v = one().await;
+            drop(s);
+            v
+        } => foo
+    };
+
+    assert_eq!(res, 1);
+}
+
+#[maybe_tokio_test]
+#[cfg(feature = "full")]
+async fn one_ready() {
+    let (tx1, rx1) = oneshot::channel::<i32>();
+    let (_tx2, rx2) = oneshot::channel::<i32>();
+
+    tx1.send(1).unwrap();
+
+    let v = tokio::select! {
+        res = rx1 => {
+            assert_ok!(res)
+        },
+        _ = rx2 => unreachable!(),
+    };
+
+    assert_eq!(1, v);
+}
+
+#[maybe_tokio_test]
+#[cfg(feature = "full")]
+async fn select_streams() {
+    use tokio::sync::mpsc;
+
+    let (tx1, mut rx1) = mpsc::unbounded_channel::<i32>();
+    let (tx2, mut rx2) = mpsc::unbounded_channel::<i32>();
+
+    tokio::spawn(async move {
+        assert_ok!(tx2.send(1));
+        tokio::task::yield_now().await;
+
+        assert_ok!(tx1.send(2));
+        tokio::task::yield_now().await;
+
+        assert_ok!(tx2.send(3));
+        tokio::task::yield_now().await;
+
+        drop((tx1, tx2));
+    });
+
+    let mut rem = true;
+    let mut msgs = vec![];
+
+    while rem {
+        tokio::select! {
+            Some(x) = rx1.recv() => {
+                msgs.push(x);
+            }
+            Some(y) = rx2.recv() => {
+                msgs.push(y);
+            }
+            else => {
+                rem = false;
+            }
+        }
+    }
+
+    msgs.sort_unstable();
+    assert_eq!(&msgs[..], &[1, 2, 3]);
+}
+
+#[maybe_tokio_test]
+async fn move_uncompleted_futures() {
+    let (tx1, mut rx1) = oneshot::channel::<i32>();
+    let (tx2, mut rx2) = oneshot::channel::<i32>();
+
+    tx1.send(1).unwrap();
+    tx2.send(2).unwrap();
+
+    let ran;
+
+    tokio::select! {
+        res = &mut rx1 => {
+            assert_eq!(1, assert_ok!(res));
+            assert_eq!(2, assert_ok!(rx2.await));
+            ran = true;
+        },
+        res = &mut rx2 => {
+            assert_eq!(2, assert_ok!(res));
+            assert_eq!(1, assert_ok!(rx1.await));
+            ran = true;
+        },
+    }
+
+    assert!(ran);
+}
+
+#[maybe_tokio_test]
+async fn nested() {
+    let res = tokio::select! {
+        x = async { 1 } => {
+            tokio::select! {
+                y = async { 2 } => x + y,
+            }
+        }
+    };
+
+    assert_eq!(res, 3);
+}
+
+#[cfg(target_pointer_width = "64")]
+mod pointer_64_tests {
+    use super::maybe_tokio_test;
+    use futures::future;
+    use std::mem;
+
+    #[maybe_tokio_test]
+    async fn struct_size_1() {
+        let fut = async {
+            let ready = future::ready(0i32);
+
+            tokio::select! {
+                _ = ready => {},
+            }
+        };
+
+        assert_eq!(mem::size_of_val(&fut), 32);
+    }
+
+    #[maybe_tokio_test]
+    async fn struct_size_2() {
+        let fut = async {
+            let ready1 = future::ready(0i32);
+            let ready2 = future::ready(0i32);
+
+            tokio::select! {
+                _ = ready1 => {},
+                _ = ready2 => {},
+            }
+        };
+
+        assert_eq!(mem::size_of_val(&fut), 40);
+    }
+
+    #[maybe_tokio_test]
+    async fn struct_size_3() {
+        let fut = async {
+            let ready1 = future::ready(0i32);
+            let ready2 = future::ready(0i32);
+            let ready3 = future::ready(0i32);
+
+            tokio::select! {
+                _ = ready1 => {},
+                _ = ready2 => {},
+                _ = ready3 => {},
+            }
+        };
+
+        assert_eq!(mem::size_of_val(&fut), 48);
+    }
+}
+
+#[maybe_tokio_test]
+async fn mutable_borrowing_future_with_same_borrow_in_block() {
+    let mut value = 234;
+
+    tokio::select! {
+        _ = require_mutable(&mut value) => { },
+        _ = async_noop() => {
+            value += 5;
+        },
+    }
+
+    assert!(value >= 234);
+}
+
+#[maybe_tokio_test]
+async fn mutable_borrowing_future_with_same_borrow_in_block_and_else() {
+    let mut value = 234;
+
+    tokio::select! {
+        _ = require_mutable(&mut value) => { },
+        _ = async_noop() => {
+            value += 5;
+        },
+        else => {
+            value += 27;
+        },
+    }
+
+    assert!(value >= 234);
+}
+
+#[maybe_tokio_test]
+async fn future_panics_after_poll() {
+    use tokio_test::task;
+
+    let (tx, rx) = oneshot::channel();
+
+    let mut polled = false;
+
+    let f = poll_fn(|_| {
+        assert!(!polled);
+        polled = true;
+        Ready(None::<()>)
+    });
+
+    let mut f = task::spawn(async {
+        tokio::select! {
+            Some(_) = f => unreachable!(),
+            ret = rx => ret.unwrap(),
+        }
+    });
+
+    assert_pending!(f.poll());
+    assert_pending!(f.poll());
+
+    assert_ok!(tx.send(1));
+
+    let res = assert_ready!(f.poll());
+    assert_eq!(1, res);
+}
+
+#[maybe_tokio_test]
+async fn disable_with_if() {
+    use tokio_test::task;
+
+    let f = poll_fn(|_| panic!());
+    let (tx, rx) = oneshot::channel();
+
+    let mut f = task::spawn(async {
+        tokio::select! {
+            _ = f, if false => unreachable!(),
+            _ = rx => (),
+        }
+    });
+
+    assert_pending!(f.poll());
+
+    assert_ok!(tx.send(()));
+    assert!(f.is_woken());
+
+    assert_ready!(f.poll());
+}
+
+#[maybe_tokio_test]
+async fn join_with_select() {
+    use tokio_test::task;
+
+    let (tx1, mut rx1) = oneshot::channel();
+    let (tx2, mut rx2) = oneshot::channel();
+
+    let mut f = task::spawn(async {
+        let mut a = None;
+        let mut b = None;
+
+        while a.is_none() || b.is_none() {
+            tokio::select! {
+                v1 = &mut rx1, if a.is_none() => a = Some(assert_ok!(v1)),
+                v2 = &mut rx2, if b.is_none() => b = Some(assert_ok!(v2))
+            }
+        }
+
+        (a.unwrap(), b.unwrap())
+    });
+
+    assert_pending!(f.poll());
+
+    assert_ok!(tx1.send(123));
+    assert!(f.is_woken());
+    assert_pending!(f.poll());
+
+    assert_ok!(tx2.send(456));
+    assert!(f.is_woken());
+    let (a, b) = assert_ready!(f.poll());
+
+    assert_eq!(a, 123);
+    assert_eq!(b, 456);
+}
+
+#[tokio::test]
+#[cfg(feature = "full")]
+async fn use_future_in_if_condition() {
+    use tokio::time::{self, Duration};
+
+    tokio::select! {
+        _ = time::sleep(Duration::from_millis(10)), if false => {
+            panic!("if condition ignored")
+        }
+        _ = async { 1u32 } => {
+        }
+    }
+}
+
+#[tokio::test]
+#[cfg(feature = "full")]
+async fn use_future_in_if_condition_biased() {
+    use tokio::time::{self, Duration};
+
+    tokio::select! {
+        biased;
+        _ = time::sleep(Duration::from_millis(10)), if false => {
+            panic!("if condition ignored")
+        }
+        _ = async { 1u32 } => {
+        }
+    }
+}
+
+#[maybe_tokio_test]
+async fn many_branches() {
+    let num = tokio::select! {
+        x = async { 1 } => x,
+        x = async { 1 } => x,
+        x = async { 1 } => x,
+        x = async { 1 } => x,
+        x = async { 1 } => x,
+        x = async { 1 } => x,
+        x = async { 1 } => x,
+        x = async { 1 } => x,
+        x = async { 1 } => x,
+        x = async { 1 } => x,
+        x = async { 1 } => x,
+        x = async { 1 } => x,
+        x = async { 1 } => x,
+        x = async { 1 } => x,
+        x = async { 1 } => x,
+        x = async { 1 } => x,
+        x = async { 1 } => x,
+        x = async { 1 } => x,
+        x = async { 1 } => x,
+        x = async { 1 } => x,
+        x = async { 1 } => x,
+        x = async { 1 } => x,
+        x = async { 1 } => x,
+        x = async { 1 } => x,
+        x = async { 1 } => x,
+        x = async { 1 } => x,
+        x = async { 1 } => x,
+        x = async { 1 } => x,
+        x = async { 1 } => x,
+        x = async { 1 } => x,
+        x = async { 1 } => x,
+        x = async { 1 } => x,
+        x = async { 1 } => x,
+        x = async { 1 } => x,
+        x = async { 1 } => x,
+        x = async { 1 } => x,
+        x = async { 1 } => x,
+        x = async { 1 } => x,
+        x = async { 1 } => x,
+        x = async { 1 } => x,
+        x = async { 1 } => x,
+        x = async { 1 } => x,
+        x = async { 1 } => x,
+        x = async { 1 } => x,
+        x = async { 1 } => x,
+        x = async { 1 } => x,
+        x = async { 1 } => x,
+        x = async { 1 } => x,
+        x = async { 1 } => x,
+        x = async { 1 } => x,
+        x = async { 1 } => x,
+        x = async { 1 } => x,
+        x = async { 1 } => x,
+        x = async { 1 } => x,
+        x = async { 1 } => x,
+        x = async { 1 } => x,
+        x = async { 1 } => x,
+        x = async { 1 } => x,
+        x = async { 1 } => x,
+        x = async { 1 } => x,
+        x = async { 1 } => x,
+        x = async { 1 } => x,
+        x = async { 1 } => x,
+        x = async { 1 } => x,
+    };
+
+    assert_eq!(1, num);
+}
+
+#[maybe_tokio_test]
+async fn never_branch_no_warnings() {
+    let t = tokio::select! {
+        _ = async_never() => 0,
+        one_async_ready = one() => one_async_ready,
+    };
+    assert_eq!(t, 1);
+}
+
+async fn one() -> usize {
+    1
+}
+
+async fn require_mutable(_: &mut i32) {}
+async fn async_noop() {}
+
+async fn async_never() -> ! {
+    futures::future::pending().await
+}
+
+// From https://github.com/tokio-rs/tokio/issues/2857
+#[maybe_tokio_test]
+async fn mut_on_left_hand_side() {
+    let v = async move {
+        let ok = async { 1 };
+        tokio::pin!(ok);
+        tokio::select! {
+            mut a = &mut ok => {
+                a += 1;
+                a
+            }
+        }
+    }
+    .await;
+    assert_eq!(v, 2);
+}
+
+#[maybe_tokio_test]
+async fn biased_one_not_ready() {
+    let (_tx1, rx1) = oneshot::channel::<i32>();
+    let (tx2, rx2) = oneshot::channel::<i32>();
+    let (tx3, rx3) = oneshot::channel::<i32>();
+
+    tx2.send(2).unwrap();
+    tx3.send(3).unwrap();
+
+    let v = tokio::select! {
+        biased;
+
+        _ = rx1 => unreachable!(),
+        res = rx2 => {
+            assert_ok!(res)
+        },
+        _ = rx3 => {
+            panic!("This branch should never be activated because `rx2` should be polled before `rx3` due to `biased;`.")
+        }
+    };
+
+    assert_eq!(2, v);
+}
+
+#[maybe_tokio_test]
+#[cfg(feature = "full")]
+async fn biased_eventually_ready() {
+    use tokio::task::yield_now;
+
+    let one = async {};
+    let two = async { yield_now().await };
+    let three = async { yield_now().await };
+
+    let mut count = 0u8;
+
+    tokio::pin!(one, two, three);
+
+    loop {
+        tokio::select! {
+            biased;
+
+            _ = &mut two, if count < 2 => {
+                count += 1;
+                assert_eq!(count, 2);
+            }
+            _ = &mut three, if count < 3 => {
+                count += 1;
+                assert_eq!(count, 3);
+            }
+            _ = &mut one, if count < 1 => {
+                count += 1;
+                assert_eq!(count, 1);
+            }
+            else => break,
+        }
+    }
+
+    assert_eq!(count, 3);
+}
+
+// https://github.com/tokio-rs/tokio/issues/3830
+// https://github.com/rust-lang/rust-clippy/issues/7304
+#[warn(clippy::default_numeric_fallback)]
+pub async fn default_numeric_fallback() {
+    tokio::select! {
+        _ = async {} => (),
+        else => (),
+    }
+}
+
+// https://github.com/tokio-rs/tokio/issues/4182
+#[maybe_tokio_test]
+async fn mut_ref_patterns() {
+    tokio::select! {
+        Some(mut foo) = async { Some("1".to_string()) } => {
+            assert_eq!(foo, "1");
+            foo = "2".to_string();
+            assert_eq!(foo, "2");
+        },
+    };
+
+    tokio::select! {
+        Some(ref foo) = async { Some("1".to_string()) } => {
+            assert_eq!(*foo, "1");
+        },
+    };
+
+    tokio::select! {
+        Some(ref mut foo) = async { Some("1".to_string()) } => {
+            assert_eq!(*foo, "1");
+            *foo = "2".to_string();
+            assert_eq!(*foo, "2");
+        },
+    };
+}
+
+#[cfg(tokio_unstable)]
+mod unstable {
+    use tokio::runtime::RngSeed;
+
+    #[test]
+    fn deterministic_select_current_thread() {
+        let seed = b"bytes used to generate seed";
+        let rt1 = tokio::runtime::Builder::new_current_thread()
+            .rng_seed(RngSeed::from_bytes(seed))
+            .build()
+            .unwrap();
+        let rt1_values = rt1.block_on(async { (select_0_to_9().await, select_0_to_9().await) });
+
+        let rt2 = tokio::runtime::Builder::new_current_thread()
+            .rng_seed(RngSeed::from_bytes(seed))
+            .build()
+            .unwrap();
+        let rt2_values = rt2.block_on(async { (select_0_to_9().await, select_0_to_9().await) });
+
+        assert_eq!(rt1_values, rt2_values);
+    }
+
+    #[test]
+    #[cfg(all(feature = "rt-multi-thread", not(target_os = "wasi")))]
+    fn deterministic_select_multi_thread() {
+        let seed = b"bytes used to generate seed";
+        let (tx, rx) = std::sync::mpsc::channel();
+        let rt1 = tokio::runtime::Builder::new_multi_thread()
+            .worker_threads(1)
+            .on_thread_park(move || tx.send(()).unwrap())
+            .rng_seed(RngSeed::from_bytes(seed))
+            .build()
+            .unwrap();
+
+        // This makes sure that `enter_runtime()` from worker thread is called before the one from main thread,
+        // ensuring that the RNG state is consistent. See also https://github.com/tokio-rs/tokio/pull/7495.
+        rx.recv().unwrap();
+
+        let rt1_values = rt1.block_on(async {
+            tokio::spawn(async { (select_0_to_9().await, select_0_to_9().await) })
+                .await
+                .unwrap()
+        });
+
+        let (tx, rx) = std::sync::mpsc::channel();
+        let rt2 = tokio::runtime::Builder::new_multi_thread()
+            .worker_threads(1)
+            .on_thread_park(move || tx.send(()).unwrap())
+            .rng_seed(RngSeed::from_bytes(seed))
+            .build()
+            .unwrap();
+
+        // This makes sure that `enter_runtime()` from worker thread is called before the one from main thread,
+        // ensuring that the RNG state is consistent. See also https://github.com/tokio-rs/tokio/pull/7495.
+        rx.recv().unwrap();
+
+        let rt2_values = rt2.block_on(async {
+            tokio::spawn(async { (select_0_to_9().await, select_0_to_9().await) })
+                .await
+                .unwrap()
+        });
+
+        assert_eq!(rt1_values, rt2_values);
+    }
+
+    async fn select_0_to_9() -> u32 {
+        tokio::select!(
+            x = async { 0 } => x,
+            x = async { 1 } => x,
+            x = async { 2 } => x,
+            x = async { 3 } => x,
+            x = async { 4 } => x,
+            x = async { 5 } => x,
+            x = async { 6 } => x,
+            x = async { 7 } => x,
+            x = async { 8 } => x,
+            x = async { 9 } => x,
+        )
+    }
+}
+
+#[tokio::test]
+async fn select_into_future() {
+    struct NotAFuture;
+    impl std::future::IntoFuture for NotAFuture {
+        type Output = ();
+        type IntoFuture = std::future::Ready<()>;
+
+        fn into_future(self) -> Self::IntoFuture {
+            std::future::ready(())
+        }
+    }
+
+    tokio::select! {
+        () = NotAFuture => {},
+    }
+}
+
+// regression test for https://github.com/tokio-rs/tokio/issues/6721
+#[tokio::test]
+async fn temporary_lifetime_extension() {
+    tokio::select! {
+        () = &mut std::future::ready(()) => {},
+    }
+}
+
+#[tokio::test]
+async fn select_is_budget_aware() {
+    const BUDGET: usize = 128;
+
+    let task = || {
+        Box::pin(async move {
+            tokio::select! {
+                biased;
+
+                () = tokio::task::coop::consume_budget() => {},
+                () = std::future::ready(()) => {}
+            }
+        })
+    };
+
+    for _ in 0..BUDGET {
+        let poll = futures::poll!(&mut task());
+        assert!(poll.is_ready());
+    }
+
+    let poll = futures::poll!(&mut task());
+    assert!(poll.is_pending());
+}

vendor/tokio/tests/macros_test.rs

@@ -0,0 +1,117 @@
+#![cfg(all(feature = "full", not(target_os = "wasi")))] // Wasi doesn't support threading
+
+use tokio::test;
+
+#[test]
+async fn test_macro_can_be_used_via_use() {
+    tokio::spawn(async {}).await.unwrap();
+}
+
+#[tokio::test]
+async fn test_macro_is_resilient_to_shadowing() {
+    tokio::spawn(async {}).await.unwrap();
+}
+
+// https://github.com/tokio-rs/tokio/issues/3403
+#[rustfmt::skip] // this `rustfmt::skip` is necessary because unused_braces does not warn if the block contains newline.
+#[tokio::main]
+pub async fn unused_braces_main() { println!("hello") }
+#[rustfmt::skip] // this `rustfmt::skip` is necessary because unused_braces does not warn if the block contains newline.
+#[tokio::test]
+async fn unused_braces_test() { assert_eq!(1 + 1, 2) }
+
+// https://github.com/tokio-rs/tokio/pull/3766#issuecomment-835508651
+#[std::prelude::v1::test]
+fn trait_method() {
+    trait A {
+        fn f(self);
+
+        fn g(self);
+    }
+    impl A for () {
+        #[tokio::main]
+        async fn f(self) {
+            self.g()
+        }
+
+        fn g(self) {}
+    }
+    ().f()
+}
+
+// https://github.com/tokio-rs/tokio/issues/4175
+#[tokio::main]
+pub async fn issue_4175_main_1() -> ! {
+    panic!();
+}
+#[tokio::main]
+pub async fn issue_4175_main_2() -> std::io::Result<()> {
+    panic!();
+}
+#[allow(unreachable_code)]
+#[tokio::test]
+pub async fn issue_4175_test() -> std::io::Result<()> {
+    return Ok(());
+    panic!();
+}
+
+// https://github.com/tokio-rs/tokio/issues/4175
+#[allow(clippy::let_unit_value)]
+pub mod clippy_semicolon_if_nothing_returned {
+    #![deny(clippy::semicolon_if_nothing_returned)]
+
+    #[tokio::main]
+    pub async fn local() {
+        let _x = ();
+    }
+    #[tokio::main]
+    pub async fn item() {
+        fn _f() {}
+    }
+    #[tokio::main]
+    pub async fn semi() {
+        panic!();
+    }
+    #[tokio::main]
+    pub async fn empty() {
+        // To trigger clippy::semicolon_if_nothing_returned lint, the block needs to contain newline.
+    }
+}
+
+// https://github.com/tokio-rs/tokio/issues/5243
+pub mod issue_5243 {
+    macro_rules! mac {
+        (async fn $name:ident() $b:block) => {
+            #[::tokio::test]
+            async fn $name() {
+                $b
+            }
+        };
+    }
+    mac!(
+        async fn foo() {}
+    );
+}
+
+#[cfg(tokio_unstable)]
+pub mod macro_rt_arg_unhandled_panic {
+    use tokio_test::assert_err;
+
+    #[tokio::test(flavor = "current_thread", unhandled_panic = "shutdown_runtime")]
+    #[should_panic]
+    async fn unhandled_panic_shutdown_runtime() {
+        let _ = tokio::spawn(async {
+            panic!("This panic should shutdown the runtime.");
+        })
+        .await;
+    }
+
+    #[tokio::test(flavor = "current_thread", unhandled_panic = "ignore")]
+    async fn unhandled_panic_ignore() {
+        let rt = tokio::spawn(async {
+            panic!("This panic should be forwarded to rt as an error.");
+        })
+        .await;
+        assert_err!(rt);
+    }
+}

vendor/tokio/tests/macros_try_join.rs

@@ -0,0 +1,269 @@
+#![cfg(feature = "macros")]
+#![allow(clippy::disallowed_names)]
+
+use std::{convert::Infallible, sync::Arc};
+
+use tokio::sync::{oneshot, Semaphore};
+use tokio_test::{assert_pending, assert_ready, task};
+
+#[cfg(all(target_family = "wasm", not(target_os = "wasi")))]
+use wasm_bindgen_test::wasm_bindgen_test as maybe_tokio_test;
+
+#[cfg(not(all(target_family = "wasm", not(target_os = "wasi"))))]
+use tokio::test as maybe_tokio_test;
+
+#[maybe_tokio_test]
+async fn sync_one_lit_expr_comma() {
+    let foo = tokio::try_join!(async { ok(1) },);
+    assert_eq!(foo, Ok((1,)));
+
+    let foo = tokio::try_join!(biased; async { ok(1) },);
+    assert_eq!(foo, Ok((1,)));
+}
+
+#[maybe_tokio_test]
+async fn sync_one_lit_expr_no_comma() {
+    let foo = tokio::try_join!(async { ok(1) });
+    assert_eq!(foo, Ok((1,)));
+
+    let foo = tokio::try_join!(biased; async { ok(1) });
+    assert_eq!(foo, Ok((1,)));
+}
+
+#[maybe_tokio_test]
+async fn sync_two_lit_expr_comma() {
+    let foo = tokio::try_join!(async { ok(1) }, async { ok(2) },);
+    assert_eq!(foo, Ok((1, 2)));
+
+    let foo = tokio::try_join!(biased;async { ok(1) }, async { ok(2) },);
+    assert_eq!(foo, Ok((1, 2)));
+}
+
+#[maybe_tokio_test]
+async fn sync_two_lit_expr_no_comma() {
+    let foo = tokio::try_join!(async { ok(1) }, async { ok(2) });
+    assert_eq!(foo, Ok((1, 2)));
+
+    let foo = tokio::try_join!(biased; async { ok(1) }, async { ok(2) });
+    assert_eq!(foo, Ok((1, 2)));
+}
+
+#[maybe_tokio_test]
+async fn two_await() {
+    let (tx1, rx1) = oneshot::channel::<&str>();
+    let (tx2, rx2) = oneshot::channel::<u32>();
+
+    let mut join = task::spawn(async { tokio::try_join!(rx1, rx2) });
+
+    assert_pending!(join.poll());
+
+    tx2.send(123).unwrap();
+    assert!(join.is_woken());
+    assert_pending!(join.poll());
+
+    tx1.send("hello").unwrap();
+    assert!(join.is_woken());
+    let res: Result<(&str, u32), _> = assert_ready!(join.poll());
+
+    assert_eq!(Ok(("hello", 123)), res);
+}
+
+#[maybe_tokio_test]
+async fn err_abort_early() {
+    let (tx1, rx1) = oneshot::channel::<&str>();
+    let (tx2, rx2) = oneshot::channel::<u32>();
+    let (_tx3, rx3) = oneshot::channel::<u32>();
+
+    let mut join = task::spawn(async { tokio::try_join!(rx1, rx2, rx3) });
+
+    assert_pending!(join.poll());
+
+    tx2.send(123).unwrap();
+    assert!(join.is_woken());
+    assert_pending!(join.poll());
+
+    drop(tx1);
+    assert!(join.is_woken());
+
+    let res = assert_ready!(join.poll());
+
+    assert!(res.is_err());
+}
+
+#[test]
+#[cfg(target_pointer_width = "64")]
+fn try_join_size() {
+    use futures::future;
+    use std::mem;
+
+    let fut = async {
+        let ready = future::ready(ok(0i32));
+        tokio::try_join!(ready)
+    };
+    assert_eq!(mem::size_of_val(&fut), 32);
+
+    let fut = async {
+        let ready1 = future::ready(ok(0i32));
+        let ready2 = future::ready(ok(0i32));
+        tokio::try_join!(ready1, ready2)
+    };
+    assert_eq!(mem::size_of_val(&fut), 48);
+}
+
+fn ok<T>(val: T) -> Result<T, ()> {
+    Ok(val)
+}
+
+async fn non_cooperative_task(permits: Arc<Semaphore>) -> Result<usize, String> {
+    let mut exceeded_budget = 0;
+
+    for _ in 0..5 {
+        // Another task should run after this task uses its whole budget
+        for _ in 0..128 {
+            let _permit = permits.clone().acquire_owned().await.unwrap();
+        }
+
+        exceeded_budget += 1;
+    }
+
+    Ok(exceeded_budget)
+}
+
+async fn poor_little_task(permits: Arc<Semaphore>) -> Result<usize, String> {
+    let mut how_many_times_i_got_to_run = 0;
+
+    for _ in 0..5 {
+        let _permit = permits.clone().acquire_owned().await.unwrap();
+
+        how_many_times_i_got_to_run += 1;
+    }
+
+    Ok(how_many_times_i_got_to_run)
+}
+
+#[tokio::test]
+async fn try_join_does_not_allow_tasks_to_starve() {
+    let permits = Arc::new(Semaphore::new(10));
+
+    // non_cooperative_task should yield after its budget is exceeded and then poor_little_task should run.
+    let result = tokio::try_join!(
+        non_cooperative_task(Arc::clone(&permits)),
+        poor_little_task(permits)
+    );
+
+    let (non_cooperative_result, little_task_result) = result.unwrap();
+
+    assert_eq!(5, non_cooperative_result);
+    assert_eq!(5, little_task_result);
+}
+
+#[tokio::test]
+async fn a_different_future_is_polled_first_every_time_poll_fn_is_polled() {
+    let poll_order = Arc::new(std::sync::Mutex::new(vec![]));
+
+    let fut = |x, poll_order: Arc<std::sync::Mutex<Vec<i32>>>| async move {
+        for _ in 0..4 {
+            {
+                let mut guard = poll_order.lock().unwrap();
+
+                guard.push(x);
+            }
+
+            tokio::task::yield_now().await;
+        }
+        Ok::<(), Infallible>(())
+    };
+
+    tokio::try_join!(
+        fut(1, Arc::clone(&poll_order)),
+        fut(2, Arc::clone(&poll_order)),
+        fut(3, Arc::clone(&poll_order)),
+    )
+    .unwrap();
+
+    // Each time the future created by join! is polled, it should start
+    // by polling a different future first.
+    assert_eq!(
+        vec![1, 2, 3, 2, 3, 1, 3, 1, 2, 1, 2, 3],
+        *poll_order.lock().unwrap()
+    );
+}
+
+#[tokio::test]
+async fn futures_are_polled_in_order_in_biased_mode() {
+    let poll_order = Arc::new(std::sync::Mutex::new(vec![]));
+
+    let fut = |x, poll_order: Arc<std::sync::Mutex<Vec<i32>>>| async move {
+        for _ in 0..4 {
+            {
+                let mut guard = poll_order.lock().unwrap();
+
+                guard.push(x);
+            }
+
+            tokio::task::yield_now().await;
+        }
+        Ok::<(), Infallible>(())
+    };
+
+    tokio::try_join!(
+        biased;
+        fut(1, Arc::clone(&poll_order)),
+        fut(2, Arc::clone(&poll_order)),
+        fut(3, Arc::clone(&poll_order)),
+    )
+    .unwrap();
+
+    // Each time the future created by join! is polled, it should start
+    // by polling in the order as declared in the macro inputs.
+    assert_eq!(
+        vec![1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3],
+        *poll_order.lock().unwrap()
+    );
+}
+
+#[test]
+#[cfg(target_pointer_width = "64")]
+fn try_join_size_biased() {
+    use futures::future;
+    use std::mem;
+
+    let fut = async {
+        let ready = future::ready(ok(0i32));
+        tokio::try_join!(biased; ready)
+    };
+    assert_eq!(mem::size_of_val(&fut), 24);
+
+    let fut = async {
+        let ready1 = future::ready(ok(0i32));
+        let ready2 = future::ready(ok(0i32));
+        tokio::try_join!(biased; ready1, ready2)
+    };
+    assert_eq!(mem::size_of_val(&fut), 40);
+}
+
+#[tokio::test]
+async fn empty_try_join() {
+    assert_eq!(tokio::try_join!() as Result<_, ()>, Ok(()));
+    assert_eq!(tokio::try_join!(biased;) as Result<_, ()>, Ok(()));
+}
+
+// Regression test for: https://github.com/tokio-rs/tokio/issues/7637
+// We want to make sure that the `const COUNT: u32` declaration
+// inside the macro body doesn't leak to the caller to cause compiler failures
+// or variable shadowing.
+#[tokio::test]
+async fn caller_names_const_count() {
+    let (tx, rx) = oneshot::channel::<u32>();
+
+    const COUNT: u32 = 2;
+
+    let mut try_join = task::spawn(async { tokio::try_join!(async { tx.send(COUNT) }) });
+    assert_ready!(try_join.poll()).unwrap();
+
+    let res = rx.await.unwrap();
+
+    // This passing demonstrates that the const in the macro is
+    // not shadowing the caller-specified COUNT value
+    assert_eq!(2, res);
+}

vendor/tokio/tests/net_bind_resource.rs

@@ -0,0 +1,14 @@
+#![warn(rust_2018_idioms)]
+#![cfg(all(feature = "full", not(target_os = "wasi")))] // Wasi doesn't support panic recovery or bind
+
+use tokio::net::TcpListener;
+
+use std::net;
+
+#[test]
+#[should_panic]
+#[cfg_attr(miri, ignore)] // No `socket` in miri.
+fn no_runtime_panics_binding_net_tcp_listener() {
+    let listener = net::TcpListener::bind("127.0.0.1:0").expect("failed to bind listener");
+    let _ = TcpListener::try_from(listener);
+}

vendor/tokio/tests/net_lookup_host.rs

@@ -0,0 +1,39 @@
+#![cfg(all(feature = "full", not(target_os = "wasi")))] // Wasi does not support direct socket operations
+
+use tokio::net;
+use tokio_test::assert_ok;
+
+use std::io;
+use std::net::{IpAddr, Ipv4Addr, Ipv6Addr, SocketAddr};
+
+#[tokio::test]
+async fn lookup_socket_addr() {
+    let addr: SocketAddr = "127.0.0.1:8000".parse().unwrap();
+
+    let actual = assert_ok!(net::lookup_host(addr).await).collect::<Vec<_>>();
+    assert_eq!(vec![addr], actual);
+}
+
+#[tokio::test]
+async fn lookup_str_socket_addr() {
+    let addr: SocketAddr = "127.0.0.1:8000".parse().unwrap();
+
+    let actual = assert_ok!(net::lookup_host("127.0.0.1:8000").await).collect::<Vec<_>>();
+    assert_eq!(vec![addr], actual);
+}
+
+#[tokio::test]
+#[cfg_attr(miri, ignore)] // No `getaddrinfo` in miri.
+async fn resolve_dns() -> io::Result<()> {
+    let mut hosts = net::lookup_host("localhost:3000").await?;
+    let host = hosts.next().unwrap();
+
+    let expected = if host.is_ipv4() {
+        SocketAddr::new(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)), 3000)
+    } else {
+        SocketAddr::new(IpAddr::V6(Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1)), 3000)
+    };
+    assert_eq!(host, expected);
+
+    Ok(())
+}

vendor/tokio/tests/net_named_pipe.rs

@@ -0,0 +1,399 @@
+#![cfg(feature = "full")]
+#![cfg(windows)]
+
+use std::io;
+use std::time::Duration;
+use tokio::io::{AsyncReadExt, AsyncWriteExt};
+use tokio::net::windows::named_pipe::{ClientOptions, PipeMode, ServerOptions};
+use tokio::time;
+use windows_sys::Win32::Foundation::{ERROR_NO_DATA, ERROR_PIPE_BUSY};
+
+#[tokio::test]
+async fn test_named_pipe_client_drop() -> io::Result<()> {
+    const PIPE_NAME: &str = r"\\.\pipe\test-named-pipe-client-drop";
+
+    let mut server = ServerOptions::new().create(PIPE_NAME)?;
+
+    let client = ClientOptions::new().open(PIPE_NAME)?;
+
+    server.connect().await?;
+    drop(client);
+
+    // instance will be broken because client is gone
+    match server.write_all(b"ping").await {
+        Err(e) if e.raw_os_error() == Some(ERROR_NO_DATA as i32) => (),
+        x => panic!("{:?}", x),
+    }
+
+    Ok(())
+}
+
+#[tokio::test]
+async fn test_named_pipe_single_client() -> io::Result<()> {
+    use tokio::io::{AsyncBufReadExt as _, BufReader};
+
+    const PIPE_NAME: &str = r"\\.\pipe\test-named-pipe-single-client";
+
+    let server = ServerOptions::new().create(PIPE_NAME)?;
+
+    let server = tokio::spawn(async move {
+        // Note: we wait for a client to connect.
+        server.connect().await?;
+
+        let mut server = BufReader::new(server);
+
+        let mut buf = String::new();
+        server.read_line(&mut buf).await?;
+        server.write_all(b"pong\n").await?;
+        Ok::<_, io::Error>(buf)
+    });
+
+    let client = tokio::spawn(async move {
+        let client = ClientOptions::new().open(PIPE_NAME)?;
+
+        let mut client = BufReader::new(client);
+
+        let mut buf = String::new();
+        client.write_all(b"ping\n").await?;
+        client.read_line(&mut buf).await?;
+        Ok::<_, io::Error>(buf)
+    });
+
+    let (server, client) = tokio::try_join!(server, client)?;
+
+    assert_eq!(server?, "ping\n");
+    assert_eq!(client?, "pong\n");
+
+    Ok(())
+}
+
+#[tokio::test]
+async fn test_named_pipe_multi_client() -> io::Result<()> {
+    use tokio::io::{AsyncBufReadExt as _, BufReader};
+
+    const PIPE_NAME: &str = r"\\.\pipe\test-named-pipe-multi-client";
+    const N: usize = 10;
+
+    // The first server needs to be constructed early so that clients can
+    // be correctly connected. Otherwise calling .wait will cause the client to
+    // error.
+    let mut server = ServerOptions::new().create(PIPE_NAME)?;
+
+    let server = tokio::spawn(async move {
+        for _ in 0..N {
+            // Wait for client to connect.
+            server.connect().await?;
+            let mut inner = BufReader::new(server);
+
+            // Construct the next server to be connected before sending the one
+            // we already have of onto a task. This ensures that the server
+            // isn't closed (after it's done in the task) before a new one is
+            // available. Otherwise the client might error with
+            // `io::ErrorKind::NotFound`.
+            server = ServerOptions::new().create(PIPE_NAME)?;
+
+            tokio::spawn(async move {
+                let mut buf = String::new();
+                inner.read_line(&mut buf).await?;
+                inner.write_all(b"pong\n").await?;
+                inner.flush().await?;
+                Ok::<_, io::Error>(())
+            });
+        }
+
+        Ok::<_, io::Error>(())
+    });
+
+    let mut clients = Vec::new();
+
+    for _ in 0..N {
+        clients.push(tokio::spawn(async move {
+            // This showcases a generic connect loop.
+            //
+            // We immediately try to create a client, if it's not found or the
+            // pipe is busy we use the specialized wait function on the client
+            // builder.
+            let client = loop {
+                match ClientOptions::new().open(PIPE_NAME) {
+                    Ok(client) => break client,
+                    Err(e) if e.raw_os_error() == Some(ERROR_PIPE_BUSY as i32) => (),
+                    Err(e) if e.kind() == io::ErrorKind::NotFound => (),
+                    Err(e) => return Err(e),
+                }
+
+                // Wait for a named pipe to become available.
+                time::sleep(Duration::from_millis(10)).await;
+            };
+
+            let mut client = BufReader::new(client);
+
+            let mut buf = String::new();
+            client.write_all(b"ping\n").await?;
+            client.flush().await?;
+            client.read_line(&mut buf).await?;
+            Ok::<_, io::Error>(buf)
+        }));
+    }
+
+    for client in clients {
+        let result = client.await?;
+        assert_eq!(result?, "pong\n");
+    }
+
+    server.await??;
+    Ok(())
+}
+
+#[tokio::test]
+async fn test_named_pipe_multi_client_ready() -> io::Result<()> {
+    use tokio::io::Interest;
+
+    const PIPE_NAME: &str = r"\\.\pipe\test-named-pipe-multi-client-ready";
+    const N: usize = 10;
+
+    // The first server needs to be constructed early so that clients can
+    // be correctly connected. Otherwise calling .wait will cause the client to
+    // error.
+    let mut server = ServerOptions::new().create(PIPE_NAME)?;
+
+    let server = tokio::spawn(async move {
+        for _ in 0..N {
+            // Wait for client to connect.
+            server.connect().await?;
+
+            let inner_server = server;
+
+            // Construct the next server to be connected before sending the one
+            // we already have of onto a task. This ensures that the server
+            // isn't closed (after it's done in the task) before a new one is
+            // available. Otherwise the client might error with
+            // `io::ErrorKind::NotFound`.
+            server = ServerOptions::new().create(PIPE_NAME)?;
+
+            tokio::spawn(async move {
+                let server = inner_server;
+
+                {
+                    let mut read_buf = [0u8; 5];
+                    let mut read_buf_cursor = 0;
+
+                    loop {
+                        server.readable().await?;
+
+                        let buf = &mut read_buf[read_buf_cursor..];
+
+                        match server.try_read(buf) {
+                            Ok(n) => {
+                                read_buf_cursor += n;
+
+                                if read_buf_cursor == read_buf.len() {
+                                    break;
+                                }
+                            }
+                            Err(e) if e.kind() == io::ErrorKind::WouldBlock => {
+                                continue;
+                            }
+                            Err(e) => {
+                                return Err(e);
+                            }
+                        }
+                    }
+                };
+
+                {
+                    let write_buf = b"pong\n";
+                    let mut write_buf_cursor = 0;
+
+                    loop {
+                        server.writable().await?;
+                        let buf = &write_buf[write_buf_cursor..];
+
+                        match server.try_write(buf) {
+                            Ok(n) => {
+                                write_buf_cursor += n;
+
+                                if write_buf_cursor == write_buf.len() {
+                                    break;
+                                }
+                            }
+                            Err(e) if e.kind() == io::ErrorKind::WouldBlock => {
+                                continue;
+                            }
+                            Err(e) => {
+                                return Err(e);
+                            }
+                        }
+                    }
+                }
+
+                Ok::<_, io::Error>(())
+            });
+        }
+
+        Ok::<_, io::Error>(())
+    });
+
+    let mut clients = Vec::new();
+
+    for _ in 0..N {
+        clients.push(tokio::spawn(async move {
+            // This showcases a generic connect loop.
+            //
+            // We immediately try to create a client, if it's not found or the
+            // pipe is busy we use the specialized wait function on the client
+            // builder.
+            let client = loop {
+                match ClientOptions::new().open(PIPE_NAME) {
+                    Ok(client) => break client,
+                    Err(e) if e.raw_os_error() == Some(ERROR_PIPE_BUSY as i32) => (),
+                    Err(e) if e.kind() == io::ErrorKind::NotFound => (),
+                    Err(e) => return Err(e),
+                }
+
+                // Wait for a named pipe to become available.
+                time::sleep(Duration::from_millis(10)).await;
+            };
+
+            let mut read_buf = [0u8; 5];
+            let mut read_buf_cursor = 0;
+            let write_buf = b"ping\n";
+            let mut write_buf_cursor = 0;
+
+            loop {
+                let mut interest = Interest::READABLE;
+                if write_buf_cursor < write_buf.len() {
+                    interest |= Interest::WRITABLE;
+                }
+
+                let ready = client.ready(interest).await?;
+
+                if ready.is_readable() {
+                    let buf = &mut read_buf[read_buf_cursor..];
+
+                    match client.try_read(buf) {
+                        Ok(n) => {
+                            read_buf_cursor += n;
+
+                            if read_buf_cursor == read_buf.len() {
+                                break;
+                            }
+                        }
+                        Err(e) if e.kind() == io::ErrorKind::WouldBlock => {
+                            continue;
+                        }
+                        Err(e) => {
+                            return Err(e);
+                        }
+                    }
+                }
+
+                if ready.is_writable() {
+                    let buf = &write_buf[write_buf_cursor..];
+
+                    if buf.is_empty() {
+                        continue;
+                    }
+
+                    match client.try_write(buf) {
+                        Ok(n) => {
+                            write_buf_cursor += n;
+                        }
+                        Err(e) if e.kind() == io::ErrorKind::WouldBlock => {
+                            continue;
+                        }
+                        Err(e) => {
+                            return Err(e);
+                        }
+                    }
+                }
+            }
+
+            let buf = String::from_utf8_lossy(&read_buf).into_owned();
+
+            Ok::<_, io::Error>(buf)
+        }));
+    }
+
+    for client in clients {
+        let result = client.await?;
+        assert_eq!(result?, "pong\n");
+    }
+
+    server.await??;
+    Ok(())
+}
+
+// This tests that message mode works as expected.
+#[tokio::test]
+async fn test_named_pipe_mode_message() -> io::Result<()> {
+    // it's easy to accidentally get a seemingly working test here because byte pipes
+    // often return contents at write boundaries. to make sure we're doing the right thing we
+    // explicitly test that it doesn't work in byte mode.
+    _named_pipe_mode_message(PipeMode::Message).await?;
+    _named_pipe_mode_message(PipeMode::Byte).await
+}
+
+async fn _named_pipe_mode_message(mode: PipeMode) -> io::Result<()> {
+    let pipe_name = format!(
+        r"\\.\pipe\test-named-pipe-mode-message-{}",
+        matches!(mode, PipeMode::Message)
+    );
+    let mut buf = [0u8; 32];
+
+    let mut server = ServerOptions::new()
+        .first_pipe_instance(true)
+        .pipe_mode(mode)
+        .create(&pipe_name)?;
+
+    let mut client = ClientOptions::new().pipe_mode(mode).open(&pipe_name)?;
+
+    server.connect().await?;
+
+    // this needs a few iterations, presumably Windows waits for a few calls before merging buffers
+    for _ in 0..10 {
+        client.write_all(b"hello").await?;
+        server.write_all(b"world").await?;
+    }
+    for _ in 0..10 {
+        let n = server.read(&mut buf).await?;
+        if buf[..n] != b"hello"[..] {
+            assert!(matches!(mode, PipeMode::Byte));
+            return Ok(());
+        }
+        let n = client.read(&mut buf).await?;
+        if buf[..n] != b"world"[..] {
+            assert!(matches!(mode, PipeMode::Byte));
+            return Ok(());
+        }
+    }
+    // byte mode should have errored before.
+    assert!(matches!(mode, PipeMode::Message));
+    Ok(())
+}
+
+// This tests `NamedPipeServer::connect` with various access settings.
+#[tokio::test]
+async fn test_named_pipe_access() -> io::Result<()> {
+    const PIPE_NAME: &str = r"\\.\pipe\test-named-pipe-access";
+
+    for (inb, outb) in [(true, true), (true, false), (false, true)] {
+        let (tx, rx) = tokio::sync::oneshot::channel();
+        let server = tokio::spawn(async move {
+            let s = ServerOptions::new()
+                .access_inbound(inb)
+                .access_outbound(outb)
+                .create(PIPE_NAME)?;
+            let mut connect_fut = tokio_test::task::spawn(s.connect());
+            assert!(connect_fut.poll().is_pending());
+            tx.send(()).unwrap();
+            connect_fut.await
+        });
+
+        // Wait for the server to call connect.
+        rx.await.unwrap();
+        let _ = ClientOptions::new().read(outb).write(inb).open(PIPE_NAME)?;
+
+        server.await??;
+    }
+    Ok(())
+}

vendor/tokio/tests/net_panic.rs

@@ -0,0 +1,196 @@
+#![warn(rust_2018_idioms)]
+#![cfg(all(feature = "full", not(target_os = "wasi")))]
+#![cfg(panic = "unwind")]
+
+use std::error::Error;
+use tokio::net::{TcpListener, TcpStream};
+use tokio::runtime::{Builder, Runtime};
+
+mod support {
+    pub mod panic;
+}
+use support::panic::test_panic;
+
+#[test]
+#[cfg_attr(miri, ignore)] // No `socket` in miri.
+fn udp_socket_from_std_panic_caller() -> Result<(), Box<dyn Error>> {
+    use std::net::SocketAddr;
+    use tokio::net::UdpSocket;
+
+    let addr = "127.0.0.1:0".parse::<SocketAddr>().unwrap();
+    let std_sock = std::net::UdpSocket::bind(addr).unwrap();
+    std_sock.set_nonblocking(true).unwrap();
+
+    let panic_location_file = test_panic(|| {
+        let rt = runtime_without_io();
+        rt.block_on(async {
+            let _sock = UdpSocket::from_std(std_sock);
+        });
+    });
+
+    // The panic location should be in this file
+    assert_eq!(&panic_location_file.unwrap(), file!());
+
+    Ok(())
+}
+
+#[test]
+#[cfg_attr(miri, ignore)] // No `socket` in miri.
+fn tcp_listener_from_std_panic_caller() -> Result<(), Box<dyn Error>> {
+    let std_listener = std::net::TcpListener::bind("127.0.0.1:0").unwrap();
+    std_listener.set_nonblocking(true).unwrap();
+
+    let panic_location_file = test_panic(|| {
+        let rt = runtime_without_io();
+        rt.block_on(async {
+            let _ = TcpListener::from_std(std_listener);
+        });
+    });
+
+    // The panic location should be in this file
+    assert_eq!(&panic_location_file.unwrap(), file!());
+
+    Ok(())
+}
+
+#[test]
+#[cfg_attr(miri, ignore)] // No `socket` in miri.
+fn tcp_stream_from_std_panic_caller() -> Result<(), Box<dyn Error>> {
+    let std_listener = std::net::TcpListener::bind("127.0.0.1:0").unwrap();
+
+    let std_stream = std::net::TcpStream::connect(std_listener.local_addr().unwrap()).unwrap();
+    std_stream.set_nonblocking(true).unwrap();
+
+    let panic_location_file = test_panic(|| {
+        let rt = runtime_without_io();
+        rt.block_on(async {
+            let _ = TcpStream::from_std(std_stream);
+        });
+    });
+
+    // The panic location should be in this file
+    assert_eq!(&panic_location_file.unwrap(), file!());
+
+    Ok(())
+}
+
+#[test]
+#[cfg(unix)]
+#[cfg_attr(miri, ignore)] // No `socket` in miri.
+fn unix_listener_bind_panic_caller() -> Result<(), Box<dyn Error>> {
+    use tokio::net::UnixListener;
+
+    let dir = tempfile::tempdir().unwrap();
+    let sock_path = dir.path().join("socket");
+
+    let panic_location_file = test_panic(|| {
+        let rt = runtime_without_io();
+        rt.block_on(async {
+            let _ = UnixListener::bind(&sock_path);
+        });
+    });
+
+    // The panic location should be in this file
+    assert_eq!(&panic_location_file.unwrap(), file!());
+
+    Ok(())
+}
+
+#[test]
+#[cfg(unix)]
+#[cfg_attr(miri, ignore)] // No `socket` in miri.
+fn unix_listener_from_std_panic_caller() -> Result<(), Box<dyn Error>> {
+    use tokio::net::UnixListener;
+
+    let dir = tempfile::tempdir().unwrap();
+    let sock_path = dir.path().join("socket");
+    let std_listener = std::os::unix::net::UnixListener::bind(sock_path).unwrap();
+
+    let panic_location_file = test_panic(|| {
+        let rt = runtime_without_io();
+        rt.block_on(async {
+            let _ = UnixListener::from_std(std_listener);
+        });
+    });
+
+    // The panic location should be in this file
+    assert_eq!(&panic_location_file.unwrap(), file!());
+
+    Ok(())
+}
+
+#[test]
+#[cfg(unix)]
+#[cfg_attr(miri, ignore)] // No `socket` in miri.
+fn unix_stream_from_std_panic_caller() -> Result<(), Box<dyn Error>> {
+    use tokio::net::UnixStream;
+
+    let dir = tempfile::tempdir().unwrap();
+    let sock_path = dir.path().join("socket");
+    let _std_listener = std::os::unix::net::UnixListener::bind(&sock_path).unwrap();
+    let std_stream = std::os::unix::net::UnixStream::connect(&sock_path).unwrap();
+
+    let panic_location_file = test_panic(|| {
+        let rt = runtime_without_io();
+        rt.block_on(async {
+            let _ = UnixStream::from_std(std_stream);
+        });
+    });
+
+    // The panic location should be in this file
+    assert_eq!(&panic_location_file.unwrap(), file!());
+
+    Ok(())
+}
+
+#[test]
+#[cfg(unix)]
+#[cfg_attr(miri, ignore)] // No `socket` in miri.
+fn unix_datagram_from_std_panic_caller() -> Result<(), Box<dyn Error>> {
+    use std::os::unix::net::UnixDatagram as StdUDS;
+    use tokio::net::UnixDatagram;
+
+    let dir = tempfile::tempdir().unwrap();
+    let sock_path = dir.path().join("socket");
+
+    // Bind the socket to a filesystem path
+    // /let socket_path = tmp.path().join("socket");
+    let std_socket = StdUDS::bind(sock_path).unwrap();
+    std_socket.set_nonblocking(true).unwrap();
+
+    let panic_location_file = test_panic(move || {
+        let rt = runtime_without_io();
+        rt.block_on(async {
+            let _ = UnixDatagram::from_std(std_socket);
+        });
+    });
+
+    // The panic location should be in this file
+    assert_eq!(&panic_location_file.unwrap(), file!());
+
+    Ok(())
+}
+
+#[test]
+#[cfg(windows)]
+fn server_options_max_instances_panic_caller() -> Result<(), Box<dyn Error>> {
+    use tokio::net::windows::named_pipe::ServerOptions;
+
+    let panic_location_file = test_panic(move || {
+        let rt = runtime_without_io();
+        rt.block_on(async {
+            let mut options = ServerOptions::new();
+            options.max_instances(255);
+        });
+    });
+
+    // The panic location should be in this file
+    assert_eq!(&panic_location_file.unwrap(), file!());
+
+    Ok(())
+}
+
+// Runtime without `enable_io` so it has no IO driver set.
+fn runtime_without_io() -> Runtime {
+    Builder::new_current_thread().build().unwrap()
+}

vendor/tokio/tests/net_quickack.rs

@@ -0,0 +1,71 @@
+#![warn(rust_2018_idioms)]
+#![cfg(all(
+    feature = "net",
+    any(
+        target_os = "linux",
+        target_os = "android",
+        target_os = "fuchsia",
+        target_os = "cygwin",
+    )
+))]
+#![cfg(not(miri))] // No `socket` in miri.
+
+use tokio::io::{AsyncReadExt, AsyncWriteExt};
+use tokio::net::TcpListener;
+use tokio::net::TcpStream;
+use tokio::sync::oneshot;
+
+#[tokio::test]
+async fn socket_works_with_quickack() {
+    const MESSAGE: &str = "Hello, tokio!";
+
+    let (tx_port, rx_port) = oneshot::channel();
+
+    let server = tokio::spawn(async move {
+        let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
+        let addr = listener.local_addr().unwrap();
+
+        tx_port.send(addr.port()).unwrap();
+
+        let (mut stream, _) = listener.accept().await.unwrap();
+        stream.set_quickack(true).unwrap();
+        assert!(stream.quickack().unwrap());
+
+        stream.write_all(MESSAGE.as_bytes()).await.unwrap();
+
+        let mut buf = vec![0; MESSAGE.len()];
+        stream.read_exact(&mut buf).await.unwrap();
+        assert_eq!(buf, MESSAGE.as_bytes());
+
+        // There is nothing special about setting quickack to false
+        // at this point, we just want to test the `false` case.
+        stream.set_quickack(false).unwrap();
+        assert!(!stream.quickack().unwrap());
+
+        stream.shutdown().await.unwrap();
+    });
+
+    let port = rx_port.await.unwrap();
+    let client = tokio::spawn(async move {
+        let mut stream = TcpStream::connect(format!("127.0.0.1:{port}"))
+            .await
+            .unwrap();
+        stream.set_quickack(true).unwrap();
+        assert!(stream.quickack().unwrap());
+
+        let mut buf = vec![0; MESSAGE.len()];
+        stream.read_exact(&mut buf).await.unwrap();
+        assert_eq!(buf, MESSAGE.as_bytes());
+
+        stream.write_all(MESSAGE.as_bytes()).await.unwrap();
+
+        // There is nothing special about setting quickack to false
+        // at this point, we just want to test the `false` case.
+        stream.set_quickack(false).unwrap();
+        assert!(!stream.quickack().unwrap());
+
+        stream.shutdown().await.unwrap();
+    });
+
+    tokio::try_join!(server, client).unwrap();
+}

vendor/tokio/tests/net_unix_pipe.rs

@@ -0,0 +1,546 @@
+#![cfg(feature = "full")]
+#![cfg(unix)]
+
+use tokio::io::{AsyncReadExt, AsyncWriteExt, Interest};
+use tokio::net::unix::pipe;
+use tokio_test::task;
+use tokio_test::{assert_err, assert_ok, assert_pending, assert_ready_ok};
+
+use std::fs::File;
+use std::io;
+use std::os::unix::fs::OpenOptionsExt;
+use std::os::unix::io::AsRawFd;
+use std::path::{Path, PathBuf};
+
+/// Helper struct which will clean up temporary files once dropped.
+struct TempFifo {
+    path: PathBuf,
+    _dir: tempfile::TempDir,
+}
+
+impl TempFifo {
+    fn new(name: &str) -> io::Result<TempFifo> {
+        let dir = tempfile::Builder::new()
+            .prefix("tokio-fifo-tests")
+            .tempdir()?;
+        let path = dir.path().join(name);
+        nix::unistd::mkfifo(&path, nix::sys::stat::Mode::S_IRWXU)?;
+
+        Ok(TempFifo { path, _dir: dir })
+    }
+}
+
+impl AsRef<Path> for TempFifo {
+    fn as_ref(&self) -> &Path {
+        self.path.as_ref()
+    }
+}
+
+#[tokio::test]
+#[cfg_attr(miri, ignore)] // No `mkfifo` in miri.
+async fn fifo_simple_send() -> io::Result<()> {
+    const DATA: &[u8] = b"this is some data to write to the fifo";
+
+    let fifo = TempFifo::new("simple_send")?;
+
+    // Create a reading task which should wait for data from the pipe.
+    let mut reader = pipe::OpenOptions::new().open_receiver(&fifo)?;
+    let mut read_fut = task::spawn(async move {
+        let mut buf = vec![0; DATA.len()];
+        reader.read_exact(&mut buf).await?;
+        Ok::<_, io::Error>(buf)
+    });
+    assert_pending!(read_fut.poll());
+
+    let mut writer = pipe::OpenOptions::new().open_sender(&fifo)?;
+    writer.write_all(DATA).await?;
+
+    // Let the IO driver poll events for the reader.
+    while !read_fut.is_woken() {
+        tokio::task::yield_now().await;
+    }
+
+    // Reading task should be ready now.
+    let read_data = assert_ready_ok!(read_fut.poll());
+    assert_eq!(&read_data, DATA);
+
+    Ok(())
+}
+
+#[tokio::test]
+#[cfg(any(target_os = "linux", target_os = "android"))]
+#[cfg_attr(miri, ignore)] // No `mkfifo` in miri.
+async fn fifo_simple_send_sender_first() -> io::Result<()> {
+    const DATA: &[u8] = b"this is some data to write to the fifo";
+
+    // Create a new fifo file with *no reading ends open*.
+    let fifo = TempFifo::new("simple_send_sender_first")?;
+
+    // Simple `open_sender` should fail with ENXIO (no such device or address).
+    let err = assert_err!(pipe::OpenOptions::new().open_sender(&fifo));
+    assert_eq!(err.raw_os_error(), Some(libc::ENXIO));
+
+    // `open_sender` in read-write mode should succeed and the pipe should be ready to write.
+    let mut writer = pipe::OpenOptions::new()
+        .read_write(true)
+        .open_sender(&fifo)?;
+    writer.write_all(DATA).await?;
+
+    // Read the written data and validate.
+    let mut reader = pipe::OpenOptions::new().open_receiver(&fifo)?;
+    let mut read_data = vec![0; DATA.len()];
+    reader.read_exact(&mut read_data).await?;
+    assert_eq!(&read_data, DATA);
+
+    Ok(())
+}
+
+// Opens a FIFO file, write and *close the writer*.
+async fn write_and_close(path: impl AsRef<Path>, msg: &[u8]) -> io::Result<()> {
+    let mut writer = pipe::OpenOptions::new().open_sender(path)?;
+    writer.write_all(msg).await?;
+    drop(writer); // Explicit drop.
+    Ok(())
+}
+
+/// Checks EOF behavior with single reader and writers sequentially opening
+/// and closing a FIFO.
+#[tokio::test]
+#[cfg_attr(miri, ignore)] // No `mkfifo` in miri.
+async fn fifo_multiple_writes() -> io::Result<()> {
+    const DATA: &[u8] = b"this is some data to write to the fifo";
+
+    let fifo = TempFifo::new("fifo_multiple_writes")?;
+
+    let mut reader = pipe::OpenOptions::new().open_receiver(&fifo)?;
+
+    write_and_close(&fifo, DATA).await?;
+    let ev = reader.ready(Interest::READABLE).await?;
+    assert!(ev.is_readable());
+    let mut read_data = vec![0; DATA.len()];
+    assert_ok!(reader.read_exact(&mut read_data).await);
+
+    // Check that reader hits EOF.
+    let err = assert_err!(reader.read_exact(&mut read_data).await);
+    assert_eq!(err.kind(), io::ErrorKind::UnexpectedEof);
+
+    // Write more data and read again.
+    write_and_close(&fifo, DATA).await?;
+    assert_ok!(reader.read_exact(&mut read_data).await);
+
+    Ok(())
+}
+
+/// Checks behavior of a resilient reader (Receiver in O_RDWR access mode)
+/// with writers sequentially opening and closing a FIFO.
+#[tokio::test]
+#[cfg(any(target_os = "linux", target_os = "android"))]
+#[cfg_attr(miri, ignore)] // No `socket` in miri.
+async fn fifo_resilient_reader() -> io::Result<()> {
+    const DATA: &[u8] = b"this is some data to write to the fifo";
+
+    let fifo = TempFifo::new("fifo_resilient_reader")?;
+
+    // Open reader in read-write access mode.
+    let mut reader = pipe::OpenOptions::new()
+        .read_write(true)
+        .open_receiver(&fifo)?;
+
+    write_and_close(&fifo, DATA).await?;
+    let ev = reader.ready(Interest::READABLE).await?;
+    let mut read_data = vec![0; DATA.len()];
+    reader.read_exact(&mut read_data).await?;
+
+    // Check that reader didn't hit EOF.
+    assert!(!ev.is_read_closed());
+
+    // Resilient reader can asynchronously wait for the next writer.
+    let mut second_read_fut = task::spawn(reader.read_exact(&mut read_data));
+    assert_pending!(second_read_fut.poll());
+
+    // Write more data and read again.
+    write_and_close(&fifo, DATA).await?;
+    assert_ok!(second_read_fut.await);
+
+    Ok(())
+}
+
+#[tokio::test]
+#[cfg_attr(miri, ignore)] // No `O_NONBLOCK` for open64 in miri.
+async fn open_detects_not_a_fifo() -> io::Result<()> {
+    let dir = tempfile::Builder::new()
+        .prefix("tokio-fifo-tests")
+        .tempdir()
+        .unwrap();
+    let path = dir.path().join("not_a_fifo");
+
+    // Create an ordinary file.
+    File::create(&path)?;
+
+    // Check if Sender detects invalid file type.
+    let err = assert_err!(pipe::OpenOptions::new().open_sender(&path));
+    assert_eq!(err.kind(), io::ErrorKind::InvalidInput);
+
+    // Check if Receiver detects invalid file type.
+    let err = assert_err!(pipe::OpenOptions::new().open_sender(&path));
+    assert_eq!(err.kind(), io::ErrorKind::InvalidInput);
+
+    Ok(())
+}
+
+#[tokio::test]
+#[cfg_attr(miri, ignore)] // No `mkfifo` in miri.
+async fn from_file() -> io::Result<()> {
+    const DATA: &[u8] = b"this is some data to write to the fifo";
+
+    let fifo = TempFifo::new("from_file")?;
+
+    // Construct a Receiver from a File.
+    let file = std::fs::OpenOptions::new()
+        .read(true)
+        .custom_flags(libc::O_NONBLOCK)
+        .open(&fifo)?;
+    let mut reader = pipe::Receiver::from_file(file)?;
+
+    // Construct a Sender from a File.
+    let file = std::fs::OpenOptions::new()
+        .write(true)
+        .custom_flags(libc::O_NONBLOCK)
+        .open(&fifo)?;
+    let mut writer = pipe::Sender::from_file(file)?;
+
+    // Write and read some data to test async.
+    let mut read_fut = task::spawn(async move {
+        let mut buf = vec![0; DATA.len()];
+        reader.read_exact(&mut buf).await?;
+        Ok::<_, io::Error>(buf)
+    });
+    assert_pending!(read_fut.poll());
+
+    writer.write_all(DATA).await?;
+
+    let read_data = assert_ok!(read_fut.await);
+    assert_eq!(&read_data, DATA);
+
+    Ok(())
+}
+
+#[tokio::test]
+#[cfg_attr(miri, ignore)] // No `fstat` in miri.
+async fn from_file_detects_not_a_fifo() -> io::Result<()> {
+    let dir = tempfile::Builder::new()
+        .prefix("tokio-fifo-tests")
+        .tempdir()
+        .unwrap();
+    let path = dir.path().join("not_a_fifo");
+
+    // Create an ordinary file.
+    File::create(&path)?;
+
+    // Check if Sender detects invalid file type.
+    let file = std::fs::OpenOptions::new().write(true).open(&path)?;
+    let err = assert_err!(pipe::Sender::from_file(file));
+    assert_eq!(err.kind(), io::ErrorKind::InvalidInput);
+
+    // Check if Receiver detects invalid file type.
+    let file = std::fs::OpenOptions::new().read(true).open(&path)?;
+    let err = assert_err!(pipe::Receiver::from_file(file));
+    assert_eq!(err.kind(), io::ErrorKind::InvalidInput);
+
+    Ok(())
+}
+
+#[tokio::test]
+#[cfg_attr(miri, ignore)] // No `mkfifo` in miri.
+async fn from_file_detects_wrong_access_mode() -> io::Result<()> {
+    let fifo = TempFifo::new("wrong_access_mode")?;
+
+    // Open a read end to open the fifo for writing.
+    let _reader = pipe::OpenOptions::new().open_receiver(&fifo)?;
+
+    // Check if Receiver detects write-only access mode.
+    let write_only = std::fs::OpenOptions::new()
+        .write(true)
+        .custom_flags(libc::O_NONBLOCK)
+        .open(&fifo)?;
+    let err = assert_err!(pipe::Receiver::from_file(write_only));
+    assert_eq!(err.kind(), io::ErrorKind::InvalidInput);
+
+    // Check if Sender detects read-only access mode.
+    let rdonly = std::fs::OpenOptions::new()
+        .read(true)
+        .custom_flags(libc::O_NONBLOCK)
+        .open(&fifo)?;
+    let err = assert_err!(pipe::Sender::from_file(rdonly));
+    assert_eq!(err.kind(), io::ErrorKind::InvalidInput);
+
+    Ok(())
+}
+
+fn is_nonblocking<T: AsRawFd>(fd: &T) -> io::Result<bool> {
+    let flags = nix::fcntl::fcntl(fd.as_raw_fd(), nix::fcntl::F_GETFL)?;
+    Ok((flags & libc::O_NONBLOCK) != 0)
+}
+
+#[tokio::test]
+#[cfg_attr(miri, ignore)] // No `mkfifo` in miri.
+async fn from_file_sets_nonblock() -> io::Result<()> {
+    let fifo = TempFifo::new("sets_nonblock")?;
+
+    // Open read and write ends to let blocking files open.
+    let _reader = pipe::OpenOptions::new().open_receiver(&fifo)?;
+    let _writer = pipe::OpenOptions::new().open_sender(&fifo)?;
+
+    // Check if Receiver sets the pipe in non-blocking mode.
+    let rdonly = std::fs::OpenOptions::new().read(true).open(&fifo)?;
+    assert!(!is_nonblocking(&rdonly)?);
+    let reader = pipe::Receiver::from_file(rdonly)?;
+    assert!(is_nonblocking(&reader)?);
+
+    // Check if Sender sets the pipe in non-blocking mode.
+    let write_only = std::fs::OpenOptions::new().write(true).open(&fifo)?;
+    assert!(!is_nonblocking(&write_only)?);
+    let writer = pipe::Sender::from_file(write_only)?;
+    assert!(is_nonblocking(&writer)?);
+
+    Ok(())
+}
+
+fn writable_by_poll(writer: &pipe::Sender) -> bool {
+    task::spawn(writer.writable()).poll().is_ready()
+}
+
+#[tokio::test]
+#[cfg_attr(miri, ignore)] // No `mkfifo` in miri.
+async fn try_read_write() -> io::Result<()> {
+    const DATA: &[u8] = b"this is some data to write to the fifo";
+
+    // Create a pipe pair over a fifo file.
+    let fifo = TempFifo::new("try_read_write")?;
+    let reader = pipe::OpenOptions::new().open_receiver(&fifo)?;
+    let writer = pipe::OpenOptions::new().open_sender(&fifo)?;
+
+    // Fill the pipe buffer with `try_write`.
+    let mut write_data = Vec::new();
+    while writable_by_poll(&writer) {
+        match writer.try_write(DATA) {
+            Ok(n) => write_data.extend(&DATA[..n]),
+            Err(e) => {
+                assert_eq!(e.kind(), io::ErrorKind::WouldBlock);
+                break;
+            }
+        }
+    }
+
+    // Drain the pipe buffer with `try_read`.
+    let mut read_data = vec![0; write_data.len()];
+    let mut i = 0;
+    while i < write_data.len() {
+        reader.readable().await?;
+        match reader.try_read(&mut read_data[i..]) {
+            Ok(n) => i += n,
+            Err(e) => {
+                assert_eq!(e.kind(), io::ErrorKind::WouldBlock);
+                continue;
+            }
+        }
+    }
+
+    assert_eq!(read_data, write_data);
+
+    Ok(())
+}
+
+#[tokio::test]
+#[cfg_attr(miri, ignore)] // No `mkfifo` in miri.
+async fn try_read_write_vectored() -> io::Result<()> {
+    const DATA: &[u8] = b"this is some data to write to the fifo";
+
+    // Create a pipe pair over a fifo file.
+    let fifo = TempFifo::new("try_read_write_vectored")?;
+    let reader = pipe::OpenOptions::new().open_receiver(&fifo)?;
+    let writer = pipe::OpenOptions::new().open_sender(&fifo)?;
+
+    let write_bufs: Vec<_> = DATA.chunks(3).map(io::IoSlice::new).collect();
+
+    // Fill the pipe buffer with `try_write_vectored`.
+    let mut write_data = Vec::new();
+    while writable_by_poll(&writer) {
+        match writer.try_write_vectored(&write_bufs) {
+            Ok(n) => write_data.extend(&DATA[..n]),
+            Err(e) => {
+                assert_eq!(e.kind(), io::ErrorKind::WouldBlock);
+                break;
+            }
+        }
+    }
+
+    // Drain the pipe buffer with `try_read_vectored`.
+    let mut read_data = vec![0; write_data.len()];
+    let mut i = 0;
+    while i < write_data.len() {
+        reader.readable().await?;
+
+        let mut read_bufs: Vec<_> = read_data[i..]
+            .chunks_mut(0x10000)
+            .map(io::IoSliceMut::new)
+            .collect();
+        match reader.try_read_vectored(&mut read_bufs) {
+            Ok(n) => i += n,
+            Err(e) => {
+                assert_eq!(e.kind(), io::ErrorKind::WouldBlock);
+                continue;
+            }
+        }
+    }
+
+    assert_eq!(read_data, write_data);
+
+    Ok(())
+}
+
+#[tokio::test]
+#[cfg_attr(miri, ignore)] // No `mkfifo` in miri.
+async fn try_read_buf() -> std::io::Result<()> {
+    const DATA: &[u8] = b"this is some data to write to the fifo";
+
+    // Create a pipe pair over a fifo file.
+    let fifo = TempFifo::new("try_read_write_vectored")?;
+    let reader = pipe::OpenOptions::new().open_receiver(&fifo)?;
+    let writer = pipe::OpenOptions::new().open_sender(&fifo)?;
+
+    // Fill the pipe buffer with `try_write`.
+    let mut write_data = Vec::new();
+    while writable_by_poll(&writer) {
+        match writer.try_write(DATA) {
+            Ok(n) => write_data.extend(&DATA[..n]),
+            Err(e) => {
+                assert_eq!(e.kind(), io::ErrorKind::WouldBlock);
+                break;
+            }
+        }
+    }
+
+    // Drain the pipe buffer with `try_read_buf`.
+    let mut read_data = vec![0; write_data.len()];
+    let mut i = 0;
+    while i < write_data.len() {
+        reader.readable().await?;
+        match reader.try_read_buf(&mut read_data) {
+            Ok(n) => i += n,
+            Err(e) => {
+                assert_eq!(e.kind(), io::ErrorKind::WouldBlock);
+                continue;
+            }
+        }
+    }
+
+    assert_eq!(read_data, write_data);
+
+    Ok(())
+}
+
+#[tokio::test]
+async fn anon_pipe_simple_send() -> io::Result<()> {
+    const DATA: &[u8] = b"this is some data to write to the pipe";
+
+    let (mut writer, mut reader) = pipe::pipe()?;
+
+    // Create a reading task which should wait for data from the pipe.
+    let mut read_fut = task::spawn(async move {
+        let mut buf = vec![0; DATA.len()];
+        reader.read_exact(&mut buf).await?;
+        Ok::<_, io::Error>(buf)
+    });
+    assert_pending!(read_fut.poll());
+
+    writer.write_all(DATA).await?;
+
+    // Let the IO driver poll events for the reader.
+    while !read_fut.is_woken() {
+        tokio::task::yield_now().await;
+    }
+
+    // Reading task should be ready now.
+    let read_data = assert_ready_ok!(read_fut.poll());
+    assert_eq!(&read_data, DATA);
+
+    Ok(())
+}
+
+#[tokio::test]
+#[cfg_attr(miri, ignore)] // No `pidfd_spawnp` in miri.
+async fn anon_pipe_spawn_echo() -> std::io::Result<()> {
+    use tokio::process::Command;
+
+    const DATA: &str = "this is some data to write to the pipe";
+
+    let (tx, mut rx) = pipe::pipe()?;
+
+    let status = Command::new("echo")
+        .arg("-n")
+        .arg(DATA)
+        .stdout(tx.into_blocking_fd()?)
+        .status();
+
+    let mut buf = vec![0; DATA.len()];
+    rx.read_exact(&mut buf).await?;
+    assert_eq!(String::from_utf8(buf).unwrap(), DATA);
+
+    let exit_code = status.await?;
+    assert!(exit_code.success());
+
+    // Check if the pipe is closed.
+    buf = Vec::new();
+    let total = assert_ok!(rx.try_read(&mut buf));
+    assert_eq!(total, 0);
+
+    Ok(())
+}
+
+#[tokio::test]
+#[cfg(target_os = "linux")]
+#[cfg_attr(miri, ignore)] // No `fstat` in miri.
+async fn anon_pipe_from_owned_fd() -> std::io::Result<()> {
+    use nix::fcntl::OFlag;
+
+    const DATA: &[u8] = b"this is some data to write to the pipe";
+
+    let (rx_fd, tx_fd) = nix::unistd::pipe2(OFlag::O_CLOEXEC | OFlag::O_NONBLOCK)?;
+
+    let mut rx = pipe::Receiver::from_owned_fd(rx_fd)?;
+    let mut tx = pipe::Sender::from_owned_fd(tx_fd)?;
+
+    let mut buf = vec![0; DATA.len()];
+    tx.write_all(DATA).await?;
+    rx.read_exact(&mut buf).await?;
+    assert_eq!(buf, DATA);
+
+    Ok(())
+}
+
+#[tokio::test]
+async fn anon_pipe_into_nonblocking_fd() -> std::io::Result<()> {
+    let (tx, rx) = pipe::pipe()?;
+
+    let tx_fd = tx.into_nonblocking_fd()?;
+    let rx_fd = rx.into_nonblocking_fd()?;
+
+    assert!(is_nonblocking(&tx_fd)?);
+    assert!(is_nonblocking(&rx_fd)?);
+
+    Ok(())
+}
+
+#[tokio::test]
+async fn anon_pipe_into_blocking_fd() -> std::io::Result<()> {
+    let (tx, rx) = pipe::pipe()?;
+
+    let tx_fd = tx.into_blocking_fd()?;
+    let rx_fd = rx.into_blocking_fd()?;
+
+    assert!(!is_nonblocking(&tx_fd)?);
+    assert!(!is_nonblocking(&rx_fd)?);
+
+    Ok(())
+}

vendor/tokio/tests/no_rt.rs

@@ -0,0 +1,47 @@
+#![cfg(all(feature = "full", not(target_os = "wasi")))] // Wasi does not support panic recovery
+
+use tokio::net::TcpStream;
+use tokio::sync::oneshot;
+use tokio::time::{timeout, Duration};
+
+use futures::executor::block_on;
+
+use std::net::TcpListener;
+
+#[test]
+#[should_panic(
+    expected = "there is no reactor running, must be called from the context of a Tokio 1.x runtime"
+)]
+fn timeout_panics_when_no_tokio_context() {
+    block_on(timeout_value());
+}
+
+#[test]
+#[should_panic(
+    expected = "there is no reactor running, must be called from the context of a Tokio 1.x runtime"
+)]
+#[cfg_attr(miri, ignore)] // No `socket` in miri.
+fn panics_when_no_reactor() {
+    let srv = TcpListener::bind("127.0.0.1:0").unwrap();
+    let addr = srv.local_addr().unwrap();
+    block_on(TcpStream::connect(&addr)).unwrap();
+}
+
+async fn timeout_value() {
+    let (_tx, rx) = oneshot::channel::<()>();
+    let dur = Duration::from_millis(10);
+    let _ = timeout(dur, rx).await;
+}
+
+#[test]
+#[should_panic(
+    expected = "there is no reactor running, must be called from the context of a Tokio 1.x runtime"
+)]
+#[cfg_attr(miri, ignore)] // No `socket` in miri.
+fn io_panics_when_no_tokio_context() {
+    let listener = std::net::TcpListener::bind("127.0.0.1:0").unwrap();
+
+    listener.set_nonblocking(true).unwrap();
+
+    let _ = tokio::net::TcpListener::from_std(listener);
+}

vendor/tokio/tests/process_arg0.rs

@@ -0,0 +1,13 @@
+#![warn(rust_2018_idioms)]
+#![cfg(all(feature = "full", unix, not(miri)))]
+
+use tokio::process::Command;
+
+#[tokio::test]
+async fn arg0() {
+    let mut cmd = Command::new("sh");
+    cmd.arg0("test_string").arg("-c").arg("echo $0");
+
+    let output = cmd.output().await.unwrap();
+    assert_eq!(output.stdout, b"test_string\n");
+}

vendor/tokio/tests/process_change_of_runtime.rs

@@ -0,0 +1,34 @@
+#![cfg(feature = "process")]
+#![warn(rust_2018_idioms)]
+// This tests test the behavior of `process::Command::spawn` when it is used
+// outside runtime, and when `process::Child::wait ` is used in a different
+// runtime from which `process::Command::spawn` is used.
+#![cfg(all(unix, not(target_os = "freebsd"), not(miri)))] // Miri cannot run system commands
+
+use std::process::Stdio;
+use tokio::{process::Command, runtime::Runtime};
+
+#[test]
+fn process_spawned_and_wait_in_different_runtime() {
+    let mut child = Runtime::new().unwrap().block_on(async {
+        Command::new("true")
+            .stdin(Stdio::piped())
+            .stdout(Stdio::null())
+            .spawn()
+            .unwrap()
+    });
+    Runtime::new().unwrap().block_on(async {
+        let _ = child.wait().await.unwrap();
+    });
+}
+
+#[test]
+#[should_panic(
+    expected = "there is no reactor running, must be called from the context of a Tokio 1.x runtime"
+)]
+fn process_spawned_outside_runtime() {
+    let _ = Command::new("true")
+        .stdin(Stdio::piped())
+        .stdout(Stdio::null())
+        .spawn();
+}

vendor/tokio/tests/process_issue_2174.rs

@@ -0,0 +1,46 @@
+#![cfg(feature = "process")]
+#![warn(rust_2018_idioms)]
+// This test reveals a difference in behavior of kqueue on FreeBSD. When the
+// reader disconnects, there does not seem to be an `EVFILT_WRITE` filter that
+// is returned.
+//
+// It is expected that `EVFILT_WRITE` would be returned with either the
+// `EV_EOF` or `EV_ERROR` flag set. If either flag is set a write would be
+// attempted, but that does not seem to occur.
+#![cfg(all(unix, not(target_os = "freebsd"), not(miri)))]
+
+use std::process::Stdio;
+use std::time::Duration;
+use tokio::io::AsyncWriteExt;
+use tokio::process::Command;
+use tokio::time;
+use tokio_test::assert_err;
+
+#[tokio::test]
+#[cfg_attr(panic = "abort", ignore)]
+async fn issue_2174() {
+    let mut child = Command::new("sleep")
+        .arg("2")
+        .stdin(Stdio::piped())
+        .stdout(Stdio::null())
+        .spawn()
+        .unwrap();
+    let mut input = child.stdin.take().unwrap();
+
+    // Writes will buffer up to 65_636. This *should* loop at least 8 times
+    // and then register interest.
+    let handle = tokio::spawn(async move {
+        let data = [0u8; 8192];
+        loop {
+            input.write_all(&data).await.unwrap();
+        }
+    });
+
+    // Sleep enough time so that the child process's stdin's buffer fills.
+    time::sleep(Duration::from_secs(1)).await;
+
+    // Kill the child process.
+    child.kill().await.unwrap();
+
+    assert_err!(handle.await);
+}

vendor/tokio/tests/process_issue_42.rs

@@ -0,0 +1,39 @@
+#![warn(rust_2018_idioms)]
+#![cfg(feature = "full")]
+#![cfg(unix)]
+#![cfg(not(miri))]
+
+use futures::future::join_all;
+use std::process::Stdio;
+use tokio::process::Command;
+use tokio::task;
+
+#[tokio::test]
+async fn issue_42() {
+    // We spawn a many batches of processes which should exit at roughly the
+    // same time (modulo OS scheduling delays), to make sure that consuming
+    // a readiness event for one process doesn't inadvertently starve another.
+    // We then do this many times (in parallel) in an effort to stress test the
+    // implementation to ensure there are no race conditions.
+    // See alexcrichton/tokio-process#42 for background
+    let join_handles = (0..10usize).map(|_| {
+        task::spawn(async {
+            let processes = (0..10usize).map(|i| {
+                let mut child = Command::new("echo")
+                    .arg(format!("I am spawned process #{i}"))
+                    .stdin(Stdio::null())
+                    .stdout(Stdio::null())
+                    .stderr(Stdio::null())
+                    .kill_on_drop(true)
+                    .spawn()
+                    .unwrap();
+
+                async move { child.wait().await }
+            });
+
+            join_all(processes).await;
+        })
+    });
+
+    join_all(join_handles).await;
+}

vendor/tokio/tests/process_issue_7144.rs

@@ -0,0 +1,36 @@
+#![cfg(feature = "process")]
+#![warn(rust_2018_idioms)]
+#![cfg(target_os = "linux")]
+#![cfg(not(miri))]
+
+use tokio::process::Command;
+use tokio::time::{sleep, Duration};
+
+#[tokio::test]
+async fn issue_7144() {
+    let mut threads = vec![];
+    for _ in 0..20 {
+        threads.push(tokio::spawn(test_one()));
+    }
+    for thread in threads {
+        thread.await.unwrap();
+    }
+}
+
+async fn has_strace() -> bool {
+    Command::new("strace").arg("-V").output().await.is_ok()
+}
+
+async fn test_one() {
+    if !has_strace().await {
+        return;
+    }
+
+    let mut t = Command::new("strace")
+        .args("-o /dev/null -D sleep 5".split(' '))
+        .spawn()
+        .unwrap();
+    sleep(Duration::from_millis(100)).await;
+    unsafe { libc::kill(t.id().unwrap() as _, libc::SIGINT) };
+    t.wait().await.unwrap();
+}

vendor/tokio/tests/process_kill_after_wait.rs

@@ -0,0 +1,27 @@
+#![warn(rust_2018_idioms)]
+#![cfg(all(feature = "full", not(target_os = "wasi"), not(miri)))] // Wasi/Miri cannot run system commands
+
+use tokio::process::Command;
+
+#[tokio::test]
+async fn kill_after_wait() {
+    let mut cmd;
+
+    if cfg!(windows) {
+        cmd = Command::new("cmd");
+        cmd.arg("/c");
+    } else {
+        cmd = Command::new("sh");
+        cmd.arg("-c");
+    }
+
+    let mut child = cmd.arg("exit 2").spawn().unwrap();
+
+    child.start_kill().unwrap();
+
+    child.wait().await.unwrap();
+
+    // Kill after `wait` is fine.
+    child.start_kill().unwrap();
+    child.kill().await.unwrap();
+}

vendor/tokio/tests/process_kill_on_drop.rs

@@ -0,0 +1,44 @@
+#![cfg(all(unix, feature = "process", not(miri)))]
+#![warn(rust_2018_idioms)]
+
+use std::io::ErrorKind;
+use std::process::Stdio;
+use std::time::Duration;
+use tokio::io::AsyncReadExt;
+use tokio::process::Command;
+use tokio::time::sleep;
+use tokio_test::assert_ok;
+
+#[tokio::test]
+async fn kill_on_drop() {
+    let mut cmd = Command::new("bash");
+    cmd.args([
+        "-c",
+        "
+       # Fork another child that won't get killed
+       sh -c 'sleep 1; echo child ran' &
+       disown -a
+
+       # Await our death
+       sleep 5
+       echo hello from beyond the grave
+    ",
+    ]);
+
+    let e = cmd.kill_on_drop(true).stdout(Stdio::piped()).spawn();
+    if e.is_err() && e.as_ref().unwrap_err().kind() == ErrorKind::NotFound {
+        println!("bash not available; skipping test");
+        return;
+    }
+    let mut child = e.unwrap();
+
+    sleep(Duration::from_secs(2)).await;
+
+    let mut out = child.stdout.take().unwrap();
+    drop(child);
+
+    let mut msg = String::new();
+    assert_ok!(out.read_to_string(&mut msg).await);
+
+    assert_eq!("child ran\n", msg);
+}

vendor/tokio/tests/process_raw_handle.rs

@@ -0,0 +1,24 @@
+#![warn(rust_2018_idioms)]
+#![cfg(feature = "full")]
+#![cfg(windows)]
+#![cfg(not(miri))]
+
+use tokio::process::Command;
+use windows_sys::Win32::System::Threading::GetProcessId;
+
+#[tokio::test]
+async fn obtain_raw_handle() {
+    let mut cmd = Command::new("cmd");
+    cmd.kill_on_drop(true);
+    cmd.arg("/c");
+    cmd.arg("pause");
+
+    let child = cmd.spawn().unwrap();
+
+    let orig_id = child.id().expect("missing id");
+    assert!(orig_id > 0);
+
+    let handle = child.raw_handle().expect("process stopped");
+    let handled_id = unsafe { GetProcessId(handle as _) };
+    assert_eq!(handled_id, orig_id);
+}

vendor/tokio/tests/process_smoke.rs

@@ -0,0 +1,34 @@
+#![warn(rust_2018_idioms)]
+#![cfg(all(feature = "full", not(target_os = "wasi"), not(miri)))] // Wasi/Miri cannot run system commands
+
+use tokio::process::Command;
+use tokio_test::assert_ok;
+
+#[tokio::test]
+async fn simple() {
+    let mut cmd;
+
+    if cfg!(windows) {
+        cmd = Command::new("cmd");
+        cmd.arg("/c");
+    } else {
+        cmd = Command::new("sh");
+        cmd.arg("-c");
+    }
+
+    let mut child = cmd.arg("exit 2").spawn().unwrap();
+
+    let id = child.id().expect("missing id");
+    assert!(id > 0);
+
+    let status = assert_ok!(child.wait().await);
+    assert_eq!(status.code(), Some(2));
+
+    // test that the `.wait()` method is fused just like the stdlib
+    let status = assert_ok!(child.wait().await);
+    assert_eq!(status.code(), Some(2));
+
+    // Can't get id after process has exited
+    assert_eq!(child.id(), None);
+    drop(child.kill());
+}

vendor/tokio/tests/rt_basic.rs

@@ -0,0 +1,499 @@
+#![warn(rust_2018_idioms)]
+#![cfg(feature = "full")]
+
+use tokio::runtime::Runtime;
+use tokio::sync::oneshot;
+use tokio::time::{timeout, Duration};
+use tokio_test::{assert_err, assert_ok};
+
+use std::future::Future;
+use std::pin::Pin;
+use std::sync::atomic::{AtomicBool, Ordering};
+use std::task::{Context, Poll};
+use std::thread;
+
+mod support {
+    pub(crate) mod mpsc_stream;
+}
+
+macro_rules! cfg_metrics {
+    ($($t:tt)*) => {
+        #[cfg(all(tokio_unstable, target_has_atomic = "64"))]
+        {
+            $( $t )*
+        }
+    }
+}
+
+#[test]
+fn spawned_task_does_not_progress_without_block_on() {
+    let (tx, mut rx) = oneshot::channel();
+
+    let rt = rt();
+
+    rt.spawn(async move {
+        assert_ok!(tx.send("hello"));
+    });
+
+    thread::sleep(Duration::from_millis(50));
+
+    assert_err!(rx.try_recv());
+
+    let out = rt.block_on(async { assert_ok!(rx.await) });
+
+    assert_eq!(out, "hello");
+}
+
+#[test]
+fn no_extra_poll() {
+    use pin_project_lite::pin_project;
+    use std::pin::Pin;
+    use std::sync::{
+        atomic::{AtomicUsize, Ordering::SeqCst},
+        Arc,
+    };
+    use std::task::{Context, Poll};
+    use tokio_stream::{Stream, StreamExt};
+
+    pin_project! {
+        struct TrackPolls<S> {
+            npolls: Arc<AtomicUsize>,
+            #[pin]
+            s: S,
+        }
+    }
+
+    impl<S> Stream for TrackPolls<S>
+    where
+        S: Stream,
+    {
+        type Item = S::Item;
+        fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
+            let this = self.project();
+            this.npolls.fetch_add(1, SeqCst);
+            this.s.poll_next(cx)
+        }
+    }
+
+    let (tx, rx) = support::mpsc_stream::unbounded_channel_stream::<()>();
+    let rx = TrackPolls {
+        npolls: Arc::new(AtomicUsize::new(0)),
+        s: rx,
+    };
+    let npolls = Arc::clone(&rx.npolls);
+
+    let rt = rt();
+
+    // TODO: could probably avoid this, but why not.
+    let mut rx = Box::pin(rx);
+
+    rt.spawn(async move { while rx.next().await.is_some() {} });
+    rt.block_on(async {
+        tokio::task::yield_now().await;
+    });
+
+    // should have been polled exactly once: the initial poll
+    assert_eq!(npolls.load(SeqCst), 1);
+
+    tx.send(()).unwrap();
+    rt.block_on(async {
+        tokio::task::yield_now().await;
+    });
+
+    // should have been polled twice more: once to yield Some(), then once to yield Pending
+    assert_eq!(npolls.load(SeqCst), 1 + 2);
+
+    drop(tx);
+    rt.block_on(async {
+        tokio::task::yield_now().await;
+    });
+
+    // should have been polled once more: to yield None
+    assert_eq!(npolls.load(SeqCst), 1 + 2 + 1);
+}
+
+#[test]
+fn acquire_mutex_in_drop() {
+    use futures::future::pending;
+    use tokio::task;
+
+    let (tx1, rx1) = oneshot::channel();
+    let (tx2, rx2) = oneshot::channel();
+
+    let rt = rt();
+
+    rt.spawn(async move {
+        let _ = rx2.await;
+        unreachable!();
+    });
+
+    rt.spawn(async move {
+        let _ = rx1.await;
+        tx2.send(()).unwrap();
+        unreachable!();
+    });
+
+    // Spawn a task that will never notify
+    rt.spawn(async move {
+        pending::<()>().await;
+        tx1.send(()).unwrap();
+    });
+
+    // Tick the loop
+    rt.block_on(async {
+        task::yield_now().await;
+    });
+
+    // Drop the rt
+    drop(rt);
+}
+
+#[test]
+fn drop_tasks_in_context() {
+    static SUCCESS: AtomicBool = AtomicBool::new(false);
+
+    struct ContextOnDrop;
+
+    impl Future for ContextOnDrop {
+        type Output = ();
+
+        fn poll(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<()> {
+            Poll::Pending
+        }
+    }
+
+    impl Drop for ContextOnDrop {
+        fn drop(&mut self) {
+            if tokio::runtime::Handle::try_current().is_ok() {
+                SUCCESS.store(true, Ordering::SeqCst);
+            }
+        }
+    }
+
+    let rt = rt();
+    rt.spawn(ContextOnDrop);
+    drop(rt);
+
+    assert!(SUCCESS.load(Ordering::SeqCst));
+}
+
+#[test]
+#[cfg_attr(target_os = "wasi", ignore = "Wasi does not support panic recovery")]
+#[should_panic(expected = "boom")]
+fn wake_in_drop_after_panic() {
+    struct WakeOnDrop(Option<oneshot::Sender<()>>);
+
+    impl Drop for WakeOnDrop {
+        fn drop(&mut self) {
+            let _ = self.0.take().unwrap().send(());
+        }
+    }
+
+    let rt = rt();
+
+    let (tx1, rx1) = oneshot::channel::<()>();
+    let (tx2, rx2) = oneshot::channel::<()>();
+
+    // Spawn two tasks. We don't know the order in which they are dropped, so we
+    // make both tasks identical. When the first task is dropped, we wake up the
+    // second task. This ensures that we trigger a wakeup on a live task while
+    // handling the "boom" panic, no matter the order in which the tasks are
+    // dropped.
+    rt.spawn(async move {
+        let _wake_on_drop = WakeOnDrop(Some(tx2));
+        let _ = rx1.await;
+        unreachable!()
+    });
+
+    rt.spawn(async move {
+        let _wake_on_drop = WakeOnDrop(Some(tx1));
+        let _ = rx2.await;
+        unreachable!()
+    });
+
+    rt.block_on(async {
+        tokio::task::yield_now().await;
+        panic!("boom");
+    });
+}
+
+#[test]
+fn spawn_two() {
+    let rt = rt();
+
+    let out = rt.block_on(async {
+        let (tx, rx) = oneshot::channel();
+
+        tokio::spawn(async move {
+            tokio::spawn(async move {
+                tx.send("ZOMG").unwrap();
+            });
+        });
+
+        assert_ok!(rx.await)
+    });
+
+    assert_eq!(out, "ZOMG");
+
+    cfg_metrics! {
+        let metrics = rt.metrics();
+        drop(rt);
+        assert_eq!(0, metrics.remote_schedule_count());
+
+        let mut local = 0;
+        for i in 0..metrics.num_workers() {
+            local += metrics.worker_local_schedule_count(i);
+        }
+
+        assert_eq!(2, local);
+    }
+}
+
+#[cfg_attr(target_os = "wasi", ignore = "WASI: std::thread::spawn not supported")]
+#[test]
+fn spawn_remote() {
+    let rt = rt();
+
+    let out = rt.block_on(async {
+        let (tx, rx) = oneshot::channel();
+
+        let handle = tokio::spawn(async move {
+            std::thread::spawn(move || {
+                std::thread::sleep(Duration::from_millis(10));
+                tx.send("ZOMG").unwrap();
+            });
+
+            rx.await.unwrap()
+        });
+
+        handle.await.unwrap()
+    });
+
+    assert_eq!(out, "ZOMG");
+
+    cfg_metrics! {
+        let metrics = rt.metrics();
+        drop(rt);
+        assert_eq!(1, metrics.remote_schedule_count());
+
+        let mut local = 0;
+        for i in 0..metrics.num_workers() {
+            local += metrics.worker_local_schedule_count(i);
+        }
+
+        assert_eq!(1, local);
+    }
+}
+
+#[test]
+#[cfg_attr(target_os = "wasi", ignore = "Wasi does not support panic recovery")]
+#[should_panic(
+    expected = "A Tokio 1.x context was found, but timers are disabled. Call `enable_time` on the runtime builder to enable timers."
+)]
+fn timeout_panics_when_no_time_handle() {
+    let rt = tokio::runtime::Builder::new_current_thread()
+        .build()
+        .unwrap();
+    rt.block_on(async {
+        let (_tx, rx) = oneshot::channel::<()>();
+        let dur = Duration::from_millis(20);
+        let _ = timeout(dur, rx).await;
+    });
+}
+
+#[cfg(tokio_unstable)]
+mod unstable {
+    use tokio::runtime::{Builder, RngSeed, UnhandledPanic};
+
+    #[test]
+    #[should_panic(
+        expected = "a spawned task panicked and the runtime is configured to shut down on unhandled panic"
+    )]
+    fn shutdown_on_panic() {
+        let rt = Builder::new_current_thread()
+            .unhandled_panic(UnhandledPanic::ShutdownRuntime)
+            .build()
+            .unwrap();
+
+        rt.block_on(async {
+            tokio::spawn(async {
+                panic!("boom");
+            });
+
+            futures::future::pending::<()>().await;
+        })
+    }
+
+    #[test]
+    #[cfg_attr(target_os = "wasi", ignore = "Wasi does not support panic recovery")]
+    fn spawns_do_nothing() {
+        use std::sync::Arc;
+
+        let rt = Builder::new_current_thread()
+            .unhandled_panic(UnhandledPanic::ShutdownRuntime)
+            .build()
+            .unwrap();
+
+        let rt1 = Arc::new(rt);
+        let rt2 = rt1.clone();
+
+        let _ = std::thread::spawn(move || {
+            rt2.block_on(async {
+                tokio::spawn(async {
+                    panic!("boom");
+                });
+
+                futures::future::pending::<()>().await;
+            })
+        })
+        .join();
+
+        let task = rt1.spawn(async {});
+        let res = futures::executor::block_on(task);
+        assert!(res.is_err());
+    }
+
+    #[test]
+    #[cfg_attr(target_os = "wasi", ignore = "Wasi does not support panic recovery")]
+    fn shutdown_all_concurrent_block_on() {
+        const N: usize = 2;
+        use std::sync::{mpsc, Arc};
+
+        let rt = Builder::new_current_thread()
+            .unhandled_panic(UnhandledPanic::ShutdownRuntime)
+            .build()
+            .unwrap();
+
+        let rt = Arc::new(rt);
+        let mut threads = vec![];
+        let (tx, rx) = mpsc::channel();
+
+        for _ in 0..N {
+            let rt = rt.clone();
+            let tx = tx.clone();
+            threads.push(std::thread::spawn(move || {
+                rt.block_on(async {
+                    tx.send(()).unwrap();
+                    futures::future::pending::<()>().await;
+                });
+            }));
+        }
+
+        for _ in 0..N {
+            rx.recv().unwrap();
+        }
+
+        rt.spawn(async {
+            panic!("boom");
+        });
+
+        for thread in threads {
+            assert!(thread.join().is_err());
+        }
+    }
+
+    #[test]
+    fn rng_seed() {
+        let seed = b"bytes used to generate seed";
+        let rt1 = tokio::runtime::Builder::new_current_thread()
+            .rng_seed(RngSeed::from_bytes(seed))
+            .build()
+            .unwrap();
+        let rt1_values = rt1.block_on(async {
+            let rand_1 = tokio::macros::support::thread_rng_n(100);
+            let rand_2 = tokio::macros::support::thread_rng_n(100);
+
+            (rand_1, rand_2)
+        });
+
+        let rt2 = tokio::runtime::Builder::new_current_thread()
+            .rng_seed(RngSeed::from_bytes(seed))
+            .build()
+            .unwrap();
+        let rt2_values = rt2.block_on(async {
+            let rand_1 = tokio::macros::support::thread_rng_n(100);
+            let rand_2 = tokio::macros::support::thread_rng_n(100);
+
+            (rand_1, rand_2)
+        });
+
+        assert_eq!(rt1_values, rt2_values);
+    }
+
+    #[test]
+    fn rng_seed_multi_enter() {
+        let seed = b"bytes used to generate seed";
+
+        fn two_rand_values() -> (u32, u32) {
+            let rand_1 = tokio::macros::support::thread_rng_n(100);
+            let rand_2 = tokio::macros::support::thread_rng_n(100);
+
+            (rand_1, rand_2)
+        }
+
+        let rt1 = tokio::runtime::Builder::new_current_thread()
+            .rng_seed(RngSeed::from_bytes(seed))
+            .build()
+            .unwrap();
+        let rt1_values_1 = rt1.block_on(async { two_rand_values() });
+        let rt1_values_2 = rt1.block_on(async { two_rand_values() });
+
+        let rt2 = tokio::runtime::Builder::new_current_thread()
+            .rng_seed(RngSeed::from_bytes(seed))
+            .build()
+            .unwrap();
+        let rt2_values_1 = rt2.block_on(async { two_rand_values() });
+        let rt2_values_2 = rt2.block_on(async { two_rand_values() });
+
+        assert_eq!(rt1_values_1, rt2_values_1);
+        assert_eq!(rt1_values_2, rt2_values_2);
+    }
+}
+
+fn rt() -> Runtime {
+    tokio::runtime::Builder::new_current_thread()
+        .enable_all()
+        .build()
+        .unwrap()
+}
+
+#[test]
+fn before_park_yields() {
+    use futures::task::ArcWake;
+    use std::sync::Arc;
+    use tokio::runtime::Builder;
+    use tokio::sync::Notify;
+
+    struct MyWaker(Notify);
+
+    impl ArcWake for MyWaker {
+        fn wake_by_ref(arc_self: &Arc<Self>) {
+            arc_self.0.notify_one();
+        }
+    }
+
+    let notify = Arc::new(MyWaker(Notify::new()));
+    let notify2 = notify.clone();
+    let waker = futures::task::waker(notify2);
+    let woken = Arc::new(AtomicBool::new(false));
+    let woken2 = woken.clone();
+
+    let rt = Builder::new_current_thread()
+        .enable_all()
+        .on_thread_park(move || {
+            if !woken2.swap(true, Ordering::SeqCst) {
+                let mut cx = Context::from_waker(&waker);
+                // `yield_now` pushes the waker to the defer slot.
+                let fut = std::pin::pin!(tokio::task::yield_now());
+                let _ = fut.poll(&mut cx);
+            }
+        })
+        .build()
+        .unwrap();
+
+    rt.block_on(async {
+        notify.0.notified().await;
+    });
+
+    assert!(woken.load(Ordering::SeqCst));
+}

vendor/tokio/tests/rt_common_before_park.rs

@@ -0,0 +1,92 @@
+#![warn(rust_2018_idioms)]
+#![cfg(feature = "full")]
+#![cfg(not(target_os = "wasi"))] // Wasi doesn't support threads
+
+use std::sync::atomic::{AtomicBool, Ordering};
+use std::sync::Arc;
+use tokio::runtime::Builder;
+use tokio::sync::Notify;
+
+#[test]
+fn before_park_wakes_block_on_task() {
+    let notify = Arc::new(Notify::new());
+    let notify2 = notify.clone();
+    let woken = Arc::new(AtomicBool::new(false));
+    let woken2 = woken.clone();
+
+    let rt = Builder::new_current_thread()
+        .enable_all()
+        .on_thread_park(move || {
+            // Only wake once to avoid busy loop if something goes wrong,
+            // though in this test we expect it to unpark immediately.
+            if !woken2.swap(true, Ordering::SeqCst) {
+                notify2.notify_one();
+            }
+        })
+        .build()
+        .unwrap();
+
+    rt.block_on(async {
+        // This will block until `notify` is notified.
+        // `before_park` should run when the runtime is about to park.
+        // It will notify `notify`, which should wake this task.
+        // The runtime should then see the task is woken and NOT park.
+        notify.notified().await;
+    });
+
+    assert!(woken.load(Ordering::SeqCst));
+}
+
+#[test]
+fn before_park_spawns_task() {
+    let notify = Arc::new(Notify::new());
+    let notify2 = notify.clone();
+    let woken = Arc::new(AtomicBool::new(false));
+    let woken2 = woken.clone();
+
+    let rt = Builder::new_current_thread()
+        .enable_all()
+        .on_thread_park(move || {
+            if !woken2.swap(true, Ordering::SeqCst) {
+                let notify = notify2.clone();
+                tokio::spawn(async move {
+                    notify.notify_one();
+                });
+            }
+        })
+        .build()
+        .unwrap();
+
+    rt.block_on(async {
+        // This will block until `notify` is notified.
+        // `before_park` should run when the runtime is about to park.
+        // It will spawn a task that notifies `notify`.
+        // The runtime should see the new task and NOT park.
+        // If it parks, it will deadlock.
+        notify.notified().await;
+    });
+
+    assert!(woken.load(Ordering::SeqCst));
+}
+
+#[test]
+fn wake_from_other_thread_block_on() {
+    let rt = Builder::new_current_thread().enable_all().build().unwrap();
+    let handle = rt.handle().clone();
+    let notify = Arc::new(Notify::new());
+    let notify2 = notify.clone();
+
+    let th = std::thread::spawn(move || {
+        // Give the main thread time to park
+        std::thread::sleep(std::time::Duration::from_millis(5));
+        handle.block_on(async move {
+            notify2.notify_one();
+        });
+    });
+
+    rt.block_on(async {
+        notify.notified().await;
+    });
+
+    th.join().unwrap();
+}

vendor/tokio/tests/rt_handle.rs

@@ -0,0 +1,125 @@
+#![warn(rust_2018_idioms)]
+#![cfg(feature = "full")]
+
+use std::sync::Arc;
+use tokio::runtime::Runtime;
+use tokio::sync::{mpsc, Barrier};
+
+#[test]
+#[cfg_attr(panic = "abort", ignore)]
+fn basic_enter() {
+    let rt1 = rt();
+    let rt2 = rt();
+
+    let enter1 = rt1.enter();
+    let enter2 = rt2.enter();
+
+    drop(enter2);
+    drop(enter1);
+}
+
+#[test]
+#[should_panic]
+#[cfg_attr(panic = "abort", ignore)]
+fn interleave_enter_different_rt() {
+    let rt1 = rt();
+    let rt2 = rt();
+
+    let enter1 = rt1.enter();
+    let enter2 = rt2.enter();
+
+    drop(enter1);
+    drop(enter2);
+}
+
+#[test]
+#[should_panic]
+#[cfg_attr(panic = "abort", ignore)]
+fn interleave_enter_same_rt() {
+    let rt1 = rt();
+
+    let _enter1 = rt1.enter();
+    let enter2 = rt1.enter();
+    let enter3 = rt1.enter();
+
+    drop(enter2);
+    drop(enter3);
+}
+
+#[test]
+#[cfg(not(target_os = "wasi"))]
+#[cfg_attr(panic = "abort", ignore)]
+fn interleave_then_enter() {
+    let _ = std::panic::catch_unwind(|| {
+        let rt1 = rt();
+        let rt2 = rt();
+
+        let enter1 = rt1.enter();
+        let enter2 = rt2.enter();
+
+        drop(enter1);
+        drop(enter2);
+    });
+
+    // Can still enter
+    let rt3 = rt();
+    let _enter = rt3.enter();
+}
+
+// If the cycle causes a leak, then miri will catch it.
+#[test]
+fn drop_tasks_with_reference_cycle() {
+    rt().block_on(async {
+        let (tx, mut rx) = mpsc::channel(1);
+
+        let barrier = Arc::new(Barrier::new(3));
+        let barrier_a = barrier.clone();
+        let barrier_b = barrier.clone();
+
+        let a = tokio::spawn(async move {
+            let b = rx.recv().await.unwrap();
+
+            // Poll the JoinHandle once. This registers the waker.
+            // The other task cannot have finished at this point due to the barrier below.
+            futures::future::select(b, std::future::ready(())).await;
+
+            barrier_a.wait().await;
+        });
+
+        let b = tokio::spawn(async move {
+            // Poll the JoinHandle once. This registers the waker.
+            // The other task cannot have finished at this point due to the barrier below.
+            futures::future::select(a, std::future::ready(())).await;
+
+            barrier_b.wait().await;
+        });
+
+        tx.send(b).await.unwrap();
+
+        barrier.wait().await;
+    });
+}
+
+#[test]
+fn runtime_id_is_same() {
+    let rt = rt();
+
+    let handle1 = rt.handle();
+    let handle2 = rt.handle();
+
+    assert_eq!(handle1.id(), handle2.id());
+}
+
+#[test]
+fn runtime_ids_different() {
+    let rt1 = rt();
+    let rt2 = rt();
+
+    assert_ne!(rt1.handle().id(), rt2.handle().id());
+}
+
+fn rt() -> Runtime {
+    tokio::runtime::Builder::new_current_thread()
+        .build()
+        .unwrap()
+}

vendor/tokio/tests/rt_handle_block_on.rs

@@ -0,0 +1,567 @@
+#![warn(rust_2018_idioms)]
+#![cfg(all(feature = "full", not(miri)))]
+
+// All io tests that deal with shutdown is currently ignored because there are known bugs in with
+// shutting down the io driver while concurrently registering new resources. See
+// https://github.com/tokio-rs/tokio/pull/3569#pullrequestreview-612703467 for more details.
+//
+// When this has been fixed we want to re-enable these tests.
+
+use std::time::Duration;
+use tokio::runtime::{Handle, Runtime};
+use tokio::sync::mpsc;
+#[cfg(not(target_os = "wasi"))]
+use tokio::{net, time};
+
+#[cfg(not(target_os = "wasi"))] // Wasi doesn't support threads
+macro_rules! multi_threaded_rt_test {
+    ($($t:tt)*) => {
+        mod threaded_scheduler_4_threads_only {
+            use super::*;
+
+            $($t)*
+
+            fn rt() -> Runtime {
+                tokio::runtime::Builder::new_multi_thread()
+                    .worker_threads(4)
+                    .enable_all()
+                    .build()
+                    .unwrap()
+            }
+        }
+
+        mod threaded_scheduler_1_thread_only {
+            use super::*;
+
+            $($t)*
+
+            fn rt() -> Runtime {
+                tokio::runtime::Builder::new_multi_thread()
+                    .worker_threads(1)
+                    .enable_all()
+                    .build()
+                    .unwrap()
+            }
+        }
+    }
+}
+
+#[cfg(not(target_os = "wasi"))]
+macro_rules! rt_test {
+    ($($t:tt)*) => {
+        mod current_thread_scheduler {
+            use super::*;
+
+            $($t)*
+
+            fn rt() -> Runtime {
+                tokio::runtime::Builder::new_current_thread()
+                    .enable_all()
+                    .build()
+                    .unwrap()
+            }
+        }
+
+        mod threaded_scheduler_4_threads {
+            use super::*;
+
+            $($t)*
+
+            fn rt() -> Runtime {
+                tokio::runtime::Builder::new_multi_thread()
+                    .worker_threads(4)
+                    .enable_all()
+                    .build()
+                    .unwrap()
+            }
+        }
+
+        mod threaded_scheduler_1_thread {
+            use super::*;
+
+            $($t)*
+
+            fn rt() -> Runtime {
+                tokio::runtime::Builder::new_multi_thread()
+                    .worker_threads(1)
+                    .enable_all()
+                    .build()
+                    .unwrap()
+            }
+        }
+    }
+}
+
+// ==== runtime independent futures ======
+
+#[test]
+fn basic() {
+    test_with_runtimes(|| {
+        let one = Handle::current().block_on(async { 1 });
+        assert_eq!(1, one);
+    });
+}
+
+#[test]
+fn bounded_mpsc_channel() {
+    test_with_runtimes(|| {
+        let (tx, mut rx) = mpsc::channel(1024);
+
+        Handle::current().block_on(tx.send(42)).unwrap();
+
+        let value = Handle::current().block_on(rx.recv()).unwrap();
+        assert_eq!(value, 42);
+    });
+}
+
+#[test]
+fn unbounded_mpsc_channel() {
+    test_with_runtimes(|| {
+        let (tx, mut rx) = mpsc::unbounded_channel();
+
+        let _ = tx.send(42);
+
+        let value = Handle::current().block_on(rx.recv()).unwrap();
+        assert_eq!(value, 42);
+    })
+}
+
+#[test]
+fn yield_in_block_in_place() {
+    test_with_runtimes(|| {
+        Handle::current().block_on(async {
+            tokio::task::block_in_place(|| {
+                Handle::current().block_on(tokio::task::yield_now());
+            });
+        });
+    })
+}
+
+#[cfg(not(target_os = "wasi"))] // Wasi doesn't support file operations or bind
+rt_test! {
+    use tokio::fs;
+    // ==== spawn blocking futures ======
+
+    #[test]
+    fn basic_fs() {
+        let rt = rt();
+        let _enter = rt.enter();
+
+        let contents = Handle::current()
+            .block_on(fs::read_to_string("Cargo.toml"))
+            .unwrap();
+        assert!(contents.contains("https://tokio.rs"));
+    }
+
+    #[test]
+    fn fs_shutdown_before_started() {
+        let rt = rt();
+        let _enter = rt.enter();
+        rt.shutdown_timeout(Duration::from_secs(1000));
+
+        let err: std::io::Error = Handle::current()
+            .block_on(fs::read_to_string("Cargo.toml"))
+            .unwrap_err();
+
+        assert_eq!(err.kind(), std::io::ErrorKind::Other);
+
+        let inner_err = err.get_ref().expect("no inner error");
+        assert_eq!(inner_err.to_string(), "background task failed");
+    }
+
+    #[test]
+    fn basic_spawn_blocking() {
+        use tokio::task::spawn_blocking;
+        let rt = rt();
+        let _enter = rt.enter();
+
+        let answer = Handle::current()
+            .block_on(spawn_blocking(|| {
+                std::thread::sleep(Duration::from_millis(100));
+                42
+            }))
+            .unwrap();
+
+        assert_eq!(answer, 42);
+    }
+
+    #[test]
+    fn spawn_blocking_after_shutdown_fails() {
+        use tokio::task::spawn_blocking;
+        let rt = rt();
+        let _enter = rt.enter();
+        rt.shutdown_timeout(Duration::from_secs(1000));
+
+        let join_err = Handle::current()
+            .block_on(spawn_blocking(|| {
+                std::thread::sleep(Duration::from_millis(100));
+                42
+            }))
+            .unwrap_err();
+
+        assert!(join_err.is_cancelled());
+    }
+
+    #[test]
+    fn spawn_blocking_started_before_shutdown_continues() {
+        use tokio::task::spawn_blocking;
+        let rt = rt();
+        let _enter = rt.enter();
+
+        let handle = spawn_blocking(|| {
+            std::thread::sleep(Duration::from_secs(1));
+            42
+        });
+
+        rt.shutdown_timeout(Duration::from_secs(1000));
+
+        let answer = Handle::current().block_on(handle).unwrap();
+
+        assert_eq!(answer, 42);
+    }
+
+    #[test]
+    fn thread_park_ok() {
+        use core::task::Poll;
+        let rt = rt();
+        let mut exit = false;
+        rt.handle().block_on(core::future::poll_fn(move |cx| {
+            if exit {
+                return Poll::Ready(());
+            }
+            cx.waker().wake_by_ref();
+            // Verify that consuming the park token does not result in a hang.
+            std::thread::current().unpark();
+            std::thread::park();
+            exit = true;
+            Poll::Pending
+        }));
+    }
+
+    // ==== net ======
+
+    #[test]
+    #[cfg_attr(miri, ignore)] // No `socket` in miri.
+    fn tcp_listener_bind() {
+        let rt = rt();
+        let _enter = rt.enter();
+
+        Handle::current()
+            .block_on(net::TcpListener::bind("127.0.0.1:0"))
+            .unwrap();
+    }
+
+    // All io tests are ignored for now. See above why that is.
+    #[ignore]
+    #[test]
+    fn tcp_listener_connect_after_shutdown() {
+        let rt = rt();
+        let _enter = rt.enter();
+
+        rt.shutdown_timeout(Duration::from_secs(1000));
+
+        let err = Handle::current()
+            .block_on(net::TcpListener::bind("127.0.0.1:0"))
+            .unwrap_err();
+
+        assert_eq!(err.kind(), std::io::ErrorKind::Other);
+        assert_eq!(
+            err.get_ref().unwrap().to_string(),
+            "A Tokio 1.x context was found, but it is being shutdown.",
+        );
+    }
+
+    // All io tests are ignored for now. See above why that is.
+    #[ignore]
+    #[test]
+    fn tcp_listener_connect_before_shutdown() {
+        let rt = rt();
+        let _enter = rt.enter();
+
+        let bind_future = net::TcpListener::bind("127.0.0.1:0");
+
+        rt.shutdown_timeout(Duration::from_secs(1000));
+
+        let err = Handle::current().block_on(bind_future).unwrap_err();
+
+        assert_eq!(err.kind(), std::io::ErrorKind::Other);
+        assert_eq!(
+            err.get_ref().unwrap().to_string(),
+            "A Tokio 1.x context was found, but it is being shutdown.",
+        );
+    }
+
+    #[test]
+    #[cfg_attr(miri, ignore)] // No `socket` in miri.
+    fn udp_socket_bind() {
+        let rt = rt();
+        let _enter = rt.enter();
+
+        Handle::current()
+            .block_on(net::UdpSocket::bind("127.0.0.1:0"))
+            .unwrap();
+    }
+
+    // All io tests are ignored for now. See above why that is.
+    #[ignore]
+    #[test]
+    fn udp_stream_bind_after_shutdown() {
+        let rt = rt();
+        let _enter = rt.enter();
+
+        rt.shutdown_timeout(Duration::from_secs(1000));
+
+        let err = Handle::current()
+            .block_on(net::UdpSocket::bind("127.0.0.1:0"))
+            .unwrap_err();
+
+        assert_eq!(err.kind(), std::io::ErrorKind::Other);
+        assert_eq!(
+            err.get_ref().unwrap().to_string(),
+            "A Tokio 1.x context was found, but it is being shutdown.",
+        );
+    }
+
+    // All io tests are ignored for now. See above why that is.
+    #[ignore]
+    #[test]
+    fn udp_stream_bind_before_shutdown() {
+        let rt = rt();
+        let _enter = rt.enter();
+
+        let bind_future = net::UdpSocket::bind("127.0.0.1:0");
+
+        rt.shutdown_timeout(Duration::from_secs(1000));
+
+        let err = Handle::current().block_on(bind_future).unwrap_err();
+
+        assert_eq!(err.kind(), std::io::ErrorKind::Other);
+        assert_eq!(
+            err.get_ref().unwrap().to_string(),
+            "A Tokio 1.x context was found, but it is being shutdown.",
+        );
+    }
+
+    // All io tests are ignored for now. See above why that is.
+    #[ignore]
+    #[cfg(unix)]
+    #[test]
+    fn unix_listener_bind_after_shutdown() {
+        let rt = rt();
+        let _enter = rt.enter();
+
+        let dir = tempfile::tempdir().unwrap();
+        let path = dir.path().join("socket");
+
+        rt.shutdown_timeout(Duration::from_secs(1000));
+
+        let err = net::UnixListener::bind(path).unwrap_err();
+
+        assert_eq!(err.kind(), std::io::ErrorKind::Other);
+        assert_eq!(
+            err.get_ref().unwrap().to_string(),
+            "A Tokio 1.x context was found, but it is being shutdown.",
+        );
+    }
+
+    // All io tests are ignored for now. See above why that is.
+    #[ignore]
+    #[cfg(unix)]
+    #[test]
+    fn unix_listener_shutdown_after_bind() {
+        let rt = rt();
+        let _enter = rt.enter();
+
+        let dir = tempfile::tempdir().unwrap();
+        let path = dir.path().join("socket");
+
+        let listener = net::UnixListener::bind(path).unwrap();
+
+        rt.shutdown_timeout(Duration::from_secs(1000));
+
+        // this should not timeout but fail immediately since the runtime has been shutdown
+        let err = Handle::current().block_on(listener.accept()).unwrap_err();
+
+        assert_eq!(err.kind(), std::io::ErrorKind::Other);
+        assert_eq!(err.get_ref().unwrap().to_string(), "reactor gone");
+    }
+
+    // All io tests are ignored for now. See above why that is.
+    #[ignore]
+    #[cfg(unix)]
+    #[test]
+    fn unix_listener_shutdown_after_accept() {
+        let rt = rt();
+        let _enter = rt.enter();
+
+        let dir = tempfile::tempdir().unwrap();
+        let path = dir.path().join("socket");
+
+        let listener = net::UnixListener::bind(path).unwrap();
+
+        let accept_future = listener.accept();
+
+        rt.shutdown_timeout(Duration::from_secs(1000));
+
+        // this should not timeout but fail immediately since the runtime has been shutdown
+        let err = Handle::current().block_on(accept_future).unwrap_err();
+
+        assert_eq!(err.kind(), std::io::ErrorKind::Other);
+        assert_eq!(err.get_ref().unwrap().to_string(), "reactor gone");
+    }
+
+    // ==== nesting ======
+
+    #[test]
+    #[should_panic(
+        expected = "Cannot start a runtime from within a runtime. This happens because a function (like `block_on`) attempted to block the current thread while the thread is being used to drive asynchronous tasks."
+    )]
+    fn nesting() {
+        fn some_non_async_function() -> i32 {
+            Handle::current().block_on(time::sleep(Duration::from_millis(10)));
+            1
+        }
+
+        let rt = rt();
+
+        rt.block_on(async { some_non_async_function() });
+    }
+
+    #[test]
+    fn spawn_after_runtime_dropped() {
+        use futures::future::FutureExt;
+
+        let rt = rt();
+
+        let handle = rt.block_on(async move {
+            Handle::current()
+        });
+
+        let jh1 = handle.spawn(futures::future::pending::<()>());
+
+        drop(rt);
+
+        let jh2 = handle.spawn(futures::future::pending::<()>());
+
+        let err1 = jh1.now_or_never().unwrap().unwrap_err();
+        let err2 = jh2.now_or_never().unwrap().unwrap_err();
+        assert!(err1.is_cancelled());
+        assert!(err2.is_cancelled());
+    }
+}
+
+#[cfg(not(target_os = "wasi"))]
+multi_threaded_rt_test! {
+    #[cfg(unix)]
+    #[cfg_attr(miri, ignore)] // No `socket` in miri.
+    #[test]
+    fn unix_listener_bind() {
+        let rt = rt();
+        let _enter = rt.enter();
+
+        let dir = tempfile::tempdir().unwrap();
+        let path = dir.path().join("socket");
+
+        let listener = net::UnixListener::bind(path).unwrap();
+
+        // this should timeout and not fail immediately since the runtime has not been shutdown
+        let _: tokio::time::error::Elapsed = Handle::current()
+            .block_on(tokio::time::timeout(
+                Duration::from_millis(10),
+                listener.accept(),
+            ))
+            .unwrap_err();
+    }
+
+    // ==== timers ======
+
+    // `Handle::block_on` doesn't work with timer futures on a current thread runtime as there is no
+    // one to drive the timers so they will just hang forever. Therefore they are not tested.
+
+    #[test]
+    fn sleep() {
+        let rt = rt();
+        let _enter = rt.enter();
+
+        Handle::current().block_on(time::sleep(Duration::from_millis(100)));
+    }
+
+    #[test]
+    #[should_panic(expected = "A Tokio 1.x context was found, but it is being shutdown.")]
+    fn sleep_before_shutdown_panics() {
+        let rt = rt();
+        let _enter = rt.enter();
+
+        let f = time::sleep(Duration::from_millis(100));
+
+        rt.shutdown_timeout(Duration::from_secs(1000));
+
+        Handle::current().block_on(f);
+    }
+
+    #[test]
+    #[should_panic(expected = "A Tokio 1.x context was found, but it is being shutdown.")]
+    fn sleep_after_shutdown_panics() {
+        let rt = rt();
+        let _enter = rt.enter();
+
+        rt.shutdown_timeout(Duration::from_secs(1000));
+
+        Handle::current().block_on(time::sleep(Duration::from_millis(100)));
+    }
+}
+
+// ==== utils ======
+
+/// Create a new multi threaded runtime
+#[cfg(not(target_os = "wasi"))]
+fn new_multi_thread(n: usize) -> Runtime {
+    tokio::runtime::Builder::new_multi_thread()
+        .worker_threads(n)
+        .enable_all()
+        .build()
+        .unwrap()
+}
+
+/// Create a new single threaded runtime
+fn new_current_thread() -> Runtime {
+    tokio::runtime::Builder::new_current_thread()
+        .enable_all()
+        .build()
+        .unwrap()
+}
+
+/// Utility to test things on both kinds of runtimes both before and after shutting it down.
+fn test_with_runtimes<F>(f: F)
+where
+    F: Fn(),
+{
+    {
+        let rt = new_current_thread();
+        let _enter = rt.enter();
+        f();
+
+        rt.shutdown_timeout(Duration::from_secs(1000));
+        f();
+    }
+
+    #[cfg(not(target_os = "wasi"))]
+    {
+        let rt = new_multi_thread(1);
+        let _enter = rt.enter();
+        f();
+
+        rt.shutdown_timeout(Duration::from_secs(1000));
+        f();
+    }
+
+    #[cfg(not(target_os = "wasi"))]
+    {
+        let rt = new_multi_thread(4);
+        let _enter = rt.enter();
+        f();
+
+        rt.shutdown_timeout(Duration::from_secs(1000));
+        f();
+    }
+}

vendor/tokio/tests/rt_local.rs

@@ -0,0 +1,170 @@
+#![warn(rust_2018_idioms)]
+#![cfg(all(feature = "full", tokio_unstable))]
+
+use std::panic;
+use tokio::runtime::LocalOptions;
+use tokio::task::spawn_local;
+use tokio::task::LocalSet;
+
+#[test]
+fn test_spawn_local_in_runtime() {
+    let rt = rt();
+
+    let res = rt.block_on(async move {
+        let (tx, rx) = tokio::sync::oneshot::channel();
+
+        spawn_local(async {
+            tokio::task::yield_now().await;
+            tx.send(5).unwrap();
+        });
+
+        rx.await.unwrap()
+    });
+
+    assert_eq!(res, 5);
+}
+
+#[test]
+fn test_spawn_from_handle() {
+    let rt = rt();
+
+    let (tx, rx) = tokio::sync::oneshot::channel();
+
+    rt.handle().spawn(async {
+        tokio::task::yield_now().await;
+        tx.send(5).unwrap();
+    });
+
+    let res = rt.block_on(async move { rx.await.unwrap() });
+
+    assert_eq!(res, 5);
+}
+
+#[test]
+fn test_spawn_local_on_runtime_object() {
+    let rt = rt();
+
+    let (tx, rx) = tokio::sync::oneshot::channel();
+
+    rt.spawn_local(async {
+        tokio::task::yield_now().await;
+        tx.send(5).unwrap();
+    });
+
+    let res = rt.block_on(async move { rx.await.unwrap() });
+
+    assert_eq!(res, 5);
+}
+
+#[test]
+fn test_spawn_local_from_guard() {
+    let rt = rt();
+
+    let (tx, rx) = tokio::sync::oneshot::channel();
+
+    let _guard = rt.enter();
+
+    spawn_local(async {
+        tokio::task::yield_now().await;
+        tx.send(5).unwrap();
+    });
+
+    let res = rt.block_on(async move { rx.await.unwrap() });
+
+    assert_eq!(res, 5);
+}
+
+#[test]
+#[cfg_attr(target_family = "wasm", ignore)] // threads not supported
+fn test_spawn_from_guard_other_thread() {
+    let (tx, rx) = std::sync::mpsc::channel();
+
+    std::thread::spawn(move || {
+        let rt = rt();
+        let handle = rt.handle().clone();
+
+        tx.send(handle).unwrap();
+    });
+
+    let handle = rx.recv().unwrap();
+
+    let _guard = handle.enter();
+
+    tokio::spawn(async {});
+}
+
+#[test]
+#[should_panic = "Local tasks can only be spawned on a LocalRuntime from the thread the runtime was created on"]
+#[cfg_attr(target_family = "wasm", ignore)] // threads not supported
+fn test_spawn_local_from_guard_other_thread() {
+    let (tx, rx) = std::sync::mpsc::channel();
+
+    std::thread::spawn(move || {
+        let rt = rt();
+        let handle = rt.handle().clone();
+
+        tx.send(handle).unwrap();
+    });
+
+    let handle = rx.recv().unwrap();
+
+    let _guard = handle.enter();
+
+    spawn_local(async {});
+}
+
+// This test guarantees that **`tokio::task::spawn_local` panics** when it is invoked
+// from a thread that is *not* running the `LocalRuntime` / `LocalSet` to which
+// the task would belong.
+// The test creates a `LocalRuntime` and `LocalSet`, drives the `LocalSet` on the `LocalRuntime`'s thread,
+// then spawns a **separate OS thread** and tries to call
+// `tokio::task::spawn_local` there. `std::panic::catch_unwind` is then used
+// to capture the panic and to assert that it indeed occurs.
+#[test]
+#[cfg_attr(target_family = "wasm", ignore)] // threads not supported
+fn test_spawn_local_panic() {
+    let rt = rt();
+    let local = LocalSet::new();
+
+    rt.block_on(local.run_until(async {
+        let thread_result = std::thread::spawn(|| {
+            let panic_result = panic::catch_unwind(|| {
+                let _jh = tokio::task::spawn_local(async {
+                    println!("you will never see this line");
+                });
+            });
+            assert!(panic_result.is_err(), "Expected panic, but none occurred");
+        })
+        .join();
+        assert!(thread_result.is_ok(), "Thread itself panicked unexpectedly");
+    }));
+}
+
+#[test]
+#[should_panic = "`spawn_local` called from outside of a `task::LocalSet` or `runtime::LocalRuntime`"]
+fn test_spawn_local_in_current_thread_runtime() {
+    let rt = tokio::runtime::Builder::new_current_thread()
+        .build()
+        .unwrap();
+
+    rt.block_on(async move {
+        spawn_local(async {});
+    })
+}
+
+#[test]
+#[should_panic = "`spawn_local` called from outside of a `task::LocalSet` or `runtime::LocalRuntime`"]
+fn test_spawn_local_in_multi_thread_runtime() {
+    let rt = tokio::runtime::Builder::new_multi_thread().build().unwrap();
+
+    rt.block_on(async move {
+        spawn_local(async {});
+    })
+}
+
+fn rt() -> tokio::runtime::LocalRuntime {
+    tokio::runtime::Builder::new_current_thread()
+        .enable_all()
+        .build_local(LocalOptions::default())
+        .unwrap()
+}

vendor/tokio/tests/rt_metrics.rs

@@ -0,0 +1,233 @@
+#![warn(rust_2018_idioms)]
+#![cfg(all(feature = "full", not(target_os = "wasi"), target_has_atomic = "64"))]
+
+use std::sync::mpsc;
+use std::time::Duration;
+use tokio::runtime::Runtime;
+use tokio::time;
+
+#[test]
+fn num_workers() {
+    let rt = current_thread();
+    assert_eq!(1, rt.metrics().num_workers());
+
+    let rt = threaded();
+    assert_eq!(2, rt.metrics().num_workers());
+}
+
+#[test]
+fn num_alive_tasks() {
+    let rt = current_thread();
+    let metrics = rt.metrics();
+    assert_eq!(0, metrics.num_alive_tasks());
+    rt.block_on(rt.spawn(async move {
+        assert_eq!(1, metrics.num_alive_tasks());
+    }))
+    .unwrap();
+
+    assert_eq!(0, rt.metrics().num_alive_tasks());
+
+    let rt = threaded();
+    let metrics = rt.metrics();
+    assert_eq!(0, metrics.num_alive_tasks());
+    rt.block_on(rt.spawn(async move {
+        assert_eq!(1, metrics.num_alive_tasks());
+    }))
+    .unwrap();
+
+    // try for 10 seconds to see if this eventually succeeds.
+    // wake_join() is called before the task is released, so in multithreaded
+    // code, this means we sometimes exit the block_on before the counter decrements.
+    for _ in 0..100 {
+        if rt.metrics().num_alive_tasks() == 0 {
+            break;
+        }
+        std::thread::sleep(std::time::Duration::from_millis(100));
+    }
+    assert_eq!(0, rt.metrics().num_alive_tasks());
+}
+
+#[test]
+fn global_queue_depth_current_thread() {
+    use std::thread;
+
+    let rt = current_thread();
+    let handle = rt.handle().clone();
+    let metrics = rt.metrics();
+
+    thread::spawn(move || {
+        handle.spawn(async {});
+    })
+    .join()
+    .unwrap();
+
+    assert_eq!(1, metrics.global_queue_depth());
+}
+
+#[test]
+fn global_queue_depth_multi_thread() {
+    for _ in 0..10 {
+        let rt = threaded();
+        let metrics = rt.metrics();
+
+        if let Ok(_blocking_tasks) = try_block_threaded(&rt) {
+            for i in 0..10 {
+                assert_eq!(i, metrics.global_queue_depth());
+                rt.spawn(async {});
+            }
+
+            return;
+        }
+    }
+
+    panic!("exhausted every try to block the runtime");
+}
+
+#[test]
+fn worker_total_busy_duration() {
+    const N: usize = 5;
+
+    let zero = Duration::from_millis(0);
+
+    let rt = current_thread();
+    let metrics = rt.metrics();
+
+    rt.block_on(async {
+        for _ in 0..N {
+            tokio::spawn(async {
+                tokio::task::yield_now().await;
+            })
+            .await
+            .unwrap();
+        }
+    });
+
+    drop(rt);
+
+    assert!(zero < metrics.worker_total_busy_duration(0));
+
+    let rt = threaded();
+    let metrics = rt.metrics();
+
+    rt.block_on(async {
+        for _ in 0..N {
+            tokio::spawn(async {
+                tokio::task::yield_now().await;
+            })
+            .await
+            .unwrap();
+        }
+    });
+
+    drop(rt);
+
+    for i in 0..metrics.num_workers() {
+        assert!(zero < metrics.worker_total_busy_duration(i));
+    }
+}
+
+#[test]
+fn worker_park_count() {
+    let rt = current_thread();
+    let metrics = rt.metrics();
+    rt.block_on(async {
+        time::sleep(Duration::from_millis(1)).await;
+    });
+    drop(rt);
+    assert!(1 <= metrics.worker_park_count(0));
+
+    let rt = threaded();
+    let metrics = rt.metrics();
+    rt.block_on(async {
+        time::sleep(Duration::from_millis(1)).await;
+    });
+    drop(rt);
+    assert!(1 <= metrics.worker_park_count(0));
+    assert!(1 <= metrics.worker_park_count(1));
+}
+
+#[test]
+fn worker_park_unpark_count() {
+    let rt = current_thread();
+    let metrics = rt.metrics();
+    rt.block_on(rt.spawn(async {})).unwrap();
+    drop(rt);
+    assert_eq!(0, metrics.worker_park_unpark_count(0) % 2);
+
+    let rt = threaded();
+    let metrics = rt.metrics();
+
+    // Wait for workers to be parked after runtime startup.
+    for _ in 0..100 {
+        if 1 <= metrics.worker_park_unpark_count(0) && 1 <= metrics.worker_park_unpark_count(1) {
+            break;
+        }
+        std::thread::sleep(std::time::Duration::from_millis(100));
+    }
+    assert_eq!(1, metrics.worker_park_unpark_count(0));
+    assert_eq!(1, metrics.worker_park_unpark_count(1));
+
+    // Spawn a task to unpark and then park a worker.
+    rt.block_on(rt.spawn(async {})).unwrap();
+    for _ in 0..100 {
+        if 3 <= metrics.worker_park_unpark_count(0) || 3 <= metrics.worker_park_unpark_count(1) {
+            break;
+        }
+        std::thread::sleep(std::time::Duration::from_millis(100));
+    }
+    assert!(3 <= metrics.worker_park_unpark_count(0) || 3 <= metrics.worker_park_unpark_count(1));
+
+    // Both threads unpark for runtime shutdown.
+    drop(rt);
+    assert_eq!(0, metrics.worker_park_unpark_count(0) % 2);
+    assert_eq!(0, metrics.worker_park_unpark_count(1) % 2);
+    assert!(4 <= metrics.worker_park_unpark_count(0) || 4 <= metrics.worker_park_unpark_count(1));
+}
+
+fn try_block_threaded(rt: &Runtime) -> Result<Vec<mpsc::Sender<()>>, mpsc::RecvTimeoutError> {
+    let (tx, rx) = mpsc::channel();
+
+    let blocking_tasks = (0..rt.metrics().num_workers())
+        .map(|_| {
+            let tx = tx.clone();
+            let (task, barrier) = mpsc::channel();
+
+            // Spawn a task per runtime worker to block it.
+            rt.spawn(async move {
+                tx.send(()).ok();
+                barrier.recv().ok();
+            });
+
+            task
+        })
+        .collect();
+
+    // Make sure the previously spawned tasks are blocking the runtime by
+    // receiving a message from each blocking task.
+    //
+    // If this times out we were unsuccessful in blocking the runtime and hit
+    // a deadlock instead (which might happen and is expected behaviour).
+    for _ in 0..rt.metrics().num_workers() {
+        rx.recv_timeout(Duration::from_secs(1))?;
+    }
+
+    // Return senders of the mpsc channels used for blocking the runtime as a
+    // surrogate handle for the tasks. Sending a message or dropping the senders
+    // will unblock the runtime.
+    Ok(blocking_tasks)
+}
+
+fn current_thread() -> Runtime {
+    tokio::runtime::Builder::new_current_thread()
+        .enable_all()
+        .build()
+        .unwrap()
+}
+
+fn threaded() -> Runtime {
+    tokio::runtime::Builder::new_multi_thread()
+        .worker_threads(2)
+        .enable_all()
+        .build()
+        .unwrap()
+}

vendor/tokio/tests/rt_panic.rs

@@ -0,0 +1,102 @@
+#![warn(rust_2018_idioms)]
+#![cfg(feature = "full")]
+#![cfg(not(target_os = "wasi"))] // Wasi doesn't support panic recovery
+#![cfg(panic = "unwind")]
+
+use futures::future;
+use std::error::Error;
+use tokio::runtime::{Builder, Handle, Runtime};
+
+mod support {
+    pub mod panic;
+}
+use support::panic::test_panic;
+
+#[test]
+fn current_handle_panic_caller() -> Result<(), Box<dyn Error>> {
+    let panic_location_file = test_panic(|| {
+        let _ = Handle::current();
+    });
+
+    // The panic location should be in this file
+    assert_eq!(&panic_location_file.unwrap(), file!());
+
+    Ok(())
+}
+
+#[test]
+fn into_panic_panic_caller() -> Result<(), Box<dyn Error>> {
+    let panic_location_file = test_panic(move || {
+        let rt = current_thread();
+        rt.block_on(async {
+            let handle = tokio::spawn(future::pending::<()>());
+
+            handle.abort();
+
+            let err = handle.await.unwrap_err();
+            assert!(!&err.is_panic());
+
+            let _ = err.into_panic();
+        });
+    });
+
+    // The panic location should be in this file
+    assert_eq!(&panic_location_file.unwrap(), file!());
+
+    Ok(())
+}
+
+#[test]
+fn builder_worker_threads_panic_caller() -> Result<(), Box<dyn Error>> {
+    let panic_location_file = test_panic(|| {
+        let _ = Builder::new_multi_thread().worker_threads(0).build();
+    });
+
+    // The panic location should be in this file
+    assert_eq!(&panic_location_file.unwrap(), file!());
+
+    Ok(())
+}
+
+#[test]
+fn builder_max_blocking_threads_panic_caller() -> Result<(), Box<dyn Error>> {
+    let panic_location_file = test_panic(|| {
+        let _ = Builder::new_multi_thread().max_blocking_threads(0).build();
+    });
+
+    // The panic location should be in this file
+    assert_eq!(&panic_location_file.unwrap(), file!());
+
+    Ok(())
+}
+
+#[test]
+fn builder_global_queue_interval_panic_caller() -> Result<(), Box<dyn Error>> {
+    let panic_location_file = test_panic(|| {
+        let _ = Builder::new_multi_thread().global_queue_interval(0).build();
+    });
+
+    // The panic location should be in this file
+    assert_eq!(&panic_location_file.unwrap(), file!());
+
+    Ok(())
+}
+
+#[test]
+fn builder_event_interval_interval_panic_caller() -> Result<(), Box<dyn Error>> {
+    let panic_location_file = test_panic(|| {
+        let _ = Builder::new_multi_thread().event_interval(0).build();
+    });
+
+    // The panic location should be in this file
+    assert_eq!(&panic_location_file.unwrap(), file!());
+
+    Ok(())
+}
+
+fn current_thread() -> Runtime {
+    tokio::runtime::Builder::new_current_thread()
+        .enable_all()
+        .build()
+        .unwrap()
+}

vendor/tokio/tests/rt_poll_callbacks.rs

@@ -0,0 +1,128 @@
+#![allow(unknown_lints, unexpected_cfgs)]
+#![cfg(tokio_unstable)]
+
+use std::sync::{atomic::AtomicUsize, Arc, Mutex};
+
+use tokio::task::yield_now;
+
+#[cfg(not(target_os = "wasi"))]
+#[test]
+fn callbacks_fire_multi_thread() {
+    let poll_start_counter = Arc::new(AtomicUsize::new(0));
+    let poll_stop_counter = Arc::new(AtomicUsize::new(0));
+    let poll_start = poll_start_counter.clone();
+    let poll_stop = poll_stop_counter.clone();
+
+    let before_task_poll_callback_task_id: Arc<Mutex<Option<tokio::task::Id>>> =
+        Arc::new(Mutex::new(None));
+    let after_task_poll_callback_task_id: Arc<Mutex<Option<tokio::task::Id>>> =
+        Arc::new(Mutex::new(None));
+
+    let before_task_poll_callback_task_id_ref = Arc::clone(&before_task_poll_callback_task_id);
+    let after_task_poll_callback_task_id_ref = Arc::clone(&after_task_poll_callback_task_id);
+    let rt = tokio::runtime::Builder::new_multi_thread()
+        .enable_all()
+        .on_before_task_poll(move |task_meta| {
+            before_task_poll_callback_task_id_ref
+                .lock()
+                .unwrap()
+                .replace(task_meta.id());
+            poll_start_counter.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
+        })
+        .on_after_task_poll(move |task_meta| {
+            after_task_poll_callback_task_id_ref
+                .lock()
+                .unwrap()
+                .replace(task_meta.id());
+            poll_stop_counter.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
+        })
+        .build()
+        .unwrap();
+    let task = rt.spawn(async {
+        yield_now().await;
+        yield_now().await;
+        yield_now().await;
+    });
+
+    let spawned_task_id = task.id();
+
+    rt.block_on(task).expect("task should succeed");
+    // We need to drop the runtime to guarantee the workers have exited (and thus called the callback)
+    drop(rt);
+
+    assert_eq!(
+        before_task_poll_callback_task_id.lock().unwrap().unwrap(),
+        spawned_task_id
+    );
+    assert_eq!(
+        after_task_poll_callback_task_id.lock().unwrap().unwrap(),
+        spawned_task_id
+    );
+    let actual_count = 4;
+    assert_eq!(
+        poll_start.load(std::sync::atomic::Ordering::Relaxed),
+        actual_count,
+        "unexpected number of poll starts"
+    );
+    assert_eq!(
+        poll_stop.load(std::sync::atomic::Ordering::Relaxed),
+        actual_count,
+        "unexpected number of poll stops"
+    );
+}
+
+#[test]
+fn callbacks_fire_current_thread() {
+    let poll_start_counter = Arc::new(AtomicUsize::new(0));
+    let poll_stop_counter = Arc::new(AtomicUsize::new(0));
+    let poll_start = poll_start_counter.clone();
+    let poll_stop = poll_stop_counter.clone();
+
+    let before_task_poll_callback_task_id: Arc<Mutex<Option<tokio::task::Id>>> =
+        Arc::new(Mutex::new(None));
+    let after_task_poll_callback_task_id: Arc<Mutex<Option<tokio::task::Id>>> =
+        Arc::new(Mutex::new(None));
+
+    let before_task_poll_callback_task_id_ref = Arc::clone(&before_task_poll_callback_task_id);
+    let after_task_poll_callback_task_id_ref = Arc::clone(&after_task_poll_callback_task_id);
+    let rt = tokio::runtime::Builder::new_current_thread()
+        .enable_all()
+        .on_before_task_poll(move |task_meta| {
+            before_task_poll_callback_task_id_ref
+                .lock()
+                .unwrap()
+                .replace(task_meta.id());
+            poll_start_counter.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
+        })
+        .on_after_task_poll(move |task_meta| {
+            after_task_poll_callback_task_id_ref
+                .lock()
+                .unwrap()
+                .replace(task_meta.id());
+            poll_stop_counter.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
+        })
+        .build()
+        .unwrap();
+
+    let task = rt.spawn(async {
+        yield_now().await;
+        yield_now().await;
+        yield_now().await;
+    });
+
+    let spawned_task_id = task.id();
+
+    let _ = rt.block_on(task);
+    drop(rt);
+
+    assert_eq!(
+        before_task_poll_callback_task_id.lock().unwrap().unwrap(),
+        spawned_task_id
+    );
+    assert_eq!(
+        after_task_poll_callback_task_id.lock().unwrap().unwrap(),
+        spawned_task_id
+    );
+    assert_eq!(poll_start.load(std::sync::atomic::Ordering::Relaxed), 4);
+    assert_eq!(poll_stop.load(std::sync::atomic::Ordering::Relaxed), 4);
+}

vendor/tokio/tests/rt_shutdown_err.rs

@@ -0,0 +1,82 @@
+#![warn(rust_2018_idioms)]
+#![cfg(feature = "full")]
+#![cfg(not(miri))] // No socket in miri.
+
+use std::io;
+use tokio::net::TcpListener;
+use tokio::runtime::Builder;
+
+fn rt() -> tokio::runtime::Runtime {
+    Builder::new_current_thread().enable_all().build().unwrap()
+}
+
+#[test]
+fn test_is_rt_shutdown_err() {
+    let rt1 = rt();
+    let rt2 = rt();
+
+    let listener = rt1.block_on(async { TcpListener::bind("127.0.0.1:0").await.unwrap() });
+
+    drop(rt1);
+
+    rt2.block_on(async {
+        let res = listener.accept().await;
+        assert!(res.is_err());
+        let err = res.as_ref().unwrap_err();
+        assert!(tokio::runtime::is_rt_shutdown_err(err));
+    });
+}
+
+#[test]
+fn test_is_not_rt_shutdown_err() {
+    let err = io::Error::new(io::ErrorKind::Other, "some other error");
+    assert!(!tokio::runtime::is_rt_shutdown_err(&err));
+
+    let err = io::Error::new(io::ErrorKind::NotFound, "not found");
+    assert!(!tokio::runtime::is_rt_shutdown_err(&err));
+}
+
+#[test]
+#[cfg_attr(panic = "abort", ignore)]
+fn test_join_error_panic() {
+    let rt = rt();
+    let handle = rt.spawn(async {
+        panic!("oops");
+    });
+
+    let join_err = rt.block_on(handle).unwrap_err();
+    let io_err: io::Error = join_err.into();
+    assert!(!tokio::runtime::is_rt_shutdown_err(&io_err));
+}
+
+#[test]
+fn test_join_error_cancelled() {
+    let rt = rt();
+    let handle = rt.spawn(async {
+        std::future::pending::<()>().await;
+    });
+    handle.abort();
+    let join_err = rt.block_on(handle).unwrap_err();
+    let io_err: io::Error = join_err.into();
+    assert!(!tokio::runtime::is_rt_shutdown_err(&io_err));
+}
+
+#[test]
+fn test_other_error_kinds_and_strings() {
+    // TimedOut
+    let err = io::Error::new(io::ErrorKind::TimedOut, "timed out");
+    assert!(!tokio::runtime::is_rt_shutdown_err(&err));
+
+    // Interrupted
+    let err = io::Error::from(io::ErrorKind::Interrupted);
+    assert!(!tokio::runtime::is_rt_shutdown_err(&err));
+
+    // String that contains the shutdown message but has a prefix/suffix
+    let msg = "A Tokio 1.x context was found, but it is being shutdown. (extra info)";
+    let err = io::Error::new(io::ErrorKind::Other, msg);
+    assert!(!tokio::runtime::is_rt_shutdown_err(&err));
+
+    let msg = "Error: A Tokio 1.x context was found, but it is being shutdown.";
+    let err = io::Error::new(io::ErrorKind::Other, msg);
+    assert!(!tokio::runtime::is_rt_shutdown_err(&err));
+}

vendor/tokio/tests/rt_threaded.rs

@@ -0,0 +1,932 @@
+#![warn(rust_2018_idioms)]
+// Too slow on miri.
+#![cfg(all(feature = "full", not(target_os = "wasi"), not(miri)))]
+
+use tokio::io::{AsyncReadExt, AsyncWriteExt};
+use tokio::net::{TcpListener, TcpStream};
+use tokio::runtime;
+use tokio::sync::oneshot;
+use tokio_test::{assert_err, assert_ok, assert_pending};
+
+use std::future::{poll_fn, Future};
+use std::pin::Pin;
+use std::sync::atomic::Ordering::Relaxed;
+use std::sync::atomic::{AtomicUsize, Ordering};
+use std::sync::{mpsc, Arc, Mutex};
+use std::task::{Context, Poll, Waker};
+
+macro_rules! cfg_metrics {
+    ($($t:tt)*) => {
+        #[cfg(all(tokio_unstable, target_has_atomic = "64"))]
+        {
+            $( $t )*
+        }
+    }
+}
+
+#[test]
+fn single_thread() {
+    // No panic when starting a runtime w/ a single thread
+    let _ = runtime::Builder::new_multi_thread()
+        .enable_all()
+        .worker_threads(1)
+        .build()
+        .unwrap();
+}
+
+#[test]
+fn many_oneshot_futures() {
+    // used for notifying the main thread
+    const NUM: usize = 1_000;
+
+    for _ in 0..5 {
+        let (tx, rx) = mpsc::channel();
+
+        let rt = rt();
+        let cnt = Arc::new(AtomicUsize::new(0));
+
+        for _ in 0..NUM {
+            let cnt = cnt.clone();
+            let tx = tx.clone();
+
+            rt.spawn(async move {
+                let num = cnt.fetch_add(1, Relaxed) + 1;
+
+                if num == NUM {
+                    tx.send(()).unwrap();
+                }
+            });
+        }
+
+        rx.recv().unwrap();
+
+        // Wait for the pool to shutdown
+        drop(rt);
+    }
+}
+
+#[test]
+fn spawn_two() {
+    let rt = rt();
+
+    let out = rt.block_on(async {
+        let (tx, rx) = oneshot::channel();
+
+        tokio::spawn(async move {
+            tokio::spawn(async move {
+                tx.send("ZOMG").unwrap();
+            });
+        });
+
+        assert_ok!(rx.await)
+    });
+
+    assert_eq!(out, "ZOMG");
+
+    cfg_metrics! {
+        let metrics = rt.metrics();
+        drop(rt);
+        assert_eq!(1, metrics.remote_schedule_count());
+
+        let mut local = 0;
+        for i in 0..metrics.num_workers() {
+            local += metrics.worker_local_schedule_count(i);
+        }
+
+        assert_eq!(1, local);
+    }
+}
+
+#[test]
+fn many_multishot_futures() {
+    const CHAIN: usize = 200;
+    const CYCLES: usize = 5;
+    const TRACKS: usize = 50;
+
+    for _ in 0..50 {
+        let rt = rt();
+        let mut start_txs = Vec::with_capacity(TRACKS);
+        let mut final_rxs = Vec::with_capacity(TRACKS);
+
+        for _ in 0..TRACKS {
+            let (start_tx, mut chain_rx) = tokio::sync::mpsc::channel(10);
+
+            for _ in 0..CHAIN {
+                let (next_tx, next_rx) = tokio::sync::mpsc::channel(10);
+
+                // Forward all the messages
+                rt.spawn(async move {
+                    while let Some(v) = chain_rx.recv().await {
+                        next_tx.send(v).await.unwrap();
+                    }
+                });
+
+                chain_rx = next_rx;
+            }
+
+            // This final task cycles if needed
+            let (final_tx, final_rx) = tokio::sync::mpsc::channel(10);
+            let cycle_tx = start_tx.clone();
+            let mut rem = CYCLES;
+
+            rt.spawn(async move {
+                for _ in 0..CYCLES {
+                    let msg = chain_rx.recv().await.unwrap();
+
+                    rem -= 1;
+
+                    if rem == 0 {
+                        final_tx.send(msg).await.unwrap();
+                    } else {
+                        cycle_tx.send(msg).await.unwrap();
+                    }
+                }
+            });
+
+            start_txs.push(start_tx);
+            final_rxs.push(final_rx);
+        }
+
+        {
+            rt.block_on(async move {
+                for start_tx in start_txs {
+                    start_tx.send("ping").await.unwrap();
+                }
+
+                for mut final_rx in final_rxs {
+                    final_rx.recv().await.unwrap();
+                }
+            });
+        }
+    }
+}
+
+#[test]
+fn lifo_slot_budget() {
+    async fn my_fn() {
+        spawn_another();
+    }
+
+    fn spawn_another() {
+        tokio::spawn(my_fn());
+    }
+
+    let rt = runtime::Builder::new_multi_thread()
+        .enable_all()
+        .worker_threads(1)
+        .build()
+        .unwrap();
+
+    let (send, recv) = oneshot::channel();
+
+    rt.spawn(async move {
+        tokio::spawn(my_fn());
+        let _ = send.send(());
+    });
+
+    let _ = rt.block_on(recv);
+}
+
+#[test]
+#[cfg_attr(miri, ignore)] // No `socket` in miri.
+fn spawn_shutdown() {
+    let rt = rt();
+    let (tx, rx) = mpsc::channel();
+
+    rt.block_on(async {
+        tokio::spawn(client_server(tx.clone()));
+    });
+
+    // Use spawner
+    rt.spawn(client_server(tx));
+
+    assert_ok!(rx.recv());
+    assert_ok!(rx.recv());
+
+    drop(rt);
+    assert_err!(rx.try_recv());
+}
+
+async fn client_server(tx: mpsc::Sender<()>) {
+    let server = assert_ok!(TcpListener::bind("127.0.0.1:0").await);
+
+    // Get the assigned address
+    let addr = assert_ok!(server.local_addr());
+
+    // Spawn the server
+    tokio::spawn(async move {
+        // Accept a socket
+        let (mut socket, _) = server.accept().await.unwrap();
+
+        // Write some data
+        socket.write_all(b"hello").await.unwrap();
+    });
+
+    let mut client = TcpStream::connect(&addr).await.unwrap();
+
+    let mut buf = vec![];
+    client.read_to_end(&mut buf).await.unwrap();
+
+    assert_eq!(buf, b"hello");
+    tx.send(()).unwrap();
+}
+
+#[test]
+fn drop_threadpool_drops_futures() {
+    for _ in 0..1_000 {
+        let num_inc = Arc::new(AtomicUsize::new(0));
+        let num_dec = Arc::new(AtomicUsize::new(0));
+        let num_drop = Arc::new(AtomicUsize::new(0));
+
+        struct Never(Arc<AtomicUsize>);
+
+        impl Future for Never {
+            type Output = ();
+
+            fn poll(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<()> {
+                Poll::Pending
+            }
+        }
+
+        impl Drop for Never {
+            fn drop(&mut self) {
+                self.0.fetch_add(1, Relaxed);
+            }
+        }
+
+        let a = num_inc.clone();
+        let b = num_dec.clone();
+
+        let rt = runtime::Builder::new_multi_thread()
+            .enable_all()
+            .on_thread_start(move || {
+                a.fetch_add(1, Relaxed);
+            })
+            .on_thread_stop(move || {
+                b.fetch_add(1, Relaxed);
+            })
+            .build()
+            .unwrap();
+
+        rt.spawn(Never(num_drop.clone()));
+
+        // Wait for the pool to shutdown
+        drop(rt);
+
+        // Assert that only a single thread was spawned.
+        let a = num_inc.load(Relaxed);
+        assert!(a >= 1);
+
+        // Assert that all threads shutdown
+        let b = num_dec.load(Relaxed);
+        assert_eq!(a, b);
+
+        // Assert that the future was dropped
+        let c = num_drop.load(Relaxed);
+        assert_eq!(c, 1);
+    }
+}
+
+#[test]
+fn start_stop_callbacks_called() {
+    use std::sync::atomic::{AtomicUsize, Ordering};
+
+    let after_start = Arc::new(AtomicUsize::new(0));
+    let before_stop = Arc::new(AtomicUsize::new(0));
+
+    let after_inner = after_start.clone();
+    let before_inner = before_stop.clone();
+    let rt = tokio::runtime::Builder::new_multi_thread()
+        .enable_all()
+        .on_thread_start(move || {
+            after_inner.clone().fetch_add(1, Ordering::Relaxed);
+        })
+        .on_thread_stop(move || {
+            before_inner.clone().fetch_add(1, Ordering::Relaxed);
+        })
+        .build()
+        .unwrap();
+
+    let (tx, rx) = oneshot::channel();
+
+    rt.spawn(async move {
+        assert_ok!(tx.send(()));
+    });
+
+    assert_ok!(rt.block_on(rx));
+
+    drop(rt);
+
+    assert!(after_start.load(Ordering::Relaxed) > 0);
+    assert!(before_stop.load(Ordering::Relaxed) > 0);
+}
+
+#[test]
+// too slow on miri
+#[cfg_attr(miri, ignore)]
+fn blocking() {
+    // used for notifying the main thread
+    const NUM: usize = 1_000;
+
+    for _ in 0..10 {
+        let (tx, rx) = mpsc::channel();
+
+        let rt = rt();
+        let cnt = Arc::new(AtomicUsize::new(0));
+
+        // there are four workers in the pool
+        // so, if we run 4 blocking tasks, we know that handoff must have happened
+        let block = Arc::new(std::sync::Barrier::new(5));
+        for _ in 0..4 {
+            let block = block.clone();
+            rt.spawn(async move {
+                tokio::task::block_in_place(move || {
+                    block.wait();
+                    block.wait();
+                })
+            });
+        }
+        block.wait();
+
+        for _ in 0..NUM {
+            let cnt = cnt.clone();
+            let tx = tx.clone();
+
+            rt.spawn(async move {
+                let num = cnt.fetch_add(1, Relaxed) + 1;
+
+                if num == NUM {
+                    tx.send(()).unwrap();
+                }
+            });
+        }
+
+        rx.recv().unwrap();
+
+        // Wait for the pool to shutdown
+        block.wait();
+    }
+}
+
+#[test]
+fn multi_threadpool() {
+    use tokio::sync::oneshot;
+
+    let rt1 = rt();
+    let rt2 = rt();
+
+    let (tx, rx) = oneshot::channel();
+    let (done_tx, done_rx) = mpsc::channel();
+
+    rt2.spawn(async move {
+        rx.await.unwrap();
+        done_tx.send(()).unwrap();
+    });
+
+    rt1.spawn(async move {
+        tx.send(()).unwrap();
+    });
+
+    done_rx.recv().unwrap();
+}
+
+// When `block_in_place` returns, it attempts to reclaim the yielded runtime
+// worker. In this case, the remainder of the task is on the runtime worker and
+// must take part in the cooperative task budgeting system.
+//
+// The test ensures that, when this happens, attempting to consume from a
+// channel yields occasionally even if there are values ready to receive.
+#[test]
+fn coop_and_block_in_place() {
+    let rt = tokio::runtime::Builder::new_multi_thread()
+        // Setting max threads to 1 prevents another thread from claiming the
+        // runtime worker yielded as part of `block_in_place` and guarantees the
+        // same thread will reclaim the worker at the end of the
+        // `block_in_place` call.
+        .max_blocking_threads(1)
+        .build()
+        .unwrap();
+
+    rt.block_on(async move {
+        let (tx, mut rx) = tokio::sync::mpsc::channel(1024);
+
+        // Fill the channel
+        for _ in 0..1024 {
+            tx.send(()).await.unwrap();
+        }
+
+        drop(tx);
+
+        tokio::spawn(async move {
+            // Block in place without doing anything
+            tokio::task::block_in_place(|| {});
+
+            // Receive all the values, this should trigger a `Pending` as the
+            // coop limit will be reached.
+            poll_fn(|cx| {
+                while let Poll::Ready(v) = {
+                    tokio::pin! {
+                        let fut = rx.recv();
+                    }
+
+                    Pin::new(&mut fut).poll(cx)
+                } {
+                    if v.is_none() {
+                        panic!("did not yield");
+                    }
+                }
+
+                Poll::Ready(())
+            })
+            .await
+        })
+        .await
+        .unwrap();
+    });
+}
+
+#[test]
+fn yield_after_block_in_place() {
+    let rt = tokio::runtime::Builder::new_multi_thread()
+        .worker_threads(1)
+        .build()
+        .unwrap();
+
+    rt.block_on(async {
+        tokio::spawn(async move {
+            // Block in place then enter a new runtime
+            tokio::task::block_in_place(|| {
+                let rt = tokio::runtime::Builder::new_current_thread()
+                    .build()
+                    .unwrap();
+
+                rt.block_on(async {});
+            });
+
+            // Yield, then complete
+            tokio::task::yield_now().await;
+        })
+        .await
+        .unwrap()
+    });
+}
+
+// Testing this does not panic
+#[test]
+fn max_blocking_threads() {
+    let _rt = tokio::runtime::Builder::new_multi_thread()
+        .max_blocking_threads(1)
+        .build()
+        .unwrap();
+}
+
+#[test]
+#[should_panic]
+fn max_blocking_threads_set_to_zero() {
+    let _rt = tokio::runtime::Builder::new_multi_thread()
+        .max_blocking_threads(0)
+        .build()
+        .unwrap();
+}
+
+/// Regression test for #6445.
+///
+/// After #6445, setting `global_queue_interval` to 1 is now technically valid.
+/// This test confirms that there is no regression in `multi_thread_runtime`
+/// when global_queue_interval is set to 1.
+#[test]
+fn global_queue_interval_set_to_one() {
+    let rt = tokio::runtime::Builder::new_multi_thread()
+        .global_queue_interval(1)
+        .build()
+        .unwrap();
+
+    // Perform a simple work.
+    let cnt = Arc::new(AtomicUsize::new(0));
+    rt.block_on(async {
+        let mut set = tokio::task::JoinSet::new();
+        for _ in 0..10 {
+            let cnt = cnt.clone();
+            set.spawn(async move { cnt.fetch_add(1, Ordering::Relaxed) });
+        }
+
+        while let Some(res) = set.join_next().await {
+            res.unwrap();
+        }
+    });
+    assert_eq!(cnt.load(Relaxed), 10);
+}
+
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn hang_on_shutdown() {
+    let (sync_tx, sync_rx) = std::sync::mpsc::channel::<()>();
+    tokio::spawn(async move {
+        tokio::task::block_in_place(|| sync_rx.recv().ok());
+    });
+
+    tokio::spawn(async {
+        tokio::time::sleep(std::time::Duration::from_secs(2)).await;
+        drop(sync_tx);
+    });
+    tokio::time::sleep(std::time::Duration::from_secs(1)).await;
+}
+
+/// Demonstrates tokio-rs/tokio#3869
+#[test]
+fn wake_during_shutdown() {
+    struct Shared {
+        waker: Option<Waker>,
+    }
+
+    struct MyFuture {
+        shared: Arc<Mutex<Shared>>,
+        put_waker: bool,
+    }
+
+    impl MyFuture {
+        fn new() -> (Self, Self) {
+            let shared = Arc::new(Mutex::new(Shared { waker: None }));
+            let f1 = MyFuture {
+                shared: shared.clone(),
+                put_waker: true,
+            };
+            let f2 = MyFuture {
+                shared,
+                put_waker: false,
+            };
+            (f1, f2)
+        }
+    }
+
+    impl Future for MyFuture {
+        type Output = ();
+
+        fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<()> {
+            let me = Pin::into_inner(self);
+            let mut lock = me.shared.lock().unwrap();
+            if me.put_waker {
+                lock.waker = Some(cx.waker().clone());
+            }
+            Poll::Pending
+        }
+    }
+
+    impl Drop for MyFuture {
+        fn drop(&mut self) {
+            let mut lock = self.shared.lock().unwrap();
+            if !self.put_waker {
+                lock.waker.take().unwrap().wake();
+            }
+            drop(lock);
+        }
+    }
+
+    let rt = tokio::runtime::Builder::new_multi_thread()
+        .worker_threads(1)
+        .enable_all()
+        .build()
+        .unwrap();
+
+    let (f1, f2) = MyFuture::new();
+
+    rt.spawn(f1);
+    rt.spawn(f2);
+
+    rt.block_on(async { tokio::time::sleep(tokio::time::Duration::from_millis(20)).await });
+}
+
+#[should_panic]
+#[tokio::test]
+async fn test_block_in_place1() {
+    tokio::task::block_in_place(|| {});
+}
+
+#[tokio::test(flavor = "multi_thread")]
+async fn test_block_in_place2() {
+    tokio::task::block_in_place(|| {});
+}
+
+#[should_panic]
+#[tokio::main(flavor = "current_thread")]
+#[test]
+async fn test_block_in_place3() {
+    tokio::task::block_in_place(|| {});
+}
+
+#[tokio::main]
+#[test]
+async fn test_block_in_place4() {
+    tokio::task::block_in_place(|| {});
+}
+
+// Repro for tokio-rs/tokio#5239
+#[test]
+fn test_nested_block_in_place_with_block_on_between() {
+    let rt = runtime::Builder::new_multi_thread()
+        .worker_threads(1)
+        // Needs to be more than 0
+        .max_blocking_threads(1)
+        .build()
+        .unwrap();
+
+    // Triggered by a race condition, so run a few times to make sure it is OK.
+    for _ in 0..100 {
+        let h = rt.handle().clone();
+
+        rt.block_on(async move {
+            tokio::spawn(async move {
+                tokio::task::block_in_place(|| {
+                    h.block_on(async {
+                        tokio::task::block_in_place(|| {});
+                    });
+                })
+            })
+            .await
+            .unwrap()
+        });
+    }
+}
+
+#[test]
+fn yield_now_in_block_in_place() {
+    let rt = runtime::Builder::new_multi_thread()
+        .worker_threads(1)
+        .build()
+        .unwrap();
+
+    rt.block_on(async {
+        tokio::spawn(async {
+            tokio::task::block_in_place(|| {
+                tokio::runtime::Handle::current().block_on(tokio::task::yield_now());
+            })
+        })
+        .await
+        .unwrap()
+    })
+}
+
+#[test]
+fn mutex_in_block_in_place() {
+    const BUDGET: usize = 128;
+
+    let rt = runtime::Builder::new_multi_thread()
+        .worker_threads(1)
+        .build()
+        .unwrap();
+
+    rt.block_on(async {
+        let lock = tokio::sync::Mutex::new(0);
+
+        tokio::spawn(async move {
+            tokio::task::block_in_place(|| {
+                tokio::runtime::Handle::current().block_on(async move {
+                    for i in 0..(BUDGET + 1) {
+                        let mut guard = lock.lock().await;
+                        *guard = i;
+                    }
+                });
+            })
+        })
+        .await
+        .unwrap();
+    })
+}
+
+#[test]
+/// Deferred tasks should be woken before starting the [`tokio::task::block_in_place`]
+// https://github.com/tokio-rs/tokio/issues/7877
+fn wake_deferred_tasks_before_block_in_place() {
+    let (tx1, rx1) = oneshot::channel::<()>();
+    let (tx2, rx2) = oneshot::channel::<()>();
+
+    let deferred_task = tokio_test::task::spawn(tokio::task::yield_now());
+    let deffered_task = Arc::new(Mutex::new(deferred_task));
+
+    let rt = runtime::Builder::new_multi_thread()
+        .worker_threads(1)
+        .build()
+        .unwrap();
+
+    let jh = {
+        let deferred_task = Arc::clone(&deffered_task);
+        rt.spawn(async move {
+            {
+                let mut lock = deferred_task.lock().unwrap();
+                assert_pending!(lock.poll());
+            }
+            tokio::task::block_in_place(|| {
+                // signal that the `block_in_place` has started
+                tx2.send(()).unwrap();
+                // wait for the shutdown signal
+                rx1.blocking_recv().unwrap();
+            });
+        })
+    };
+
+    // wait for the `block_in_place` to start
+    rx2.blocking_recv().unwrap();
+
+    // check that the deferred task was woken before the `block_in_place` ends
+    let is_woken = {
+        let lock = deffered_task.lock().unwrap();
+        lock.is_woken()
+    };
+
+    // signal the `block_in_place` to shutdown
+    tx1.send(()).unwrap();
+
+    rt.block_on(jh).unwrap();
+
+    assert!(is_woken);
+}
+
+// Testing the tuning logic is tricky as it is inherently timing based, and more
+// of a heuristic than an exact behavior. This test checks that the interval
+// changes over time based on load factors. There are no assertions, completion
+// is sufficient. If there is a regression, this test will hang. In theory, we
+// could add limits, but that would be likely to fail on CI.
+#[test]
+#[cfg(not(tokio_no_tuning_tests))]
+fn test_tuning() {
+    use std::sync::atomic::AtomicBool;
+    use std::time::Duration;
+
+    let rt = runtime::Builder::new_multi_thread()
+        .worker_threads(1)
+        .build()
+        .unwrap();
+
+    fn iter(flag: Arc<AtomicBool>, counter: Arc<AtomicUsize>, stall: bool) {
+        if flag.load(Relaxed) {
+            if stall {
+                std::thread::sleep(Duration::from_micros(5));
+            }
+
+            counter.fetch_add(1, Relaxed);
+            tokio::spawn(async move { iter(flag, counter, stall) });
+        }
+    }
+
+    let flag = Arc::new(AtomicBool::new(true));
+    let counter = Arc::new(AtomicUsize::new(61));
+    let interval = Arc::new(AtomicUsize::new(61));
+
+    {
+        let flag = flag.clone();
+        let counter = counter.clone();
+        rt.spawn(async move { iter(flag, counter, true) });
+    }
+
+    // Now, hammer the injection queue until the interval drops.
+    let mut n = 0;
+    loop {
+        let curr = interval.load(Relaxed);
+
+        if curr <= 8 {
+            n += 1;
+        } else {
+            n = 0;
+        }
+
+        // Make sure we get a few good rounds. Jitter in the tuning could result
+        // in one "good" value without being representative of reaching a good
+        // state.
+        if n == 3 {
+            break;
+        }
+
+        if Arc::strong_count(&interval) < 5_000 {
+            let counter = counter.clone();
+            let interval = interval.clone();
+
+            rt.spawn(async move {
+                let prev = counter.swap(0, Relaxed);
+                interval.store(prev, Relaxed);
+            });
+
+            std::thread::yield_now();
+        }
+    }
+
+    flag.store(false, Relaxed);
+
+    let w = Arc::downgrade(&interval);
+    drop(interval);
+
+    while w.strong_count() > 0 {
+        std::thread::sleep(Duration::from_micros(500));
+    }
+
+    // Now, run it again with a faster task
+    let flag = Arc::new(AtomicBool::new(true));
+    // Set it high, we know it shouldn't ever really be this high
+    let counter = Arc::new(AtomicUsize::new(10_000));
+    let interval = Arc::new(AtomicUsize::new(10_000));
+
+    {
+        let flag = flag.clone();
+        let counter = counter.clone();
+        rt.spawn(async move { iter(flag, counter, false) });
+    }
+
+    // Now, hammer the injection queue until the interval reaches the expected range.
+    let mut n = 0;
+    loop {
+        let curr = interval.load(Relaxed);
+
+        if curr <= 1_000 && curr > 32 {
+            n += 1;
+        } else {
+            n = 0;
+        }
+
+        if n == 3 {
+            break;
+        }
+
+        if Arc::strong_count(&interval) <= 5_000 {
+            let counter = counter.clone();
+            let interval = interval.clone();
+
+            rt.spawn(async move {
+                let prev = counter.swap(0, Relaxed);
+                interval.store(prev, Relaxed);
+            });
+        }
+
+        std::thread::yield_now();
+    }
+
+    flag.store(false, Relaxed);
+}
+
+fn rt() -> runtime::Runtime {
+    runtime::Runtime::new().unwrap()
+}
+
+#[cfg(tokio_unstable)]
+mod unstable {
+    use super::*;
+
+    #[test]
+    fn test_disable_lifo_slot() {
+        use std::sync::mpsc::{channel, RecvTimeoutError};
+
+        let rt = runtime::Builder::new_multi_thread()
+            .disable_lifo_slot()
+            .worker_threads(2)
+            .build()
+            .unwrap();
+
+        // Spawn a background thread to poke the runtime periodically.
+        //
+        // This is necessary because we may end up triggering the issue in:
+        // <https://github.com/tokio-rs/tokio/issues/4730>
+        //
+        // Spawning a task will wake up the second worker, which will then steal
+        // the task. However, the steal will fail if the task is in the LIFO
+        // slot, because the LIFO slot cannot be stolen.
+        //
+        // Note that this only happens rarely. Most of the time, this thread is
+        // not necessary.
+        let (kill_bg_thread, recv) = channel::<()>();
+        let handle = rt.handle().clone();
+        let bg_thread = std::thread::spawn(move || {
+            let one_sec = std::time::Duration::from_secs(1);
+            while recv.recv_timeout(one_sec) == Err(RecvTimeoutError::Timeout) {
+                handle.spawn(async {});
+            }
+        });
+
+        rt.block_on(async {
+            tokio::spawn(async {
+                // Spawn another task and block the thread until completion. If the LIFO slot
+                // is used then the test doesn't complete.
+                futures::executor::block_on(tokio::spawn(async {})).unwrap();
+            })
+            .await
+            .unwrap();
+        });
+
+        drop(kill_bg_thread);
+        bg_thread.join().unwrap();
+    }
+
+    #[test]
+    fn runtime_id_is_same() {
+        let rt = rt();
+
+        let handle1 = rt.handle();
+        let handle2 = rt.handle();
+
+        assert_eq!(handle1.id(), handle2.id());
+    }
+
+    #[test]
+    fn runtime_ids_different() {
+        let rt1 = rt();
+        let rt2 = rt();
+
+        assert_ne!(rt1.handle().id(), rt2.handle().id());
+    }
+}

vendor/tokio/tests/rt_time_start_paused.rs

@@ -0,0 +1,14 @@
+#![cfg(feature = "full")]
+
+use tokio::time::{Duration, Instant};
+
+#[tokio::test(start_paused = true)]
+async fn test_start_paused() {
+    let now = Instant::now();
+
+    // Pause a few times w/ std sleep and ensure `now` stays the same
+    for _ in 0..5 {
+        std::thread::sleep(Duration::from_millis(1));
+        assert_eq!(now, Instant::now());
+    }
+}

vendor/tokio/tests/rt_unstable_metrics.rs

@@ -0,0 +1,853 @@
+#![warn(rust_2018_idioms)]
+#![cfg(all(
+    feature = "full",
+    tokio_unstable,
+    not(target_os = "wasi"),
+    target_has_atomic = "64"
+))]
+
+use std::future::Future;
+use std::sync::{mpsc, Arc, Mutex};
+use std::task::Poll;
+use std::thread;
+use tokio::macros::support::poll_fn;
+
+use tokio::runtime::{HistogramConfiguration, HistogramScale, LogHistogram, Runtime};
+use tokio::task::consume_budget;
+use tokio::time::{self, Duration};
+
+#[test]
+fn num_workers() {
+    let rt = current_thread();
+    assert_eq!(1, rt.metrics().num_workers());
+
+    let rt = threaded();
+    assert_eq!(2, rt.metrics().num_workers());
+}
+
+#[test]
+fn num_blocking_threads() {
+    let rt = current_thread();
+    assert_eq!(0, rt.metrics().num_blocking_threads());
+    let _ = rt.block_on(rt.spawn_blocking(move || {}));
+    assert_eq!(1, rt.metrics().num_blocking_threads());
+
+    let rt = threaded();
+    assert_eq!(0, rt.metrics().num_blocking_threads());
+    let _ = rt.block_on(rt.spawn_blocking(move || {}));
+    assert_eq!(1, rt.metrics().num_blocking_threads());
+}
+
+#[test]
+fn num_idle_blocking_threads() {
+    let rt = current_thread();
+    assert_eq!(0, rt.metrics().num_idle_blocking_threads());
+    let _ = rt.block_on(rt.spawn_blocking(move || {}));
+    rt.block_on(async {
+        time::sleep(Duration::from_millis(5)).await;
+    });
+
+    // We need to wait until the blocking thread has become idle. Usually 5ms is
+    // enough for this to happen, but not always. When it isn't enough, sleep
+    // for another second. We don't always wait for a whole second since we want
+    // the test suite to finish quickly.
+    //
+    // Note that the timeout for idle threads to be killed is 10 seconds.
+    if 0 == rt.metrics().num_idle_blocking_threads() {
+        rt.block_on(async {
+            time::sleep(Duration::from_secs(1)).await;
+        });
+    }
+
+    assert_eq!(1, rt.metrics().num_idle_blocking_threads());
+}
+
+#[test]
+fn num_idle_blocking_threads_is_zero_after_shutdown() {
+    let rt = current_thread();
+    let handle = rt.handle().clone();
+
+    // Spawn a blocking task to create a worker thread.
+    let _ = rt.block_on(rt.spawn_blocking(move || {}));
+
+    // Wait for the thread to become idle.
+    rt.block_on(async {
+        time::sleep(Duration::from_millis(5)).await;
+    });
+    if handle.metrics().num_idle_blocking_threads() == 0 {
+        rt.block_on(async {
+            time::sleep(Duration::from_secs(1)).await;
+        });
+    }
+    assert_eq!(1, handle.metrics().num_idle_blocking_threads());
+
+    // Drop the runtime, which triggers shutdown and joins all blocking
+    // threads. Before the fix for #6439, the shutdown path incremented
+    // num_idle_threads a second time for each idle worker, so this
+    // counter stayed at 1 instead of going back to 0.
+    drop(rt);
+
+    assert_eq!(
+        0,
+        handle.metrics().num_idle_blocking_threads(),
+        "num_idle_blocking_threads should be 0 after shutdown (see #6439)"
+    );
+}
+
+#[test]
+fn blocking_queue_depth() {
+    let rt = tokio::runtime::Builder::new_current_thread()
+        .enable_all()
+        .max_blocking_threads(1)
+        .build()
+        .unwrap();
+
+    assert_eq!(0, rt.metrics().blocking_queue_depth());
+
+    let ready = Arc::new(Mutex::new(()));
+    let guard = ready.lock().unwrap();
+
+    let ready_cloned = ready.clone();
+    let wait_until_ready = move || {
+        let _unused = ready_cloned.lock().unwrap();
+    };
+
+    let h1 = rt.spawn_blocking(wait_until_ready.clone());
+    let h2 = rt.spawn_blocking(wait_until_ready);
+    assert!(rt.metrics().blocking_queue_depth() > 0);
+
+    drop(guard);
+
+    let _ = rt.block_on(h1);
+    let _ = rt.block_on(h2);
+
+    assert_eq!(0, rt.metrics().blocking_queue_depth());
+}
+
+#[test]
+fn spawned_tasks_count() {
+    let rt = current_thread();
+    let metrics = rt.metrics();
+    assert_eq!(0, metrics.spawned_tasks_count());
+
+    rt.block_on(rt.spawn(async move {
+        assert_eq!(1, metrics.spawned_tasks_count());
+    }))
+    .unwrap();
+
+    assert_eq!(1, rt.metrics().spawned_tasks_count());
+
+    let rt = threaded();
+    let metrics = rt.metrics();
+    assert_eq!(0, metrics.spawned_tasks_count());
+
+    rt.block_on(rt.spawn(async move {
+        assert_eq!(1, metrics.spawned_tasks_count());
+    }))
+    .unwrap();
+
+    assert_eq!(1, rt.metrics().spawned_tasks_count());
+}
+
+#[test]
+fn remote_schedule_count() {
+    use std::thread;
+
+    let rt = current_thread();
+    let handle = rt.handle().clone();
+    let task = thread::spawn(move || {
+        handle.spawn(async {
+            // DO nothing
+        })
+    })
+    .join()
+    .unwrap();
+
+    rt.block_on(task).unwrap();
+
+    assert_eq!(1, rt.metrics().remote_schedule_count());
+
+    let rt = threaded();
+    let handle = rt.handle().clone();
+    let task = thread::spawn(move || {
+        handle.spawn(async {
+            // DO nothing
+        })
+    })
+    .join()
+    .unwrap();
+
+    rt.block_on(task).unwrap();
+
+    assert_eq!(1, rt.metrics().remote_schedule_count());
+}
+
+#[test]
+fn worker_thread_id_current_thread() {
+    let rt = current_thread();
+    let metrics = rt.metrics();
+
+    // Check that runtime is on this thread.
+    rt.block_on(async {});
+    assert_eq!(Some(thread::current().id()), metrics.worker_thread_id(0));
+
+    // Move runtime to another thread.
+    let thread_id = std::thread::scope(|scope| {
+        let join_handle = scope.spawn(|| {
+            rt.block_on(async {});
+        });
+        join_handle.thread().id()
+    });
+    assert_eq!(Some(thread_id), metrics.worker_thread_id(0));
+
+    // Move runtime back to this thread.
+    rt.block_on(async {});
+    assert_eq!(Some(thread::current().id()), metrics.worker_thread_id(0));
+}
+
+#[test]
+fn worker_thread_id_threaded() {
+    let rt = threaded();
+    let metrics = rt.metrics();
+
+    rt.block_on(rt.spawn(async move {
+        // Check that we are running on a worker thread and determine
+        // the index of our worker.
+        let thread_id = std::thread::current().id();
+        let this_worker = (0..2)
+            .position(|w| metrics.worker_thread_id(w) == Some(thread_id))
+            .expect("task not running on any worker thread");
+
+        // Force worker to another thread.
+        let moved_thread_id = tokio::task::block_in_place(|| {
+            assert_eq!(thread_id, std::thread::current().id());
+
+            // Wait for worker to move to another thread.
+            for _ in 0..100 {
+                let new_id = metrics.worker_thread_id(this_worker).unwrap();
+                if thread_id != new_id {
+                    return new_id;
+                }
+                std::thread::sleep(Duration::from_millis(100));
+            }
+
+            panic!("worker did not move to new thread");
+        });
+
+        // After blocking task worker either stays on new thread or
+        // is moved back to current thread.
+        assert!(
+            metrics.worker_thread_id(this_worker) == Some(moved_thread_id)
+                || metrics.worker_thread_id(this_worker) == Some(thread_id)
+        );
+    }))
+    .unwrap()
+}
+
+#[test]
+fn worker_noop_count() {
+    // There isn't really a great way to generate no-op parks as they happen as
+    // false-positive events under concurrency.
+
+    let rt = current_thread();
+    let metrics = rt.metrics();
+    rt.block_on(async {
+        time::sleep(Duration::from_millis(1)).await;
+    });
+    drop(rt);
+    assert!(0 < metrics.worker_noop_count(0));
+
+    let rt = threaded();
+    let metrics = rt.metrics();
+    rt.block_on(async {
+        time::sleep(Duration::from_millis(1)).await;
+    });
+    drop(rt);
+    assert!(0 < metrics.worker_noop_count(0));
+    assert!(0 < metrics.worker_noop_count(1));
+}
+
+#[test]
+fn worker_steal_count() {
+    // This metric only applies to the multi-threaded runtime.
+    for _ in 0..10 {
+        let rt = threaded_no_lifo();
+        let metrics = rt.metrics();
+
+        let successfully_spawned_stealable_task = rt.block_on(async {
+            // The call to `try_spawn_stealable_task` may time out, which means
+            // that the sending task couldn't be scheduled due to a deadlock in
+            // the runtime.
+            // This is expected behaviour, we just retry until we succeed or
+            // exhaust all tries, the latter causing this test to fail.
+            try_spawn_stealable_task().await.is_ok()
+        });
+
+        drop(rt);
+
+        if successfully_spawned_stealable_task {
+            let n: u64 = (0..metrics.num_workers())
+                .map(|i| metrics.worker_steal_count(i))
+                .sum();
+
+            assert_eq!(1, n);
+            return;
+        }
+    }
+
+    panic!("exhausted every try to schedule the stealable task");
+}
+
+#[test]
+fn worker_poll_count_and_time() {
+    const N: u64 = 5;
+
+    async fn task() {
+        // Sync sleep
+        std::thread::sleep(std::time::Duration::from_micros(10));
+    }
+
+    let rt = current_thread();
+    let metrics = rt.metrics();
+    rt.block_on(async {
+        for _ in 0..N {
+            tokio::spawn(task()).await.unwrap();
+        }
+    });
+    drop(rt);
+    assert_eq!(N, metrics.worker_poll_count(0));
+    // Not currently supported for current-thread runtime
+    assert_eq!(Duration::default(), metrics.worker_mean_poll_time(0));
+
+    // Does not populate the histogram
+    assert!(!metrics.poll_time_histogram_enabled());
+    for i in 0..10 {
+        assert_eq!(0, metrics.poll_time_histogram_bucket_count(0, i));
+    }
+
+    let rt = threaded();
+    let metrics = rt.metrics();
+    rt.block_on(async {
+        for _ in 0..N {
+            tokio::spawn(task()).await.unwrap();
+        }
+    });
+    drop(rt);
+    // Account for the `block_on` task
+    let n = (0..metrics.num_workers())
+        .map(|i| metrics.worker_poll_count(i))
+        .sum();
+
+    assert_eq!(N, n);
+
+    let n: Duration = (0..metrics.num_workers())
+        .map(|i| metrics.worker_mean_poll_time(i))
+        .sum();
+
+    assert!(n > Duration::default());
+
+    // Does not populate the histogram
+    assert!(!metrics.poll_time_histogram_enabled());
+    for n in 0..metrics.num_workers() {
+        for i in 0..10 {
+            assert_eq!(0, metrics.poll_time_histogram_bucket_count(n, i));
+        }
+    }
+}
+
+#[test]
+fn log_histogram() {
+    const N: u64 = 50;
+    let rt = tokio::runtime::Builder::new_current_thread()
+        .enable_all()
+        .enable_metrics_poll_time_histogram()
+        .metrics_poll_time_histogram_configuration(HistogramConfiguration::log(
+            LogHistogram::builder()
+                .max_value(Duration::from_secs(60))
+                .min_value(Duration::from_nanos(100))
+                .max_error(0.25),
+        ))
+        .build()
+        .unwrap();
+    let metrics = rt.metrics();
+    let num_buckets = rt.metrics().poll_time_histogram_num_buckets();
+    assert_eq!(num_buckets, 119);
+    rt.block_on(async {
+        for _ in 0..N {
+            tokio::spawn(async {}).await.unwrap();
+        }
+    });
+    drop(rt);
+    assert_eq!(
+        metrics.poll_time_histogram_bucket_range(0),
+        Duration::from_nanos(0)..Duration::from_nanos(96)
+    );
+    assert_eq!(
+        metrics.poll_time_histogram_bucket_range(1),
+        Duration::from_nanos(96)..Duration::from_nanos(96 + 2_u64.pow(4))
+    );
+    assert_eq!(
+        metrics.poll_time_histogram_bucket_range(118).end,
+        Duration::from_nanos(u64::MAX)
+    );
+    let n = (0..metrics.num_workers())
+        .flat_map(|i| (0..num_buckets).map(move |j| (i, j)))
+        .map(|(worker, bucket)| metrics.poll_time_histogram_bucket_count(worker, bucket))
+        .sum();
+    assert_eq!(N, n);
+}
+
+#[test]
+fn minimal_log_histogram() {
+    let rt = tokio::runtime::Builder::new_current_thread()
+        .enable_all()
+        .enable_metrics_poll_time_histogram()
+        .metrics_poll_time_histogram_configuration(HistogramConfiguration::log(
+            LogHistogram::builder()
+                .max_value(Duration::from_millis(4))
+                .min_value(Duration::from_micros(20))
+                .precision_exact(0),
+        ))
+        .build()
+        .unwrap();
+    let metrics = rt.metrics();
+    let num_buckets = rt.metrics().poll_time_histogram_num_buckets();
+    for b in 1..num_buckets - 1 {
+        let range = metrics.poll_time_histogram_bucket_range(b);
+        let size = range.end - range.start;
+        // Assert the buckets continue doubling in size
+        assert_eq!(
+            size,
+            Duration::from_nanos((1 << (b - 1)) * 16384),
+            "incorrect range for {b}"
+        );
+    }
+    assert_eq!(num_buckets, 10);
+}
+
+#[test]
+#[allow(deprecated)]
+fn legacy_log_histogram() {
+    let rt = tokio::runtime::Builder::new_multi_thread()
+        .enable_all()
+        .enable_metrics_poll_time_histogram()
+        .metrics_poll_count_histogram_scale(HistogramScale::Log)
+        .metrics_poll_count_histogram_resolution(Duration::from_micros(50))
+        .metrics_poll_count_histogram_buckets(20)
+        .build()
+        .unwrap();
+    let num_buckets = rt.metrics().poll_time_histogram_num_buckets();
+    assert_eq!(num_buckets, 20);
+}
+
+#[test]
+fn log_histogram_default_configuration() {
+    let rt = tokio::runtime::Builder::new_current_thread()
+        .enable_all()
+        .enable_metrics_poll_time_histogram()
+        .metrics_poll_time_histogram_configuration(HistogramConfiguration::log(
+            LogHistogram::default(),
+        ))
+        .build()
+        .unwrap();
+    let num_buckets = rt.metrics().poll_time_histogram_num_buckets();
+    assert_eq!(num_buckets, 119);
+}
+
+#[test]
+fn worker_poll_count_histogram() {
+    const N: u64 = 5;
+
+    let rts = [
+        tokio::runtime::Builder::new_current_thread()
+            .enable_all()
+            .enable_metrics_poll_time_histogram()
+            .metrics_poll_time_histogram_configuration(HistogramConfiguration::linear(
+                Duration::from_millis(50),
+                3,
+            ))
+            .build()
+            .unwrap(),
+        tokio::runtime::Builder::new_multi_thread()
+            .worker_threads(2)
+            .enable_all()
+            .enable_metrics_poll_time_histogram()
+            .metrics_poll_time_histogram_configuration(HistogramConfiguration::linear(
+                Duration::from_millis(50),
+                3,
+            ))
+            .build()
+            .unwrap(),
+    ];
+
+    for rt in rts {
+        let metrics = rt.metrics();
+        rt.block_on(async {
+            for _ in 0..N {
+                tokio::spawn(async {}).await.unwrap();
+            }
+        });
+        drop(rt);
+
+        let num_workers = metrics.num_workers();
+        let num_buckets = metrics.poll_time_histogram_num_buckets();
+
+        assert!(metrics.poll_time_histogram_enabled());
+        assert_eq!(num_buckets, 3);
+
+        let n = (0..num_workers)
+            .flat_map(|i| (0..num_buckets).map(move |j| (i, j)))
+            .map(|(worker, bucket)| metrics.poll_time_histogram_bucket_count(worker, bucket))
+            .sum();
+        assert_eq!(N, n);
+    }
+}
+
+#[test]
+fn worker_poll_count_histogram_range() {
+    let max = Duration::from_nanos(u64::MAX);
+
+    let rt = tokio::runtime::Builder::new_current_thread()
+        .enable_all()
+        .enable_metrics_poll_time_histogram()
+        .metrics_poll_time_histogram_configuration(HistogramConfiguration::linear(us(50), 3))
+        .build()
+        .unwrap();
+    let metrics = rt.metrics();
+
+    assert_eq!(metrics.poll_time_histogram_bucket_range(0), us(0)..us(50));
+    assert_eq!(metrics.poll_time_histogram_bucket_range(1), us(50)..us(100));
+    assert_eq!(metrics.poll_time_histogram_bucket_range(2), us(100)..max);
+
+    // ensure the old methods work too
+    #[allow(deprecated)]
+    let rt = tokio::runtime::Builder::new_current_thread()
+        .enable_all()
+        .enable_metrics_poll_time_histogram()
+        .metrics_poll_count_histogram_scale(tokio::runtime::HistogramScale::Log)
+        .metrics_poll_count_histogram_buckets(3)
+        .metrics_poll_count_histogram_resolution(us(50))
+        .build()
+        .unwrap();
+    let metrics = rt.metrics();
+
+    let a = Duration::from_nanos(50000_u64.next_power_of_two());
+    let b = a * 2;
+
+    assert_eq!(metrics.poll_time_histogram_bucket_range(0), us(0)..a);
+    assert_eq!(metrics.poll_time_histogram_bucket_range(1), a..b);
+    assert_eq!(metrics.poll_time_histogram_bucket_range(2), b..max);
+}
+
+#[test]
+fn worker_poll_count_histogram_disabled_without_explicit_enable() {
+    let rts = [
+        tokio::runtime::Builder::new_current_thread()
+            .enable_all()
+            .metrics_poll_time_histogram_configuration(HistogramConfiguration::linear(
+                Duration::from_millis(50),
+                3,
+            ))
+            .build()
+            .unwrap(),
+        tokio::runtime::Builder::new_multi_thread()
+            .worker_threads(2)
+            .enable_all()
+            .metrics_poll_time_histogram_configuration(HistogramConfiguration::linear(
+                Duration::from_millis(50),
+                3,
+            ))
+            .build()
+            .unwrap(),
+    ];
+
+    for rt in rts {
+        let metrics = rt.metrics();
+        assert!(!metrics.poll_time_histogram_enabled());
+    }
+}
+
+#[test]
+fn worker_local_schedule_count() {
+    let rt = current_thread();
+    let metrics = rt.metrics();
+    rt.block_on(async {
+        tokio::spawn(async {}).await.unwrap();
+    });
+    drop(rt);
+
+    assert_eq!(1, metrics.worker_local_schedule_count(0));
+    assert_eq!(0, metrics.remote_schedule_count());
+
+    let rt = threaded();
+    let metrics = rt.metrics();
+    rt.block_on(async {
+        // Move to the runtime
+        tokio::spawn(async {
+            tokio::spawn(async {}).await.unwrap();
+        })
+        .await
+        .unwrap();
+    });
+    drop(rt);
+
+    let n: u64 = (0..metrics.num_workers())
+        .map(|i| metrics.worker_local_schedule_count(i))
+        .sum();
+
+    assert_eq!(2, n);
+    assert_eq!(1, metrics.remote_schedule_count());
+}
+
+#[test]
+fn worker_overflow_count() {
+    // Only applies to the threaded worker
+    let rt = threaded();
+    let metrics = rt.metrics();
+    rt.block_on(async {
+        // Move to the runtime
+        tokio::spawn(async {
+            let (tx1, rx1) = std::sync::mpsc::channel();
+            let (tx2, rx2) = std::sync::mpsc::channel();
+
+            // First, we need to block the other worker until all tasks have
+            // been spawned.
+            //
+            // We spawn from outside the runtime to ensure that the other worker
+            // will pick it up:
+            // <https://github.com/tokio-rs/tokio/issues/4730>
+            tokio::task::spawn_blocking(|| {
+                tokio::spawn(async move {
+                    tx1.send(()).unwrap();
+                    rx2.recv().unwrap();
+                });
+            });
+
+            rx1.recv().unwrap();
+
+            // Spawn many tasks
+            for _ in 0..300 {
+                tokio::spawn(async {});
+            }
+
+            tx2.send(()).unwrap();
+        })
+        .await
+        .unwrap();
+    });
+    drop(rt);
+
+    let n: u64 = (0..metrics.num_workers())
+        .map(|i| metrics.worker_overflow_count(i))
+        .sum();
+
+    assert_eq!(1, n);
+}
+
+#[test]
+fn worker_local_queue_depth() {
+    const N: usize = 100;
+
+    let rt = current_thread();
+    let metrics = rt.metrics();
+    rt.block_on(async {
+        for _ in 0..N {
+            tokio::spawn(async {});
+        }
+
+        assert_eq!(N, metrics.worker_local_queue_depth(0));
+    });
+
+    let rt = threaded();
+    let metrics = rt.metrics();
+    rt.block_on(async move {
+        // Move to the runtime
+        tokio::spawn(async move {
+            let (tx1, rx1) = std::sync::mpsc::channel();
+            let (tx2, rx2) = std::sync::mpsc::channel();
+
+            // First, we need to block the other worker until all tasks have
+            // been spawned.
+            tokio::spawn(async move {
+                tx1.send(()).unwrap();
+                rx2.recv().unwrap();
+            });
+
+            // Bump the next-run spawn
+            tokio::spawn(async {});
+
+            rx1.recv().unwrap();
+
+            // Spawn some tasks
+            for _ in 0..100 {
+                tokio::spawn(async {});
+            }
+
+            let n: usize = (0..metrics.num_workers())
+                .map(|i| metrics.worker_local_queue_depth(i))
+                .sum();
+
+            assert_eq!(n, N);
+
+            tx2.send(()).unwrap();
+        })
+        .await
+        .unwrap();
+    });
+}
+
+#[test]
+fn budget_exhaustion_yield() {
+    let rt = current_thread();
+    let metrics = rt.metrics();
+
+    assert_eq!(0, metrics.budget_forced_yield_count());
+
+    let mut did_yield = false;
+
+    // block on a task which consumes budget until it yields
+    rt.block_on(poll_fn(|cx| loop {
+        if did_yield {
+            return Poll::Ready(());
+        }
+
+        let fut = consume_budget();
+        tokio::pin!(fut);
+
+        if fut.poll(cx).is_pending() {
+            did_yield = true;
+            return Poll::Pending;
+        }
+    }));
+
+    assert_eq!(1, rt.metrics().budget_forced_yield_count());
+}
+
+#[test]
+fn budget_exhaustion_yield_with_joins() {
+    let rt = current_thread();
+    let metrics = rt.metrics();
+
+    assert_eq!(0, metrics.budget_forced_yield_count());
+
+    let mut did_yield_1 = false;
+    let mut did_yield_2 = false;
+
+    // block on a task which consumes budget until it yields
+    rt.block_on(async {
+        tokio::join!(
+            poll_fn(|cx| loop {
+                if did_yield_1 {
+                    return Poll::Ready(());
+                }
+
+                let fut = consume_budget();
+                tokio::pin!(fut);
+
+                if fut.poll(cx).is_pending() {
+                    did_yield_1 = true;
+                    return Poll::Pending;
+                }
+            }),
+            poll_fn(|cx| loop {
+                if did_yield_2 {
+                    return Poll::Ready(());
+                }
+
+                let fut = consume_budget();
+                tokio::pin!(fut);
+
+                if fut.poll(cx).is_pending() {
+                    did_yield_2 = true;
+                    return Poll::Pending;
+                }
+            })
+        )
+    });
+
+    assert_eq!(1, rt.metrics().budget_forced_yield_count());
+}
+
+#[cfg(any(target_os = "linux", target_os = "macos"))]
+#[test]
+fn io_driver_fd_count() {
+    let rt = current_thread();
+    let metrics = rt.metrics();
+
+    assert_eq!(metrics.io_driver_fd_registered_count(), 0);
+
+    let stream = tokio::net::TcpStream::connect("google.com:80");
+    let stream = rt.block_on(async move { stream.await.unwrap() });
+
+    assert_eq!(metrics.io_driver_fd_registered_count(), 1);
+    assert_eq!(metrics.io_driver_fd_deregistered_count(), 0);
+
+    drop(stream);
+
+    assert_eq!(metrics.io_driver_fd_deregistered_count(), 1);
+    assert_eq!(metrics.io_driver_fd_registered_count(), 1);
+}
+
+#[cfg(any(target_os = "linux", target_os = "macos"))]
+#[test]
+fn io_driver_ready_count() {
+    let rt = current_thread();
+    let metrics = rt.metrics();
+
+    let stream = tokio::net::TcpStream::connect("google.com:80");
+    let _stream = rt.block_on(async move { stream.await.unwrap() });
+
+    assert_eq!(metrics.io_driver_ready_count(), 1);
+}
+
+async fn try_spawn_stealable_task() -> Result<(), mpsc::RecvTimeoutError> {
+    // We use a blocking channel to synchronize the tasks.
+    let (tx, rx) = mpsc::channel();
+
+    // Make sure we are in the context of the runtime.
+    tokio::spawn(async move {
+        // Spawn the task that sends to the channel.
+        //
+        // Note that the runtime needs to have the lifo slot disabled to make
+        // this task stealable.
+        tokio::spawn(async move {
+            tx.send(()).unwrap();
+        });
+
+        // Blocking receive on the channel, timing out if the sending task
+        // wasn't scheduled in time.
+        rx.recv_timeout(Duration::from_secs(1))
+    })
+    .await
+    .unwrap()?;
+
+    Ok(())
+}
+
+fn current_thread() -> Runtime {
+    tokio::runtime::Builder::new_current_thread()
+        .enable_all()
+        .build()
+        .unwrap()
+}
+
+fn threaded() -> Runtime {
+    tokio::runtime::Builder::new_multi_thread()
+        .worker_threads(2)
+        .enable_all()
+        .build()
+        .unwrap()
+}
+
+fn threaded_no_lifo() -> Runtime {
+    tokio::runtime::Builder::new_multi_thread()
+        .worker_threads(2)
+        .disable_lifo_slot()
+        .enable_all()
+        .build()
+        .unwrap()
+}
+
+fn us(n: u64) -> Duration {
+    Duration::from_micros(n)
+}

vendor/tokio/tests/signal_ctrl_c.rs

@@ -0,0 +1,23 @@
+#![warn(rust_2018_idioms)]
+#![cfg(feature = "full")]
+#![cfg(unix)]
+#![cfg(not(miri))] // No `sigaction` on Miri
+
+mod support {
+    pub mod signal;
+}
+use support::signal::send_signal;
+
+use tokio::signal;
+use tokio_test::assert_ok;
+
+#[tokio::test]
+async fn ctrl_c() {
+    let ctrl_c = signal::ctrl_c();
+
+    tokio::spawn(async {
+        send_signal(libc::SIGINT);
+    });
+
+    assert_ok!(ctrl_c.await);
+}

vendor/tokio/tests/signal_drop_recv.rs

@@ -0,0 +1,23 @@
+#![warn(rust_2018_idioms)]
+#![cfg(feature = "full")]
+#![cfg(unix)]
+#![cfg(not(miri))] // No `sigaction` in Miri.
+
+mod support {
+    pub mod signal;
+}
+use support::signal::send_signal;
+
+use tokio::signal::unix::{signal, SignalKind};
+
+#[tokio::test]
+async fn drop_then_get_a_signal() {
+    let kind = SignalKind::user_defined1();
+    let sig = signal(kind).expect("failed to create first signal");
+    drop(sig);
+
+    send_signal(libc::SIGUSR1);
+    let mut sig = signal(kind).expect("failed to create second signal");
+
+    let _ = sig.recv().await;
+}

vendor/tokio/tests/signal_drop_rt.rs

@@ -0,0 +1,45 @@
+#![warn(rust_2018_idioms)]
+#![cfg(feature = "full")]
+#![cfg(unix)]
+#![cfg(not(miri))] // No `sigaction` in miri.
+
+mod support {
+    pub mod signal;
+}
+use support::signal::send_signal;
+
+use tokio::runtime::Runtime;
+use tokio::signal::unix::{signal, SignalKind};
+
+#[test]
+fn dropping_loops_does_not_cause_starvation() {
+    let kind = SignalKind::user_defined1();
+
+    let first_rt = rt();
+    let mut first_signal =
+        first_rt.block_on(async { signal(kind).expect("failed to register first signal") });
+
+    let second_rt = rt();
+    let mut second_signal =
+        second_rt.block_on(async { signal(kind).expect("failed to register second signal") });
+
+    send_signal(libc::SIGUSR1);
+
+    first_rt
+        .block_on(first_signal.recv())
+        .expect("failed to await first signal");
+
+    drop(first_rt);
+    drop(first_signal);
+
+    send_signal(libc::SIGUSR1);
+
+    second_rt.block_on(second_signal.recv());
+}
+
+fn rt() -> Runtime {
+    tokio::runtime::Builder::new_current_thread()
+        .enable_all()
+        .build()
+        .unwrap()
+}

vendor/tokio/tests/signal_drop_signal.rs

@@ -0,0 +1,27 @@
+#![warn(rust_2018_idioms)]
+#![cfg(feature = "full")]
+#![cfg(unix)]
+#![cfg(not(miri))] // No `sigaction` in miri.
+
+mod support {
+    pub mod signal;
+}
+use support::signal::send_signal;
+
+use tokio::signal::unix::{signal, SignalKind};
+
+#[tokio::test]
+async fn dropping_signal_does_not_deregister_any_other_instances() {
+    let kind = SignalKind::user_defined1();
+
+    // Signals should not starve based on ordering
+    let first_duplicate_signal = signal(kind).expect("failed to register first duplicate signal");
+    let mut sig = signal(kind).expect("failed to register signal");
+    let second_duplicate_signal = signal(kind).expect("failed to register second duplicate signal");
+
+    drop(first_duplicate_signal);
+    drop(second_duplicate_signal);
+
+    send_signal(libc::SIGUSR1);
+    let _ = sig.recv().await;
+}

vendor/tokio/tests/signal_info.rs

@@ -0,0 +1,35 @@
+#![warn(rust_2018_idioms)]
+#![cfg(feature = "full")]
+#![cfg(any(
+    target_os = "dragonfly",
+    target_os = "freebsd",
+    target_os = "macos",
+    target_os = "netbsd",
+    target_os = "openbsd",
+    target_os = "illumos"
+))]
+#![cfg(not(miri))] // No `sigaction` on Miri
+
+mod support {
+    pub mod signal;
+}
+use support::signal::send_signal;
+
+use tokio::signal;
+use tokio::signal::unix::SignalKind;
+use tokio::time::{timeout, Duration};
+
+#[tokio::test]
+async fn siginfo() {
+    let mut sig = signal::unix::signal(SignalKind::info()).expect("installed signal handler");
+
+    tokio::spawn(async {
+        send_signal(libc::SIGINFO);
+    });
+
+    // Add a timeout to ensure the test doesn't hang.
+    timeout(Duration::from_secs(5), sig.recv())
+        .await
+        .expect("received SIGINFO signal in time")
+        .expect("received SIGINFO signal");
+}

vendor/tokio/tests/signal_multi_rt.rs

@@ -0,0 +1,55 @@
+#![warn(rust_2018_idioms)]
+#![cfg(feature = "full")]
+#![cfg(unix)]
+#![cfg(not(miri))] // No `sigaction` on Miri.
+
+mod support {
+    pub mod signal;
+}
+use support::signal::send_signal;
+
+use tokio::runtime::Runtime;
+use tokio::signal::unix::{signal, SignalKind};
+
+use std::sync::mpsc::channel;
+use std::thread;
+
+#[test]
+fn multi_loop() {
+    // An "ordinary" (non-future) channel
+    let (sender, receiver) = channel();
+    // Run multiple times, to make sure there are no race conditions
+    for _ in 0..10 {
+        // Run multiple event loops, each one in its own thread
+        let threads: Vec<_> = (0..4)
+            .map(|_| {
+                let sender = sender.clone();
+                thread::spawn(move || {
+                    let rt = rt();
+                    let _ = rt.block_on(async {
+                        let mut signal = signal(SignalKind::hangup()).unwrap();
+                        sender.send(()).unwrap();
+                        signal.recv().await
+                    });
+                })
+            })
+            .collect();
+        // Wait for them to declare they're ready
+        for &_ in threads.iter() {
+            receiver.recv().unwrap();
+        }
+        // Send a signal
+        send_signal(libc::SIGHUP);
+        // Make sure the threads terminated correctly
+        for t in threads {
+            t.join().unwrap();
+        }
+    }
+}
+
+fn rt() -> Runtime {
+    tokio::runtime::Builder::new_current_thread()
+        .enable_all()
+        .build()
+        .unwrap()
+}

vendor/tokio/tests/signal_no_rt.rs

@@ -0,0 +1,13 @@
+#![warn(rust_2018_idioms)]
+#![cfg(feature = "full")]
+#![cfg(unix)]
+#![cfg(not(miri))] // No `sigaction` on Miri.
+
+use tokio::signal::unix::{signal, SignalKind};
+
+#[cfg_attr(target_os = "wasi", ignore = "Wasi does not support panic recovery")]
+#[test]
+#[should_panic]
+fn no_runtime_panics_creating_signals() {
+    let _ = signal(SignalKind::hangup());
+}

vendor/tokio/tests/signal_notify_both.rs

@@ -0,0 +1,24 @@
+#![warn(rust_2018_idioms)]
+#![cfg(feature = "full")]
+#![cfg(unix)]
+#![cfg(not(miri))] // No `sigaction` on Miri.
+
+mod support {
+    pub mod signal;
+}
+use support::signal::send_signal;
+
+use tokio::signal::unix::{signal, SignalKind};
+
+#[tokio::test]
+async fn notify_both() {
+    let kind = SignalKind::user_defined2();
+
+    let mut signal1 = signal(kind).expect("failed to create signal1");
+    let mut signal2 = signal(kind).expect("failed to create signal2");
+
+    send_signal(libc::SIGUSR2);
+
+    signal1.recv().await;
+    signal2.recv().await;
+}