wasmtime 22.0.0 → 23.0.2

data/ext/cargo-vendor/wasi-common-23.0.2/.cargo-checksum.json

@@ -0,0 +1 @@
+{"files":{"Cargo.toml":"e98a46eeefcb9394fb5aa96a877ab16633661bf925b23d81a7e43ea68c688b49","LICENSE":"268872b9816f90fd8e85db5a28d33f8150ebb8dd016653fb39ef1f94f2686bc5","README.md":"033504feca189aceb1127385592096a7b9f44c396df9a5740bac670c80b44f4c","src/clocks.rs":"3d6f01b3129bd4cb60eca5f17137e589365092a03f1bbec812c655d6c023476e","src/ctx.rs":"268de2fdab60ef9299fafe554fdefe573be96a34ab23aac09856ae28929bbfd0","src/dir.rs":"fd8df63ddf4247a3ea5b63200d798a9537ead1dedba4748718085598e9679705","src/error.rs":"81fff5a99f40cc3892e0e6d7f5bbb4420a0d87d5cf75521370b306eee17ac3ce","src/file.rs":"156da21bba7e23f7830af521cbf4a8f5980bd23b732a7b0a5784dea20d5e1079","src/lib.rs":"712932bc7f9f9bcc22fb22c066524f6cc22993b03f5ea65b82b0444d14d22587","src/pipe.rs":"831100b9c595894cab45d802199d9d659d5f8b99cf3ac677b5f72c40c38d20be","src/random.rs":"a7d4bb5649223a868f4d2d3072c0d36cf6f8d3ec25420267505488374dc8a775","src/sched.rs":"d0629edb4f36414671be086038eaefc7984b69d740337772a872e69e1e8ab96c","src/sched/subscription.rs":"5e588932bf8b1068d2f1d89401617ba111d05c85c26d13f35bc3f968161b07cc","src/snapshots/mod.rs":"8a0ebeaed2f7234d4bb92286da3048e8c61e2ae8e6115bff8f5aa7115e8b1d35","src/snapshots/preview_0.rs":"6020b714116181f64986a4791f33e856f480b28907df2c94bfa7b284c63b3b5f","src/snapshots/preview_1.rs":"753911905053499bb9bb5d39d1d94509cb61256bc07c9df5b8e0285a4880608e","src/snapshots/preview_1/error.rs":"8a4222a297b7310494524a517e7a936180e2fbab14fb1601bf7fcfb082509676","src/string_array.rs":"48b846445ab96f96f25d3621e4d99b45967cbb8e9928a7430d33f1bee87fa915","src/sync/clocks.rs":"fb2eede865a3e20b9f16af9b23f64dff4f28197161bcd4c5b388624907eab8d5","src/sync/dir.rs":"4675ac744622487c010c8a82cb692fc62693b232224494e9d93af01f809a9e57","src/sync/file.rs":"796cc6378191b505c977bc27ee2114b631475223f01fb44bc26fd1298b85cebc","src/sync/mod.rs":"d0f468568263a6f1ee961638b7967c0f465a8bd2b29027e91791f2080905cfb2","src/sync/net.rs":"0c3736fd55765e46d29a54ffbad8c31f97b748620832200159b427d23fb03e31","src/sync/sched.rs":"3d57d08385df1b1751c96b0d38e6d07f0f4e938cf03ea3776694afc403124954","src/sync/sched/unix.rs":"1b6a8c68613a8a354e6e3c94238a79477acbad6c4ec68ccb0abdb3c41336aa11","src/sync/sched/windows.rs":"261ae4288d4ec68b12a37330d3b8c945c751378fc1f256c99cf6db065a7c8854","src/sync/stdio.rs":"99a303ec7841e1c1cb84de9a3e8df37298a06984374948dda0186ec41c8d079b","src/table.rs":"0f546fbdf092a425de70c19e5e7632a5d1d266b57e2c856843046669da783294","src/tokio/dir.rs":"3a092fcf005b49a26b7981b61722d8393daee83b17e19db8bdad265fe186cb9b","src/tokio/file.rs":"136115f301a73bbcdfd3effebbc1e32d66990502e36c93c71924b0ca2d4d4987","src/tokio/mod.rs":"8a33a54400fdf6990dc9c64a73b6cedfc1679f2d17e9b728798ef4f17becb539","src/tokio/net.rs":"790626f827f65e91fad2e98dc2b4179eda3daff1786704d56ab2eded1a46f13c","src/tokio/sched.rs":"50a1fe0c52130894e4bfcf908c8a8712bf12b6c2d8befedd728b30f9ce1f8c92","src/tokio/sched/unix.rs":"f26618b267dff768a1429f9262ac992b34bf5fe38ef4de2d6abdea22a9be7141","src/tokio/sched/windows.rs":"2646717b9f20c3a00775ec0dbc709b56b24159c30a7df90061037c4311c9dd73","src/tokio/stdio.rs":"d5ed3529f55d3bf6142d1650a7476489e24297f706f7acd122ac96a7b7fd68df","tests/all/async_.rs":"92c2b4f004d1053077b8d6e0a3345fe13569f165207c24ac2b49ab0d81bde2cb","tests/all/main.rs":"1e1d6e96f940f182f53aa106f3ae0b9cab40e4706ad3cf03a09125dbb715dd3a","tests/all/sync.rs":"734b34b6336a63f5e818be93bfd5ff23fc2f091fca0428a8fb2dd39373879c89","witx/preview0/typenames.witx":"b45680d63d3cd0b4214e37997e43b184f812c897755053c774e7bec54d39c1aa","witx/preview0/wasi_unstable.witx":"8998761927fdf36c77ddc282a689a56154541ea634c22822a7cce013205b3735","witx/preview1/typenames.witx":"65b41b94060e923ef543621080c2bdcb258bc550494a819ade2688eb1fcccfa6","witx/preview1/wasi_snapshot_preview1.witx":"56135b1fdfe9eb4e2fbaabf93178070cd5b0cc5fe451ae74d218ebfc7dda7e88"},"package":"9c19d0b2b2f88ef39e8f5fd0e29e8b00d129e0824cc8c06d2caf9866a6a72b6b"}

