Migrate resource_floats test to wit-bindgen test (#1261)

* Migrate `resource_floats` test to `wit-bindgen test`

* More migration

Author: alexcrichton

crates/test-rust-wasm/Cargo.toml

@@ -27,10 +27,6 @@ test = false
 name = "resources"
 test = false
 
-[[bin]]
-name = "resource_floats"
-test = false
-
 [[bin]]
 name = "resource_with_lists"
 test = false

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

@@ -0,0 +1,18 @@
+package example:composition;
+
+let leaf = new test:leaf { ... };
+let intermediate = new test:intermediate {
+  test: leaf.test,
+  imports: leaf.imports,
+  float: leaf.test.float,
+  ...
+};
+let runner = new test:runner {
+  exports: intermediate.exports,
+  test: leaf.test,
+  float: leaf.test.float,
+  add: intermediate.add,
+  ...
+};
+
+export runner...;

tests/runtime-new/resource_floats/compose.wac

@@ -1,7 +1,7 @@
-using Import1 = ResourceFloatsWorld.wit.imports.IImports;
-using Import2 = ResourceFloatsWorld.wit.imports.test.resourceFloats.ITest;
+using Import1 = IntermediateWorld.wit.imports.IImports;
+using Import2 = IntermediateWorld.wit.imports.test.resourceFloats.ITest;
 
-namespace ResourceFloatsWorld.wit.exports
+namespace IntermediateWorld.wit.exports
 {
     public class ExportsImpl : IExports {
 	public class Float : IExports.Float, IExports.IFloat {
@@ -22,8 +22,8 @@ public static IExports.Float Add(IExports.Float a, double b) {
     }
 }
 
-namespace ResourceFloatsWorld {
-    public class ResourceFloatsWorldImpl : IResourceFloatsWorld {
+namespace IntermediateWorld {
+    public class IntermediateWorldImpl : IIntermediateWorld {
 	public static Import2.Float Add(Import2.Float a, Import2.Float b) {
 	    return new Import2.Float(a.Get() + b.Get() + 5.0);
 	}

tests/runtime/resource_floats/wasm.cs renamed to tests/runtime-new/resource_floats/intermediate.cs

@@ -1,6 +1,4 @@
-wit_bindgen::generate!({
-    path: "../../tests/runtime/resource_floats",
-});
+include!(env!("BINDINGS"));
 
 use exports::exports::{Float as FloatExport, GuestFloat};
 use imports::Float as ImportFloat1;

tests/runtime/resource_floats/wasm.rs renamed to tests/runtime-new/resource_floats/intermediate.rs

@@ -0,0 +1,43 @@
+include!(env!("BINDINGS"));
+
+use exports::imports::{Float as ImportFloat1, Guest, GuestFloat};
+use exports::test::resource_floats::test::{Guest as Guest2, GuestFloat as GuestFloat2};
+
+struct Component;
+
+export!(Component);
+
+#[derive(Default)]
+pub struct MyFloat(f64);
+
+impl Guest for Component {
+    type Float = MyFloat;
+}
+
+impl GuestFloat for MyFloat {
+    fn new(v: f64) -> MyFloat {
+        MyFloat(v + 2.0)
+    }
+
+    fn get(&self) -> f64 {
+        self.0 + 4.0
+    }
+
+    fn add(a: ImportFloat1, b: f64) -> ImportFloat1 {
+        ImportFloat1::new(<MyFloat as GuestFloat>::new(a.get::<MyFloat>().0 + b + 6.0))
+    }
+}
+
+impl Guest2 for Component {
+    type Float = MyFloat;
+}
+
+impl GuestFloat2 for MyFloat {
+    fn new(v: f64) -> MyFloat {
+        MyFloat(v + 1.0)
+    }
+
+    fn get(&self) -> f64 {
+        self.0 + 3.0
+    }
+}

tests/runtime-new/resource_floats/leaf.rs

@@ -0,0 +1,14 @@
+include!(env!("BINDINGS"));
+
+use exports::Float as Float2;
+
+fn main() {
+    let float3 = add(&Float::new(42.0), &Float::new(55.0));
+    assert_eq!(float3.get(), 114.0);
+
+    let float3 = Float2::new(22.0);
+    assert_eq!(float3.get(), 22. + 1. + 2. + 4. + 3.);
+
+    let res = Float2::add(float3, 7.0);
+    assert_eq!(res.get(), 59.0);
+}

tests/runtime-new/resource_floats/runner.rs

@@ -0,0 +1,59 @@
+//@ dependencies = ['intermediate', 'leaf']
+//@ wac = 'compose.wac'
+
+package test:resource-floats;
+
+interface test {
+  resource float {
+    constructor(v: f64);
+    get: func() -> f64;
+  }
+}
+
+world leaf {
+  export test;
+
+  export imports: interface {
+    resource float {
+      constructor(v: f64);
+      get: func() -> f64;
+      add: static func(a: float, b: f64) -> float;
+    }
+  }
+}
+
+world intermediate {
+  use test.{float};
+
+  export exports: interface {
+    resource float {
+      constructor(v: f64);
+      get: func() -> f64;
+      add: static func(a: float, b: f64) -> float;
+    }
+  }
+
+  import imports: interface {
+    resource float {
+      constructor(v: f64);
+      get: func() -> f64;
+      add: static func(a: float, b: f64) -> float;
+    }
+  }
+
+  export add: func(a: borrow<float>, b: borrow<float>) -> own<float>;
+}
+
+world runner {
+  use test.{float};
+
+  import exports: interface {
+    resource float {
+      constructor(v: f64);
+      get: func() -> f64;
+      add: static func(a: float, b: f64) -> float;
+    }
+  }
+
+  import add: func(a: borrow<float>, b: borrow<float>) -> own<float>;
+}

tests/runtime-new/resource_floats/test.wit

@@ -15,7 +15,6 @@ use wit_parser::{Resolve, WorldId, WorldItem};
 
 mod flavorful;
 mod options;
-mod resource_floats;
 mod resource_with_lists;
 mod resources;
 mod results;