More debugging.

Author: sunfishcode

src/commands/run.rs

@@ -118,8 +118,11 @@ impl RunCommand {
             .handle_module(&store, &module_registry)
             .with_context(|| format!("failed to run main module `{}`", self.module.display()))
         {
-            Ok(()) => (),
+            Ok(()) => {
+                eprintln!("ok!");
+            }
             Err(e) => {
+                eprintln!("error: {:?}", e);
                 // If the program exited because of a trap, return an error code
                 // to the outside environment indicating a more severe problem
                 // than a simple failure.
@@ -139,6 +142,7 @@ impl RunCommand {
                 return Err(e);
             }
         }
+        eprintln!("all good");
 
         Ok(())
     }
@@ -227,27 +231,32 @@ impl RunCommand {
     }
 
     fn handle_module(&self, store: &Store, module_registry: &ModuleRegistry) -> Result<()> {
+        eprintln!("instantiating module...");
         let (instance, module, data) =
             Self::instantiate_module(store, module_registry, &self.module)?;
 
         // If a function to invoke was given, invoke it.
         if let Some(name) = self.invoke.as_ref() {
+            eprintln!("invoking {}...", name);
             let data = ModuleData::new(&data)?;
             self.invoke_export(instance, &data, name)?;
         } else if module
             .exports()
             .iter()
             .any(|export| export.name().is_empty())
         {
+            eprintln!("invoking default command export...");
             // Launch the default command export.
             let data = ModuleData::new(&data)?;
             self.invoke_export(instance, &data, "")?;
         } else {
+            eprintln!("invoking the _start function...");
             // If the module doesn't have a default command export, launch the
             // _start function if one is present, as a compatibility measure.
             let data = ModuleData::new(&data)?;
             self.invoke_export(instance, &data, "_start")?;
         }
+        eprintln!("success!");
 
         Ok(())
     }

tests/cli_tests.rs

@@ -10,7 +10,11 @@ fn run_wasmtime_for_output(args: &[&str]) -> Result<Output> {
     me.pop(); // chop off the file name
     me.pop(); // chop off `deps`
     me.push("wasmtime");
-    Command::new(&me).args(args).output().map_err(Into::into)
+    Command::new(&me)
+        .args(args)
+        .env("RUST_LOG", "trace")
+        .output()
+        .map_err(Into::into)
 }
 
 // Run the wasmtime CLI with the provided args and, if it succeeds, return
@@ -85,21 +89,29 @@ fn run_wasmtime_simple_wat() -> Result<()> {
 // Running a wat that traps.
 #[test]
 fn run_wasmtime_unreachable_wat() -> Result<()> {
+    dbg!("hi");
     let wasm = build_wasm("tests/wasm/unreachable.wat")?;
+    dbg!("go");
     let output = run_wasmtime_for_output(&[wasm.path().to_str().unwrap(), "--disable-cache"])?;
 
+    dbg!("yes");
     eprintln!(
-        "stderr='{:?}' stdout='{:?}' status='{:?}'",
-        output.stderr, output.stdout, output.status
+        "stderr='{}' stdout='{}' status='{:?}'",
+        String::from_utf8_lossy(&output.stderr),
+        String::from_utf8_lossy(&output.stdout),
+        output.status
     );
-    assert_ne!(output.stderr, b"");
-    assert_eq!(output.stdout, b"");
+    dbg!("printed");
+    assert_ne!(String::from_utf8_lossy(&output.stderr), "".to_owned());
+    assert_eq!(String::from_utf8_lossy(&output.stdout), "".to_owned());
     assert!(!output.status.success());
+    dbg!("ok");
 
     let code = output
         .status
         .code()
         .expect("wasmtime process should exit normally");
+    dbg!("done");
 
     // Test for the specific error code Wasmtime uses to indicate a trap return.
     #[cfg(unix)]