data/ext/cargo-vendor/wasi-common-23.0.2/Cargo.toml

@@ -0,0 +1,234 @@
+# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO
+#
+# When uploading crates to the registry Cargo will automatically
+# "normalize" Cargo.toml files for maximal compatibility
+# with all versions of Cargo and also rewrite `path` dependencies
+# to registry (e.g., crates.io) dependencies.
+#
+# If you are reading this file be aware that the original Cargo.toml
+# will likely look very different (and much more reasonable).
+# See Cargo.toml.orig for the original contents.
+
+[package]
+edition = "2021"
+name = "wasi-common"
+version = "23.0.2"
+authors = ["The Wasmtime Project Developers"]
+build = false
+include = [
+    "src/**/*",
+    "tests/**/*",
+    "witx",
+    "README.md",
+    "LICENSE",
+    "build.rs",
+]
+autobins = false
+autoexamples = false
+autotests = false
+autobenches = false
+description = "WASI implementation in Rust"
+readme = "README.md"
+keywords = [
+    "webassembly",
+    "wasm",
+]
+categories = ["wasm"]
+license = "Apache-2.0 WITH LLVM-exception"
+repository = "https://github.com/bytecodealliance/wasmtime"
+
+[package.metadata.docs.rs]
+all-features = true
+
+[lib]
+name = "wasi_common"
+path = "src/lib.rs"
+
+[[test]]
+name = "all"
+path = "tests/all/main.rs"
+
+[dependencies.anyhow]
+version = "1.0.22"
+features = ["std"]
+default-features = false
+
+[dependencies.bitflags]
+version = "2.0"
+
+[dependencies.cap-fs-ext]
+version = "3.0.0"
+optional = true
+
+[dependencies.cap-rand]
+version = "3.0.0"
+features = ["small_rng"]
+
+[dependencies.cap-std]
+version = "3.0.0"
+
+[dependencies.cap-time-ext]
+version = "3.0.0"
+optional = true
+
+[dependencies.fs-set-times]
+version = "0.20.1"
+optional = true
+
+[dependencies.io-lifetimes]
+version = "2.0.3"
+optional = true
+default-features = false
+
+[dependencies.libc]
+version = "0.2.112"
+optional = true
+default-features = true
+
+[dependencies.log]
+version = "0.4.8"
+default-features = false
+
+[dependencies.system-interface]
+version = "0.27.1"
+features = [
+    "cap_std_impls",
+    "cap_std_impls",
+]
+optional = true
+
+[dependencies.thiserror]
+version = "1.0.43"
+
+[dependencies.tokio]
+version = "1.26.0"
+features = [
+    "rt",
+    "time",
+    "rt",
+    "fs",
+    "time",
+    "io-util",
+    "net",
+    "io-std",
+    "rt-multi-thread",
+]
+optional = true
+
+[dependencies.tracing]
+version = "0.1.26"
+
+[dependencies.wasmtime]
+version = "23.0.2"
+features = ["runtime"]
+optional = true
+default-features = false
+
+[dependencies.wiggle]
+version = "=23.0.2"
+default-features = false
+
+[dev-dependencies.tempfile]
+version = "3.1.0"
+
+[dev-dependencies.test-log]
+version = "0.2"
+features = ["trace"]
+default-features = false
+
+[dev-dependencies.tokio]
+version = "1.26.0"
+features = [
+    "rt",
+    "time",
+    "macros",
+    "rt-multi-thread",
+]
+
+[dev-dependencies.tracing-subscriber]
+version = "0.3.1"
+features = [
+    "fmt",
+    "env-filter",
+    "ansi",
+    "tracing-log",
+]
+default-features = false
+
+[dev-dependencies.wasmtime]
+version = "23.0.2"
+features = [
+    "cranelift",
+    "async",
+    "runtime",
+]
+default-features = false
+
+[features]
+default = [
+    "trace_log",
+    "wasmtime",
+    "sync",
+]
+exit = [
+    "wasmtime",
+    "dep:libc",
+]
+sync = [
+    "wasmtime",
+    "dep:cap-fs-ext",
+    "dep:cap-time-ext",
+    "dep:fs-set-times",
+    "dep:system-interface",
+    "dep:io-lifetimes",
+]
+tokio = [
+    "sync",
+    "wasmtime/async",
+    "wiggle/wasmtime_async",
+    "dep:tokio",
+]
+trace_log = [
+    "wiggle/tracing_log",
+    "tracing/log",
+]
+wasmtime = [
+    "dep:wasmtime",
+    "wiggle/wasmtime",
+]
+wiggle_metadata = ["wiggle/wiggle_metadata"]
+
+[target."cfg(unix)".dependencies.rustix]
+version = "0.38.31"
+features = [
+    "fs",
+    "event",
+]
+
+[target."cfg(windows)".dependencies.io-extras]
+version = "0.18.1"
+
+[target."cfg(windows)".dependencies.once_cell]
+version = "1.12.0"
+default-features = false
+
+[target."cfg(windows)".dependencies.rustix]
+version = "0.38.31"
+features = ["net"]
+
+[target."cfg(windows)".dependencies.windows-sys]
+version = "0.52.0"
+features = [
+    "Win32_Foundation",
+    "Win32_Networking_WinSock",
+]
+
+[lints.clippy]
+all = "allow"
+
+[lints.rust]
+trivial_numeric_casts = "warn"
+unstable_features = "warn"
+unused-lifetimes = "warn"
+unused_extern_crates = "warn"
+unused_import_braces = "warn"

