Migrate ownership test to wit-bindgen test (#1255)

Nice test to make use of many-runners-but-one-test.

Author: alexcrichton

crates/test-rust-wasm/Cargo.toml

@@ -23,18 +23,6 @@ test = false
 name = "options"
 test = false
 
-[[bin]]
-name = "owning"
-test = false
-
-[[bin]]
-name = "borrowing"
-test = false
-
-[[bin]]
-name = "borrowing-duplicate-if-necessary"
-test = false
-
 [[bin]]
 name = "resources"
 test = false

crates/test-rust-wasm/src/bin/borrowing-duplicate-if-necessary.rs

@@ -0,0 +1,43 @@
+//@ args = '--ownership borrowing-duplicate-if-necessary'
+
+include!(env!("BINDINGS"));
+
+impl PartialEq for thing_in_and_out::ThingResult {
+    fn eq(&self, other: &Self) -> bool {
+        self.name == other.name && self.value == other.value
+    }
+}
+
+fn main() {
+    let value = &[&["foo", "bar"] as &[_]] as &[_];
+    assert_eq!(
+        vec![vec!["foo".to_owned(), "bar".to_owned()]],
+        lists::foo(value)
+    );
+
+    thing_in::bar(thing_in::Thing {
+        name: "thing 1",
+        value: &["some value", "another value"],
+    });
+
+    let value = thing_in_and_out::ThingParam {
+        name: "thing 1",
+        value: &["some value", "another value"],
+    };
+    assert_eq!(
+        thing_in_and_out::ThingResult {
+            name: "thing 1".to_owned(),
+            value: vec!["some value".to_owned(), "another value".to_owned()],
+        },
+        thing_in_and_out::baz(value)
+    );
+
+    let strings = vec!["foo", "bar", "baz"];
+    let resource = test::ownership::both_list_and_resource::TheResource::new(&strings);
+    test::ownership::both_list_and_resource::list_and_resource(
+        test::ownership::both_list_and_resource::Thing {
+            a: strings.iter().map(|s| s.to_string()).collect(),
+            b: resource,
+        },
+    );
+}

crates/test-rust-wasm/src/bin/borrowing.rs

@@ -0,0 +1,37 @@
+//@ args = '--ownership borrowing'
+
+include!(env!("BINDINGS"));
+
+impl PartialEq for thing_in_and_out::Thing {
+    fn eq(&self, other: &Self) -> bool {
+        self.name == other.name && self.value == other.value
+    }
+}
+
+fn main() {
+    let value = &[&["foo", "bar"] as &[_]] as &[_];
+    assert_eq!(
+        vec![vec!["foo".to_owned(), "bar".to_owned()]],
+        lists::foo(value)
+    );
+
+    thing_in::bar(thing_in::Thing {
+        name: "thing 1",
+        value: &["some value", "another value"],
+    });
+
+    let value = thing_in_and_out::Thing {
+        name: "thing 1".to_owned(),
+        value: vec!["some value".to_owned(), "another value".to_owned()],
+    };
+    assert_eq!(value, thing_in_and_out::baz(&value));
+
+    let strings = vec!["foo", "bar", "baz"];
+    let resource = test::ownership::both_list_and_resource::TheResource::new(&strings);
+    test::ownership::both_list_and_resource::list_and_resource(
+        test::ownership::both_list_and_resource::Thing {
+            a: strings.iter().map(|s| s.to_string()).collect(),
+            b: resource,
+        },
+    );
+}

crates/test-rust-wasm/src/bin/owning.rs

@@ -0,0 +1,33 @@
+//@ args = '--ownership owning'
+
+include!(env!("BINDINGS"));
+impl PartialEq for thing_in_and_out::Thing {
+    fn eq(&self, other: &Self) -> bool {
+        self.name == other.name && self.value == other.value
+    }
+}
+
+fn main() {
+    let value = vec![vec!["foo".to_owned(), "bar".to_owned()]];
+    assert_eq!(value, lists::foo(&value));
+
+    thing_in::bar(&thing_in::Thing {
+        name: "thing 1".to_owned(),
+        value: vec!["some value".to_owned(), "another value".to_owned()],
+    });
+
+    let value = thing_in_and_out::Thing {
+        name: "thing 1".to_owned(),
+        value: vec!["some value".to_owned(), "another value".to_owned()],
+    };
+    assert_eq!(value, thing_in_and_out::baz(&value));
+
+    let strings = vec!["foo".to_string(), "bar".to_string(), "baz".to_string()];
+    let resource = test::ownership::both_list_and_resource::TheResource::new(&strings);
+    test::ownership::both_list_and_resource::list_and_resource(
+        test::ownership::both_list_and_resource::Thing {
+            a: strings,
+            b: resource,
+        },
+    );
+}

tests/runtime-new/rust/ownership/runner-borrowing-duplicate-if-necessary.rs

@@ -0,0 +1,40 @@
+include!(env!("BINDINGS"));
+
+use crate::exports::test::ownership::both_list_and_resource;
+use crate::exports::{lists, thing_in, thing_in_and_out};
+
+struct Component;
+
+export!(Component);
+
+struct MyResource(Vec<String>);
+
+impl lists::Guest for Component {
+    fn foo(list: Vec<Vec<String>>) -> Vec<Vec<String>> {
+        list
+    }
+}
+
+impl thing_in::Guest for Component {
+    fn bar(_value: thing_in::Thing) {}
+}
+
+impl thing_in_and_out::Guest for Component {
+    fn baz(value: thing_in_and_out::Thing) -> thing_in_and_out::Thing {
+        value
+    }
+}
+
+impl both_list_and_resource::Guest for Component {
+    type TheResource = MyResource;
+
+    fn list_and_resource(value: both_list_and_resource::Thing) {
+        assert_eq!(value.a, value.b.get::<MyResource>().0);
+    }
+}
+
+impl both_list_and_resource::GuestTheResource for MyResource {
+    fn new(list: Vec<String>) -> MyResource {
+        MyResource(list)
+    }
+}

tests/runtime-new/rust/ownership/runner-borrowing.rs

@@ -12,7 +12,7 @@ interface both-list-and-resource {
     list-and-resource: func(a: thing);
 }
 
-world ownership {
+world runner {
     import lists: interface {
         foo: func(a: list<list<string>>) -> list<list<string>>;
     }
@@ -36,6 +36,30 @@ world ownership {
     }
 
     import both-list-and-resource;
+}
+
+world test {
+    export lists: interface {
+        foo: func(a: list<list<string>>) -> list<list<string>>;
+    }
+
+    export thing-in: interface {
+        record thing {
+            name: string,
+            value: list<string>
+        }
+
+        bar: func(a: thing);
+    }
+
+    export thing-in-and-out: interface {
+        record thing {
+            name: string,
+            value: list<string>
+        }
+
+        baz: func(a: thing) -> thing;
+    }
 
-    export foo: func();
+    export both-list-and-resource;
 }

tests/runtime-new/rust/ownership/runner-owning.rs

@@ -15,7 +15,6 @@ use wit_parser::{Resolve, WorldId, WorldItem};
 
 mod flavorful;
 mod options;
-mod ownership;
 mod resource_alias;
 mod resource_floats;
 mod resource_import_and_export;