Initial reorg.

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

crates/api/tests/examples.rs

@@ -0,0 +1,39 @@
+use std::env;
+use std::process::{Command, Stdio};
+
+fn run_example(name: &'static str) {
+    let cargo = env::var("CARGO").unwrap_or("cargo".to_string());
+    let pkg_dir = env!("CARGO_MANIFEST_DIR");
+    assert!(
+        Command::new(cargo)
+            .current_dir(pkg_dir)
+            .stdout(Stdio::null())
+            .args(&["run", "-q", "--example", name])
+            .status()
+            .expect("success")
+            .success(),
+        "failed to execute the example '{}'",
+        name,
+    );
+}
+
+#[test]
+fn test_run_hello_example() {
+    run_example("hello");
+}
+
+#[test]
+fn test_run_gcd_example() {
+    run_example("gcd");
+}
+
+#[test]
+fn test_run_memory_example() {
+    run_example("memory");
+}
+
+#[cfg(not(target_os = "windows"))]
+#[test]
+fn test_run_multi_example() {
+    run_example("multi");
+}

crates/api/tests/import_calling_export.rs

@@ -0,0 +1,70 @@
+extern crate alloc;
+
+use alloc::rc::Rc;
+use core::cell::{Ref, RefCell};
+use std::fs::read;
+use wasmtime_api::*;
+
+#[test]
+fn test_import_calling_export() {
+    struct Callback {
+        pub other: RefCell<Option<HostRef<Func>>>,
+    }
+
+    impl Callable for Callback {
+        fn call(&self, _params: &[Val], _results: &mut [Val]) -> Result<(), HostRef<Trap>> {
+            self.other
+                .borrow()
+                .as_ref()
+                .expect("expected a function ref")
+                .borrow()
+                .call(&[])
+                .expect("expected function not to trap");
+            Ok(())
+        }
+    }
+
+    let engine = HostRef::new(Engine::new(Config::default()));
+    let store = HostRef::new(Store::new(&engine));
+    let module = HostRef::new(
+        Module::new(
+            &store,
+            &read("tests/import_calling_export.wasm").expect("failed to read wasm file"),
+        )
+        .expect("failed to create module"),
+    );
+
+    let callback = Rc::new(Callback {
+        other: RefCell::new(None),
+    });
+
+    let callback_func = HostRef::new(Func::new(
+        &store,
+        FuncType::new(Box::new([]), Box::new([])),
+        callback.clone(),
+    ));
+
+    let imports = vec![callback_func.into()];
+    let instance = HostRef::new(
+        Instance::new(&store, &module, imports.as_slice()).expect("failed to instantiate module"),
+    );
+
+    let exports = Ref::map(instance.borrow(), |instance| instance.exports());
+    assert!(!exports.is_empty());
+
+    let run_func = exports[0]
+        .func()
+        .expect("expected a run func in the module");
+
+    *callback.other.borrow_mut() = Some(
+        exports[1]
+            .func()
+            .expect("expected an other func in the module")
+            .clone(),
+    );
+
+    run_func
+        .borrow()
+        .call(&[])
+        .expect("expected function not to trap");
+}

crates/api/tests/import_calling_export.wat

@@ -0,0 +1,8 @@
+(module
+  (type $t0 (func))
+  (import "" "imp" (func $.imp (type $t0)))
+  (func $run call $.imp)
+  (func $other)
+  (export "run" (func $run))
+  (export "other" (func $other))
+)