data/ext/cargo-vendor/wasi-common-23.0.2/src/tokio/mod.rs

@@ -0,0 +1,135 @@
+mod dir;
+mod file;
+pub mod net;
+pub mod sched;
+pub mod stdio;
+
+use self::sched::sched_ctx;
+use crate::sync::net::Socket;
+pub use crate::sync::{clocks_ctx, random_ctx};
+use crate::{file::FileAccessMode, Error, Table, WasiCtx, WasiFile};
+pub use dir::Dir;
+pub use file::File;
+pub use net::*;
+use std::future::Future;
+use std::mem;
+use std::path::Path;
+
+pub struct WasiCtxBuilder {
+    ctx: WasiCtx,
+    built: bool,
+}
+
+impl WasiCtxBuilder {
+    pub fn new() -> Self {
+        WasiCtxBuilder {
+            ctx: WasiCtx::new(random_ctx(), clocks_ctx(), sched_ctx(), Table::new()),
+            built: false,
+        }
+    }
+    pub fn env(&mut self, var: &str, value: &str) -> Result<&mut Self, crate::StringArrayError> {
+        self.ctx.push_env(var, value)?;
+        Ok(self)
+    }
+    pub fn envs(&mut self, env: &[(String, String)]) -> Result<&mut Self, crate::StringArrayError> {
+        for (k, v) in env {
+            self.ctx.push_env(k, v)?;
+        }
+        Ok(self)
+    }
+    pub fn inherit_env(&mut self) -> Result<&mut Self, crate::StringArrayError> {
+        for (key, value) in std::env::vars() {
+            self.ctx.push_env(&key, &value)?;
+        }
+        Ok(self)
+    }
+    pub fn arg(&mut self, arg: &str) -> Result<&mut Self, crate::StringArrayError> {
+        self.ctx.push_arg(arg)?;
+        Ok(self)
+    }
+    pub fn args(&mut self, arg: &[String]) -> Result<&mut Self, crate::StringArrayError> {
+        for a in arg {
+            self.ctx.push_arg(&a)?;
+        }
+        Ok(self)
+    }
+    pub fn inherit_args(&mut self) -> Result<&mut Self, crate::StringArrayError> {
+        for arg in std::env::args() {
+            self.ctx.push_arg(&arg)?;
+        }
+        Ok(self)
+    }
+    pub fn stdin(&mut self, f: Box<dyn WasiFile>) -> &mut Self {
+        self.ctx.set_stdin(f);
+        self
+    }
+    pub fn stdout(&mut self, f: Box<dyn WasiFile>) -> &mut Self {
+        self.ctx.set_stdout(f);
+        self
+    }
+    pub fn stderr(&mut self, f: Box<dyn WasiFile>) -> &mut Self {
+        self.ctx.set_stderr(f);
+        self
+    }
+    pub fn inherit_stdin(&mut self) -> &mut Self {
+        self.stdin(Box::new(crate::tokio::stdio::stdin()))
+    }
+    pub fn inherit_stdout(&mut self) -> &mut Self {
+        self.stdout(Box::new(crate::tokio::stdio::stdout()))
+    }
+    pub fn inherit_stderr(&mut self) -> &mut Self {
+        self.stderr(Box::new(crate::tokio::stdio::stderr()))
+    }
+    pub fn inherit_stdio(&mut self) -> &mut Self {
+        self.inherit_stdin().inherit_stdout().inherit_stderr()
+    }
+    pub fn preopened_dir(
+        &mut self,
+        dir: cap_std::fs::Dir,
+        guest_path: impl AsRef<Path>,
+    ) -> Result<&mut Self, Error> {
+        let dir = Box::new(crate::tokio::dir::Dir::from_cap_std(dir));
+        self.ctx.push_preopened_dir(dir, guest_path)?;
+        Ok(self)
+    }
+    pub fn preopened_socket(
+        &mut self,
+        fd: u32,
+        socket: impl Into<Socket>,
+    ) -> Result<&mut Self, Error> {
+        let socket: Socket = socket.into();
+        let file: Box<dyn WasiFile> = socket.into();
+        self.ctx
+            .insert_file(fd, file, FileAccessMode::READ | FileAccessMode::WRITE);
+        Ok(self)
+    }
+
+    pub fn build(&mut self) -> WasiCtx {
+        assert!(!self.built);
+        let WasiCtxBuilder { ctx, .. } = mem::replace(self, Self::new());
+        self.built = true;
+        ctx
+    }
+}
+
+// Much of this mod is implemented in terms of `async` methods from the
+// wasmtime_wasi::sync module. These methods may be async in signature, however,
+// they are synchronous in implementation (always Poll::Ready on first poll)
+// and perform blocking syscalls.
+//
+// This function takes this blocking code and executes it using a dummy executor
+// to assert its immediate readiness. We tell tokio this is a blocking operation
+// with the block_in_place function.
+pub(crate) fn block_on_dummy_executor<'a, F, Fut, T>(f: F) -> Result<T, Error>
+where
+    F: FnOnce() -> Fut + Send + 'a,
+    Fut: Future<Output = Result<T, Error>>,
+    T: Send + 'static,
+{
+    tokio::task::block_in_place(move || {
+        wiggle::run_in_dummy_executor(f()).expect("wrapped operation should be synchronous")
+    })
+}
+
+#[cfg(feature = "wasmtime")]
+super::define_wasi!(async T: Send);

