Migrate resource-alias-redux test to new framework

crates/test-rust-wasm/Cargo.toml

@@ -59,10 +59,6 @@ test = false
 name = "resource_borrow_export"
 test = false
 
-[[bin]]
-name = "resource_alias_redux"
-test = false
-
 [[bin]]
 name = "resource_alias"
 test = false

tests/runtime-new/resource_alias_redux/_test_disabled.cs

@@ -0,0 +1,41 @@
+namespace TestWorld.wit.exports.test.resourceAliasRedux
+{
+    public class ResourceAlias1Impl : IResourceAlias1 {
+	public class Thing : IResourceAlias1.Thing, IResourceAlias1.IThing {
+	    public string val;
+
+	    public Thing(string v) {
+		this.val = v + " GuestThing";
+	    }
+
+	    public string Get() {
+		return this.val + " GuestThing.get";
+	    }
+	}
+
+	public static List<IResourceAlias1.Thing> A(IResourceAlias1.Foo f) {
+	    var newList = new List<IResourceAlias1.Thing>();
+	    newList.Add(f.thing);
+	    return newList;
+	}
+    }
+
+    public class ResourceAlias2Impl : IResourceAlias2 {
+	public static List<IResourceAlias1.Thing> B(IResourceAlias2.Foo f, IResourceAlias1.Foo g) {
+	    var newList = new List<IResourceAlias1.Thing>();
+	    newList.Add(f.thing);
+	    newList.Add(g.thing);
+	    return newList;
+	}
+    }
+}
+
+namespace TestWorld {
+    using TestWorld.wit.exports.test.resourceAliasRedux;
+
+    public class TestWorldImpl : ITestWorld {
+	public static List<IResourceAlias1.Thing> Test(List<IResourceAlias1.Thing> things) {
+	    return things;
+	}
+    }
+}

tests/runtime-new/resource_alias_redux/runner.cs

@@ -0,0 +1,27 @@
+using System;
+using System.Runtime.InteropServices;
+using System.Diagnostics;
+using RunnerWorld.wit.imports.test.resourceAliasRedux;
+using RunnerWorld.wit.imports;
+using System.Text;
+
+public class Program {
+    public static void Main() {
+        IResourceAlias1.Thing thing1 = new IResourceAlias1.Thing("Ni Hao");
+        List<IResourceAlias1.Thing> myList = new List<IResourceAlias1.Thing>();
+        myList.Add(thing1);
+        List<IResourceAlias1.Thing> ret = TheTestInterop.Test(myList);
+        Debug.Assert(ret[0].Get() == "Ni Hao GuestThing GuestThing.get");
+
+        ret = ResourceAlias1Interop.A(
+            new IResourceAlias1.Foo(new IResourceAlias1.Thing("Ciao")));
+        Debug.Assert(ret[0].Get() == "Ciao GuestThing GuestThing.get");
+
+        ret = ResourceAlias2Interop.B(
+            new IResourceAlias2.Foo(new IResourceAlias1.Thing("Ciao")),
+            new IResourceAlias1.Foo(new IResourceAlias1.Thing("Aloha"))
+        );
+        Debug.Assert(ret[0].Get() == "Ciao GuestThing GuestThing.get");
+        Debug.Assert(ret[1].Get() == "Aloha GuestThing GuestThing.get");
+    }
+}

tests/runtime-new/resource_alias_redux/runner.rs

@@ -0,0 +1,25 @@
+include!(env!("BINDINGS"));
+
+use crate::test::resource_alias_redux::resource_alias1 as a1;
+use crate::test::resource_alias_redux::resource_alias2 as a2;
+use crate::the_test::test;
+
+fn main() {
+    let thing1 = crate::the_test::Thing::new("Ni Hao");
+    let result = test(vec![thing1]);
+    assert_eq!(result.len(), 1);
+    assert_eq!(result[0].get(), "Ni Hao GuestThing GuestThing.get");
+
+    let thing2 = crate::test::resource_alias_redux::resource_alias1::Thing::new("Ciao");
+    let result = a1::a(a1::Foo { thing: thing2 });
+    assert_eq!(result.len(), 1);
+    assert_eq!(result[0].get(), "Ciao GuestThing GuestThing.get");
+
+    let thing3 = crate::test::resource_alias_redux::resource_alias1::Thing::new("Ciao");
+    let thing4 = crate::test::resource_alias_redux::resource_alias1::Thing::new("Aloha");
+
+    let result = a2::b(a2::Foo { thing: thing3 }, a2::Bar { thing: thing4 });
+    assert_eq!(result.len(), 2);
+    assert_eq!(result[0].get(), "Ciao GuestThing GuestThing.get");
+    assert_eq!(result[1].get(), "Aloha GuestThing GuestThing.get");
+}

tests/runtime-new/resource_alias_redux/test.rs

@@ -0,0 +1,44 @@
+include!(env!("BINDINGS"));
+
+use crate::exports::test::resource_alias_redux::resource_alias1 as a1;
+use crate::exports::test::resource_alias_redux::resource_alias2 as a2;
+use crate::exports::the_test::{Guest, Thing};
+
+struct Component;
+
+export!(Component);
+
+struct MyThing(String);
+
+impl Guest for Component {
+    fn test(things: Vec<Thing>) -> Vec<Thing> {
+        things
+    }
+}
+
+impl a1::Guest for Component {
+    type Thing = MyThing;
+
+    fn a(f: a1::Foo) -> Vec<Thing> {
+        vec![f.thing]
+    }
+}
+
+impl a2::Guest for Component {
+    fn b(f: a2::Foo, g: a2::Bar) -> Vec<Thing> {
+        vec![f.thing, g.thing]
+    }
+}
+
+impl a1::GuestThing for MyThing {
+    fn new(mut msg: String) -> MyThing {
+        msg.push_str(" GuestThing");
+        MyThing(msg)
+    }
+
+    fn get(&self) -> String {
+        let mut ret = self.0.clone();
+        ret.push_str(" GuestThing.get");
+        ret
+    }
+}

tests/runtime/resource_alias_redux/world.wit → tests/runtime-new/resource_alias_redux/test.wit

@@ -19,13 +19,22 @@ interface resource-alias2 {
   b: func(f: foo, g: bar) -> list<thing>;
 }
 
-world resource-alias-redux {
-  use resource-alias1.{thing};
+world test {
+  export resource-alias1;
+  export resource-alias2;
+
+  export the-test: interface {
+    use resource-alias1.{thing};
+    test: func(things: list<thing>) -> list<thing>;
+  }
+}
 
+world runner {
   import resource-alias1;
   import resource-alias2;
-  export resource-alias1;
-  export resource-alias2;
 
-  export test: func(things: list<thing>) -> list<thing>;
+  import the-test: interface {
+    use resource-alias1.{thing};
+    test: func(things: list<thing>) -> list<thing>;
+  }
 }

tests/runtime/main.rs

@@ -17,7 +17,6 @@ mod flavorful;
 mod options;
 mod ownership;
 mod resource_alias;
-mod resource_alias_redux;
 mod resource_borrow_export;
 mod resource_borrow_import;
 mod resource_borrow_simple;