Port tests that use only basic features

Author: afdw

tests/all/closures.rs

@@ -0,0 +1,94 @@
+use super::project;
+
+#[test]
+fn serde() {
+    project()
+        .serde(true)
+        .depend("serde = '1.0'")
+        .depend("serde_derive = '1.0'")
+        .file(
+            "src/lib.rs",
+            r#"
+                #![feature(use_extern_macros)]
+
+                extern crate wasm_bindgen;
+                #[macro_use]
+                extern crate serde_derive;
+
+                use wasm_bindgen::prelude::*;
+
+                #[derive(Deserialize, Serialize)]
+                pub struct Foo {
+                    a: u32,
+                    b: String,
+                    c: Option<Bar>,
+                    d: Bar,
+                }
+
+                #[derive(Deserialize, Serialize)]
+                pub struct Bar {
+                    a: u32,
+                }
+
+                #[wasm_bindgen(module = "./test")]
+                extern {
+                    fn verify(a: JsValue) -> JsValue;
+                }
+
+                #[wasm_bindgen]
+                pub fn run() {
+                    let js = JsValue::from_serde("foo").unwrap();
+                    assert_eq!(js.as_string(), Some("foo".to_string()));
+
+                    let ret = verify(JsValue::from_serde(&Foo {
+                        a: 0,
+                        b: "foo".to_string(),
+                        c: None,
+                        d: Bar { a: 1 },
+                    }).unwrap());
+
+                    let foo = ret.into_serde::<Foo>().unwrap();
+                    assert_eq!(foo.a, 2);
+                    assert_eq!(foo.b, "bar");
+                    assert!(foo.c.is_some());
+                    assert_eq!(foo.c.as_ref().unwrap().a, 3);
+                    assert_eq!(foo.d.a, 4);
+                }
+
+                #[wasm_bindgen]
+                pub fn parse(j: &JsValue) {
+                    let s = j.into_serde::<String>().unwrap();
+                    assert_eq!(s, "bar");
+                }
+            "#,
+        )
+        .file(
+            "test.js",
+            r#"
+                import { run, parse } from "./out";
+                import * as assert from "assert";
+
+                export function verify(a) {
+                    assert.deepStrictEqual(a, {
+                        a: 0,
+                        b: 'foo',
+                        c: null,
+                        d: { a: 1 }
+                    });
+
+                    return {
+                        a: 2,
+                        b: 'bar',
+                        c: { a: 3 },
+                        d: { a: 4 },
+                    }
+                }
+
+                export function test() {
+                    run();
+                    parse('bar');
+                }
+            "#,
+        )
+        .test();
+}