data/ext/cargo-vendor/wasi-common-23.0.2/tests/all/async_.rs

@@ -0,0 +1,295 @@
+use super::*;
+use test_programs_artifacts::*;
+use wasi_common::tokio::{add_to_linker, WasiCtxBuilder};
+
+foreach_preview1!(assert_test_exists);
+
+pub fn prepare_workspace(exe_name: &str) -> Result<TempDir> {
+    let prefix = format!("wasi_tokio_{}_", exe_name);
+    let tempdir = tempfile::Builder::new().prefix(&prefix).tempdir()?;
+    Ok(tempdir)
+}
+
+async fn run(path: &str, inherit_stdio: bool) -> Result<()> {
+    let path = Path::new(path);
+    let name = path.file_stem().unwrap().to_str().unwrap();
+    let workspace = prepare_workspace(name)?;
+    let stdout = WritePipe::new_in_memory();
+    let stderr = WritePipe::new_in_memory();
+    let r = {
+        let engine = test_programs_artifacts::engine(|config| {
+            config.async_support(true);
+        });
+        let mut linker = Linker::new(&engine);
+        add_to_linker(&mut linker, |cx| cx)?;
+
+        // Create our wasi context.
+        // Additionally register any preopened directories if we have them.
+        let mut builder = WasiCtxBuilder::new();
+
+        if inherit_stdio {
+            builder.inherit_stdio();
+        } else {
+            builder
+                .stdout(Box::new(stdout.clone()))
+                .stderr(Box::new(stderr.clone()));
+        }
+        builder.arg(name)?.arg(".")?;
+        println!("preopen: {:?}", workspace);
+        let preopen_dir =
+            cap_std::fs::Dir::open_ambient_dir(workspace.path(), cap_std::ambient_authority())?;
+        builder.preopened_dir(preopen_dir, ".")?;
+        for (var, val) in test_programs_artifacts::wasi_tests_environment() {
+            builder.env(var, val)?;
+        }
+
+        let mut store = Store::new(&engine, builder.build());
+        let module = Module::from_file(&engine, path)?;
+        let instance = linker.instantiate_async(&mut store, &module).await?;
+        let start = instance.get_typed_func::<(), ()>(&mut store, "_start")?;
+        start.call_async(&mut store, ()).await?;
+        Ok(())
+    };
+
+    r.map_err(move |trap: anyhow::Error| {
+        let stdout = stdout
+            .try_into_inner()
+            .expect("sole ref to stdout")
+            .into_inner();
+        if !stdout.is_empty() {
+            println!("guest stdout:\n{}\n===", String::from_utf8_lossy(&stdout));
+        }
+        let stderr = stderr
+            .try_into_inner()
+            .expect("sole ref to stderr")
+            .into_inner();
+        if !stderr.is_empty() {
+            println!("guest stderr:\n{}\n===", String::from_utf8_lossy(&stderr));
+        }
+        trap.context(format!(
+            "error while testing wasi-tests {} with cap-std-sync",
+            name
+        ))
+    })?;
+    Ok(())
+}
+
+// Below here is mechanical: there should be one test for every binary in
+// wasi-tests.
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_big_random_buf() {
+    run(PREVIEW1_BIG_RANDOM_BUF, true).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_clock_time_get() {
+    run(PREVIEW1_CLOCK_TIME_GET, true).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_close_preopen() {
+    run(PREVIEW1_CLOSE_PREOPEN, true).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_dangling_fd() {
+    run(PREVIEW1_DANGLING_FD, true).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_dangling_symlink() {
+    run(PREVIEW1_DANGLING_SYMLINK, true).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_directory_seek() {
+    run(PREVIEW1_DIRECTORY_SEEK, true).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_dir_fd_op_failures() {
+    run(PREVIEW1_DIR_FD_OP_FAILURES, true).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_fd_advise() {
+    run(PREVIEW1_FD_ADVISE, true).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_fd_filestat_get() {
+    run(PREVIEW1_FD_FILESTAT_GET, true).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_fd_filestat_set() {
+    run(PREVIEW1_FD_FILESTAT_SET, true).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_fd_flags_set() {
+    run(PREVIEW1_FD_FLAGS_SET, true).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_fd_readdir() {
+    run(PREVIEW1_FD_READDIR, true).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_file_allocate() {
+    run(PREVIEW1_FILE_ALLOCATE, true).await.unwrap()
+}
+// see sync.rs for notes about ignores here
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+#[cfg_attr(not(target_os = "linux"), ignore)]
+async fn preview1_file_pread_pwrite() {
+    run(PREVIEW1_FILE_PREAD_PWRITE, true).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_file_read_write() {
+    run(PREVIEW1_FILE_READ_WRITE, true).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_file_seek_tell() {
+    run(PREVIEW1_FILE_SEEK_TELL, true).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_file_truncation() {
+    run(PREVIEW1_FILE_TRUNCATION, true).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_file_unbuffered_write() {
+    run(PREVIEW1_FILE_UNBUFFERED_WRITE, true).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_interesting_paths() {
+    run(PREVIEW1_INTERESTING_PATHS, true).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_regular_file_isatty() {
+    run(PREVIEW1_REGULAR_FILE_ISATTY, false).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_nofollow_errors() {
+    run(PREVIEW1_NOFOLLOW_ERRORS, true).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_overwrite_preopen() {
+    run(PREVIEW1_OVERWRITE_PREOPEN, true).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_path_exists() {
+    run(PREVIEW1_PATH_EXISTS, true).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_path_filestat() {
+    run(PREVIEW1_PATH_FILESTAT, true).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_path_link() {
+    run(PREVIEW1_PATH_LINK, true).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_path_open_create_existing() {
+    run(PREVIEW1_PATH_OPEN_CREATE_EXISTING, true).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_path_open_read_write() {
+    run(PREVIEW1_PATH_OPEN_READ_WRITE, true).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_path_open_dirfd_not_dir() {
+    run(PREVIEW1_PATH_OPEN_DIRFD_NOT_DIR, true).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_path_open_missing() {
+    run(PREVIEW1_PATH_OPEN_MISSING, true).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_path_open_nonblock() {
+    run(PREVIEW1_PATH_OPEN_NONBLOCK, true).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_path_rename_dir_trailing_slashes() {
+    run(PREVIEW1_PATH_RENAME_DIR_TRAILING_SLASHES, true)
+        .await
+        .unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_path_rename() {
+    run(PREVIEW1_PATH_RENAME, true).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_path_symlink_trailing_slashes() {
+    run(PREVIEW1_PATH_SYMLINK_TRAILING_SLASHES, true)
+        .await
+        .unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_poll_oneoff_files() {
+    run(PREVIEW1_POLL_ONEOFF_FILES, false).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_poll_oneoff_stdio() {
+    run(PREVIEW1_POLL_ONEOFF_STDIO, true).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_readlink() {
+    run(PREVIEW1_READLINK, true).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_remove_directory() {
+    run(PREVIEW1_REMOVE_DIRECTORY, true).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_remove_nonempty_directory() {
+    run(PREVIEW1_REMOVE_NONEMPTY_DIRECTORY, true).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_renumber() {
+    run(PREVIEW1_RENUMBER, true).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_sched_yield() {
+    run(PREVIEW1_SCHED_YIELD, true).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_stdio() {
+    run(PREVIEW1_STDIO, true).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_stdio_isatty() {
+    // Only a valid test if the host executable's stdio is a terminal:
+    if test_programs_artifacts::stdio_is_terminal() {
+        // Inherit stdio, test asserts it is a tty:
+        run(PREVIEW1_STDIO_ISATTY, true).await.unwrap()
+    }
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_stdio_not_isatty() {
+    // Don't inherit stdio, test asserts each is not tty:
+    run(PREVIEW1_STDIO_NOT_ISATTY, false).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_symlink_create() {
+    run(PREVIEW1_SYMLINK_CREATE, true).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_symlink_filestat() {
+    run(PREVIEW1_SYMLINK_FILESTAT, true).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_symlink_loop() {
+    run(PREVIEW1_SYMLINK_LOOP, true).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_unlink_file_trailing_slashes() {
+    run(PREVIEW1_UNLINK_FILE_TRAILING_SLASHES, true)
+        .await
+        .unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_path_open_preopen() {
+    run(PREVIEW1_PATH_OPEN_PREOPEN, true).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_unicode_output() {
+    run(PREVIEW1_UNICODE_OUTPUT, true).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_file_write() {
+    run(PREVIEW1_FILE_WRITE, true).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_path_open_lots() {
+    run(PREVIEW1_PATH_OPEN_LOTS, true).await.unwrap()
+}