migrate variants test to new test framework (#1239)

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 = "variants"
-test = false
-
 [[bin]]
 name = "flavorful"
 test = false

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

@@ -0,0 +1,135 @@
+#include <assert.h>
+#include <runner.h>
+#include <stddef.h>
+
+int main() {
+    {
+        float a = 1;
+        uint8_t r;
+        assert(test_variants_to_test_roundtrip_option(&a, &r) && r == 1);
+        assert(!test_variants_to_test_roundtrip_option(NULL, &r));
+        a = 2;
+        assert(test_variants_to_test_roundtrip_option(&a, &r) && r == 2);
+    }
+
+    {
+        test_variants_to_test_result_u32_f32_t a;
+        double b_ok;
+        uint8_t b_err;
+
+        a.is_err = false;
+        a.val.ok = 2;
+        assert(test_variants_to_test_roundtrip_result(&a, &b_ok, &b_err));
+        assert(b_ok == 2.0);
+
+        a.val.ok = 4;
+        assert(test_variants_to_test_roundtrip_result(&a, &b_ok, &b_err));
+        assert(b_ok == 4);
+
+        a.is_err = true;
+        a.val.err = 5.3;
+        assert(!test_variants_to_test_roundtrip_result(&a, &b_ok, &b_err));
+        assert(b_err == 5);
+    }
+
+    assert(test_variants_to_test_roundtrip_enum(TEST_VARIANTS_TO_TEST_E1_A) == TEST_VARIANTS_TO_TEST_E1_A);
+    assert(test_variants_to_test_roundtrip_enum(TEST_VARIANTS_TO_TEST_E1_B) == TEST_VARIANTS_TO_TEST_E1_B);
+
+    assert(test_variants_to_test_invert_bool(true) == false);
+    assert(test_variants_to_test_invert_bool(false) == true);
+
+    {
+        test_variants_to_test_casts_t c, ret;
+        c.f0.tag = TEST_VARIANTS_TO_TEST_C1_A;
+        c.f0.val.a = 1;
+        c.f1.tag = TEST_VARIANTS_TO_TEST_C2_A;
+        c.f1.val.a = 2;
+        c.f2.tag = TEST_VARIANTS_TO_TEST_C3_A;
+        c.f2.val.a = 3;
+        c.f3.tag = TEST_VARIANTS_TO_TEST_C4_A;
+        c.f3.val.a = 4;
+        c.f4.tag = TEST_VARIANTS_TO_TEST_C5_A;
+        c.f4.val.a = 5;
+        c.f5.tag = TEST_VARIANTS_TO_TEST_C6_A;
+        c.f5.val.a = 6;
+        test_variants_to_test_variant_casts(&c, &ret);
+        assert(ret.f0.tag == TEST_VARIANTS_TO_TEST_C1_A && ret.f0.val.a == 1);
+        assert(ret.f1.tag == TEST_VARIANTS_TO_TEST_C2_A && ret.f1.val.a == 2);
+        assert(ret.f2.tag == TEST_VARIANTS_TO_TEST_C3_A && ret.f2.val.a == 3);
+        assert(ret.f3.tag == TEST_VARIANTS_TO_TEST_C4_A && ret.f3.val.a == 4);
+        assert(ret.f4.tag == TEST_VARIANTS_TO_TEST_C5_A && ret.f4.val.a == 5);
+        assert(ret.f5.tag == TEST_VARIANTS_TO_TEST_C6_A && ret.f5.val.a == 6);
+    }
+
+    {
+        test_variants_to_test_casts_t c, ret;
+        c.f0.tag = TEST_VARIANTS_TO_TEST_C1_B;
+        c.f0.val.b = 1;
+        c.f1.tag = TEST_VARIANTS_TO_TEST_C2_B;
+        c.f1.val.b = 2;
+        c.f2.tag = TEST_VARIANTS_TO_TEST_C3_B;
+        c.f2.val.b = 3;
+        c.f3.tag = TEST_VARIANTS_TO_TEST_C4_B;
+        c.f3.val.b = 4;
+        c.f4.tag = TEST_VARIANTS_TO_TEST_C5_B;
+        c.f4.val.b = 5;
+        c.f5.tag = TEST_VARIANTS_TO_TEST_C6_B;
+        c.f5.val.b = 6;
+        test_variants_to_test_variant_casts(&c, &ret);
+        assert(ret.f0.tag == TEST_VARIANTS_TO_TEST_C1_B && ret.f0.val.b == 1);
+        assert(ret.f1.tag == TEST_VARIANTS_TO_TEST_C2_B && ret.f1.val.b == 2);
+        assert(ret.f2.tag == TEST_VARIANTS_TO_TEST_C3_B && ret.f2.val.b == 3);
+        assert(ret.f3.tag == TEST_VARIANTS_TO_TEST_C4_B && ret.f3.val.b == 4);
+        assert(ret.f4.tag == TEST_VARIANTS_TO_TEST_C5_B && ret.f4.val.b == 5);
+        assert(ret.f5.tag == TEST_VARIANTS_TO_TEST_C6_B && ret.f5.val.b == 6);
+    }
+
+    {
+        test_variants_to_test_zeros_t c, ret;
+        c.f0.tag = TEST_VARIANTS_TO_TEST_Z1_A;
+        c.f0.val.a = 1;
+        c.f1.tag = TEST_VARIANTS_TO_TEST_Z2_A;
+        c.f1.val.a = 2;
+        c.f2.tag = TEST_VARIANTS_TO_TEST_Z3_A;
+        c.f2.val.a = 3;
+        c.f3.tag = TEST_VARIANTS_TO_TEST_Z4_A;
+        c.f3.val.a = 4;
+        test_variants_to_test_variant_zeros(&c, &ret);
+        assert(ret.f0.tag == TEST_VARIANTS_TO_TEST_Z1_A && ret.f0.val.a == 1);
+        assert(ret.f1.tag == TEST_VARIANTS_TO_TEST_Z2_A && ret.f1.val.a == 2);
+        assert(ret.f2.tag == TEST_VARIANTS_TO_TEST_Z3_A && ret.f2.val.a == 3);
+        assert(ret.f3.tag == TEST_VARIANTS_TO_TEST_Z4_A && ret.f3.val.a == 4);
+    }
+
+    {
+        test_variants_to_test_zeros_t c, ret;
+        c.f0.tag = TEST_VARIANTS_TO_TEST_Z1_B;
+        c.f1.tag = TEST_VARIANTS_TO_TEST_Z2_B;
+        c.f2.tag = TEST_VARIANTS_TO_TEST_Z3_B;
+        c.f3.tag = TEST_VARIANTS_TO_TEST_Z4_B;
+        test_variants_to_test_variant_zeros(&c, &ret);
+        assert(ret.f0.tag == TEST_VARIANTS_TO_TEST_Z1_B);
+        assert(ret.f1.tag == TEST_VARIANTS_TO_TEST_Z2_B);
+        assert(ret.f2.tag == TEST_VARIANTS_TO_TEST_Z3_B);
+        assert(ret.f3.tag == TEST_VARIANTS_TO_TEST_Z4_B);
+    }
+
+    {
+        bool b = false;
+        test_variants_to_test_result_typedef_t c;
+        c.is_err = true;
+        test_variants_to_test_variant_typedefs(NULL, b, &c);
+    }
+
+    {
+        test_variants_to_test_tuple3_bool_result_void_void_my_errno_t ret;
+        test_variants_to_test_result_void_void_t b;
+        b.is_err = false;
+        test_variants_to_test_variant_enums(true, &b, TEST_VARIANTS_TO_TEST_MY_ERRNO_SUCCESS, &ret);
+        assert(ret.f0 == true);
+        assert(!ret.f1.is_err);
+        assert(ret.f2 == TEST_VARIANTS_TO_TEST_MY_ERRNO_SUCCESS);
+    }
+
+    return 0;
+}

tests/runtime-new/variants/runner.c

@@ -0,0 +1,74 @@
+using System;
+using System.Runtime.InteropServices;
+using System.Diagnostics;
+using RunnerWorld.wit.imports.test.variants;
+using System.Text;
+using RunnerWorld;
+
+public class Program
+{
+    public static void Main(string[] args)
+    {
+        Debug.Assert(ToTestInterop.RoundtripOption(1.0f).Value == 1);
+        Debug.Assert(ToTestInterop.RoundtripOption(null).HasValue == false);
+        Debug.Assert(ToTestInterop.RoundtripOption(2.0f).Value == 2);
+
+        Debug.Assert(ToTestInterop.RoundtripResult(Result<uint, float>.Ok(2)) == 2.0);
+        Debug.Assert(ToTestInterop.RoundtripResult(Result<uint, float>.Ok(4)) == 4.0);
+        try
+        {
+            ToTestInterop.RoundtripResult(Result<uint, float>.Err(5.3f));
+            throw new Exception();
+        }
+        catch (WitException e)
+        {
+            Debug.Assert((byte)e.Value == 5);
+        }
+
+        Debug.Assert(ToTestInterop.RoundtripEnum(IToTest.E1.A) == IToTest.E1.A);
+        Debug.Assert(ToTestInterop.RoundtripEnum(IToTest.E1.B) == IToTest.E1.B);
+
+        Debug.Assert(ToTestInterop.InvertBool(true) == false);
+        Debug.Assert(ToTestInterop.InvertBool(false) == true);
+
+        var (a1, a2, a3, a4, a5, a6) =
+        ToTestInterop.VariantCasts((IToTest.C1.A(1), IToTest.C2.A(2), IToTest.C3.A(3), IToTest.C4.A(4), IToTest.C5.A(5), IToTest.C6.A(6.0f)));
+        Debug.Assert(a1.AsA == 1);
+        Debug.Assert(a2.AsA == 2);
+        Debug.Assert(a3.AsA == 3);
+        Debug.Assert(a4.AsA == 4);
+        Debug.Assert(a5.AsA == 5);
+        Debug.Assert(a6.AsA == 6.0f);
+
+        var (b1, b2, b3, b4, b5, b6) =
+ToTestInterop.VariantCasts((IToTest.C1.B(1), IToTest.C2.B(2), IToTest.C3.B(3), IToTest.C4.B(4), IToTest.C5.B(5), IToTest.C6.B(6.0)));
+        Debug.Assert(b1.AsB == 1);
+        Debug.Assert(b2.AsB == 2.0f);
+        Debug.Assert(b3.AsB == 3.0f);
+        Debug.Assert(b4.AsB == 4.0f);
+        Debug.Assert(b5.AsB == 5.0f);
+        Debug.Assert(b6.AsB == 6.0);
+
+        var (za1, za2, za3, za4) =
+ToTestInterop.VariantZeros((IToTest.Z1.A(1), IToTest.Z2.A(2), IToTest.Z3.A(3.0f), IToTest.Z4.A(4.0f)));
+        Debug.Assert(za1.AsA == 1);
+        Debug.Assert(za2.AsA == 2);
+        Debug.Assert(za3.AsA == 3.0f);
+        Debug.Assert(za4.AsA == 4.0f);
+
+        var (zb1, zb2, zb3, zb4) =
+ToTestInterop.VariantZeros((IToTest.Z1.B(), IToTest.Z2.B(), IToTest.Z3.B(), IToTest.Z4.B()));
+        //TODO: Add comparison operator to variants and None
+        //Debug.Assert(zb1.AsB == IToTest.Z1.b());
+        //Debug.Assert(zb2.AsB == IToTest.Z2.b());
+        //Debug.Assert(zb3.AsB == IToTest.Z3.b());
+        //Debug.Assert(zb4.AsB == IToTest.Z4.b());
+
+        ToTestInterop.VariantTypedefs(null, false, Result<uint, None>.Err(new None()));
+
+        var (a, b, c) = ToTestInterop.VariantEnums(true, Result<None, None>.Ok(new None()), IToTest.MyErrno.SUCCESS);
+        Debug.Assert(a == true);
+        var test = b.AsOk;
+        Debug.Assert(c == IToTest.MyErrno.SUCCESS);
+    }
+}

tests/runtime-new/variants/runner.cs

@@ -0,0 +1,61 @@
+include!(env!("BINDINGS"));
+
+use crate::test::variants::to_test::*;
+
+fn main() {
+    assert_eq!(roundtrip_option(Some(1.0)), Some(1));
+    assert_eq!(roundtrip_option(None), None);
+    assert_eq!(roundtrip_option(Some(2.0)), Some(2));
+    assert_eq!(roundtrip_result(Ok(2)), Ok(2.0));
+    assert_eq!(roundtrip_result(Ok(4)), Ok(4.0));
+    assert_eq!(roundtrip_result(Err(5.3)), Err(5));
+
+    assert_eq!(roundtrip_enum(E1::A), E1::A);
+    assert_eq!(roundtrip_enum(E1::B), E1::B);
+
+    assert_eq!(invert_bool(true), false);
+    assert_eq!(invert_bool(false), true);
+
+    let (a1, a2, a3, a4, a5, a6) =
+        variant_casts((C1::A(1), C2::A(2), C3::A(3), C4::A(4), C5::A(5), C6::A(6.0)));
+    assert!(matches!(a1, C1::A(1)));
+    assert!(matches!(a2, C2::A(2)));
+    assert!(matches!(a3, C3::A(3)));
+    assert!(matches!(a4, C4::A(4)));
+    assert!(matches!(a5, C5::A(5)));
+    assert!(matches!(a6, C6::A(b) if b == 6.0));
+
+    let (a1, a2, a3, a4, a5, a6) = variant_casts((
+        C1::B(1),
+        C2::B(2.0),
+        C3::B(3.0),
+        C4::B(4.0),
+        C5::B(5.0),
+        C6::B(6.0),
+    ));
+    assert!(matches!(a1, C1::B(1)));
+    assert!(matches!(a2, C2::B(b) if b == 2.0));
+    assert!(matches!(a3, C3::B(b) if b == 3.0));
+    assert!(matches!(a4, C4::B(b) if b == 4.0));
+    assert!(matches!(a5, C5::B(b) if b == 5.0));
+    assert!(matches!(a6, C6::B(b) if b == 6.0));
+
+    let (a1, a2, a3, a4) = variant_zeros((Z1::A(1), Z2::A(2), Z3::A(3.0), Z4::A(4.0)));
+    assert!(matches!(a1, Z1::A(1)));
+    assert!(matches!(a2, Z2::A(2)));
+    assert!(matches!(a3, Z3::A(b) if b == 3.0));
+    assert!(matches!(a4, Z4::A(b) if b == 4.0));
+
+    let (a1, a2, a3, a4) = variant_zeros((Z1::B, Z2::B, Z3::B, Z4::B));
+    assert!(matches!(a1, Z1::B));
+    assert!(matches!(a2, Z2::B));
+    assert!(matches!(a3, Z3::B));
+    assert!(matches!(a4, Z4::B));
+
+    variant_typedefs(None, false, Err(()));
+
+    assert_eq!(
+        variant_enums(true, Ok(()), MyErrno::Success),
+        (true, Ok(()), MyErrno::Success)
+    );
+}

tests/runtime-new/variants/runner.rs

@@ -0,0 +1,49 @@
+#include <assert.h>
+#include <test.h>
+#include <stddef.h>
+
+bool exports_test_variants_to_test_roundtrip_option(float *a, uint8_t *ret0) {
+    if (a) {
+        *ret0 = *a;
+    }
+    return a != NULL;
+}
+
+bool exports_test_variants_to_test_roundtrip_result(exports_test_variants_to_test_result_u32_f32_t *a, double *ok, uint8_t *err) {
+    if (a->is_err) {
+        *err = a->val.err;
+        return false;
+    } else {
+        *ok = a->val.ok;
+        return true;
+    }
+}
+
+exports_test_variants_to_test_e1_t exports_test_variants_to_test_roundtrip_enum(exports_test_variants_to_test_e1_t a) {
+    return a;
+}
+
+bool exports_test_variants_to_test_invert_bool(bool a) {
+    return !a;
+}
+
+void exports_test_variants_to_test_variant_casts(exports_test_variants_to_test_casts_t *a, exports_test_variants_to_test_casts_t *ret) {
+    *ret = *a;
+}
+
+void exports_test_variants_to_test_variant_zeros(exports_test_variants_to_test_zeros_t *a, exports_test_variants_to_test_zeros_t *b) {
+    *b = *a;
+}
+
+void exports_test_variants_to_test_variant_typedefs(uint32_t *a, exports_test_variants_to_test_bool_typedef_t b, exports_test_variants_to_test_result_typedef_t *c) {
+}
+
+void exports_test_variants_to_test_variant_enums(
+    bool a,
+    exports_test_variants_to_test_result_void_void_t *b,
+    exports_test_variants_to_test_my_errno_t c,
+    exports_test_variants_to_test_tuple3_bool_result_void_void_my_errno_t *ret) {
+    ret->f0 = a;
+    ret->f1 = *b;
+    ret->f2 = c;
+}

tests/runtime-new/variants/test.c

@@ -0,0 +1,49 @@
+namespace TestWorld.wit.exports.test.variants
+{
+    public class ToTestImpl : ITestWorld
+    {
+        public static byte? RoundtripOption(float? a)
+        {
+            return a is null ? null : (byte)a;
+        }
+
+        public static double RoundtripResult(Result<uint, float> a)
+        {
+            switch (a.Tag)
+            {
+                case Result<double, byte>.Tags.Ok: return (double)a.AsOk;
+                case Result<double, byte>.Tags.Err: throw new WitException((byte)a.AsErr, 0);
+                default: throw new ArgumentException();
+            }
+        }
+
+        public static IToTest.E1 RoundtripEnum(IToTest.E1 a)
+        {
+            return a;
+        }
+
+        public static bool InvertBool(bool a)
+        {
+            return !a;
+        }
+
+        public static (IToTest.C1, IToTest.C2, IToTest.C3, IToTest.C4, IToTest.C5, IToTest.C6)
+            VariantCasts((IToTest.C1, IToTest.C2, IToTest.C3, IToTest.C4, IToTest.C5, IToTest.C6) a)
+        {
+            return a;
+        }
+
+        public static (bool, Result<None, None>, IToTest.MyErrno)
+            VariantEnums(bool a, Result<None, None> b, IToTest.MyErrno c)
+        {
+            return new(a, b, c);
+        }
+
+        public static void VariantTypedefs(uint? a, bool b, Result<uint, None> c) { }
+
+        public static (IToTest.Z1, IToTest.Z2, IToTest.Z3, IToTest.Z4) VariantZeros((IToTest.Z1, IToTest.Z2, IToTest.Z3, IToTest.Z4) a)
+        {
+            return a;
+        }
+    }
+}