Remaining non-resource tests

Author: QuantumSegfault

crates/d/src/wit_common.d

@@ -166,6 +166,19 @@ public:
     T unwrapOrElse(D)(scope D fallback)
     if (is(D R == return) && is(R : T) && is(D == __parameters))
     { return _present ? _value : fallback(); }
+
+    bool opEquals(in Option rhs) const {
+        if (isSome != rhs.isSome) return false;
+
+        if (isSome) return unwrap == rhs.unwrap;
+        else return true;
+    }
+
+    size_t toHash() const @safe pure nothrow
+    {
+        if (isSome) return this.unwrap.hashOf(true.hashOf);
+        return false.hashOf;
+    }
 }
 
 auto some(T)(inout T value) @safe @nogc nothrow {
@@ -240,6 +253,29 @@ public:
         ref inout(E) unwrapErr() inout @trusted @nogc nothrow return
         in (isErr) do { return _storage.error; }
     }
+
+    bool opEquals(in Result rhs) const {
+        if (isErr != rhs.isErr) return false;
+
+        if (isErr) {
+            static if (!is(E == void)) return unwrapErr == rhs.unwrapErr;
+            else return true;
+        }
+
+        static if (!is(T == void)) return unwrap == rhs.unwrap;
+        else return true;
+    }
+
+    size_t toHash() const @safe pure nothrow
+    {
+        if (isErr) {
+            static if (!is(E == void)) return this.unwrapErr.hashOf(true.hashOf);
+            return true.hashOf;
+        }
+
+        static if (!is(T == void)) return this.unwrap.hashOf(false.hashOf);
+        else return false.hashOf;
+    }
 }
 
 auto ok(E, T)(inout T value) @safe @nogc nothrow {

tests/runtime/common-types/leaf.d

@@ -2,7 +2,7 @@ import wit.test.common.leaf;
 import wit.common;
 
 @witExport("test:common/to-test", "wrap")
-R1 wrap(in F1 flag) {
+R1 wrap(F1 flag) {
     switch (flag.bits) with (F1) {
         case a.bits:
             return R1(1, flag);

tests/runtime/common-types/middle.d

@@ -4,7 +4,7 @@ import wit.common;
 import imps = wit.test.common.to_test.imports;
 
 @witExport("test:common/to-test", "wrap")
-R1 wrap(in F1 flag) {
+R1 wrap(F1 flag) {
     return imps.wrap(flag);
 }
 

tests/runtime/results/intermediate.d

@@ -0,0 +1,43 @@
+import wit.test.results.intermediate;
+import imports = wit.test.results.test.imports;
+
+import wit.common;
+
+@witExport("test:results/test", "string-error")
+Result!(float, WitString) stringError(float a) {
+    return imports.stringError(a);
+}
+
+@witExport("test:results/test", "enum-error")
+Result!(float, E) enumError(float a) {
+    return imports.enumError(a);
+}
+
+@witExport("test:results/test", "record-error")
+Result!(float, E2) recordError(float a) {
+    return imports.recordError(a);
+}
+
+@witExport("test:results/test", "variant-error")
+Result!(float, E3) variantError(float a) {
+    return imports.variantError(a);
+}
+
+@witExport("test:results/test", "empty-error")
+Result!(uint, void) emptyError(uint a) {
+    return imports.emptyError(a);
+}
+
+@witExport("test:results/test", "double-error")
+Result!(Result!(void, WitString), WitString) doubleError(uint a) {
+    return imports.doubleError(a);
+}
+
+alias Exports = wit.test.results.intermediate.Exports!(
+    stringError,
+    enumError,
+    recordError,
+    variantError,
+    emptyError,
+    doubleError
+);

tests/runtime/results/leaf.d

@@ -0,0 +1,85 @@
+import wit.test.results.leaf;
+
+import wit.common;
+
+@witExport("test:results/test", "string-error")
+Result!(float, WitString) stringError(float a) {
+    if (a == 0.0) {
+        return "zero".witList.witClone.err!float;
+    }
+
+    return a.ok!WitString;
+}
+
+@witExport("test:results/test", "enum-error")
+Result!(float, E) enumError(float a) {
+    if (a == 0.0) {
+        return E.a.err!float;
+    }
+
+    return a.ok!E;
+}
+
+@witExport("test:results/test", "record-error")
+Result!(float, E2) recordError(float a) {
+    if (a == 0.0) {
+        return E2(
+            line: 420,
+            column: 0
+        ).err!float;
+    } else if (a == 1.0) {
+        return E2(
+            line: 77,
+            column: 2
+        ).err!float;
+    }
+
+    return a.ok!E2;
+}
+
+@witExport("test:results/test", "variant-error")
+Result!(float, E3) variantError(float a) {
+    if (a == 0.0) {
+        return E3.e2(E2(
+            line: 420,
+            column: 0
+        )).err!float;
+    } else if (a == 1.0) {
+        return E3.e1(E.b).err!float;
+    } else if (a == 2.0) {
+        return E3.e1(E.c).err!float;
+    }
+
+    return a.ok!E3;
+}
+
+@witExport("test:results/test", "empty-error")
+Result!(uint, void) emptyError(uint a) {
+    if (a == 0) {
+        return err!uint;
+    } else if (a == 1) {
+        return 42u.ok!void;
+    }
+
+    return a.ok!void;
+}
+
+@witExport("test:results/test", "double-error")
+Result!(Result!(void, WitString), WitString) doubleError(uint a) {
+    if (a == 0) {
+        return ok!WitString.ok!WitString;
+    } else if (a == 1) {
+        return "one".witList.witClone.err!void.ok!WitString;
+    }
+
+    return "two".witList.witClone.err!(Result!(void, WitString));
+}
+
+alias Exports = wit.test.results.leaf.Exports!(
+    stringError,
+    enumError,
+    recordError,
+    variantError,
+    emptyError,
+    doubleError
+);

tests/runtime/results/runner.d

@@ -0,0 +1,69 @@
+import wit.test.results.runner;
+
+import wit.common;
+
+@witExport("$root", "run")
+void run() {
+    {
+        auto result = stringError(0.0);
+        scope(exit) result.witFree;
+
+        assert(result == "zero".witList.err!float);
+    }
+
+    {
+        auto result = stringError(1.0);
+        scope(exit) result.witFree;
+
+        assert(result == 1.0f.ok!WitString);
+    }
+
+    assert(enumError(0.0) == E.a.err!float);
+    assert(enumError(1.0) == 1.0f.ok!E);
+
+    assert(recordError(0.0) == E2(
+        line: 420,
+        column: 0
+    ).err!float);
+    assert(recordError(1.0) == E2(
+        line: 77,
+        column: 2
+    ).err!float);
+    assert(recordError(2.0).isOk);
+
+    assert(variantError(0.0) == E3.e2(E2(
+        line: 420,
+        column: 0
+    )).err!float);
+    assert(variantError(1.0) == E3.e1(E.b).err!float);
+    assert(variantError(2.0) == E3.e1(E.c).err!float);
+
+    assert(emptyError(0) == err!uint);
+    assert(emptyError(1) == 42u.ok!void);
+    assert(emptyError(2) == 2u.ok!void);
+
+    {
+        auto result = doubleError(0);
+        scope(exit) result.witFree;
+
+        assert(result == ok!WitString.ok!WitString);
+    }
+
+    {
+        auto result = doubleError(1);
+        scope(exit) result.witFree;
+
+        assert(result == "one".witList.err!void.ok!WitString);
+    }
+
+    {
+        auto result = doubleError(2);
+        scope(exit) result.witFree;
+
+        assert(result == "two".witList.err!(Result!(void, WitString)));
+    }
+}
+
+alias Exports = wit.test.results.runner.Exports!(
+    run
+);

tests/runtime/strings-alias/runner.d

@@ -0,0 +1,17 @@
+import wit.my.strings.runner;
+
+import wit.common;
+
+@witExport("$root", "run")
+void run() {
+    foo("hello".witList);
+
+    auto str = bar();
+    scope(exit) str.witFree;
+
+    assert(str == "world");
+}
+
+alias Exports = wit.my.strings.runner.Exports!(
+    run
+);

tests/runtime/strings-alias/test.d

@@ -0,0 +1,18 @@
+import wit.my.strings.test;
+
+import wit.common;
+
+@witExport("cat", "foo")
+void foo(in MyString str) {
+    assert(str == "hello");
+}
+
+@witExport("cat", "bar")
+MyString bar() {
+    return "world".witList.witClone;
+}
+
+alias Exports = wit.my.strings.test.Exports!(
+    foo,
+    bar
+);

tests/runtime/strings-simple/runner.d

@@ -0,0 +1,17 @@
+import wit.my.strings.runner;
+
+import wit.common;
+
+@witExport("$root", "run")
+void run() {
+    foo("hello".witList);
+
+    auto str = bar();
+    scope(exit) str.witFree;
+
+    assert(str == "world");
+}
+
+alias Exports = wit.my.strings.runner.Exports!(
+    run
+);

tests/runtime/strings-simple/test.d

@@ -0,0 +1,18 @@
+import wit.my.strings.test;
+
+import wit.common;
+
+@witExport("cat", "foo")
+void foo(in WitString str) {
+    assert(str == "hello");
+}
+
+@witExport("cat", "bar")
+WitString bar() {
+    return "world".witList.witClone;
+}
+
+alias Exports = wit.my.strings.test.Exports!(
+    foo,
+    bar
+);