Add the ability to run tests with either jit or native.

Don't actually make `make test` run them with native though, it doesn't pass yet.

Cargo.toml

@@ -129,6 +129,13 @@ test-llvm = [
     "llvm",
 ]
 
+test-native = [
+    "native",
+]
+test-jit = [
+    "jit",
+]
+
 # Disable trap asserts in the WAST tests. This is useful for running the tests in a
 # context where signal handling is a problem, such as tarpaulin for code coverage.
 test-no-traps = ["wasmer-wast/test-no-traps"]

Makefile

@@ -94,16 +94,26 @@ build-capi-llvm:
 # Testing #
 ###########
 
-test: $(foreach compiler,$(compilers),test-$(compiler)) test-packages test-examples test-deprecated
+test: $(foreach compiler,$(compilers),test-$(compiler)-jit) test-packages test-examples test-deprecated
 
-test-singlepass:
-	cargo test --release $(compiler_features) --features "test-singlepass"
+# Singlepass and native engine don't work together, this rule does nothing.
+test-singlepass-native:
+	@:
 
-test-cranelift:
-	cargo test --release $(compiler_features) --features "test-cranelift"
+test-singlepass-jit:
+	cargo test --release $(compiler_features) --features "test-singlepass test-jit"
 
-test-llvm:
-	cargo test --release $(compiler_features) --features "test-llvm"
+test-cranelift-native:
+	cargo test --release $(compiler_features) --features "test-cranelift test-native"
+
+test-cranelift-jit:
+	cargo test --release $(compiler_features) --features "test-cranelift test-jit"
+
+test-llvm-native:
+	cargo test --release $(compiler_features) --features "test-llvm test-native"
+
+test-llvm-jit:
+	cargo test --release $(compiler_features) --features "test-llvm test-jit"
 
 test-packages:
 	cargo test -p wasmer --release

tests/compilers/utils.rs

@@ -2,8 +2,10 @@ use std::sync::Arc;
 use wasmer::{FunctionMiddlewareGenerator, Store};
 use wasmer_compiler::CompilerConfig;
 use wasmer_engine::Engine;
+#[cfg(feature = "test-jit")]
 use wasmer_engine_jit::JIT;
-// use wasmer_engine_native::Native;
+#[cfg(feature = "test-native")]
+use wasmer_engine_native::Native;
 
 pub fn get_compiler(canonicalize_nans: bool) -> impl CompilerConfig {
     cfg_if::cfg_if! {
@@ -33,12 +35,18 @@ pub fn get_compiler(canonicalize_nans: bool) -> impl CompilerConfig {
     }
 }
 
-pub fn get_engine() -> impl Engine {
+#[cfg(feature = "test-jit")]
+    pub fn get_engine() -> impl Engine {
     let compiler_config = get_compiler(false);
     JIT::new(&compiler_config).engine()
     // let mut compiler_config = get_compiler(false);
     // Native::new(&mut compiler_config).engine()
 }
+#[cfg(feature = "test-native")]
+    pub fn get_engine() -> impl Engine {
+    let mut compiler_config = get_compiler(false);
+    Native::new(&mut compiler_config).engine()
+}
 
 pub fn get_store() -> Store {
     Store::new(&get_engine())
@@ -51,12 +59,20 @@ pub fn get_store_with_middlewares<I: Iterator<Item = Arc<dyn FunctionMiddlewareG
     for x in middlewares {
         compiler_config.push_middleware(x);
     }
+    #[cfg(feature = "test-jit")]
     let engine = JIT::new(&compiler_config).engine();
-    // let engine = Native::new(&mut compiler_config).engine();
+    #[cfg(feature = "test-native")]
+    let engine = Native::new(&mut compiler_config).engine();
     Store::new(&engine)
 }
 
+#[cfg(feature = "test-jit")]
 pub fn get_headless_store() -> Store {
     Store::new(&JIT::headless().engine())
     // Store::new(&Native::headless().engine())
 }
+
+#[cfg(feature = "test-native")]
+pub fn get_headless_store() -> Store {
+    Store::new(&Native::headless().engine())
+}

tests/compilers/wast.rs

@@ -3,10 +3,10 @@
 use crate::utils::get_compiler;
 use std::path::Path;
 use wasmer::{Features, Store};
-#[cfg(feature = "jit")]
+#[cfg(feature = "test-jit")]
 use wasmer_engine_jit::JIT;
-// #[cfg(feature = "native")]
-// use wasmer_engine_native::Native;
+ #[cfg(feature = "test-native")]
+use wasmer_engine_native::Native;
 use wasmer_wast::Wast;
 
 // The generated tests (from build.rs) look like:
@@ -28,6 +28,18 @@ fn _native_prefixer(bytes: &[u8]) -> String {
     format!("{}", hash.to_hex())
 }
 
+#[cfg(feature = "test-jit")]
+fn get_store(features: Features, try_nan_canonicalization: bool) -> Store {
+    let compiler_config = get_compiler(try_nan_canonicalization);
+    Store::new(&JIT::new(&compiler_config).features(features).engine())
+}
+
+#[cfg(feature = "test-native")]
+fn get_store(features: Features, try_nan_canonicalization: bool) -> Store {
+    let mut compiler_config = get_compiler(try_nan_canonicalization);
+    Store::new(&Native::new(&mut compiler_config).features(features).engine())
+}
+
 pub fn run_wast(wast_path: &str, compiler: &str) -> anyhow::Result<()> {
     println!(
         "Running wast `{}` with the {} compiler",
@@ -45,13 +57,7 @@ pub fn run_wast(wast_path: &str, compiler: &str) -> anyhow::Result<()> {
     }
     #[cfg(feature = "test-singlepass")]
     features.multi_value(false);
-    let compiler_config = get_compiler(try_nan_canonicalization);
-    let store = Store::new(&JIT::new(&compiler_config).features(features).engine());
-    // let mut compiler_config = compiler_config;
-    // let native = Native::new(&mut compiler_config)
-    //     .features(features)
-    //     .engine();
-    // let store = Store::new(&native);
+    let store = get_store(features, try_nan_canonicalization);
     let mut wast = Wast::new_with_spectest(store);
     if is_simd {
         // We allow this, so tests can be run properly for `simd_const` test.