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

wasm: support the wasm32-unknown-emscripten target (#8281)

Browse Source
This commit is contained in:
Guy Bedford
2026-09-05 10:35:22 +02:00
committed by GitHub
parent 4917528a97
commit 060cc4e46a
101 changed files with 1013 additions and 182 deletions
Download Patch File Download Diff File Expand all files Collapse all files
.github/workflows/ci.yml
+55
View File
@@ -19,6 +19,8 @@ env:
rust_nightly: nightly-2025-10-12
# Pin a specific miri version
rust_miri_nightly: nightly-2026-06-29
rust_emscripten_nightly: nightly-2026-08-17
emsdk_version: '6.0.8'
rust_clippy: '1.88'
# When updating this, also update:
# - README.md
@@ -1193,6 +1195,59 @@ jobs:
RUSTFLAGS: --cfg tokio_unstable
CARGO_TARGET_WASM32_WASIP2_RUNNER: wasmtime run -Sinherit-network
wasm32-unknown-emscripten:
name: test tokio for wasm32-unknown-emscripten
needs: basics
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v7
- name: Install Rust ${{ env.rust_stable }}
uses: dtolnay/rust-toolchain@stable
with:
toolchain: ${{ env.rust_stable }}
targets: wasm32-unknown-emscripten
- name: Install Emscripten
uses: mymindstorm/setup-emsdk@v14
with:
version: ${{ env.emsdk_version }}
- uses: actions/setup-node@v4
with:
node-version: 26
- uses: Swatinem/rust-cache@v2
- name: Install cargo-hack
uses: taiki-e/install-action@v2
with:
tool: cargo-hack
- name: Check tokio feature matrix for emscripten
run: cargo hack check -p tokio --each-feature --exclude-features full,net,process,signal,rt-multi-thread,io-uring,taskdump,schedule-latency --target wasm32-unknown-emscripten
working-directory: tokio
- name: Test tokio for emscripten
run: cargo test -p tokio --target wasm32-unknown-emscripten --features "rt,time,sync,macros,fs,io-util,io-std,test-util" --tests
working-directory: tokio
env:
CARGO_TARGET_WASM32_UNKNOWN_EMSCRIPTEN_RUNNER: node
RUSTFLAGS: "-Dwarnings -Clink-args=-sALLOW_MEMORY_GROWTH=1 -Clink-args=-sEXIT_RUNTIME=1 -Clink-args=-sSTACK_SIZE=1048576"
- name: Install Rust ${{ env.rust_emscripten_nightly }}
uses: dtolnay/rust-toolchain@nightly
with:
toolchain: ${{ env.rust_emscripten_nightly }}
targets: wasm32-unknown-emscripten
components: rust-src
- name: Test tokio multi-thread runtime for emscripten (pthreads)
run: cargo +${{ env.rust_emscripten_nightly }} test -Zbuild-std=std,panic_abort -p tokio --target wasm32-unknown-emscripten --features "rt,rt-multi-thread,time,sync,macros" --test rt_multi_thread_emscripten
working-directory: tokio
env:
CARGO_TARGET_WASM32_UNKNOWN_EMSCRIPTEN_RUNNER: node
RUSTFLAGS: "-Dwarnings -Ctarget-feature=+atomics,+bulk-memory,+mutable-globals -Clink-args=-pthread -Clink-args=-sPTHREAD_POOL_SIZE=8 -Clink-args=-sINITIAL_MEMORY=134217728 -Clink-args=-sEXIT_RUNTIME=1 -Clink-args=-sSTACK_SIZE=1048576"
check-external-types:
name: check-external-types (${{ matrix.os }})
needs: basics
spellcheck.dic
+5 -1
View File
@@ -1,4 +1,4 @@
327
331
&
+
<
@@ -106,6 +106,8 @@ dns
DNS
DoS
dwOpenMode
Emscripten
Emscripten's
endian
enqueue
enqueued
@@ -213,6 +215,7 @@ plaintext
poller
POSIX
proxied
pthreads
qos
RAII
RCU
@@ -323,6 +326,7 @@ Wakers
wakeup
wakeups
WASI
Wasm
watchOS
workstealing
ZST
tokio/Cargo.toml
+10 -4
View File
@@ -101,7 +101,7 @@ bytes = { version = "1.2.1", optional = true }
mio = { version = "1.2.0", optional = true, default-features = false }
parking_lot = { version = "0.12.0", optional = true }
[target.'cfg(any(not(target_family = "wasm"), all(target_os = "wasi", not(target_env = "p1"))))'.dependencies]
[target.'cfg(any(not(target_family = "wasm"), target_os = "emscripten", all(target_os = "wasi", not(target_env = "p1"))))'.dependencies]
socket2 = { version = "0.6.3", optional = true, features = ["all"] }
# Currently unstable. The API exposed by these features may be broken at any time.
@@ -130,6 +130,8 @@ libc = { version = "0.2.168", optional = true }
[target.'cfg(unix)'.dev-dependencies]
libc = { version = "0.2.168" }
[target.'cfg(all(unix, not(target_os = "emscripten")))'.dev-dependencies]
nix = { version = "0.31.0", default-features = false, features = ["aio", "fs", "socket"] }
[target.'cfg(windows)'.dependencies.windows-sys]
@@ -146,22 +148,26 @@ features = [
[dev-dependencies]
tokio-test = "0.4.0"
tokio-stream = "0.1"
tokio-util = { version = "0.7", features = ["rt"] }
futures = { version = "0.3.0", features = ["async-await"] }
futures-test = "0.3.31"
mockall = "0.13.0"
async-stream = "0.3"
futures-concurrency = "7.6.3"
[target.'cfg(not(target_os = "emscripten"))'.dev-dependencies]
tokio-util = { version = "0.7", features = ["rt"] }
[target.'cfg(not(target_family = "wasm"))'.dev-dependencies]
socket2 = "0.6.0"
tempfile = "3.1.0"
proptest = "1"
[target.'cfg(any(not(target_family = "wasm"), target_os = "emscripten"))'.dev-dependencies]
tempfile = "3.1.0"
[target.'cfg(not(all(target_family = "wasm", target_os = "unknown")))'.dev-dependencies]
rand = "0.9"
[target.'cfg(all(target_family = "wasm", not(target_os = "wasi")))'.dev-dependencies]
[target.'cfg(all(target_family = "wasm", target_os = "unknown"))'.dev-dependencies]
wasm-bindgen-test = "0.3.0"
[target.'cfg(target_os = "freebsd")'.dev-dependencies]
tokio/src/blocking.rs
+30
View File
@@ -1,12 +1,42 @@
cfg_rt! {
#[cfg(any(not(target_os = "emscripten"), target_feature = "atomics"))]
pub(crate) use crate::runtime::spawn_blocking;
cfg_fs! {
#[cfg(any(not(target_os = "emscripten"), target_feature = "atomics"))]
#[allow(unused_imports)]
pub(crate) use crate::runtime::spawn_mandatory_blocking;
}
#[cfg(any(not(target_os = "emscripten"), target_feature = "atomics"))]
pub(crate) use crate::task::JoinHandle;
// Non-pthread emscripten has no blocking pool, and the `std` calls behind
// `fs` and `io-std` complete synchronously there, so this internal shim
// runs the closure inline and hands back an already-completed future. The
// public `task::spawn_blocking` is not routed through here and keeps its
// native semantics. Pthread builds (`+atomics`) use the native pool.
#[cfg(all(target_os = "emscripten", not(target_feature = "atomics")))]
pub(crate) type JoinHandle<T> = std::future::Ready<Result<T, crate::task::JoinError>>;
#[cfg(all(target_os = "emscripten", not(target_feature = "atomics")))]
pub(crate) fn spawn_blocking<F, R>(f: F) -> JoinHandle<R>
where
F: FnOnce() -> R + Send + 'static,
R: Send + 'static,
{
std::future::ready(Ok(f()))
}
#[cfg(all(target_os = "emscripten", not(target_feature = "atomics"), feature = "fs"))]
#[allow(dead_code)] // unit tests replace this with the `fs::mocks` version
pub(crate) fn spawn_mandatory_blocking<F, R>(f: F) -> Option<JoinHandle<R>>
where
F: FnOnce() -> R + Send + 'static,
R: Send + 'static,
{
Some(spawn_blocking(f))
}
}
cfg_not_rt! {
tokio/src/io/stdio_common.rs
+1
View File
@@ -108,6 +108,7 @@ where
#[cfg(test)]
#[cfg(not(loom))]
#[cfg(not(target_os = "emscripten"))]
mod tests {
use crate::io::blocking::DEFAULT_MAX_BUF_SIZE;
use crate::io::AsyncWriteExt;
tokio/src/lib.rs
+55 -17
View File
@@ -424,8 +424,11 @@
//!
//! ## `WASM` support
//!
//! Tokio has some limited support for the `WASM` platform. Without the
//! `tokio_unstable` flag, the following features are supported:
//! Tokio has some limited support for Wasm platforms.
//!
//! Many of Tokio's feature flags are restricted on Wasm, and unsupported
//! combinations of feature flags will fail to build. However, all Wasm targets
//! can be built with the following features:
//!
//! * `sync`
//! * `macros`
@@ -434,26 +437,45 @@
//! * `time`
//!
//! Enabling any other feature (including `full`) will cause a compilation
//! failure.
//! failure. Furthermore, some operations available under these feature flags
//! may panic if they are unsupported. For example:
//!
//! The `time` module will only work on `WASM` platforms that have support for
//! timers (e.g. wasm32-wasi). The timing functions will panic if used on a `WASM`
//! platform that does not support timers.
//! * Using timers will panic on Wasm targets that do not support blocking the
//! thread.
//! * If the runtime becomes indefinitely idle (e.g., the program triggers a
//! deadlock), then this will panic on most Wasm targets.
//! * Operations such as `spawn_blocking` that involve spawning threads will
//! panic on Wasm targets that do not support threads.
//!
//! Note also that if the runtime becomes indefinitely idle, it will panic
//! immediately instead of blocking forever. On platforms that don't support
//! time, this means that the runtime can never be idle in any way.
//! All Wasm targets are still experimental, and breaking behavior changes can
//! occur in an effort to make Tokio use native Wasm operations. For instance,
//! the behavior of timers could be changed from panicking or blocking the
//! thread to starting a JavaScript timer. As another example, the
//! `spawn_blocking` method could be changed from starting a new thread to
//! creating a new cooperatively scheduled context of execution, if the Wasm
//! target supports such contexts. As a third example, the `#[tokio::main]` or
//! `#[tokio::test]` macros could be changed to work better with the Wasm
//! environment.
//!
//! ## Unstable `WASM` support
//! ### `WASI` support
//!
//! Tokio also has unstable support for some additional `WASM` features. This
//! requires the use of the `tokio_unstable` flag.
//! The `wasm32-wasip1` and `wasm32-wasip2` targets support the above features.
//! Timers work correctly as blocking the thread is supported.
//!
//! Using this flag enables the use of `tokio::net` on the wasm32-wasi target.
//! However, not all methods are available on the networking types as `WASI`
//! currently does not support the creation of new sockets from within `WASM`.
//! Because of this, sockets must currently be created via the `FromRawFd`
//! trait.
//! Under the `tokio_unstable` flag, these targets support the use
//! of `tokio::net`. On `wasm32-wasip1`, not all methods are available on the
//! networking types as this target does not support the creation of new
//! sockets from within `WASM`. Because of this, sockets must currently be
//! created via the `FromRawFd` trait on `wasm32-wasip1`. The `wasm32-wasip2`
//! target does not have this limitation.
//!
//! ### Emscripten support
//!
//! The `wasm32-unknown-emscripten` target supports the single-threaded runtime
//! with the `rt`, `time`, `sync`, `macros`, `fs`, `io-util`, `io-std`, and
//! `test-util` features. The `rt-multi-thread` feature is additionally
//! supported when building with Emscripten pthreads (`-pthread`). The `net`,
//! `process`, and `signal` features are not supported.
// Test that pointer width is compatible. This asserts that e.g. usize is at
// least 32 bits, which a lot of components in Tokio currently assumes.
@@ -467,6 +489,7 @@ compile_error! {
#[cfg(all(
not(tokio_unstable),
target_family = "wasm",
not(target_os = "emscripten"),
any(
feature = "fs",
feature = "io-std",
@@ -478,6 +501,21 @@ compile_error! {
))]
compile_error!("Only features sync,macros,io-util,rt,time are supported on wasm.");
#[cfg(all(
target_os = "emscripten",
any(feature = "net", feature = "process", feature = "signal")
))]
compile_error!("Features net,process,signal are not supported on wasm32-unknown-emscripten.");
#[cfg(all(
target_os = "emscripten",
feature = "rt-multi-thread",
not(target_feature = "atomics")
))]
compile_error!(
"The `rt-multi-thread` feature on wasm32-unknown-emscripten requires pthreads support (build with `-pthread`)."
);
#[cfg(all(
tokio_unstable,
feature = "taskdump",
tokio/src/macros/cfg.rs
+27 -15
View File
@@ -398,6 +398,7 @@ macro_rules! cfg_process {
#[cfg_attr(docsrs, doc(cfg(feature = "process")))]
#[cfg(not(loom))]
#[cfg(not(target_os = "wasi"))]
#[cfg(not(target_os = "emscripten"))]
$item
)*
}
@@ -405,16 +406,29 @@ macro_rules! cfg_process {
macro_rules! cfg_process_driver {
($($item:item)*) => {
#[cfg(unix)]
#[cfg(not(loom))]
cfg_process! { $($item)* }
$(
#[cfg(all(
unix,
not(loom),
feature = "process",
not(target_os = "wasi"),
not(target_os = "emscripten"),
))]
$item
)*
}
}
macro_rules! cfg_not_process_driver {
($($item:item)*) => {
$(
#[cfg(not(all(unix, not(loom), feature = "process")))]
#[cfg(not(all(
unix,
not(loom),
feature = "process",
not(target_os = "wasi"),
not(target_os = "emscripten"),
)))]
$item
)*
}
@@ -427,6 +441,7 @@ macro_rules! cfg_signal {
#[cfg_attr(docsrs, doc(cfg(feature = "signal")))]
#[cfg(not(loom))]
#[cfg(not(target_os = "wasi"))]
#[cfg(not(target_os = "emscripten"))]
$item
)*
}
@@ -437,6 +452,7 @@ macro_rules! cfg_signal_internal {
$(
#[cfg(any(feature = "signal", all(unix, feature = "process")))]
#[cfg(not(loom))]
#[cfg(not(target_os = "emscripten"))]
$item
)*
}
@@ -449,10 +465,15 @@ macro_rules! cfg_signal_internal_and_unix {
}
}
macro_rules! cfg_not_signal_internal {
macro_rules! cfg_not_signal_internal_and_unix {
($($item:item)*) => {
$(
#[cfg(any(loom, not(unix), not(any(feature = "signal", all(unix, feature = "process")))))]
#[cfg(not(all(
unix,
any(feature = "signal", all(unix, feature = "process")),
not(loom),
not(target_os = "emscripten"),
)))]
$item
)*
}
@@ -712,15 +733,6 @@ macro_rules! cfg_not_wasip1 {
}
}
macro_rules! cfg_is_wasm_not_wasi {
($($item:item)*) => {
$(
#[cfg(all(target_family = "wasm", not(target_os = "wasi")))]
$item
)*
}
}
/// Use this macro to provide two different implementations of the same API — one for stable
/// builds and one for unstable builds.
macro_rules! cfg_metrics_variant {
tokio/src/runtime/blocking/pool.rs
+11 -3
View File
@@ -182,7 +182,13 @@ pub(crate) struct Task {
#[derive(PartialEq, Eq)]
pub(crate) enum Mandatory {
#[cfg_attr(not(feature = "fs"), allow(dead_code))]
#[cfg_attr(
any(
not(feature = "fs"),
all(target_os = "emscripten", not(target_feature = "atomics"))
),
allow(dead_code)
)]
Mandatory,
NonMandatory,
}
@@ -246,7 +252,8 @@ where
cfg_fs! {
#[cfg_attr(any(
all(loom, not(test)), // the function is covered by loom tests
test
test,
all(target_os = "emscripten", not(target_feature = "atomics")), // fs uses the inline shim
), allow(dead_code))]
/// Runs the provided function on an executor dedicated to blocking
/// operations. Tasks will be scheduled as mandatory, meaning they are
@@ -385,7 +392,8 @@ impl Spawner {
#[track_caller]
#[cfg_attr(any(
all(loom, not(test)), // the function is covered by loom tests
test
test,
all(target_os = "emscripten", not(target_feature = "atomics")), // fs uses the inline shim
), allow(dead_code))]
pub(crate) fn spawn_mandatory_blocking<F, R>(&self, rt: &Handle, func: F) -> Option<JoinHandle<R>>
where
tokio/src/runtime/driver.rs
+1 -1
View File
@@ -251,7 +251,7 @@ cfg_signal_internal_and_unix! {
}
}
cfg_not_signal_internal! {
cfg_not_signal_internal_and_unix! {
pub(crate) type SignalHandle = ();
cfg_io_driver! {
tokio/src/runtime/mod.rs
+5
View File
@@ -550,6 +550,11 @@ cfg_rt! {
}
cfg_fs! {
// Non-pthread emscripten uses the inline shim in `crate::blocking`.
#[cfg_attr(
all(target_os = "emscripten", not(target_feature = "atomics")),
allow(unused_imports)
)]
pub(crate) use blocking::spawn_mandatory_blocking;
}
tokio/src/runtime/time/tests/mod.rs
+1 -1
View File
@@ -1,4 +1,4 @@
#![cfg(not(target_os = "wasi"))]
#![cfg(all(not(target_os = "wasi"), not(target_os = "emscripten")))]
use std::{task::Context, time::Duration};
tokio/src/sync/tests/atomic_waker.rs
+1 -1
View File
@@ -15,7 +15,7 @@ impl AssertSync for AtomicWaker {}
impl AssertSend for Waker {}
impl AssertSync for Waker {}
#[cfg(all(target_family = "wasm", not(target_os = "wasi")))]
#[cfg(all(target_family = "wasm", target_os = "unknown"))]
use wasm_bindgen_test::wasm_bindgen_test as test;
#[test]
tokio/src/sync/tests/notify.rs
+1 -1
View File
@@ -3,7 +3,7 @@ use std::future::Future;
use std::sync::Arc;
use std::task::{Context, RawWaker, RawWakerVTable, Waker};
#[cfg(all(target_family = "wasm", not(target_os = "wasi")))]
#[cfg(all(target_family = "wasm", target_os = "unknown"))]
use wasm_bindgen_test::wasm_bindgen_test as test;
#[test]
tokio/src/sync/tests/semaphore_batch.rs
+1 -1
View File
@@ -3,7 +3,7 @@ use tokio_test::*;
const MAX_PERMITS: usize = crate::sync::Semaphore::MAX_PERMITS;
#[cfg(all(target_family = "wasm", not(target_os = "wasi")))]
#[cfg(all(target_family = "wasm", target_os = "unknown"))]
use wasm_bindgen_test::wasm_bindgen_test as test;
#[test]
tokio/src/task/coop/mod.rs
+1 -1
View File
@@ -496,7 +496,7 @@ cfg_coop! {
mod test {
use super::*;
#[cfg(all(target_family = "wasm", not(target_os = "wasi")))]
#[cfg(all(target_family = "wasm", target_os = "unknown"))]
use wasm_bindgen_test::wasm_bindgen_test as test;
fn get() -> Budget {
tokio/src/task/local.rs
+1 -1
View File
@@ -1276,7 +1276,7 @@ impl LocalState {
// ensure they are on the same thread that owns the `LocalSet`.
unsafe impl Send for LocalState {}
#[cfg(all(test, not(loom)))]
#[cfg(all(test, not(loom), not(target_os = "emscripten")))]
mod tests {
use super::*;
tokio/src/util/idle_notified_set.rs
+1 -1
View File
@@ -492,7 +492,7 @@ unsafe impl<T> linked_list::Link for ListEntry<T> {
}
}
#[cfg(all(test, not(loom)))]
#[cfg(all(test, not(loom), not(target_os = "emscripten")))]
mod tests {
use crate::runtime::Builder;
use crate::task::JoinSet;
tokio/tests/fs.rs
+13 -1
View File
@@ -1,5 +1,13 @@
#![warn(rust_2018_idioms)]
#![cfg(all(feature = "full", not(target_os = "wasi")))] // Wasi does not support file operations
#![cfg(any(
all(feature = "full", not(target_os = "wasi")), // Wasi does not support file operations
all(
target_os = "emscripten",
feature = "rt",
feature = "macros",
feature = "fs"
)
))]
use tokio::fs;
use tokio_test::assert_ok;
@@ -16,6 +24,10 @@ async fn path_read_write() {
}
#[tokio::test]
#[cfg_attr(
target_os = "emscripten",
ignore = "emscripten libc does not implement dup()/try_clone()"
)]
async fn try_clone_should_preserve_max_buf_size() {
let buf_size = 128;
let temp = tempdir();
tokio/tests/fs_canonicalize_dir.rs
+13 -1
View File
@@ -1,5 +1,17 @@
#![warn(rust_2018_idioms)]
#![cfg(all(feature = "full", not(target_os = "wasi")))] // WASI does not support all fs operations
#![cfg(all(
any(
feature = "full",
all(
target_os = "emscripten",
feature = "fs",
feature = "macros",
feature = "rt",
feature = "io-util"
)
),
not(target_os = "wasi")
))] // WASI does not support all fs operations
use tokio::fs;
tokio/tests/fs_copy.rs
+13 -1
View File
@@ -1,5 +1,17 @@
#![warn(rust_2018_idioms)]
#![cfg(all(feature = "full", not(target_os = "wasi")))] // WASI does not support all fs operations
#![cfg(all(
any(
feature = "full",
all(
target_os = "emscripten",
feature = "fs",
feature = "macros",
feature = "rt",
feature = "io-util"
)
),
not(target_os = "wasi")
))] // WASI does not support all fs operations
use tempfile::tempdir;
use tokio::fs;
tokio/tests/fs_dir.rs
+13 -1
View File
@@ -1,5 +1,17 @@
#![warn(rust_2018_idioms)]
#![cfg(all(feature = "full", not(target_os = "wasi")))] // WASI does not support all fs operations
#![cfg(all(
any(
feature = "full",
all(
target_os = "emscripten",
feature = "fs",
feature = "macros",
feature = "rt",
feature = "io-util"
)
),
not(target_os = "wasi")
))] // WASI does not support all fs operations
use tokio::fs;
use tokio_test::{assert_err, assert_ok};
tokio/tests/fs_file.rs
+21 -1
View File
@@ -1,5 +1,17 @@
#![warn(rust_2018_idioms)]
#![cfg(all(feature = "full", not(target_os = "wasi")))] // WASI does not support all fs operations
#![cfg(all(
any(
feature = "full",
all(
target_os = "emscripten",
feature = "fs",
feature = "macros",
feature = "rt",
feature = "io-util"
)
),
not(target_os = "wasi")
))] // WASI does not support all fs operations
use futures::future::FutureExt;
use std::io::prelude::*;
@@ -99,6 +111,10 @@ async fn rewind_seek_position() {
}
#[tokio::test]
#[cfg_attr(
target_os = "emscripten",
ignore = "inline-fs shim does not insert cooperative yield points"
)]
async fn coop() {
let mut tempfile = tempfile();
tempfile.write_all(HELLO).unwrap();
@@ -124,6 +140,10 @@ async fn coop() {
}
#[tokio::test]
#[cfg_attr(
target_os = "emscripten",
ignore = "emscripten libc does not implement dup()/try_clone()"
)]
async fn write_to_clone() {
let tempfile = tempfile();
tokio/tests/fs_link.rs
+17 -1
View File
@@ -1,5 +1,17 @@
#![warn(rust_2018_idioms)]
#![cfg(all(feature = "full", not(target_os = "wasi")))] // WASI does not support all fs operations
#![cfg(all(
any(
feature = "full",
all(
target_os = "emscripten",
feature = "fs",
feature = "macros",
feature = "rt",
feature = "io-util"
)
),
not(target_os = "wasi")
))] // WASI does not support all fs operations
use tokio::fs;
@@ -8,6 +20,7 @@ use tempfile::tempdir;
#[tokio::test]
#[cfg_attr(miri, ignore)] // No `linkat` in miri.
#[cfg_attr(target_os = "emscripten", ignore = "MEMFS rejects link() with EMLINK")]
async fn test_hard_link() {
let dir = tempdir().unwrap();
let src = dir.path().join("src.txt");
@@ -63,6 +76,7 @@ async fn test_symlink() {
#[tokio::test]
#[cfg_attr(miri, ignore)] // No `linkat` in miri.
#[cfg_attr(target_os = "emscripten", ignore = "MEMFS rejects link() with EMLINK")]
async fn test_hard_link_error_source_not_found() {
let dir = tempdir().unwrap();
let src = dir.path().join("nonexistent.txt");
@@ -72,6 +86,7 @@ async fn test_hard_link_error_source_not_found() {
assert_eq!(err.kind(), std::io::ErrorKind::NotFound);
}
// On emscripten MEMFS reports EEXIST before its unconditional link() EMLINK.
#[tokio::test]
#[cfg_attr(miri, ignore)] // No `linkat` in miri.
async fn test_hard_link_error_destination_already_exists() {
@@ -92,6 +107,7 @@ async fn test_hard_link_error_destination_already_exists() {
#[tokio::test]
#[cfg_attr(miri, ignore)] // No `linkat` in miri.
#[cfg_attr(target_os = "emscripten", ignore = "MEMFS rejects link() with EMLINK")]
async fn test_hard_link_error_source_is_directory() {
let dir = tempdir().unwrap();
let src_dir = dir.path().join("src_directory");
tokio/tests/fs_open_options.rs
+13 -1
View File
@@ -1,5 +1,17 @@
#![warn(rust_2018_idioms)]
#![cfg(all(feature = "full", not(target_os = "wasi")))] // WASI does not support all fs operations
#![cfg(all(
any(
feature = "full",
all(
target_os = "emscripten",
feature = "fs",
feature = "macros",
feature = "rt",
feature = "io-util"
)
),
not(target_os = "wasi")
))] // WASI does not support all fs operations
use std::io::Write;
use tempfile::NamedTempFile;
tokio/tests/fs_remove_dir_all.rs
+13 -1
View File
@@ -1,5 +1,17 @@
#![warn(rust_2018_idioms)]
#![cfg(all(feature = "full", not(target_os = "wasi")))] // WASI does not support all fs operations
#![cfg(all(
any(
feature = "full",
all(
target_os = "emscripten",
feature = "fs",
feature = "macros",
feature = "rt",
feature = "io-util"
)
),
not(target_os = "wasi")
))] // WASI does not support all fs operations
use tempfile::tempdir;
use tokio::fs;
tokio/tests/fs_remove_file.rs
+13 -1
View File
@@ -1,5 +1,17 @@
#![warn(rust_2018_idioms)]
#![cfg(all(feature = "full", not(target_os = "wasi")))] // WASI does not support all fs operations
#![cfg(all(
any(
feature = "full",
all(
target_os = "emscripten",
feature = "fs",
feature = "macros",
feature = "rt",
feature = "io-util"
)
),
not(target_os = "wasi")
))] // WASI does not support all fs operations
use tempfile::tempdir;
use tokio::fs;
tokio/tests/fs_rename.rs
+13 -1
View File
@@ -1,5 +1,17 @@
#![warn(rust_2018_idioms)]
#![cfg(all(feature = "full", not(target_os = "wasi")))] // WASI does not support all fs operations
#![cfg(all(
any(
feature = "full",
all(
target_os = "emscripten",
feature = "fs",
feature = "macros",
feature = "rt",
feature = "io-util"
)
),
not(target_os = "wasi")
))] // WASI does not support all fs operations
use tempfile::tempdir;
use tokio::fs;
tokio/tests/fs_try_exists.rs
+13 -1
View File
@@ -1,5 +1,17 @@
#![warn(rust_2018_idioms)]
#![cfg(all(feature = "full", not(target_os = "wasi")))] // WASI does not support all fs operations
#![cfg(all(
any(
feature = "full",
all(
target_os = "emscripten",
feature = "fs",
feature = "macros",
feature = "rt",
feature = "io-util"
)
),
not(target_os = "wasi")
))] // WASI does not support all fs operations
use tempfile::tempdir;
use tokio::fs;
tokio/tests/fs_write.rs
+13 -1
View File
@@ -1,5 +1,17 @@
#![warn(rust_2018_idioms)]
#![cfg(all(feature = "full", not(target_os = "wasi")))] // WASI does not support all fs operations
#![cfg(all(
any(
feature = "full",
all(
target_os = "emscripten",
feature = "fs",
feature = "macros",
feature = "rt",
feature = "io-util"
)
),
not(target_os = "wasi")
))] // WASI does not support all fs operations
use tempfile::tempdir;
use tokio::fs;
tokio/tests/io_async_read.rs
+9 -1
View File
@@ -1,5 +1,13 @@
#![warn(rust_2018_idioms)]
#![cfg(feature = "full")]
#![cfg(any(
feature = "full",
all(
target_os = "emscripten",
feature = "rt",
feature = "macros",
feature = "io-util"
)
))]
use tokio::io::AsyncRead;
tokio/tests/io_buf_reader.rs
+9 -1
View File
@@ -1,5 +1,13 @@
#![warn(rust_2018_idioms)]
#![cfg(feature = "full")]
#![cfg(any(
feature = "full",
all(
target_os = "emscripten",
feature = "rt",
feature = "macros",
feature = "io-util"
)
))]
// https://github.com/rust-lang/futures-rs/blob/1803948ff091b4eabf7f3bf39e16bbbdefca5cc8/futures/tests/io_buf_reader.rs
tokio/tests/io_buf_writer.rs
+9 -1
View File
@@ -1,5 +1,13 @@
#![warn(rust_2018_idioms)]
#![cfg(feature = "full")]
#![cfg(any(
feature = "full",
all(
target_os = "emscripten",
feature = "rt",
feature = "macros",
feature = "io-util"
)
))]
// https://github.com/rust-lang/futures-rs/blob/1803948ff091b4eabf7f3bf39e16bbbdefca5cc8/futures/tests/io_buf_writer.rs
tokio/tests/io_chain.rs
+9 -1
View File
@@ -1,5 +1,13 @@
#![warn(rust_2018_idioms)]
#![cfg(feature = "full")]
#![cfg(any(
feature = "full",
all(
target_os = "emscripten",
feature = "rt",
feature = "macros",
feature = "io-util"
)
))]
use tokio::io::AsyncReadExt;
use tokio_test::assert_ok;
tokio/tests/io_copy.rs
+9 -1
View File
@@ -1,5 +1,13 @@
#![warn(rust_2018_idioms)]
#![cfg(feature = "full")]
#![cfg(any(
feature = "full",
all(
target_os = "emscripten",
feature = "rt",
feature = "macros",
feature = "io-util"
)
))]
use bytes::BytesMut;
use tokio::io::{self, AsyncRead, AsyncReadExt, AsyncWrite, AsyncWriteExt, ReadBuf};
tokio/tests/io_emscripten.rs
+59
View File
@@ -0,0 +1,59 @@
//! Standard I/O tests for emscripten.
//!
//! `tokio::io::{stdout, stderr}` round through emscripten's libc to the JS
//! `print`/`printErr` hooks; these tests mostly check that writes don't fail —
//! observable output verification is left to manual `--nocapture` runs.
//!
//! `tokio::io::stdin` reads fd 0 synchronously in emscripten, so this only
//! completes when stdin is non-interactive (EOF), as under CI where
//! the runner's stdin is `/dev/null`. The contract worth pinning is "a stdin
//! read returns rather than deadlocking", not a specific errno.
#![cfg(all(target_os = "emscripten", feature = "io-std"))]
use tokio::io::{AsyncReadExt, AsyncWriteExt};
#[tokio::test]
async fn stdout_write_completes() {
let mut out = tokio::io::stdout();
out.write_all(b"hello from stdout\n").await.unwrap();
out.flush().await.unwrap();
}
#[tokio::test]
async fn stderr_write_completes() {
let mut err = tokio::io::stderr();
err.write_all(b"hello from stderr\n").await.unwrap();
err.flush().await.unwrap();
}
#[tokio::test]
async fn stdout_large_multichunk_write_completes() {
// Exercises the BufWriter chunking inside `Stdout` (writes larger than
// the internal buffer force multiple underlying writes).
let mut out = tokio::io::stdout();
let data = vec![b'x'; 64 * 1024];
out.write_all(&data).await.unwrap();
out.flush().await.unwrap();
}
#[tokio::test]
async fn stdout_interleaved_writes_complete() {
let mut out = tokio::io::stdout();
for i in 0..16 {
out.write_all(format!("line {i}\n").as_bytes())
.await
.unwrap();
}
out.flush().await.unwrap();
}
#[tokio::test]
async fn stdin_read_does_not_hang() {
// The runner detaches stdin onto the null device, so a read must return
// promptly (Ok(0) EOF or an I/O error) rather than blocking the host
// loop. The runner's watchdog fails the test if this ever deadlocks.
let mut stdin = tokio::io::stdin();
let mut buf = [0u8; 32];
let _ = stdin.read(&mut buf).await;
}
tokio/tests/io_fill_buf.rs
+10 -1
View File
@@ -1,5 +1,14 @@
#![warn(rust_2018_idioms)]
#![cfg(all(feature = "full", not(target_os = "wasi")))] // Wasi does not support file operations
#![cfg(any(
all(feature = "full", not(target_os = "wasi")),
all(
target_os = "emscripten",
feature = "rt",
feature = "macros",
feature = "io-util",
feature = "fs"
)
))]
use tempfile::NamedTempFile;
use tokio::fs::File;
tokio/tests/io_join.rs
+9 -1
View File
@@ -1,5 +1,13 @@
#![warn(rust_2018_idioms)]
#![cfg(feature = "full")]
#![cfg(any(
feature = "full",
all(
target_os = "emscripten",
feature = "rt",
feature = "macros",
feature = "io-util"
)
))]
use tokio::io::{join, AsyncRead, AsyncReadExt, AsyncWrite, AsyncWriteExt, Join, ReadBuf};
tokio/tests/io_lines.rs
+9 -1
View File
@@ -1,5 +1,13 @@
#![warn(rust_2018_idioms)]
#![cfg(feature = "full")]
#![cfg(any(
feature = "full",
all(
target_os = "emscripten",
feature = "rt",
feature = "macros",
feature = "io-util"
)
))]
use std::io::{Error, ErrorKind};
use std::string::FromUtf8Error;
tokio/tests/io_mem_stream.rs
+9 -1
View File
@@ -1,5 +1,13 @@
#![warn(rust_2018_idioms)]
#![cfg(feature = "full")]
#![cfg(any(
feature = "full",
all(
target_os = "emscripten",
feature = "rt",
feature = "macros",
feature = "io-util"
)
))]
use futures::FutureExt;
use std::io::IoSlice;
tokio/tests/io_panic.rs
+9 -6
View File
@@ -1,5 +1,8 @@
#![warn(rust_2018_idioms)]
#![cfg(all(feature = "full", not(target_os = "wasi")))] // Wasi does not support panic recovery
#![cfg(any(
all(feature = "full", not(target_os = "wasi")), // Wasi does not support panic recovery
all(target_os = "emscripten", feature = "io-util")
))]
#![cfg(panic = "unwind")]
use std::task::{Context, Poll};
@@ -42,7 +45,7 @@ impl AsyncWrite for RW {
}
}
#[cfg(unix)]
#[cfg(all(unix, not(target_os = "emscripten")))]
mod unix {
use std::os::unix::prelude::{AsRawFd, RawFd};
@@ -168,7 +171,7 @@ fn new_unsplit_zero_capacity_panic_caller() -> Result<(), Box<dyn Error>> {
}
#[test]
#[cfg(unix)]
#[cfg(all(unix, not(target_os = "emscripten")))]
fn async_fd_new_panic_caller() -> Result<(), Box<dyn Error>> {
use tokio::io::unix::AsyncFd;
use tokio::runtime::Builder;
@@ -190,7 +193,7 @@ fn async_fd_new_panic_caller() -> Result<(), Box<dyn Error>> {
}
#[test]
#[cfg(unix)]
#[cfg(all(unix, not(target_os = "emscripten")))]
fn async_fd_with_interest_panic_caller() -> Result<(), Box<dyn Error>> {
use tokio::io::unix::AsyncFd;
use tokio::io::Interest;
@@ -213,7 +216,7 @@ fn async_fd_with_interest_panic_caller() -> Result<(), Box<dyn Error>> {
}
#[test]
#[cfg(unix)]
#[cfg(all(unix, not(target_os = "emscripten")))]
fn async_fd_try_new_panic_caller() -> Result<(), Box<dyn Error>> {
use tokio::io::unix::AsyncFd;
use tokio::runtime::Builder;
@@ -235,7 +238,7 @@ fn async_fd_try_new_panic_caller() -> Result<(), Box<dyn Error>> {
}
#[test]
#[cfg(unix)]
#[cfg(all(unix, not(target_os = "emscripten")))]
fn async_fd_try_with_interest_panic_caller() -> Result<(), Box<dyn Error>> {
use tokio::io::unix::AsyncFd;
use tokio::io::Interest;
tokio/tests/io_read.rs
+9 -1
View File
@@ -1,5 +1,13 @@
#![warn(rust_2018_idioms)]
#![cfg(all(feature = "full", not(target_os = "wasi")))] // Wasi does not support panic recovery
#![cfg(any(
all(feature = "full", not(target_os = "wasi")), // Wasi does not support panic recovery
all(
target_os = "emscripten",
feature = "rt",
feature = "macros",
feature = "io-util"
)
))]
use tokio::io::{AsyncRead, AsyncReadExt, ReadBuf};
use tokio_test::assert_ok;
tokio/tests/io_read_buf.rs
+9 -1
View File
@@ -1,5 +1,13 @@
#![warn(rust_2018_idioms)]
#![cfg(feature = "full")]
#![cfg(any(
feature = "full",
all(
target_os = "emscripten",
feature = "rt",
feature = "macros",
feature = "io-util"
)
))]
use tokio::io::{AsyncRead, AsyncReadExt, ReadBuf};
use tokio_test::assert_ok;
tokio/tests/io_read_exact.rs
+9 -1
View File
@@ -1,5 +1,13 @@
#![warn(rust_2018_idioms)]
#![cfg(feature = "full")]
#![cfg(any(
feature = "full",
all(
target_os = "emscripten",
feature = "rt",
feature = "macros",
feature = "io-util"
)
))]
use tokio::io::AsyncReadExt;
use tokio_test::assert_ok;
tokio/tests/io_read_line.rs
+9 -1
View File
@@ -1,5 +1,13 @@
#![warn(rust_2018_idioms)]
#![cfg(feature = "full")]
#![cfg(any(
feature = "full",
all(
target_os = "emscripten",
feature = "rt",
feature = "macros",
feature = "io-util"
)
))]
use std::io::ErrorKind;
use std::str::Utf8Error;
tokio/tests/io_read_to_end.rs
+9 -1
View File
@@ -1,5 +1,13 @@
#![warn(rust_2018_idioms)]
#![cfg(feature = "full")]
#![cfg(any(
feature = "full",
all(
target_os = "emscripten",
feature = "rt",
feature = "macros",
feature = "io-util"
)
))]
use std::pin::Pin;
use std::task::{Context, Poll};
tokio/tests/io_read_to_string.rs
+9 -1
View File
@@ -1,5 +1,13 @@
#![warn(rust_2018_idioms)]
#![cfg(feature = "full")]
#![cfg(any(
feature = "full",
all(
target_os = "emscripten",
feature = "rt",
feature = "macros",
feature = "io-util"
)
))]
use std::io;
use std::str::Utf8Error;
tokio/tests/io_read_until.rs
+9 -1
View File
@@ -1,5 +1,13 @@
#![warn(rust_2018_idioms)]
#![cfg(feature = "full")]
#![cfg(any(
feature = "full",
all(
target_os = "emscripten",
feature = "rt",
feature = "macros",
feature = "io-util"
)
))]
use std::io::ErrorKind;
use tokio::io::{AsyncBufReadExt, BufReader, Error};
tokio/tests/io_repeat.rs
+9 -1
View File
@@ -1,5 +1,13 @@
#![warn(rust_2018_idioms)]
#![cfg(all(feature = "full", not(miri)))]
#![cfg(any(
all(feature = "full", not(miri)),
all(
target_os = "emscripten",
feature = "rt",
feature = "macros",
feature = "io-util"
)
))]
use tokio::io::AsyncReadExt;
tokio/tests/io_sink.rs
+9 -1
View File
@@ -1,5 +1,13 @@
#![warn(rust_2018_idioms)]
#![cfg(feature = "full")]
#![cfg(any(
feature = "full",
all(
target_os = "emscripten",
feature = "rt",
feature = "macros",
feature = "io-util"
)
))]
use tokio::io::AsyncWriteExt;
tokio/tests/io_split.rs
+9 -1
View File
@@ -1,5 +1,13 @@
#![warn(rust_2018_idioms)]
#![cfg(all(feature = "full", not(target_os = "wasi")))] // Wasi does not support panic recovery
#![cfg(any(
all(feature = "full", not(target_os = "wasi")), // Wasi does not support panic recovery
all(
target_os = "emscripten",
feature = "rt",
feature = "macros",
feature = "io-util"
)
))]
use tokio::io::{
split, AsyncRead, AsyncReadExt, AsyncWrite, AsyncWriteExt, ReadBuf, ReadHalf, WriteHalf,
tokio/tests/io_take.rs
+9 -1
View File
@@ -1,5 +1,13 @@
#![warn(rust_2018_idioms)]
#![cfg(all(feature = "full", not(target_os = "wasi")))] // Wasi does not support panic recovery
#![cfg(any(
all(feature = "full", not(target_os = "wasi")), // Wasi does not support panic recovery
all(
target_os = "emscripten",
feature = "rt",
feature = "macros",
feature = "io-util"
)
))]
use std::pin::Pin;
use std::task::{Context, Poll};
tokio/tests/io_util_empty.rs
+9 -1
View File
@@ -1,4 +1,12 @@
#![cfg(feature = "full")]
#![cfg(any(
feature = "full",
all(
target_os = "emscripten",
feature = "rt",
feature = "macros",
feature = "io-util"
)
))]
use tokio::io::{AsyncBufReadExt, AsyncReadExt, AsyncSeekExt};
#[tokio::test]
tokio/tests/io_write.rs
+9 -1
View File
@@ -1,5 +1,13 @@
#![warn(rust_2018_idioms)]
#![cfg(feature = "full")]
#![cfg(any(
feature = "full",
all(
target_os = "emscripten",
feature = "rt",
feature = "macros",
feature = "io-util"
)
))]
use tokio::io::{AsyncWrite, AsyncWriteExt};
use tokio_test::assert_ok;
tokio/tests/io_write_all.rs
+9 -1
View File
@@ -1,5 +1,13 @@
#![warn(rust_2018_idioms)]
#![cfg(feature = "full")]
#![cfg(any(
feature = "full",
all(
target_os = "emscripten",
feature = "rt",
feature = "macros",
feature = "io-util"
)
))]
use tokio::io::{AsyncWrite, AsyncWriteExt};
use tokio_test::assert_ok;
tokio/tests/io_write_all_buf.rs
+9 -1
View File
@@ -1,5 +1,13 @@
#![warn(rust_2018_idioms)]
#![cfg(feature = "full")]
#![cfg(any(
feature = "full",
all(
target_os = "emscripten",
feature = "rt",
feature = "macros",
feature = "io-util"
)
))]
use tokio::io::{AsyncWrite, AsyncWriteExt};
use tokio_test::{assert_err, assert_ok};
tokio/tests/io_write_buf.rs
+9 -1
View File
@@ -1,5 +1,13 @@
#![warn(rust_2018_idioms)]
#![cfg(feature = "full")]
#![cfg(any(
feature = "full",
all(
target_os = "emscripten",
feature = "rt",
feature = "macros",
feature = "io-util"
)
))]
use tokio::io::{AsyncWrite, AsyncWriteExt};
use tokio_test::assert_ok;
tokio/tests/io_write_int.rs
+9 -1
View File
@@ -1,5 +1,13 @@
#![warn(rust_2018_idioms)]
#![cfg(feature = "full")]
#![cfg(any(
feature = "full",
all(
target_os = "emscripten",
feature = "rt",
feature = "macros",
feature = "io-util"
)
))]
use tokio::io::{AsyncWrite, AsyncWriteExt};
tokio/tests/join_handle_panic.rs
+4 -1
View File
@@ -1,5 +1,8 @@
#![warn(rust_2018_idioms)]
#![cfg(all(feature = "full", not(target_os = "wasi")))] // Wasi doesn't support panic recovery
#![cfg(any(
all(feature = "full", not(target_os = "wasi")), // Wasi doesn't support panic recovery
all(target_os = "emscripten", feature = "rt", feature = "macros", feature = "time")
))]
#![cfg(panic = "unwind")]
struct PanicsOnDrop;
tokio/tests/macros_join.rs
+3 -3
View File
@@ -2,13 +2,13 @@
#![allow(clippy::disallowed_names)]
use std::sync::Arc;
#[cfg(all(target_family = "wasm", not(target_os = "wasi")))]
#[cfg(all(target_family = "wasm", target_os = "unknown"))]
#[cfg(target_pointer_width = "64")]
use wasm_bindgen_test::wasm_bindgen_test as test;
#[cfg(all(target_family = "wasm", not(target_os = "wasi")))]
#[cfg(all(target_family = "wasm", target_os = "unknown"))]
use wasm_bindgen_test::wasm_bindgen_test as maybe_tokio_test;
#[cfg(not(all(target_family = "wasm", not(target_os = "wasi"))))]
#[cfg(not(all(target_family = "wasm", target_os = "unknown")))]
use tokio::test as maybe_tokio_test;
use tokio::sync::{oneshot, Semaphore};
tokio/tests/macros_pin.rs
+2 -2
View File
@@ -1,9 +1,9 @@
#![cfg(feature = "macros")]
#[cfg(all(target_family = "wasm", not(target_os = "wasi")))]
#[cfg(all(target_family = "wasm", target_os = "unknown"))]
use wasm_bindgen_test::wasm_bindgen_test as maybe_tokio_test;
#[cfg(not(all(target_family = "wasm", not(target_os = "wasi"))))]
#[cfg(not(all(target_family = "wasm", target_os = "unknown")))]
use tokio::test as maybe_tokio_test;
async fn one() {}
tokio/tests/macros_select.rs
+2 -2
View File
@@ -1,10 +1,10 @@
#![cfg(feature = "macros")]
#![allow(clippy::disallowed_names)]
#[cfg(all(target_family = "wasm", not(target_os = "wasi")))]
#[cfg(all(target_family = "wasm", target_os = "unknown"))]
use wasm_bindgen_test::wasm_bindgen_test as maybe_tokio_test;
#[cfg(not(all(target_family = "wasm", not(target_os = "wasi"))))]
#[cfg(not(all(target_family = "wasm", target_os = "unknown")))]
use tokio::test as maybe_tokio_test;
use tokio::sync::oneshot;
tokio/tests/macros_try_join.rs
+2 -2
View File
@@ -6,10 +6,10 @@ 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")))]
#[cfg(all(target_family = "wasm", target_os = "unknown"))]
use wasm_bindgen_test::wasm_bindgen_test as maybe_tokio_test;
#[cfg(not(all(target_family = "wasm", not(target_os = "wasi"))))]
#[cfg(not(all(target_family = "wasm", target_os = "unknown")))]
use tokio::test as maybe_tokio_test;
#[maybe_tokio_test]
tokio/tests/rt_basic.rs
+16 -4
View File
@@ -1,5 +1,8 @@
#![warn(rust_2018_idioms)]
#![cfg(feature = "full")]
#![cfg(any(
feature = "full",
all(target_os = "emscripten", feature = "rt", feature = "macros")
))]
use tokio::runtime::{self, Runtime};
use tokio::sync::oneshot;
@@ -249,7 +252,10 @@ fn spawn_two() {
}
}
#[cfg_attr(target_os = "wasi", ignore = "WASI: std::thread::spawn not supported")]
#[cfg_attr(
target_family = "wasm",
ignore = "wasm targets do not support std::thread::spawn"
)]
#[test]
fn spawn_remote() {
let rt = rt();
@@ -346,7 +352,10 @@ mod unstable {
}
#[test]
#[cfg_attr(target_os = "wasi", ignore = "Wasi does not support panic recovery")]
#[cfg_attr(
target_family = "wasm",
ignore = "wasm targets do not support std::thread::spawn"
)]
fn spawns_do_nothing() {
use std::sync::Arc;
@@ -375,7 +384,10 @@ mod unstable {
}
#[test]
#[cfg_attr(target_os = "wasi", ignore = "Wasi does not support panic recovery")]
#[cfg_attr(
target_family = "wasm",
ignore = "wasm targets do not support std::thread::spawn"
)]
fn shutdown_all_concurrent_block_on() {
const N: usize = 2;
use std::sync::{mpsc, Arc};
tokio/tests/rt_handle.rs
+4 -1
View File
@@ -1,5 +1,8 @@
#![warn(rust_2018_idioms)]
#![cfg(feature = "full")]
#![cfg(any(
feature = "full",
all(target_os = "emscripten", feature = "rt", feature = "macros")
))]
use std::sync::Arc;
use tokio::runtime::Runtime;
tokio/tests/rt_multi_thread_emscripten.rs
+72
View File
@@ -0,0 +1,72 @@
#![warn(rust_2018_idioms)]
#![cfg(all(
target_os = "emscripten",
feature = "rt-multi-thread",
feature = "macros"
))]
//! Multi-thread runtime tests for `wasm32-unknown-emscripten` built with
//! pthreads (`-pthread`).
use std::sync::atomic::{AtomicUsize, Ordering};
use std::sync::{Arc, Barrier};
use std::time::Duration;
#[test]
fn block_on_multi_thread() {
let rt = tokio::runtime::Builder::new_multi_thread()
.worker_threads(2)
.enable_time()
.build()
.unwrap();
let out = rt.block_on(async {
let jh = tokio::spawn(async {
tokio::time::sleep(Duration::from_millis(10)).await;
"hello"
});
jh.await.unwrap()
});
assert_eq!(out, "hello");
}
#[test]
fn spawn_blocking_runs_in_parallel() {
let rt = tokio::runtime::Builder::new_multi_thread()
.worker_threads(2)
.build()
.unwrap();
// Both closures must be running concurrently for the barrier to release.
let barrier = Arc::new(Barrier::new(2));
rt.block_on(async {
let a = tokio::task::spawn_blocking({
let barrier = barrier.clone();
move || {
barrier.wait();
}
});
let b = tokio::task::spawn_blocking(move || {
barrier.wait();
});
a.await.unwrap();
b.await.unwrap();
});
}
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn macro_multi_thread() {
static COUNT: AtomicUsize = AtomicUsize::new(0);
let mut handles = Vec::new();
for _ in 0..8 {
handles.push(tokio::spawn(async {
tokio::task::yield_now().await;
COUNT.fetch_add(1, Ordering::Relaxed);
}));
}
for handle in handles {
handle.await.unwrap();
}
assert_eq!(COUNT.load(Ordering::Relaxed), 8);
}
tokio/tests/rt_panic.rs
+12 -2
View File
@@ -1,11 +1,16 @@
#![warn(rust_2018_idioms)]
#![cfg(feature = "full")]
#![cfg(any(
feature = "full",
all(target_os = "emscripten", feature = "rt", feature = "macros")
))]
#![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};
#[cfg(feature = "rt-multi-thread")]
use tokio::runtime::Builder;
use tokio::runtime::{Handle, Runtime};
mod support {
pub mod panic;
@@ -47,6 +52,7 @@ fn into_panic_panic_caller() -> Result<(), Box<dyn Error>> {
}
#[test]
#[cfg(feature = "rt-multi-thread")]
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();
@@ -59,6 +65,7 @@ fn builder_worker_threads_panic_caller() -> Result<(), Box<dyn Error>> {
}
#[test]
#[cfg(feature = "rt-multi-thread")]
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();
@@ -71,6 +78,7 @@ fn builder_max_blocking_threads_panic_caller() -> Result<(), Box<dyn Error>> {
}
#[test]
#[cfg(feature = "rt-multi-thread")]
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();
@@ -83,6 +91,7 @@ fn builder_global_queue_interval_panic_caller() -> Result<(), Box<dyn Error>> {
}
#[test]
#[cfg(feature = "rt-multi-thread")]
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();
@@ -95,6 +104,7 @@ fn builder_event_interval_interval_panic_caller() -> Result<(), Box<dyn Error>>
}
#[test]
#[cfg(feature = "rt-multi-thread")]
fn builder_name_panic_caller() -> Result<(), Box<dyn Error>> {
let panic_location_file = test_panic(|| {
let _ = Builder::new_multi_thread().name(" ").build();
tokio/tests/rt_shutdown_err.rs
+3 -1
View File
@@ -1,8 +1,9 @@
#![warn(rust_2018_idioms)]
#![cfg(feature = "full")]
#![cfg(any(feature = "full", all(target_os = "emscripten", feature = "rt")))]
#![cfg(not(miri))] // No socket in miri.
use std::io;
#[cfg(not(target_family = "wasm"))]
use tokio::net::TcpListener;
use tokio::runtime::Builder;
@@ -10,6 +11,7 @@ fn rt() -> tokio::runtime::Runtime {
Builder::new_current_thread().enable_all().build().unwrap()
}
#[cfg(not(target_family = "wasm"))] // needs net (TcpListener)
#[test]
fn test_is_rt_shutdown_err() {
let rt1 = rt();
tokio/tests/rt_time_start_paused.rs
+9 -1
View File
@@ -1,4 +1,12 @@
#![cfg(feature = "full")]
#![cfg(any(
feature = "full",
all(
target_os = "emscripten",
feature = "rt",
feature = "macros",
feature = "test-util"
)
))]
use tokio::time::{Duration, Instant};
tokio/tests/sync_barrier.rs
+1 -1
View File
@@ -2,7 +2,7 @@
#![warn(rust_2018_idioms)]
#![cfg(feature = "sync")]
#[cfg(all(target_family = "wasm", not(target_os = "wasi")))]
#[cfg(all(target_family = "wasm", target_os = "unknown"))]
use wasm_bindgen_test::wasm_bindgen_test as test;
use tokio::sync::Barrier;
tokio/tests/sync_broadcast.rs
+2 -2
View File
@@ -2,7 +2,7 @@
#![warn(rust_2018_idioms)]
#![cfg(feature = "sync")]
#[cfg(all(target_family = "wasm", not(target_os = "wasi")))]
#[cfg(all(target_family = "wasm", target_os = "unknown"))]
use wasm_bindgen_test::wasm_bindgen_test as test;
use tokio::sync::broadcast;
@@ -563,7 +563,7 @@ fn sender_len() {
}
#[test]
#[cfg(not(all(target_family = "wasm", not(target_os = "wasi"))))]
#[cfg(not(all(target_family = "wasm", target_os = "unknown")))]
fn sender_len_random() {
let (tx, mut rx1) = broadcast::channel(16);
let mut rx2 = tx.subscribe();
tokio/tests/sync_broadcast_weak.rs
+1 -1
View File
@@ -2,7 +2,7 @@
#![warn(rust_2018_idioms)]
#![cfg(feature = "sync")]
#[cfg(all(target_family = "wasm", not(target_os = "wasi")))]
#[cfg(all(target_family = "wasm", target_os = "unknown"))]
use wasm_bindgen_test::wasm_bindgen_test as test;
use tokio::sync::broadcast::{self, channel};
tokio/tests/sync_errors.rs
+1 -1
View File
@@ -1,7 +1,7 @@
#![warn(rust_2018_idioms)]
#![cfg(feature = "sync")]
#[cfg(all(target_family = "wasm", not(target_os = "wasi")))]
#[cfg(all(target_family = "wasm", target_os = "unknown"))]
use wasm_bindgen_test::wasm_bindgen_test as test;
fn is_error<T: std::error::Error + Send + Sync>() {}
tokio/tests/sync_mpsc.rs
+3 -3
View File
@@ -2,12 +2,12 @@
#![warn(rust_2018_idioms)]
#![cfg(feature = "sync")]
#[cfg(all(target_family = "wasm", not(target_os = "wasi")))]
#[cfg(all(target_family = "wasm", target_os = "unknown"))]
use wasm_bindgen_test::wasm_bindgen_test as test;
#[cfg(all(target_family = "wasm", not(target_os = "wasi")))]
#[cfg(all(target_family = "wasm", target_os = "unknown"))]
use wasm_bindgen_test::wasm_bindgen_test as maybe_tokio_test;
#[cfg(not(all(target_family = "wasm", not(target_os = "wasi"))))]
#[cfg(not(all(target_family = "wasm", target_os = "unknown")))]
use tokio::test as maybe_tokio_test;
use std::fmt;
tokio/tests/sync_mpsc_weak.rs
+1 -1
View File
@@ -2,7 +2,7 @@
#![warn(rust_2018_idioms)]
#![cfg(feature = "sync")]
#[cfg(all(target_family = "wasm", not(target_os = "wasi")))]
#[cfg(all(target_family = "wasm", target_os = "unknown"))]
use wasm_bindgen_test::wasm_bindgen_test as test;
use std::sync::atomic::AtomicUsize;
tokio/tests/sync_mutex.rs
+3 -3
View File
@@ -1,12 +1,12 @@
#![warn(rust_2018_idioms)]
#![cfg(feature = "sync")]
#[cfg(all(target_family = "wasm", not(target_os = "wasi")))]
#[cfg(all(target_family = "wasm", target_os = "unknown"))]
use wasm_bindgen_test::wasm_bindgen_test as test;
#[cfg(all(target_family = "wasm", not(target_os = "wasi")))]
#[cfg(all(target_family = "wasm", target_os = "unknown"))]
use wasm_bindgen_test::wasm_bindgen_test as maybe_tokio_test;
#[cfg(not(all(target_family = "wasm", not(target_os = "wasi"))))]
#[cfg(not(all(target_family = "wasm", target_os = "unknown")))]
use tokio::test as maybe_tokio_test;
use tokio::sync::Mutex;
tokio/tests/sync_mutex_owned.rs
+3 -3
View File
@@ -1,12 +1,12 @@
#![warn(rust_2018_idioms)]
#![cfg(feature = "sync")]
#[cfg(all(target_family = "wasm", not(target_os = "wasi")))]
#[cfg(all(target_family = "wasm", target_os = "unknown"))]
use wasm_bindgen_test::wasm_bindgen_test as test;
#[cfg(all(target_family = "wasm", not(target_os = "wasi")))]
#[cfg(all(target_family = "wasm", target_os = "unknown"))]
use wasm_bindgen_test::wasm_bindgen_test as maybe_tokio_test;
#[cfg(not(all(target_family = "wasm", not(target_os = "wasi"))))]
#[cfg(not(all(target_family = "wasm", target_os = "unknown")))]
use tokio::test as maybe_tokio_test;
use tokio::sync::Mutex;
tokio/tests/sync_notify.rs
+1 -1
View File
@@ -1,7 +1,7 @@
#![warn(rust_2018_idioms)]
#![cfg(feature = "sync")]
#[cfg(all(target_family = "wasm", not(target_os = "wasi")))]
#[cfg(all(target_family = "wasm", target_os = "unknown"))]
use wasm_bindgen_test::wasm_bindgen_test as test;
use tokio::sync::Notify;
tokio/tests/sync_notify_owned.rs
+1 -1
View File
@@ -1,7 +1,7 @@
#![warn(rust_2018_idioms)]
#![cfg(feature = "sync")]
#[cfg(all(target_family = "wasm", not(target_os = "wasi")))]
#[cfg(all(target_family = "wasm", target_os = "unknown"))]
use wasm_bindgen_test::wasm_bindgen_test as test;
use std::sync::Arc;
tokio/tests/sync_once_cell.rs
+9 -1
View File
@@ -1,5 +1,13 @@
#![warn(rust_2018_idioms)]
#![cfg(feature = "full")]
#![cfg(any(
feature = "full",
all(
target_os = "emscripten",
feature = "rt",
feature = "macros",
feature = "test-util"
)
))]
use std::mem;
use std::sync::atomic::{AtomicU32, Ordering};
tokio/tests/sync_oneshot.rs
+3 -3
View File
@@ -1,12 +1,12 @@
#![warn(rust_2018_idioms)]
#![cfg(feature = "sync")]
#[cfg(all(target_family = "wasm", not(target_os = "wasi")))]
#[cfg(all(target_family = "wasm", target_os = "unknown"))]
use wasm_bindgen_test::wasm_bindgen_test as test;
#[cfg(all(target_family = "wasm", not(target_os = "wasi")))]
#[cfg(all(target_family = "wasm", target_os = "unknown"))]
use wasm_bindgen_test::wasm_bindgen_test as maybe_tokio_test;
#[cfg(not(all(target_family = "wasm", not(target_os = "wasi"))))]
#[cfg(not(all(target_family = "wasm", target_os = "unknown")))]
use tokio::test as maybe_tokio_test;
use tokio::sync::oneshot;
tokio/tests/sync_panic.rs
+4 -1
View File
@@ -1,5 +1,8 @@
#![warn(rust_2018_idioms)]
#![cfg(all(feature = "full", not(target_os = "wasi")))]
#![cfg(any(
all(feature = "full", not(target_os = "wasi")),
all(target_os = "emscripten", feature = "rt", feature = "sync")
))]
#![cfg(panic = "unwind")]
use std::{error::Error, sync::Arc};
tokio/tests/sync_rwlock.rs
+3 -3
View File
@@ -1,12 +1,12 @@
#![warn(rust_2018_idioms)]
#![cfg(feature = "sync")]
#[cfg(all(target_family = "wasm", not(target_os = "wasi")))]
#[cfg(all(target_family = "wasm", target_os = "unknown"))]
use wasm_bindgen_test::wasm_bindgen_test as test;
#[cfg(all(target_family = "wasm", not(target_os = "wasi")))]
#[cfg(all(target_family = "wasm", target_os = "unknown"))]
use wasm_bindgen_test::wasm_bindgen_test as maybe_tokio_test;
#[cfg(not(all(target_family = "wasm", not(target_os = "wasi"))))]
#[cfg(not(all(target_family = "wasm", target_os = "unknown")))]
use tokio::test as maybe_tokio_test;
use std::task::Poll;
tokio/tests/sync_semaphore.rs
+1 -1
View File
@@ -1,6 +1,6 @@
#![cfg(feature = "sync")]
#[cfg(all(target_family = "wasm", not(target_os = "wasi")))]
#[cfg(all(target_family = "wasm", target_os = "unknown"))]
use wasm_bindgen_test::wasm_bindgen_test as test;
use std::sync::Arc;
tokio/tests/sync_semaphore_owned.rs
+1 -1
View File
@@ -1,6 +1,6 @@
#![cfg(feature = "sync")]
#[cfg(all(target_family = "wasm", not(target_os = "wasi")))]
#[cfg(all(target_family = "wasm", target_os = "unknown"))]
use wasm_bindgen_test::wasm_bindgen_test as test;
use std::sync::Arc;
tokio/tests/sync_set_once.rs
+9 -1
View File
@@ -1,5 +1,13 @@
#![warn(rust_2018_idioms)]
#![cfg(feature = "full")]
#![cfg(any(
feature = "full",
all(
target_os = "emscripten",
feature = "rt",
feature = "sync",
feature = "macros"
)
))]
use std::sync::{
atomic::{AtomicU32, Ordering},
tokio/tests/sync_watch.rs
+1 -1
View File
@@ -2,7 +2,7 @@
#![warn(rust_2018_idioms)]
#![cfg(feature = "sync")]
#[cfg(all(target_family = "wasm", not(target_os = "wasi")))]
#[cfg(all(target_family = "wasm", target_os = "unknown"))]
use wasm_bindgen_test::wasm_bindgen_test as test;
use tokio::sync::watch;
tokio/tests/task_abort.rs
+15 -5
View File
@@ -1,16 +1,22 @@
#![warn(rust_2018_idioms)]
#![cfg(all(feature = "full", not(target_os = "wasi")))] // Wasi doesn't support panic recovery
#![cfg(any(
all(feature = "full", not(target_os = "wasi")), // Wasi doesn't support panic recovery
all(target_os = "emscripten", feature = "rt", feature = "time")
))]
#[cfg(not(target_family = "wasm"))]
use std::sync::Arc;
#[cfg(not(target_family = "wasm"))]
use std::thread::sleep;
#[cfg(not(target_family = "wasm"))]
use tokio::time::Duration;
use tokio::runtime::Builder;
#[cfg(panic = "unwind")]
#[cfg(all(panic = "unwind", not(target_family = "wasm")))]
struct PanicOnDrop;
#[cfg(panic = "unwind")]
#[cfg(all(panic = "unwind", not(target_family = "wasm")))]
impl Drop for PanicOnDrop {
fn drop(&mut self) {
panic!("Well what did you expect would happen...");
@@ -19,6 +25,7 @@ impl Drop for PanicOnDrop {
/// Checks that a suspended task can be aborted without panicking as reported in
/// issue #3157: <https://github.com/tokio-rs/tokio/issues/3157>.
#[cfg(not(target_family = "wasm"))]
#[test]
fn test_abort_without_panic_3157() {
let rt = Builder::new_multi_thread()
@@ -41,6 +48,7 @@ fn test_abort_without_panic_3157() {
/// Checks that a suspended task can be aborted inside of a current_thread
/// executor without panicking as reported in issue #3662:
/// <https://github.com/tokio-rs/tokio/issues/3662>.
#[cfg(not(target_family = "wasm"))]
#[test]
fn test_abort_without_panic_3662() {
use std::sync::atomic::{AtomicBool, Ordering};
@@ -104,6 +112,7 @@ fn test_abort_without_panic_3662() {
/// Checks that a suspended LocalSet task can be aborted from a remote thread
/// without panicking and without running the tasks destructor on the wrong thread.
/// <https://github.com/tokio-rs/tokio/issues/3929>
#[cfg(not(target_family = "wasm"))]
#[test]
fn remote_abort_local_set_3929() {
struct DropCheck {
@@ -147,6 +156,7 @@ fn remote_abort_local_set_3929() {
/// Checks that a suspended task can be aborted even if the `JoinHandle` is immediately dropped.
/// issue #3964: <https://github.com/tokio-rs/tokio/issues/3964>.
#[cfg(not(target_family = "wasm"))]
#[test]
fn test_abort_wakes_task_3964() {
let rt = Builder::new_current_thread().enable_time().build().unwrap();
@@ -177,8 +187,8 @@ fn test_abort_wakes_task_3964() {
/// Checks that aborting a task whose destructor panics does not allow the
/// panic to escape the task.
#[cfg(all(panic = "unwind", not(target_family = "wasm")))]
#[test]
#[cfg(panic = "unwind")]
fn test_abort_task_that_panics_on_drop_contained() {
let rt = Builder::new_current_thread().enable_time().build().unwrap();
@@ -201,8 +211,8 @@ fn test_abort_task_that_panics_on_drop_contained() {
}
/// Checks that aborting a task whose destructor panics has the expected result.
#[cfg(all(panic = "unwind", not(target_family = "wasm")))]
#[test]
#[cfg(panic = "unwind")]
fn test_abort_task_that_panics_on_drop_returned() {
let rt = Builder::new_current_thread().enable_time().build().unwrap();
tokio/tests/task_emscripten.rs
+12
View File
@@ -0,0 +1,12 @@
#![cfg(all(target_os = "emscripten", not(target_feature = "atomics")))]
/// There is no threadpool on a single-threaded JS worker: the public
/// `spawn_blocking` is unsupported on non-pthread emscripten, as on the other
/// single-threaded wasm targets. `tokio::fs` and
/// `tokio::io::{stdin, stdout, stderr}` do not rely on it there — their
/// syscalls complete synchronously.
#[tokio::test]
#[should_panic = "OS can't spawn worker thread"]
async fn spawn_blocking_is_unsupported() {
let _ = tokio::task::spawn_blocking(|| 42).await;
}
tokio/tests/task_id.rs
+20 -8
View File
@@ -1,10 +1,19 @@
#![warn(rust_2018_idioms)]
#![cfg(feature = "full")]
#![cfg(any(
feature = "full",
all(
target_os = "emscripten",
feature = "rt",
feature = "sync",
feature = "macros"
)
))]
use std::error::Error;
use std::future::Future;
use std::pin::Pin;
use std::task::{Context, Poll};
#[cfg(not(target_family = "wasm"))]
use tokio::runtime::Runtime;
use tokio::sync::oneshot;
use tokio::task::{self, Id, LocalSet};
@@ -21,7 +30,7 @@ async fn task_id_spawn() {
.unwrap();
}
#[cfg(not(target_os = "wasi"))]
#[cfg(not(any(target_os = "wasi", target_os = "emscripten")))]
#[tokio::test(flavor = "current_thread")]
async fn task_id_spawn_blocking() {
task::spawn_blocking(|| println!("task id: {}", task::id()))
@@ -38,7 +47,7 @@ async fn task_id_collision_current_thread() {
assert_ne!(id1.unwrap(), id2.unwrap());
}
#[cfg(not(target_os = "wasi"))]
#[cfg(not(target_family = "wasm"))]
#[tokio::test(flavor = "multi_thread")]
async fn task_id_collision_multi_thread() {
let handle1 = tokio::spawn(async { task::id() });
@@ -59,7 +68,7 @@ async fn task_ids_match_current_thread() {
handle.await.unwrap();
}
#[cfg(not(target_os = "wasi"))]
#[cfg(not(target_family = "wasm"))]
#[tokio::test(flavor = "multi_thread")]
async fn task_ids_match_multi_thread() {
let (tx, rx) = oneshot::channel();
@@ -72,7 +81,8 @@ async fn task_ids_match_multi_thread() {
}
#[cfg(not(target_os = "wasi"))]
#[tokio::test(flavor = "multi_thread")]
#[cfg_attr(target_os = "emscripten", tokio::test(flavor = "current_thread"))]
#[cfg_attr(not(target_os = "emscripten"), tokio::test(flavor = "multi_thread"))]
async fn task_id_future_destructor_completion() {
struct MyFuture {
tx: Option<oneshot::Sender<Id>>,
@@ -100,7 +110,8 @@ async fn task_id_future_destructor_completion() {
}
#[cfg(not(target_os = "wasi"))]
#[tokio::test(flavor = "multi_thread")]
#[cfg_attr(target_os = "emscripten", tokio::test(flavor = "current_thread"))]
#[cfg_attr(not(target_os = "emscripten"), tokio::test(flavor = "multi_thread"))]
async fn task_id_future_destructor_abort() {
struct MyFuture {
tx: Option<oneshot::Sender<Id>>,
@@ -205,7 +216,7 @@ fn task_try_id_outside_task() {
assert_eq!(None, task::try_id());
}
#[cfg(not(target_os = "wasi"))]
#[cfg(not(target_family = "wasm"))]
#[test]
fn task_try_id_inside_block_on() {
let rt = Runtime::new().unwrap();
@@ -248,7 +259,7 @@ async fn task_id_nested_spawn_local() {
.await;
}
#[cfg(not(target_os = "wasi"))]
#[cfg(not(target_family = "wasm"))]
#[tokio::test(flavor = "multi_thread")]
async fn task_id_block_in_place_block_on_spawn() {
use tokio::runtime::Builder;
@@ -283,6 +294,7 @@ fn task_id_outside_task_panic_caller() -> Result<(), Box<dyn Error>> {
Ok(())
}
#[cfg(not(target_family = "wasm"))]
#[test]
#[cfg_attr(not(panic = "unwind"), ignore)]
fn task_id_inside_block_on_panic_caller() -> Result<(), Box<dyn Error>> {
tokio/tests/task_join_set.rs
+11 -1
View File
@@ -1,5 +1,14 @@
#![warn(rust_2018_idioms)]
#![cfg(feature = "full")]
#![cfg(any(
feature = "full",
all(
target_os = "emscripten",
feature = "rt",
feature = "sync",
feature = "macros",
feature = "time"
)
))]
use futures::future::{pending, FutureExt};
use std::panic;
@@ -433,6 +442,7 @@ mod spawn_local {
set.spawn_local(async {});
}
#[cfg(not(target_family = "wasm"))]
#[tokio::test(flavor = "multi_thread")]
#[should_panic(
expected = "`spawn_local` called from outside of a `task::LocalSet` or `runtime::LocalRuntime`"
tokio/tests/task_local.rs
+6 -2
View File
@@ -1,11 +1,15 @@
#![cfg(all(feature = "full", not(target_os = "wasi")))] // Wasi doesn't support threads
#![cfg(any(
all(feature = "full", not(target_os = "wasi")), // Wasi doesn't support threads
all(target_os = "emscripten", feature = "rt", feature = "macros")
))]
use std::future::Future;
use std::pin::Pin;
use std::task::{Context, Poll};
use tokio::sync::oneshot;
#[tokio::test(flavor = "multi_thread")]
#[cfg_attr(not(target_family = "wasm"), tokio::test(flavor = "multi_thread"))]
#[cfg_attr(target_family = "wasm", tokio::test)]
async fn local() {
tokio::task_local! {
static REQ_ID: u32;
tokio/tests/task_panic.rs
+8 -2
View File
@@ -1,11 +1,16 @@
#![warn(rust_2018_idioms)]
#![cfg(all(feature = "full", not(target_os = "wasi")))]
#![cfg(any(
all(feature = "full", not(target_os = "wasi")),
all(target_os = "emscripten", feature = "rt", feature = "macros")
))]
#![cfg(panic = "unwind")]
use futures::future;
use std::error::Error;
use tokio::runtime::Builder;
use tokio::task::{self, block_in_place};
use tokio::task;
#[cfg(feature = "rt-multi-thread")]
use tokio::task::block_in_place;
mod support {
pub mod panic;
@@ -13,6 +18,7 @@ mod support {
use support::panic::test_panic;
#[test]
#[cfg(feature = "rt-multi-thread")]
fn block_in_place_panic_caller() -> Result<(), Box<dyn Error>> {
let panic_location_file = test_panic(|| {
let rt = Builder::new_current_thread().enable_all().build().unwrap();
tokio/tests/task_yield_now.rs
+9 -1
View File
@@ -1,4 +1,11 @@
#![cfg(all(feature = "full", not(target_os = "wasi"), tokio_unstable))]
#![cfg(all(
any(
feature = "full",
all(target_os = "emscripten", feature = "rt", feature = "macros")
),
not(target_os = "wasi"),
tokio_unstable
))]
use tokio::task;
use tokio_test::task::spawn;
@@ -15,6 +22,7 @@ fn yield_now_outside_of_runtime() {
assert!(task.poll().is_ready());
}
#[cfg(not(target_family = "wasm"))]
#[tokio::test(flavor = "multi_thread")]
async fn yield_now_external_executor_and_block_in_place() {
let j = tokio::spawn(async {
tokio/tests/test_clock.rs
+9 -1
View File
@@ -1,5 +1,13 @@
#![warn(rust_2018_idioms)]
#![cfg(feature = "full")]
#![cfg(any(
feature = "full",
all(
target_os = "emscripten",
feature = "rt",
feature = "macros",
feature = "test-util"
)
))]
use tokio::time::{self, Duration, Instant};
tokio/tests/time_interval.rs
+9 -1
View File
@@ -1,5 +1,13 @@
#![warn(rust_2018_idioms)]
#![cfg(feature = "full")]
#![cfg(any(
feature = "full",
all(
target_os = "emscripten",
feature = "rt",
feature = "macros",
feature = "test-util"
)
))]
use std::pin::Pin;
use std::task::{Context, Poll};
tokio/tests/time_panic.rs
+20 -14
View File
@@ -1,5 +1,8 @@
#![warn(rust_2018_idioms)]
#![cfg(all(feature = "full", not(target_os = "wasi")))] // Wasi doesn't support panic recovery
#![cfg(any(
all(feature = "full", not(target_os = "wasi")), // Wasi doesn't support panic recovery
all(target_os = "emscripten", feature = "rt", feature = "time")
))]
#![cfg(panic = "unwind")]
use futures::future;
@@ -22,21 +25,24 @@ fn rt_combinations() -> Vec<Runtime> {
.unwrap();
rts.push(rt);
let rt = tokio::runtime::Builder::new_multi_thread()
.worker_threads(1)
.enable_all()
.build()
.unwrap();
rts.push(rt);
#[cfg(not(target_os = "emscripten"))]
{
let rt = tokio::runtime::Builder::new_multi_thread()
.worker_threads(1)
.enable_all()
.build()
.unwrap();
rts.push(rt);
let rt = tokio::runtime::Builder::new_multi_thread()
.worker_threads(4)
.enable_all()
.build()
.unwrap();
rts.push(rt);
let rt = tokio::runtime::Builder::new_multi_thread()
.worker_threads(4)
.enable_all()
.build()
.unwrap();
rts.push(rt);
}
#[cfg(tokio_unstable)]
#[cfg(all(tokio_unstable, not(target_os = "emscripten")))]
{
let rt = tokio::runtime::Builder::new_multi_thread()
.worker_threads(1)
tokio/tests/time_pause.rs
+10 -2
View File
@@ -1,5 +1,13 @@
#![warn(rust_2018_idioms)]
#![cfg(feature = "full")]
#![cfg(any(
feature = "full",
all(
target_os = "emscripten",
feature = "rt",
feature = "macros",
feature = "test-util"
)
))]
#![cfg(not(miri))] // Too slow on miri.
use rand::SeedableRng;
@@ -7,7 +15,7 @@ use rand::{rngs::StdRng, Rng};
use tokio::time::{self, Duration, Instant, Sleep};
use tokio_test::{assert_elapsed, assert_pending, assert_ready, assert_ready_eq, task};
#[cfg(not(target_os = "wasi"))]
#[cfg(all(feature = "full", not(target_os = "wasi")))]
use tokio_test::assert_err;
use std::{
tokio/tests/time_sleep.rs
+9 -1
View File
@@ -1,5 +1,13 @@
#![warn(rust_2018_idioms)]
#![cfg(feature = "full")]
#![cfg(any(
feature = "full",
all(
target_os = "emscripten",
feature = "rt",
feature = "macros",
feature = "test-util"
)
))]
#![cfg(not(miri))] // Too slow on Miri.
use std::future::Future;
tokio/tests/time_timeout.rs
+9 -1
View File
@@ -1,5 +1,13 @@
#![warn(rust_2018_idioms)]
#![cfg(feature = "full")]
#![cfg(any(
feature = "full",
all(
target_os = "emscripten",
feature = "rt",
feature = "macros",
feature = "test-util"
)
))]
use tokio::sync::oneshot;
use tokio::time::{self, timeout, timeout_at, Instant};
tokio/tests/time_wasm.rs
+5 -1
View File
@@ -1,5 +1,9 @@
#![warn(rust_2018_idioms)]
#![cfg(all(target_arch = "wasm32", not(target_os = "wasi")))]
#![cfg(all(
target_arch = "wasm32",
not(target_os = "wasi"),
not(target_os = "emscripten")
))]
use wasm_bindgen_test::wasm_bindgen_test;

Some files were not shown because too many files have changed in this diff Show More