Migrage records test to new test framework (#1229)

Signed-off-by: James Sturtevant <jsturtevant@gmail.com>

Author: jsturtevant

crates/test-rust-wasm/Cargo.toml

@@ -12,10 +12,6 @@ rust-xcrate-test = { path = './rust-xcrate-test' }
 test = false
 doctest = false
 
-[[bin]]
-name = "records"
-test = false
-
 [[bin]]
 name = "variants"
 test = false

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

@@ -0,0 +1,60 @@
+#include <assert.h>
+#include "runner.h"
+
+int main()
+{
+    {
+        runner_tuple2_u8_u16_t ret;
+        test_records_to_test_multiple_results(&ret);
+        assert(ret.f0 == 4);
+        assert(ret.f1 == 5);
+    }
+
+    runner_tuple2_u8_u32_t input;
+    runner_tuple2_u32_u8_t output;
+    input.f0 = 1;
+    input.f1 = 2;
+    test_records_to_test_swap_tuple(&input, &output);
+    assert(output.f0 == 2);
+    assert(output.f1 == 1);
+
+    assert(test_records_to_test_roundtrip_flags1(TEST_RECORDS_TO_TEST_F1_A) == TEST_RECORDS_TO_TEST_F1_A);
+    assert(test_records_to_test_roundtrip_flags1(0) == 0);
+    assert(test_records_to_test_roundtrip_flags1(TEST_RECORDS_TO_TEST_F1_B) == TEST_RECORDS_TO_TEST_F1_B);
+    assert(test_records_to_test_roundtrip_flags1(TEST_RECORDS_TO_TEST_F1_A | TEST_RECORDS_TO_TEST_F1_B) == (TEST_RECORDS_TO_TEST_F1_A | TEST_RECORDS_TO_TEST_F1_B));
+
+    assert(test_records_to_test_roundtrip_flags2(TEST_RECORDS_TO_TEST_F2_C) == TEST_RECORDS_TO_TEST_F2_C);
+    assert(test_records_to_test_roundtrip_flags2(0) == 0);
+    assert(test_records_to_test_roundtrip_flags2(TEST_RECORDS_TO_TEST_F2_D) == TEST_RECORDS_TO_TEST_F2_D);
+    assert(test_records_to_test_roundtrip_flags2(TEST_RECORDS_TO_TEST_F2_C | TEST_RECORDS_TO_TEST_F2_E) == (TEST_RECORDS_TO_TEST_F2_C | TEST_RECORDS_TO_TEST_F2_E));
+
+    test_records_to_test_tuple3_flag8_flag16_flag32_t ret;
+    test_records_to_test_roundtrip_flags3(TEST_RECORDS_TO_TEST_FLAG8_B0, TEST_RECORDS_TO_TEST_FLAG16_B1, TEST_RECORDS_TO_TEST_FLAG32_B2,
+                                       &ret);
+    assert(ret.f0 == TEST_RECORDS_TO_TEST_FLAG8_B0);
+    assert(ret.f1 == TEST_RECORDS_TO_TEST_FLAG16_B1);
+    assert(ret.f2 == TEST_RECORDS_TO_TEST_FLAG32_B2);
+
+    {
+        test_records_to_test_r1_t a, b;
+        a.a = 8;
+        a.b = 0;
+        test_records_to_test_roundtrip_record1(&a, &b);
+        assert(b.a == 8);
+        assert(b.b == 0);
+    }
+
+    {
+        test_records_to_test_r1_t a, b;
+        a.a = 0;
+        a.b = TEST_RECORDS_TO_TEST_F1_A | TEST_RECORDS_TO_TEST_F1_B;
+        test_records_to_test_roundtrip_record1(&a, &b);
+        assert(b.a == 0);
+        assert(b.b == (TEST_RECORDS_TO_TEST_F1_A | TEST_RECORDS_TO_TEST_F1_B));
+    }
+
+    runner_tuple1_u8_t t1, t2;
+    t1.f0 = 1;
+    test_records_to_test_tuple1(&t1, &t2);
+    assert(t2.f0 == 1);
+}

tests/runtime-new/records/runner.c

@@ -0,0 +1,59 @@
+using System;
+using System.Runtime.InteropServices;
+using System.Diagnostics;
+using RunnerWorld.wit.imports.test.records;
+using RunnerWorld;
+
+public class Program {
+    public static void Main()
+    {
+        {
+                var results = ToTestInterop.MultipleResults();
+                Debug.Assert(results.Item1 == 4);
+                Debug.Assert(results.Item2 == 5);
+            }
+
+            (byte, uint) input = (1, 2);
+            (uint, byte) output = ToTestInterop.SwapTuple(input);
+            Debug.Assert(output.Item1 == 2);
+            Debug.Assert(output.Item2 == 1);
+
+            Debug.Assert(ToTestInterop.RoundtripFlags1(IToTest.F1.A) == IToTest.F1.A);
+            Debug.Assert(ToTestInterop.RoundtripFlags1(0) == 0);
+            Debug.Assert(ToTestInterop.RoundtripFlags1(IToTest.F1.B) == IToTest.F1.B);
+            Debug.Assert(ToTestInterop.RoundtripFlags1(IToTest.F1.A | IToTest.F1.B) == (IToTest.F1.A | IToTest.F1.B));
+
+            Debug.Assert(ToTestInterop.RoundtripFlags2(IToTest.F2.C) == IToTest.F2.C);
+            Debug.Assert(ToTestInterop.RoundtripFlags2(0) == 0);
+            Debug.Assert(ToTestInterop.RoundtripFlags2(IToTest.F2.D) == IToTest.F2.D);
+            Debug.Assert(ToTestInterop.RoundtripFlags2(IToTest.F2.C | IToTest.F2.E) == (IToTest.F2.C | IToTest.F2.E));
+
+            {
+                var result = ToTestInterop.RoundtripFlags3(IToTest.Flag8.B0, IToTest.Flag16.B1,
+                    IToTest.Flag32.B2);
+                Debug.Assert(result.Item1 == IToTest.Flag8.B0);
+                Debug.Assert(result.Item2 == IToTest.Flag16.B1);
+                Debug.Assert(result.Item3 == IToTest.Flag32.B2);
+            }
+
+            {
+                IToTest.R1 inputRecord = new(8, 0);
+                var result = ToTestInterop.RoundtripRecord1(inputRecord);
+                Debug.Assert(result.a == 8);
+                Debug.Assert(result.b == 0);
+            }
+
+            {
+                IToTest.R1 inputRecord = new(0, IToTest.F1.A | IToTest.F1.B);
+
+                var result = ToTestInterop.RoundtripRecord1(inputRecord);
+                Debug.Assert(result.a == 0);
+                Debug.Assert(result.b == (IToTest.F1.A | IToTest.F1.B));
+            }
+
+            {
+                var result = ToTestInterop.Tuple1(1);
+                Debug.Assert(result == 1);
+            }
+    }
+}

tests/runtime-new/records/runner.cs

@@ -0,0 +1,39 @@
+include!(env!("BINDINGS"));
+
+use crate::test::records::to_test::*;
+
+fn main() {
+    assert_eq!(multiple_results(), (4, 5));
+
+    assert_eq!(swap_tuple((1u8, 2u32)), (2u32, 1u8));
+    assert_eq!(roundtrip_flags1(F1::A), F1::A);
+    assert_eq!(roundtrip_flags1(F1::empty()), F1::empty());
+    assert_eq!(roundtrip_flags1(F1::B), F1::B);
+    assert_eq!(roundtrip_flags1(F1::A | F1::B), F1::A | F1::B);
+
+    assert_eq!(roundtrip_flags2(F2::C), F2::C);
+    assert_eq!(roundtrip_flags2(F2::empty()), F2::empty());
+    assert_eq!(roundtrip_flags2(F2::D), F2::D);
+    assert_eq!(roundtrip_flags2(F2::C | F2::E), F2::C | F2::E);
+
+    assert_eq!(
+        roundtrip_flags3(Flag8::B0, Flag16::B1, Flag32::B2),
+        (Flag8::B0, Flag16::B1, Flag32::B2)
+    );
+
+    let r = roundtrip_record1(R1 {
+        a: 8,
+        b: F1::empty(),
+    });
+    assert_eq!(r.a, 8);
+    assert_eq!(r.b, F1::empty());
+
+    let r = roundtrip_record1(R1 {
+        a: 0,
+        b: F1::A | F1::B,
+    });
+    assert_eq!(r.a, 0);
+    assert_eq!(r.b, F1::A | F1::B);
+
+    assert_eq!(tuple1((1,)), (1,));
+}

tests/runtime-new/records/runner.rs

@@ -0,0 +1,39 @@
+#include <assert.h>
+#include "test.h"
+
+void exports_test_records_to_test_multiple_results(test_tuple2_u8_u16_t *ret) {
+    ret->f0 = 4;
+    ret->f1 = 5;
+  }
+  
+  void exports_test_records_to_test_swap_tuple(test_tuple2_u8_u32_t *a, test_tuple2_u32_u8_t *b) {
+    b->f0 = a->f1;
+    b->f1 = a->f0;
+  }
+  
+  exports_test_records_to_test_f1_t exports_test_records_to_test_roundtrip_flags1(exports_test_records_to_test_f1_t a) {
+    return a;
+  }
+  
+  exports_test_records_to_test_f2_t exports_test_records_to_test_roundtrip_flags2(exports_test_records_to_test_f2_t a) {
+    return a;
+  }
+  
+  void exports_test_records_to_test_roundtrip_flags3(
+        exports_test_records_to_test_flag8_t a,
+        exports_test_records_to_test_flag16_t b,
+        exports_test_records_to_test_flag32_t c,
+        exports_test_records_to_test_tuple3_flag8_flag16_flag32_t *ret) {
+    ret->f0 = a;
+    ret->f1 = b;
+    ret->f2 = c;
+  }
+  
+  void exports_test_records_to_test_roundtrip_record1(exports_test_records_to_test_r1_t *a, exports_test_records_to_test_r1_t *ret0) {
+    *ret0 = *a;
+  }
+  
+  void exports_test_records_to_test_tuple1(test_tuple1_u8_t *a, test_tuple1_u8_t *b) {
+    b->f0 = a->f0;
+  }
+  

tests/runtime-new/records/test.c

@@ -0,0 +1,48 @@
+namespace TestWorld.wit.exports.test.records
+{
+    public class ToTestImpl : ITestWorld
+    {
+        public static (byte, ushort) MultipleResults()
+        {
+            return (4, 5);
+        }
+
+        public static (uint, byte) SwapTuple((byte, uint) a)
+        {
+            return (a.Item2, a.Item1);
+        }
+
+        public static IToTest.F1 RoundtripFlags1(
+            IToTest.F1 a)
+        {
+            return a;
+        }
+
+        public static IToTest.F2 RoundtripFlags2(
+            IToTest.F2 a)
+        {
+            return a;
+        }
+
+        public static (IToTest.Flag8,
+            IToTest.Flag16,
+            IToTest.Flag32) RoundtripFlags3(
+                IToTest.Flag8 a,
+                IToTest.Flag16 b,
+                IToTest.Flag32 c)
+        {
+            return (a, b, c);
+        }
+
+        public static IToTest.R1 RoundtripRecord1(
+            IToTest.R1 a)
+        {
+            return a;
+        }
+
+        public static byte Tuple1(byte a)
+        {
+            return a;
+        }
+    }
+}

tests/runtime-new/records/test.cs

@@ -0,0 +1,37 @@
+include!(env!("BINDINGS"));
+
+use crate::exports::test::records::to_test::*;
+
+pub struct Test {}
+
+export!(Test);
+
+impl Guest for Test {
+    fn multiple_results() -> (u8, u16) {
+        (4, 5)
+    }
+
+    fn swap_tuple(a: (u8, u32)) -> (u32, u8) {
+        (a.1, a.0)
+    }
+
+    fn roundtrip_flags1(a: F1) -> F1 {
+        a
+    }
+
+    fn roundtrip_flags2(a: F2) -> F2 {
+        a
+    }
+
+    fn roundtrip_flags3(a: Flag8, b: Flag16, c: Flag32) -> (Flag8, Flag16, Flag32) {
+        (a, b, c)
+    }
+
+    fn roundtrip_record1(a: R1) -> R1 {
+        a
+    }
+
+    fn tuple1(a: (u8,)) -> (u8,) {
+        (a.0,)
+    }
+}

tests/runtime-new/records/test.rs

@@ -1,6 +1,6 @@
 package test:records;
 
-interface test {
+interface to-test {
   multiple-results: func() -> tuple<u8, u16>;
 
   swap-tuple: func(a: tuple<u8, u32>) -> tuple<u32, u8>;
@@ -37,9 +37,10 @@ interface test {
   tuple1: func(a: tuple<u8>) -> tuple<u8>;
 }
 
-world records {
-  import test;
-  export test;
+world test {
+  export to-test;
+}
 
-  export test-imports: func();
+world runner {
+  import to-test;
 }

tests/runtime/records/world.wit tests/runtime-new/records/test.wittests/runtime/records/world.wit renamed to tests/runtime-new/records/test.wit

@@ -16,7 +16,6 @@ use wit_parser::{Resolve, WorldId, WorldItem};
 mod flavorful;
 mod options;
 mod ownership;
-mod records;
 mod resource_alias;
 mod resource_alias_redux;
 mod resource_borrow_export;