Fix test for LLVM (assert, infixEq on Byte)

Author: marzipankaiser

examples/stdlib/binstream.effekt

@@ -4,51 +4,51 @@ import test
 
 def main() = {
   suite("Binstream", false){
-    test("literal hex 10"){ assertEqual(x"10${()}", 16) }
-    test("literal hex ff"){ assertEqual(x"ff${()}", 255) }
-    test("literal char a"){ assertEqual(x"${'a'}", x"61${()}") }
-    test("literal string ba"){ assertEqual(x"${"ba"}", x"62${()}" * 256 + x"61${()}") }
-    test("int back-and-forth (17)"){ assertEqual(x"${17}", 17)}
-    test("int back-and-forth (17), explicit BE"){ assertEqual(x"${17.BE}", 17) }
-    test("int back-and-forth (17), explicit LE"){ assertEqual(x"${17.LE}", 17 * 256 * 256 * 256) }
+    test("literal hex 10"){ assert(x"10${()}", 16) }
+    test("literal hex ff"){ assert(x"ff${()}", 255) }
+    test("literal char a"){ assert(x"${'a'}", x"61${()}") }
+    test("literal string ba"){ assert(x"${"ba"}", x"62${()}" * 256 + x"61${()}") }
+    test("int back-and-forth (17)"){ assert(x"${17}", 17)}
+    test("int back-and-forth (17), explicit BE"){ assert(x"${17.BE}", 17) }
+    test("int back-and-forth (17), explicit LE"){ assert(x"${17.LE}", 17 * 256 * 256 * 256) }
     test("byte 00101010"){
-      with on[MissingValue].default{ assertEqual(true, false) }
-      assertEqual(first[Byte]{groupBytes{ bit"00101010${()}" }}.toInt, 42)
+      with on[MissingValue].default{ assert(true, false) }
+      assert(first[Byte]{groupBytes{ bit"00101010${()}" }}.toInt, 42)
     }
     test("to bits and back"){ 
-      with on[MissingValue].default{ assertEqual(true, false) }
+      with on[MissingValue].default{ assert(true, false) }
       [42.toByte, 12.toByte, 113.toByte, 0.toByte, 255.toByte].foreach{ v =>
-        assertEqual(first[Byte]{ groupBytes{ bits(v) } }, v)
+        assert(first[Byte]{ groupBytes{ bits(v) } }, v)
       }
     }
     test("to bits and back LE bitorder"){ 
-      with on[MissingValue].default{ assertEqual(true, false) }
+      with on[MissingValue].default{ assert(true, false) }
       [42.toByte, 12.toByte, 113.toByte, 0.toByte, 255.toByte].foreach{ v =>
-        assertEqual(first[Byte]{ groupBytesLE{ bitsLE(v) } }, v)
+        assert(first[Byte]{ groupBytesLE{ bitsLE(v) } }, v)
       }
     }
     test("to bits and back BE bitorder"){ 
-      with on[MissingValue].default{ assertEqual(true, false) }
+      with on[MissingValue].default{ assert(true, false) }
       [42.toByte, 12.toByte, 113.toByte, 0.toByte, 255.toByte].foreach{ v =>
-        assertEqual(first[Byte]{ groupBytesBE{ bitsBE(v) } }, v)
+        assert(first[Byte]{ groupBytesBE{ bitsBE(v) } }, v)
       }
     }
     test("append 0 means *2"){
-      with on[MissingValue].default{ assertEqual(true, false) }
+      with on[MissingValue].default{ assert(true, false) }
       [42.toByte, 12.toByte, 127.toByte].foreach{ v =>
-        assertEqual(nth[Byte](1){ groupBytes{ repeat(7){ do emit(B0()) }; bits(v); do emit(B0()) } }, (v.toInt * 2).toByte)
+        assert(nth[Byte](1){ groupBytes{ repeat(7){ do emit(B0()) }; bits(v); do emit(B0()) } }, (v.toInt * 2).toByte)
       }
     }
     test("pow agrees with double one"){
-      assertEqual(pow(2,5), pow(2.0,5).toInt)
+      assert(pow(2,5), pow(2.0,5).toInt)
     }
     test("LE 2s-complement"){
-      with on[MissingValue].default{ assertEqual(true, false) }
-      assertEqual(first[Byte]{ groupBytesLE{ twoscomplementLE{ bitsLE(6.toByte) } } }, 250.toByte)
+      with on[MissingValue].default{ assert(true, false) }
+      assert(first[Byte]{ groupBytesLE{ twoscomplementLE{ bitsLE(6.toByte) } } }, 250.toByte)
     }
     test("BE 2s-complement"){
-      with on[MissingValue].default{ assertEqual(true, false) }
-      assertEqual(first[Byte]{ groupBytesBE{ bit"${-6.Signed.BE.OfWidth(8)}" } }, 250.toByte)
+      with on[MissingValue].default{ assert(true, false) }
+      assert(first[Byte]{ groupBytesBE{ bit"${-6.Signed.BE.OfWidth(8)}" } }, 250.toByte)
     }
   }
   ()

libraries/common/effekt.effekt

@@ -234,6 +234,10 @@ extern pure def infixNeq(x: Int, y: Int): Bool =
   """
   vm "effekt::infixNeq(Int, Int)"
 
+def infixEq(x: Byte, y: Byte): Bool = {
+  x.toInt == y.toInt
+}
+
 extern pure def infixEq(x: Char, y: Char): Bool =
   js "${x} === ${y}"
   chez "(equal? ${x} ${y})"

libraries/common/test.effekt

@@ -33,6 +33,9 @@ def assert(obtained: String, expected: String, msg: String): Unit / Assertion =
 def assert(obtained: Int, expected: Int): Unit / { Assertion, Formatted } =
   assertEqual(obtained, expected) { (x, y) => x == y } { x => show(x) }
 
+def assert(obtained: Byte, expected: Byte): Unit / { Assertion, Formatted } =
+  assertEqual(obtained, expected) { (x, y) => x == y } { x => show(x) }
+
 def assert(obtained: Bool, expected: Bool): Unit / { Assertion, Formatted } =
   assertEqual(obtained, expected) { (x, y) => x == y } { x => show(x) }