wasmtime 16.0.0 → 17.0.0

data/ext/cargo-vendor/wasmtime-wasi-17.0.0/tests/all/api.rs

@@ -0,0 +1,217 @@
+use anyhow::Result;
+use cap_std::ambient_authority;
+use cap_std::fs::Dir;
+use std::io::Write;
+use std::sync::Mutex;
+use std::time::Duration;
+use wasmtime::component::{Component, Linker, ResourceTable};
+use wasmtime::{Config, Engine, Store};
+use wasmtime_wasi::preview2::bindings::wasi::clocks::wall_clock;
+use wasmtime_wasi::preview2::bindings::wasi::filesystem::types as filesystem;
+use wasmtime_wasi::preview2::command::{add_to_linker, Command};
+use wasmtime_wasi::preview2::{
+    self, DirPerms, FilePerms, HostMonotonicClock, HostWallClock, WasiCtx, WasiCtxBuilder, WasiView,
+};
+
+struct CommandCtx {
+    table: ResourceTable,
+    wasi: WasiCtx,
+}
+
+impl WasiView for CommandCtx {
+    fn table(&self) -> &ResourceTable {
+        &self.table
+    }
+    fn table_mut(&mut self) -> &mut ResourceTable {
+        &mut self.table
+    }
+    fn ctx(&self) -> &WasiCtx {
+        &self.wasi
+    }
+    fn ctx_mut(&mut self) -> &mut WasiCtx {
+        &mut self.wasi
+    }
+}
+
+use test_programs_artifacts::*;
+
+foreach_api!(assert_test_exists);
+
+async fn instantiate(path: &str, ctx: CommandCtx) -> Result<(Store<CommandCtx>, Command)> {
+    let mut config = Config::new();
+    config.async_support(true).wasm_component_model(true);
+    let engine = Engine::new(&config)?;
+    let mut linker = Linker::new(&engine);
+    add_to_linker(&mut linker)?;
+
+    let mut store = Store::new(&engine, ctx);
+    let component = Component::from_file(&engine, path)?;
+    let (command, _instance) = Command::instantiate_async(&mut store, &component, &linker).await?;
+    Ok((store, command))
+}
+
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn api_time() -> Result<()> {
+    struct FakeWallClock;
+
+    impl HostWallClock for FakeWallClock {
+        fn resolution(&self) -> Duration {
+            Duration::from_secs(1)
+        }
+
+        fn now(&self) -> Duration {
+            Duration::new(1431648000, 100)
+        }
+    }
+
+    struct FakeMonotonicClock {
+        now: Mutex<u64>,
+    }
+
+    impl HostMonotonicClock for FakeMonotonicClock {
+        fn resolution(&self) -> u64 {
+            1_000_000_000
+        }
+
+        fn now(&self) -> u64 {
+            let mut now = self.now.lock().unwrap();
+            let then = *now;
+            *now += 42 * 1_000_000_000;
+            then
+        }
+    }
+
+    let table = ResourceTable::new();
+    let wasi = WasiCtxBuilder::new()
+        .monotonic_clock(FakeMonotonicClock { now: Mutex::new(0) })
+        .wall_clock(FakeWallClock)
+        .build();
+
+    let (mut store, command) = instantiate(API_TIME_COMPONENT, CommandCtx { table, wasi }).await?;
+
+    command
+        .wasi_cli_run()
+        .call_run(&mut store)
+        .await?
+        .map_err(|()| anyhow::anyhow!("command returned with failing exit status"))
+}
+
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn api_read_only() -> Result<()> {
+    let dir = tempfile::tempdir()?;
+
+    std::fs::File::create(dir.path().join("bar.txt"))?.write_all(b"And stood awhile in thought")?;
+    std::fs::create_dir(dir.path().join("sub"))?;
+
+    let table = ResourceTable::new();
+    let open_dir = Dir::open_ambient_dir(dir.path(), ambient_authority())?;
+    let wasi = WasiCtxBuilder::new()
+        .preopened_dir(open_dir, DirPerms::READ, FilePerms::READ, "/")
+        .build();
+
+    let (mut store, command) =
+        instantiate(API_READ_ONLY_COMPONENT, CommandCtx { table, wasi }).await?;
+
+    command
+        .wasi_cli_run()
+        .call_run(&mut store)
+        .await?
+        .map_err(|()| anyhow::anyhow!("command returned with failing exit status"))
+}
+
+// This is tested in the wasi-http crate, but need to satisfy the `foreach_api!`
+// macro above.
+#[allow(dead_code)]
+fn api_proxy() {}
+
+// This is tested in the wasi-http crate, but need to satisfy the `foreach_api!`
+// macro above.
+#[allow(dead_code)]
+fn api_proxy_streaming() {}
+
+wasmtime::component::bindgen!({
+    world: "test-reactor",
+    async: true,
+    with: {
+       "wasi:io/streams": preview2::bindings::io::streams,
+       "wasi:filesystem/types": preview2::bindings::filesystem::types,
+       "wasi:filesystem/preopens": preview2::bindings::filesystem::preopens,
+       "wasi:cli/environment": preview2::bindings::cli::environment,
+       "wasi:cli/exit": preview2::bindings::cli::exit,
+       "wasi:cli/stdin": preview2::bindings::cli::stdin,
+       "wasi:cli/stdout": preview2::bindings::cli::stdout,
+       "wasi:cli/stderr": preview2::bindings::cli::stderr,
+       "wasi:cli/terminal_input": preview2::bindings::cli::terminal_input,
+       "wasi:cli/terminal_output": preview2::bindings::cli::terminal_output,
+       "wasi:cli/terminal_stdin": preview2::bindings::cli::terminal_stdin,
+       "wasi:cli/terminal_stdout": preview2::bindings::cli::terminal_stdout,
+       "wasi:cli/terminal_stderr": preview2::bindings::cli::terminal_stderr,
+    },
+    ownership: Borrowing {
+        duplicate_if_necessary: false
+    }
+});
+
+#[test_log::test(tokio::test)]
+async fn api_reactor() -> Result<()> {
+    let table = ResourceTable::new();
+    let wasi = WasiCtxBuilder::new().env("GOOD_DOG", "gussie").build();
+
+    let mut config = Config::new();
+    config.async_support(true).wasm_component_model(true);
+    let engine = Engine::new(&config)?;
+    let mut linker = Linker::new(&engine);
+    add_to_linker(&mut linker)?;
+
+    let mut store = Store::new(&engine, CommandCtx { table, wasi });
+    let component = Component::from_file(&engine, API_REACTOR_COMPONENT)?;
+    let (reactor, _instance) =
+        TestReactor::instantiate_async(&mut store, &component, &linker).await?;
+
+    // Show that integration with the WASI context is working - the guest will
+    // interpolate $GOOD_DOG to gussie here using the environment:
+    let r = reactor
+        .call_add_strings(&mut store, &["hello", "$GOOD_DOG"])
+        .await?;
+    assert_eq!(r, 2);
+
+    let contents = reactor.call_get_strings(&mut store).await?;
+    assert_eq!(contents, &["hello", "gussie"]);
+
+    // Show that we can pass in a resource type whose impls are defined in the
+    // `host` and `wasi-common` crate.
+    // Note, this works because of the add_to_linker invocations using the
+    // `host` crate for `streams`, not because of `with` in the bindgen macro.
+    let writepipe = preview2::pipe::MemoryOutputPipe::new(4096);
+    let stream: preview2::OutputStream = Box::new(writepipe.clone());
+    let table_ix = store.data_mut().table_mut().push(stream)?;
+    let r = reactor.call_write_strings_to(&mut store, table_ix).await?;
+    assert_eq!(r, Ok(()));
+
+    assert_eq!(writepipe.contents().as_ref(), b"hellogussie");
+
+    // Show that the `with` invocation in the macro means we get to re-use the
+    // type definitions from inside the `host` crate for these structures:
+    let ds = filesystem::DescriptorStat {
+        data_access_timestamp: Some(wall_clock::Datetime {
+            nanoseconds: 123,
+            seconds: 45,
+        }),
+        data_modification_timestamp: Some(wall_clock::Datetime {
+            nanoseconds: 789,
+            seconds: 10,
+        }),
+        link_count: 0,
+        size: 0,
+        status_change_timestamp: Some(wall_clock::Datetime {
+            nanoseconds: 0,
+            seconds: 1,
+        }),
+        type_: filesystem::DescriptorType::Unknown,
+    };
+    let expected = format!("{ds:?}");
+    let got = reactor.call_pass_an_imported_record(&mut store, ds).await?;
+    assert_eq!(expected, got);
+
+    Ok(())
+}

