runtime tests up through lists

Author: QuantumSegfault

tests/runtime/fixed-length-lists/test.d

@@ -19,13 +19,13 @@ void listParam3(in int[20] a) {
 
 @witExport("test:fixed-length-lists/to-test", "list-minmax16")
 Tuple!(ushort[4], short[4]) listMinmax16(in ushort[4] a, in short[4] b) {
-    return Tuple!(ushort[4], short[4])(a, b);
+    return tuple(a, b);
 }
 
 
 @witExport("test:fixed-length-lists/to-test", "list-minmax-float")
 Tuple!(float[2], double[2]) listMinmaxFloat(in float[2] a, in double[2] b) {
-    return Tuple!(float[2], double[2])(a, b);
+    return tuple(a, b);
 }
 
 @witExport("test:fixed-length-lists/to-test", "list-roundtrip")
@@ -36,12 +36,12 @@ ubyte[8] listResult() => ['0', '1', 'A', 'B', 'a', 'b', 128, 255];
 
 @witExport("test:fixed-length-lists/to-test", "nested-roundtrip")
 Tuple!(uint[2][2], int[2][2]) nestedRoundtrip(in uint[2][2] a, in int[2][2] b) {
-    return Tuple!(uint[2][2], int[2][2])(a, b);
+    return tuple(a, b);
 }
 
 @witExport("test:fixed-length-lists/to-test", "large-roundtrip")
 Tuple!(uint[2][2], int[4][4]) largeRoundtrip(in uint[2][2] a, in int[4][4] b) {
-    return Tuple!(uint[2][2], int[4][4])(a, b);
+    return tuple(a, b);
 }
 
 @witExport("test:fixed-length-lists/to-test", "nightmare-on-cpp")

tests/runtime/flavorful/test.d

@@ -63,10 +63,10 @@ Tuple!(ListTypedef2, ListTypedef3) listTypedefs(in ListTypedef a, in ListTypedef
         cast(WitString)"typedef4".witList
     ];
 
-    return (const Tuple!(ListTypedef2, ListTypedef3)(
+    return tuple(
         (cast(immutable ubyte[])"typedef3").witList,
         strings[].witList
-    )).witClone;
+    ).witClone;
 }
 
 
