Initial reorg.

This is largely the same as #305, but updated for the current tree.

crates/wasi-common/tests/wasm_tests/main.rs

@@ -0,0 +1,16 @@
+#![cfg(feature = "wasm_tests")]
+
+mod runtime;
+mod utils;
+
+use std::sync::Once;
+
+static LOG_INIT: Once = Once::new();
+
+fn setup_log() {
+    LOG_INIT.call_once(|| {
+        pretty_env_logger::init();
+    })
+}
+
+include!(concat!(env!("OUT_DIR"), "/wasi_misc_tests.rs"));

crates/wasi-common/tests/wasm_tests/runtime.rs

@@ -0,0 +1,111 @@
+use anyhow::{bail, Context};
+use cranelift_codegen::settings::{self, Configurable};
+use std::fs::File;
+use std::{collections::HashMap, path::Path};
+use wasmtime_api::{Config, Engine, HostRef, Instance, Module, Store};
+use wasmtime_jit::{CompilationStrategy, Features};
+
+pub fn instantiate(data: &[u8], bin_name: &str, workspace: Option<&Path>) -> anyhow::Result<()> {
+    // Prepare runtime
+    let mut flag_builder = settings::builder();
+
+    // Enable proper trap for division
+    flag_builder
+        .enable("avoid_div_traps")
+        .context("error while enabling proper division trap")?;
+
+    let config = Config::new(
+        settings::Flags::new(flag_builder),
+        Features::default(),
+        false,
+        CompilationStrategy::Auto,
+    );
+    let engine = HostRef::new(Engine::new(config));
+    let store = HostRef::new(Store::new(&engine));
+
+    let mut module_registry = HashMap::new();
+    let global_exports = store.borrow().global_exports().clone();
+    let get_preopens = |workspace: Option<&Path>| -> anyhow::Result<Vec<_>> {
+        if let Some(workspace) = workspace {
+            let preopen_dir = wasi_common::preopen_dir(workspace)
+                .context(format!("error while preopening {:?}", workspace))?;
+
+            Ok(vec![(".".to_owned(), preopen_dir)])
+        } else {
+            Ok(vec![])
+        }
+    };
+
+    // Create our wasi context with pretty standard arguments/inheritance/etc.
+    // Additionally register andy preopened directories if we have them.
+    let mut builder = wasi_common::WasiCtxBuilder::new()
+        .arg(bin_name)
+        .arg(".")
+        .inherit_stdio();
+    for (dir, file) in get_preopens(workspace)? {
+        builder = builder.preopened_dir(file, dir);
+    }
+
+    // The nonstandard thing we do with `WasiCtxBuilder` is to ensure that
+    // `stdin` is always an unreadable pipe. This is expected in the test suite
+    // where `stdin` is never ready to be read. In some CI systems, however,
+    // stdin is closed which causes tests to fail.
+    let (reader, _writer) = os_pipe::pipe()?;
+    builder = builder.stdin(reader_to_file(reader));
+
+    module_registry.insert(
+        "wasi_unstable".to_owned(),
+        Instance::from_handle(
+            &store,
+            wasmtime_wasi::instantiate_wasi_with_context(
+                "",
+                global_exports.clone(),
+                builder.build().context("failed to build wasi context")?,
+            )
+            .context("failed to instantiate wasi")?,
+        )
+        .context("failed to create instance from handle")?,
+    );
+
+    let module = HostRef::new(Module::new(&store, &data).context("failed to create wasm module")?);
+    let imports = module
+        .borrow()
+        .imports()
+        .iter()
+        .map(|i| {
+            let module_name = i.module().to_string();
+            if let Some((instance, map)) = module_registry.get(&module_name) {
+                let field_name = i.name().to_string();
+                if let Some(export_index) = map.get(&field_name) {
+                    Ok(instance.exports()[*export_index].clone())
+                } else {
+                    bail!(
+                        "import {} was not found in module {}",
+                        field_name,
+                        module_name
+                    )
+                }
+            } else {
+                bail!("import module {} was not found", module_name)
+            }
+        })
+        .collect::<Result<Vec<_>, _>>()?;
+    let _ = HostRef::new(Instance::new(&store, &module, &imports).context(format!(
+        "error while instantiating Wasm module '{}'",
+        bin_name,
+    ))?);
+
+    Ok(())
+}
+
+#[cfg(unix)]
+fn reader_to_file(reader: os_pipe::PipeReader) -> File {
+    use std::os::unix::prelude::*;
+    unsafe { File::from_raw_fd(reader.into_raw_fd()) }
+}
+
+#[cfg(windows)]
+fn reader_to_file(reader: os_pipe::PipeReader) -> File {
+    use std::os::windows::prelude::*;
+    unsafe { File::from_raw_handle(reader.into_raw_handle()) }
+}

crates/wasi-common/tests/wasm_tests/utils.rs

@@ -0,0 +1,30 @@
+use std::fs;
+use std::path::Path;
+use tempfile::{Builder, TempDir};
+
+pub fn read_wasm(path: &Path) -> anyhow::Result<Vec<u8>> {
+    let data = fs::read(path)?;
+    if data.starts_with(&[b'\0', b'a', b's', b'm']) {
+        Ok(data)
+    } else {
+        anyhow::bail!("Invalid Wasm file encountered")
+    }
+}
+
+pub fn prepare_workspace(exe_name: &str) -> anyhow::Result<TempDir> {
+    let prefix = format!("wasi_common_{}", exe_name);
+    let tempdir = Builder::new().prefix(&prefix).tempdir()?;
+    Ok(tempdir)
+}
+
+pub fn extract_exec_name_from_path(path: &Path) -> anyhow::Result<String> {
+    path.file_stem()
+        .and_then(|s| s.to_str())
+        .map(String::from)
+        .ok_or_else(|| {
+            anyhow::anyhow!(
+                "couldn't extract the file stem from path {}",
+                path.display()
+            )
+        })
+}