data/ext/cargo-vendor/wasmtime-wasi-17.0.0/tests/all/async_.rs

@@ -0,0 +1,364 @@
+use super::*;
+use std::path::Path;
+use test_programs_artifacts::*;
+use wasmtime_wasi::preview2::command::{add_to_linker, Command};
+
+async fn run(path: &str, inherit_stdio: bool) -> Result<()> {
+    let path = Path::new(path);
+    let name = path.file_stem().unwrap().to_str().unwrap();
+    let mut config = Config::new();
+    config.async_support(true).wasm_component_model(true);
+    let engine = Engine::new(&config)?;
+    let mut linker = Linker::new(&engine);
+    add_to_linker(&mut linker)?;
+
+    let (mut store, _td) = store(&engine, name, inherit_stdio)?;
+    let component = Component::from_file(&engine, path)?;
+    let (command, _instance) = Command::instantiate_async(&mut store, &component, &linker).await?;
+    command
+        .wasi_cli_run()
+        .call_run(&mut store)
+        .await?
+        .map_err(|()| anyhow::anyhow!("run returned a failure"))
+}
+
+foreach_preview1!(assert_test_exists);
+foreach_preview2!(assert_test_exists);
+
+// 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_COMPONENT, false).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_clock_time_get() {
+    run(PREVIEW1_CLOCK_TIME_GET_COMPONENT, false).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_close_preopen() {
+    run(PREVIEW1_CLOSE_PREOPEN_COMPONENT, false).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_dangling_fd() {
+    run(PREVIEW1_DANGLING_FD_COMPONENT, false).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_dangling_symlink() {
+    run(PREVIEW1_DANGLING_SYMLINK_COMPONENT, false)
+        .await
+        .unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_directory_seek() {
+    run(PREVIEW1_DIRECTORY_SEEK_COMPONENT, false).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_dir_fd_op_failures() {
+    run(PREVIEW1_DIR_FD_OP_FAILURES_COMPONENT, false)
+        .await
+        .unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_fd_advise() {
+    run(PREVIEW1_FD_ADVISE_COMPONENT, false).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_fd_filestat_get() {
+    run(PREVIEW1_FD_FILESTAT_GET_COMPONENT, false)
+        .await
+        .unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_fd_filestat_set() {
+    run(PREVIEW1_FD_FILESTAT_SET_COMPONENT, false)
+        .await
+        .unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_fd_flags_set() {
+    run(PREVIEW1_FD_FLAGS_SET_COMPONENT, false).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_fd_readdir() {
+    run(PREVIEW1_FD_READDIR_COMPONENT, false).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_file_allocate() {
+    run(PREVIEW1_FILE_ALLOCATE_COMPONENT, false).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_file_pread_pwrite() {
+    run(PREVIEW1_FILE_PREAD_PWRITE_COMPONENT, false)
+        .await
+        .unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_file_seek_tell() {
+    run(PREVIEW1_FILE_SEEK_TELL_COMPONENT, false).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_file_truncation() {
+    run(PREVIEW1_FILE_TRUNCATION_COMPONENT, false)
+        .await
+        .unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_file_unbuffered_write() {
+    run(PREVIEW1_FILE_UNBUFFERED_WRITE_COMPONENT, false)
+        .await
+        .unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_interesting_paths() {
+    run(PREVIEW1_INTERESTING_PATHS_COMPONENT, true)
+        .await
+        .unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_regular_file_isatty() {
+    run(PREVIEW1_REGULAR_FILE_ISATTY_COMPONENT, false)
+        .await
+        .unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_nofollow_errors() {
+    run(PREVIEW1_NOFOLLOW_ERRORS_COMPONENT, false)
+        .await
+        .unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_overwrite_preopen() {
+    run(PREVIEW1_OVERWRITE_PREOPEN_COMPONENT, false)
+        .await
+        .unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_path_exists() {
+    run(PREVIEW1_PATH_EXISTS_COMPONENT, false).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_path_filestat() {
+    run(PREVIEW1_PATH_FILESTAT_COMPONENT, false).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_path_link() {
+    run(PREVIEW1_PATH_LINK_COMPONENT, false).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_path_open_create_existing() {
+    run(PREVIEW1_PATH_OPEN_CREATE_EXISTING_COMPONENT, false)
+        .await
+        .unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_path_open_read_write() {
+    run(PREVIEW1_PATH_OPEN_READ_WRITE_COMPONENT, false)
+        .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_COMPONENT, false)
+        .await
+        .unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_path_open_missing() {
+    run(PREVIEW1_PATH_OPEN_MISSING_COMPONENT, false)
+        .await
+        .unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_path_open_nonblock() {
+    run(PREVIEW1_PATH_OPEN_NONBLOCK_COMPONENT, false)
+        .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_COMPONENT, false)
+        .await
+        .unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_path_rename() {
+    run(PREVIEW1_PATH_RENAME_COMPONENT, false).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_path_symlink_trailing_slashes() {
+    run(PREVIEW1_PATH_SYMLINK_TRAILING_SLASHES_COMPONENT, false)
+        .await
+        .unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_poll_oneoff_files() {
+    run(PREVIEW1_POLL_ONEOFF_FILES_COMPONENT, false)
+        .await
+        .unwrap()
+}
+
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_poll_oneoff_stdio() {
+    run(PREVIEW1_POLL_ONEOFF_STDIO_COMPONENT, true)
+        .await
+        .unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_readlink() {
+    run(PREVIEW1_READLINK_COMPONENT, false).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_remove_directory() {
+    run(PREVIEW1_REMOVE_DIRECTORY_COMPONENT, false)
+        .await
+        .unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_remove_nonempty_directory() {
+    run(PREVIEW1_REMOVE_NONEMPTY_DIRECTORY_COMPONENT, false)
+        .await
+        .unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_renumber() {
+    run(PREVIEW1_RENUMBER_COMPONENT, false).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_sched_yield() {
+    run(PREVIEW1_SCHED_YIELD_COMPONENT, false).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_stdio() {
+    run(PREVIEW1_STDIO_COMPONENT, false).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_stdio_isatty() {
+    // If the test process is setup such that stdio is a terminal:
+    if test_programs_artifacts::stdio_is_terminal() {
+        // Inherit stdio, test asserts each is not tty:
+        run(PREVIEW1_STDIO_ISATTY_COMPONENT, 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_COMPONENT, false)
+        .await
+        .unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_symlink_create() {
+    run(PREVIEW1_SYMLINK_CREATE_COMPONENT, false).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_symlink_filestat() {
+    run(PREVIEW1_SYMLINK_FILESTAT_COMPONENT, false)
+        .await
+        .unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_symlink_loop() {
+    run(PREVIEW1_SYMLINK_LOOP_COMPONENT, false).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_unlink_file_trailing_slashes() {
+    run(PREVIEW1_UNLINK_FILE_TRAILING_SLASHES_COMPONENT, false)
+        .await
+        .unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_path_open_preopen() {
+    run(PREVIEW1_PATH_OPEN_PREOPEN_COMPONENT, false)
+        .await
+        .unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_unicode_output() {
+    run(PREVIEW1_UNICODE_OUTPUT_COMPONENT, true).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_file_write() {
+    run(PREVIEW1_FILE_WRITE_COMPONENT, false).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_path_open_lots() {
+    run(PREVIEW1_PATH_OPEN_LOTS_COMPONENT, false).await.unwrap()
+}
+
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview2_sleep() {
+    run(PREVIEW2_SLEEP_COMPONENT, false).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview2_random() {
+    run(PREVIEW2_RANDOM_COMPONENT, false).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview2_ip_name_lookup() {
+    run(PREVIEW2_IP_NAME_LOOKUP_COMPONENT, false).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview2_tcp_sockopts() {
+    run(PREVIEW2_TCP_SOCKOPTS_COMPONENT, false).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview2_tcp_sample_application() {
+    run(PREVIEW2_TCP_SAMPLE_APPLICATION_COMPONENT, false)
+        .await
+        .unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview2_tcp_states() {
+    run(PREVIEW2_TCP_STATES_COMPONENT, false).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview2_tcp_bind() {
+    run(PREVIEW2_TCP_BIND_COMPONENT, false).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview2_tcp_connect() {
+    run(PREVIEW2_TCP_CONNECT_COMPONENT, false).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview2_udp_sockopts() {
+    run(PREVIEW2_UDP_SOCKOPTS_COMPONENT, false).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview2_udp_sample_application() {
+    run(PREVIEW2_UDP_SAMPLE_APPLICATION_COMPONENT, false)
+        .await
+        .unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview2_udp_states() {
+    run(PREVIEW2_UDP_STATES_COMPONENT, false).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview2_udp_bind() {
+    run(PREVIEW2_UDP_BIND_COMPONENT, false).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview2_udp_connect() {
+    run(PREVIEW2_UDP_CONNECT_COMPONENT, false).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview2_stream_pollable_correct() {
+    run(PREVIEW2_STREAM_POLLABLE_CORRECT_COMPONENT, false)
+        .await
+        .unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview2_stream_pollable_traps() {
+    let e = run(PREVIEW2_STREAM_POLLABLE_TRAPS_COMPONENT, false)
+        .await
+        .unwrap_err();
+    assert_eq!(
+        format!("{}", e.source().expect("trap source")),
+        "resource has children"
+    )
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview2_adapter_badfd() {
+    run(PREVIEW2_ADAPTER_BADFD_COMPONENT, false).await.unwrap()
+}

data/ext/cargo-vendor/wasmtime-wasi-17.0.0/tests/all/main.rs

@@ -0,0 +1,112 @@
+use anyhow::Result;
+use tempfile::TempDir;
+use wasmtime::{
+    component::{Component, Linker, ResourceTable},
+    Config, Engine, Store,
+};
+use wasmtime_wasi::preview2::{
+    pipe::MemoryOutputPipe,
+    preview1::{WasiPreview1Adapter, WasiPreview1View},
+    DirPerms, FilePerms, WasiCtx, WasiCtxBuilder, WasiView,
+};
+
+struct Ctx {
+    table: ResourceTable,
+    wasi: WasiCtx,
+    stdout: MemoryOutputPipe,
+    stderr: MemoryOutputPipe,
+    adapter: WasiPreview1Adapter,
+}
+
+impl WasiView for Ctx {
+    fn table(&self) -> &ResourceTable {
+        &self.table
+    }
+    fn table_mut(&mut self) -> &mut ResourceTable {
+        &mut self.table
+    }
+    fn ctx(&self) -> &WasiCtx {
+        &self.wasi
+    }
+    fn ctx_mut(&mut self) -> &mut WasiCtx {
+        &mut self.wasi
+    }
+}
+
+impl WasiPreview1View for Ctx {
+    fn adapter(&self) -> &WasiPreview1Adapter {
+        &self.adapter
+    }
+    fn adapter_mut(&mut self) -> &mut WasiPreview1Adapter {
+        &mut self.adapter
+    }
+}
+
+fn prepare_workspace(exe_name: &str) -> Result<TempDir> {
+    let prefix = format!("wasi_components_{}_", exe_name);
+    let tempdir = tempfile::Builder::new().prefix(&prefix).tempdir()?;
+    Ok(tempdir)
+}
+
+fn store(engine: &Engine, name: &str, inherit_stdio: bool) -> Result<(Store<Ctx>, TempDir)> {
+    let stdout = MemoryOutputPipe::new(4096);
+    let stderr = MemoryOutputPipe::new(4096);
+    let workspace = prepare_workspace(name)?;
+
+    // Create our wasi context.
+    let mut builder = WasiCtxBuilder::new();
+    if inherit_stdio {
+        builder.inherit_stdio();
+    } else {
+        builder.stdout(stdout.clone()).stderr(stderr.clone());
+    }
+
+    builder
+        .args(&[name, "."])
+        .inherit_network()
+        .allow_ip_name_lookup(true);
+    println!("preopen: {:?}", workspace);
+    let preopen_dir =
+        cap_std::fs::Dir::open_ambient_dir(workspace.path(), cap_std::ambient_authority())?;
+    builder.preopened_dir(preopen_dir, DirPerms::all(), FilePerms::all(), ".");
+    for (var, val) in test_programs_artifacts::wasi_tests_environment() {
+        builder.env(var, val);
+    }
+
+    let ctx = Ctx {
+        table: ResourceTable::new(),
+        wasi: builder.build(),
+        stderr,
+        stdout,
+        adapter: WasiPreview1Adapter::new(),
+    };
+
+    Ok((Store::new(&engine, ctx), workspace))
+}
+
+impl Drop for Ctx {
+    fn drop(&mut self) {
+        let stdout = self.stdout.contents();
+        if !stdout.is_empty() {
+            println!("[guest] stdout:\n{}\n===", String::from_utf8_lossy(&stdout));
+        }
+        let stderr = self.stderr.contents();
+        if !stderr.is_empty() {
+            println!("[guest] stderr:\n{}\n===", String::from_utf8_lossy(&stderr));
+        }
+    }
+}
+
+// Assert that each of `sync` and `async` below are testing everything through
+// assertion of the existence of the test function itself.
+macro_rules! assert_test_exists {
+    ($name:ident) => {
+        #[allow(unused_imports)]
+        use self::$name as _;
+    };
+}
+
+mod api;
+mod async_;
+mod preview1;
+mod sync;