@@ -85,11 +85,11 @@ Tuple!(WitList!bool, WitList!(Result!()), WitList!MyErrno) listOfVariants(in Wit
     static immutable bool[] boolsOut = [false, true];
     static immutable Result!(void)[] resultsOut = [Result!().err, Result!().ok];
     static immutable MyErrno[] enumsOut = [MyErrno.a, MyErrno.b];
-    return (const Tuple!(WitList!bool, WitList!(Result!()), WitList!MyErrno)(
+    return tuple(
         boolsOut.witList,
         resultsOut.witList,
         enumsOut.witList
-    )).witClone;
+    ).witClone;
 }
 
 alias Exports = wit.test.flavorful.test.Exports!(

tests/runtime/gated-features/runner.d

@@ -0,0 +1,14 @@
+//@ args = '--features y'
+
+import wit.foo.bar.runner;
+import wit.common;
+
+@witExport("$root", "run")
+void run() {
+    y();
+    z();
+}
+
+alias Exports = wit.foo.bar.runner.Exports!(
+    run
+);

tests/runtime/gated-features/test.d

@@ -0,0 +1,15 @@
+//@ args = '--features y'
+
+import wit.foo.bar.test;
+import wit.common;
+
+@witExport("foo:bar/bindings@1.2.3", "y")
+void y() {}
+
+@witExport("foo:bar/bindings@1.2.3", "z")
+void z() {}
+
+alias Exports = wit.foo.bar.test.Exports!(
+    y,
+    z
+);

tests/runtime/list-in-variant/runner.d

@@ -0,0 +1,88 @@
+import wit.test.list_in_variant.runner;
+import wit.common;
+
+@witExport("$root", "run")
+void run() {
+    const WitString[2] hw = ["hello".witList, "world".witList];
+    {
+        auto result = listInOption(some(hw[].witList));
+        scope(exit) result.witFree;
+
+        assert(result == "hello,world");
+    }
+    {
+        auto result = listInOption(none!(WitList!WitString));
+        scope(exit) result.witFree;
+
+        assert(result == "none");
+    }
+
+    const WitString[3] fbb_data = ["foo".witList, "bar".witList, "baz".witList];
+    auto fbb = PayloadOrEmpty.withData(fbb_data.witList);
+    {
+        auto result = listInVariant(fbb);
+        scope(exit) result.witFree;
+
+        assert(result == "foo,bar,baz");
+    }
+    {
+        auto result = listInVariant(PayloadOrEmpty.empty);
+        scope(exit) result.witFree;
+
+        assert(result == "empty");
+    }
+
+    const WitString[3] abc = ["a".witList, "b".witList, "c".witList];
+    {
+        auto result = listInResult(Result!(WitList!WitString, WitString).ok(abc[].witList));
+        scope(exit) result.witFree;
+
+        assert(result == "a,b,c");
+    }
+    {
+        auto result = listInResult(Result!(WitList!WitString, WitString).err("oops".witList));
+        scope(exit) result.witFree;
+
+        assert(result == "err:oops");
+    }
+
+    const WitString[2] hw2 = ["hello".witList, "world".witList];
+    auto s1 = listInOptionWithReturn(some(hw2.witList));
+    {
+        auto result = s1.count;
+        scope(exit) result.witFree;
+
+        assert(result == 2);
+    }
+    {
+        auto result = s1.label;
+        scope(exit) result.witFree;
+
+        assert(result == "hello,world");
+    }
+    auto s2 = listInOptionWithReturn(none!(WitList!WitString));
+    {
+        auto result = s2.count;
+        scope(exit) result.witFree;
+
+        assert(result == 0);
+    }
+    {
+        auto result = s2.label;
+        scope(exit) result.witFree;
+
+        assert(result == "none");
+    }
+
+    const WitString[3] xyz = ["x".witList, "y".witList, "z".witList];
+    {
+        auto result = topLevelList(xyz.witList);
+        scope(exit) result.witFree;
+
+        assert(result == "x,y,z");
+    }
+}
+
+alias Exports = wit.test.list_in_variant.runner.Exports!(
+    run
+);

tests/runtime/list-in-variant/test.d

@@ -0,0 +1,94 @@
+import wit.test.list_in_variant.test;
+import wit.common;
+
+// Allocates directly with `malloc`, so no witClone needed.
+extern(C) void* malloc(size_t size);
+
+char[] commaJoin(in WitString[] strs) {
+    if (strs.length == 0) return null;
+
+    size_t total = 0;
+    foreach (i, str; strs) {
+        total += str.length;
+
+        if (i+1 != strs.length) {
+            total += 1; // comma
+        }
+    }
+
+    void* ptr = malloc(total);
+    assert(ptr);
+    char[] chars = cast(char[])ptr[0..total];
+
+    size_t cursor = 0;
+    foreach (i, str; strs) {
+        foreach (chr; str) {
+            chars[cursor++] = chr;
+        }
+
+        if (i+1 != strs.length) {
+            chars[cursor++] = ',';
+        }
+    }
+
+    return chars;
+}
+
+@witExport("test:list-in-variant/to-test", "list-in-option")
+WitString listInOption(in Option!(WitList!WitString) data) {
+    if (data.isSome) {
+        return data.unwrap.commaJoin.witList; // no clone
+    }
+    return "none".witList.witClone;
+}
+
+@witExport("test:list-in-variant/to-test", "list-in-variant")
+WitString listInVariant(in PayloadOrEmpty data) {
+    if (data.isWithData) {
+        return data.getWithData.commaJoin.witList; // no clone
+    }
+    return "empty".witList.witClone;
+}
+
+@witExport("test:list-in-variant/to-test", "list-in-result")
+WitString listInResult(in Result!(WitList!WitString, WitString) data) {
+    if (data.isOk) {
+        return data.unwrap.commaJoin.witList;
+    }
+
+
+    auto errStr = data.unwrapErr;
+    void* ptr = malloc(errStr.length+4);
+    assert(ptr);
+    char[] chars = cast(char[])ptr[0..errStr.length+4];
+
+    chars[0..4] = "err:";
+    foreach (i, ref chr; chars[4..$]) {
+        chr = errStr[i];
+    }
+
+    return chars.witList; // no clone
+}
+
+@witExport("test:list-in-variant/to-test", "list-in-option-with-return")
+Summary listInOptionWithReturn(in Option!(WitList!WitString) data) {
+    if (data.isSome) {
+        auto items = data.unwrap();
+        return Summary(items.length, items.commaJoin.witList); // no clone
+    }
+
+    return Summary(0, "none".witList.witClone);
+}
+
+@witExport("test:list-in-variant/to-test", "top-level-list")
+WitString topLevelList(in WitList!WitString data) {
+    return data.commaJoin.witList; // no clone
+}
+
+alias Exports = wit.test.list_in_variant.test.Exports!(
+    listInOption,
+    listInVariant,
+    listInResult,
+    listInOptionWithReturn,
+    topLevelList
+);