Enable cargo test where possible

Currently `#[wasm_bindgen]` generates a bunch of references to symbols that
don't actually exist on non-wasm targets, making it more difficult to get a
crate working across multiple platforms. This commit updates the symbol
references to be dummy ones that panic on non-wasm targets to allow simple
testing/benchmarking to work on native targets.

While this isn't a perfect solution for #114 it's probably as good as we can do
for now pending upstream Cargo features, so I'm gonna say that it...

Closes #114

tests/all/non_wasm.rs

@@ -0,0 +1,86 @@
+use std::process::Command;
+use super::{run, project};
+
+#[test]
+fn works() {
+    let mut p = project();
+    let name = p.crate_name();
+    p
+        .rlib(true)
+        .file("src/lib.rs", r#"
+            #![feature(proc_macro, wasm_custom_section, wasm_import_module)]
+
+            extern crate wasm_bindgen;
+
+            use wasm_bindgen::prelude::*;
+
+            #[wasm_bindgen]
+            pub struct A {
+                x: u32,
+            }
+
+            #[wasm_bindgen]
+            impl A {
+                pub fn new() -> A {
+                    A { x: 3 }
+                }
+
+                pub fn foo(&self) {
+                }
+            }
+
+            #[wasm_bindgen]
+            pub fn foo(x: bool) {
+                A::new().foo();
+
+                if x {
+                    bar("test");
+                    baz(JsValue::from(3));
+                }
+            }
+
+            #[wasm_bindgen]
+            extern {
+                fn some_import();
+                static A: JsValue;
+            }
+
+            #[wasm_bindgen]
+            pub fn bar(_: &str) -> JsValue {
+                some_import();
+                A.clone()
+            }
+
+            #[wasm_bindgen]
+            pub fn baz(_: JsValue) {
+            }
+        "#)
+        .file("tests/foo.rs", &format!("
+            extern crate {} as mytest;
+
+            #[test]
+            fn foo() {{
+                mytest::foo(false);
+                mytest::A::new().foo();
+            }}
+        ", name))
+        .file("benches/foo.rs", &format!("
+            #![feature(test)]
+            extern crate test;
+            extern crate {} as mytest;
+
+            #[bench]
+            fn foo(b: &mut test::Bencher) {{
+                b.iter(|| mytest::foo(false));
+            }}
+        ", name));
+    let (root, target_dir) = p.build();
+    let mut cmd = Command::new("cargo");
+    cmd.arg("test")
+        .arg("--test").arg("foo")
+        .arg("--bench").arg("foo")
+        .current_dir(&root)
+        .env("CARGO_TARGET_DIR", &target_dir);
+    run(&mut cmd, "cargo");
+}
+