tests/compilers: remove Engine configuration

Since there's only one Engine now.

tests/compilers/config.rs

@@ -1,5 +1,5 @@
 use std::sync::Arc;
-use wasmer::{CompilerConfig, Engine as WasmerEngine, Features, ModuleMiddleware, Store};
+use wasmer::{CompilerConfig, Engine, Features, ModuleMiddleware, Store};
 
 #[derive(Clone, Debug, PartialEq)]
 pub enum Compiler {
@@ -8,25 +8,18 @@ pub enum Compiler {
     Singlepass,
 }
 
-#[derive(Clone, Debug, PartialEq)]
-pub enum Engine {
-    Universal,
-}
-
 #[derive(Clone)]
 pub struct Config {
     pub compiler: Compiler,
-    pub engine: Engine,
     pub features: Option<Features>,
     pub middlewares: Vec<Arc<dyn ModuleMiddleware>>,
     pub canonicalize_nans: bool,
 }
 
 impl Config {
-    pub fn new(engine: Engine, compiler: Compiler) -> Self {
+    pub fn new(compiler: Compiler) -> Self {
         Self {
             compiler,
-            engine,
             features: None,
             canonicalize_nans: false,
             middlewares: vec![],
@@ -56,34 +49,16 @@ impl Config {
         Store::new(&*engine)
     }
 
-    pub fn engine(&self, compiler_config: Box<dyn CompilerConfig>) -> Box<dyn WasmerEngine> {
-        match &self.engine {
-            #[cfg(feature = "universal")]
-            Engine::Universal => {
-                let mut engine = wasmer_compiler::Universal::new(compiler_config);
-                if let Some(ref features) = self.features {
-                    engine = engine.features(features.clone())
-                }
-                Box::new(engine.engine())
-            }
-            #[allow(unreachable_patterns)]
-            engine => panic!(
-                "The {:?} Engine is not enabled. Please enable it using the features",
-                engine
-            ),
+    pub fn engine(&self, compiler_config: Box<dyn CompilerConfig>) -> Box<dyn Engine> {
+        let mut engine = wasmer_compiler::Universal::new(compiler_config);
+        if let Some(ref features) = self.features {
+            engine = engine.features(features.clone())
         }
+        Box::new(engine.engine())
     }
 
-    pub fn engine_headless(&self) -> Box<dyn WasmerEngine> {
-        match &self.engine {
-            #[cfg(feature = "universal")]
-            Engine::Universal => Box::new(wasmer_compiler::Universal::headless().engine()),
-            #[allow(unreachable_patterns)]
-            engine => panic!(
-                "The {:?} Engine is not enabled. Please enable it using the features",
-                engine
-            ),
-        }
+    pub fn engine_headless(&self) -> Box<dyn Engine> {
+        Box::new(wasmer_compiler::Universal::headless().engine())
     }
 
     pub fn compiler_config(&self, canonicalize_nans: bool) -> Box<dyn CompilerConfig> {

tests/compilers/main.rs

@@ -18,7 +18,7 @@ mod traps;
 mod wasi;
 mod wast;
 
-pub use crate::config::{Compiler, Config, Engine};
+pub use crate::config::{Compiler, Config};
 pub use crate::wasi::run_wasi;
 pub use crate::wast::run_wast;
 pub use wasmer_wast::WasiFileSystemKind;

tests/compilers/wast.rs

@@ -42,18 +42,6 @@ pub fn run_wast(mut config: crate::Config, wast_path: &str) -> anyhow::Result<()
     wast.allow_trap_message("uninitialized element 2", "uninitialized element");
     // `liking.wast` has different wording but the same meaning
     wast.allow_trap_message("out of bounds memory access", "memory out of bounds");
-    /*
-    if config.compiler == crate::Compiler::Cranelift && config.engine == crate::Engine::Dylib {
-        wast.allow_trap_message("call stack exhausted", "out of bounds memory access");
-        wast.allow_trap_message("indirect call type mismatch", "call stack exhausted");
-        wast.allow_trap_message("integer divide by zero", "call stack exhausted");
-        wast.allow_trap_message("integer overflow", "call stack exhausted");
-        wast.allow_trap_message("invalid conversion to integer", "call stack exhausted");
-        wast.allow_trap_message("undefined element", "call stack exhausted");
-        wast.allow_trap_message("uninitialized element", "call stack exhausted");
-        wast.allow_trap_message("unreachable", "call stack exhausted");
-    }
-    */
     if cfg!(feature = "coverage") {
         wast.disable_assert_and_exhaustion();
     }

tests/integration/cli/src/util.rs

@@ -19,19 +19,6 @@ impl Compiler {
     }
 }
 
-#[derive(Debug, Copy, Clone)]
-pub enum Engine {
-    Universal,
-}
-
-impl Engine {
-    pub const fn to_flag(self) -> &'static str {
-        match self {
-            Engine::Universal => "--universal",
-        }
-    }
-}
-
 pub fn run_code(
     operating_dir: &Path,
     executable_path: &Path,

tests/lib/compiler-test-derive/src/lib.rs

@@ -74,7 +74,6 @@ pub fn compiler_test(attrs: TokenStream, input: TokenStream) -> TokenStream {
                                  engine_feature_name: &str|
      -> ::proc_macro2::TokenStream {
         let config_compiler = ::quote::format_ident!("{}", compiler_name);
-        let config_engine = ::quote::format_ident!("{}", engine_name);
         let test_name = ::quote::format_ident!("{}", engine_name.to_lowercase());
         let mut new_sig = func.sig.clone();
         let attrs = func
@@ -89,7 +88,7 @@ pub fn compiler_test(attrs: TokenStream, input: TokenStream) -> TokenStream {
             #attrs
             #[cfg(feature = #engine_feature_name)]
             #new_sig {
-                #fn_name(crate::Config::new(crate::Engine::#config_engine, crate::Compiler::#config_compiler))
+                #fn_name(crate::Config::new(crate::Compiler::#config_compiler))
             }
         };
         if should_ignore(

tests/lib/compiler-test-derive/src/tests.rs

@@ -59,7 +59,6 @@ gen_tests! {
                 #[cfg(feature = "universal")]
                 fn universal() {
                     foo(crate::Config::new(
-                        crate::Engine::Universal,
                         crate::Compiler::Singlepass
                     ))
                 }
@@ -73,7 +72,6 @@ gen_tests! {
                 #[cfg(feature = "universal")]
                 fn universal() {
                     foo(crate::Config::new(
-                        crate::Engine::Universal,
                         crate::Compiler::Cranelift
                     ))
                 }
@@ -87,7 +85,6 @@ gen_tests! {
                 #[cfg(feature = "universal")]
                 fn universal() {
                     foo(crate::Config::new(
-                        crate::Engine::Universal,
                         crate::Compiler::LLVM
                     ))
                 }