finish tests, add changelog

changelogs/unreleased/1215-dark64

@@ -0,0 +1 @@
+Add a casting utility module to stdlib

zokrates_stdlib/tests/tests/utils/casts/u16.zok

@@ -14,6 +14,51 @@ from "utils/casts.zok" import cast;
 // u16[N] -> u64[P]
 
 def main() {
-    // TODO
+    // u16 -> bool[16]
+    bool[16] v0 = cast(0xFFFF);
+    assert(v0 == [true; 16]);
+
+    // u16[N] -> bool[P]
+    bool[32] v1 = cast([0xFFFF, 0x00FF]);
+    assert(v1 == [...[true; 16], ...[false; 8], ...[true; 8]]);
+
+    // u16 -> field
+    field v2 = cast(0x1234);
+    assert(v2 == 4660);
+
+    field[2] v3 = cast([0x1234, 0x5678]);
+    assert(v3 == [4660, 22136]);
+
+    // u16 -> u8[2]
+    u8[2] v4 = cast(0x1234);
+    assert(v4 == [0x12, 0x34]);
+
+    // u16[N] -> u8[P]
+    u8[4] v5 = cast([0x1234, 0x5678]);
+    assert(v5 == [0x12, 0x34, 0x56, 0x78]);
+
+    // u16 -> u32
+    u32 v6 = cast(0xFFFF);
+    assert(v6 == 0x0000FFFF);
+
+    // u16[2] -> u32
+    u32 v7 = cast([0x1234, 0x5678]);
+    assert(v7 == 0x12345678);
+
+    // u16[4] -> u32[2]
+    u32[2] v8 = cast([0x1234, 0x5678, 0x8765, 0x4321]);
+    assert(v8 == [0x12345678, 0x87654321]);
+
+    // u16 -> u64
+    u64 v9 = cast(0xFFFF);
+    assert(v9 == 0x000000000000FFFF);
+
+    // u16[4] -> u64
+    u64 v10 = cast([0x1234, 0x5678, 0x8765, 0x4321]);
+    assert(v10 == 0x1234567887654321);
+
+    // u16[8] -> u64[2]
+    u64[2] v11 = cast([0xFFFF; 8]);
+    assert(v11 == [0xFFFFFFFFFFFFFFFF; 2]);
     return;
 }

zokrates_stdlib/tests/tests/utils/casts/u32.zok

@@ -13,6 +13,49 @@ from "utils/casts.zok" import cast;
 // u32[N] -> u64[P]
 
 def main() {
-    // TODO
+    // u32 -> bool[32]
+    bool[32] v0 = cast(0x0000FFFF);
+    assert(v0 == [...[false; 16], ...[true; 16]]);
+
+    // u32[2] -> bool[64]
+    bool[64] v1 = cast([0x0000FFFF, 0xFFFFFFFF]);
+    assert(v1 == [...[false; 16], ...[true; 16], ...[true; 32]]);
+
+    // u32 -> field
+    field v2 = cast(0x12345678);
+    assert(v2 == 305419896);
+
+    // u32[2] -> field[2]
+    field[2] v3 = cast([0x12345678, 0x87654321]);
+    assert(v3 == [305419896, 2271560481]);
+
+    // u32 -> u8[4]
+    u8[4] v4 = cast(0x12345678);
+    assert(v4 == [0x12, 0x34, 0x56, 0x78]);
+
+    // u32[2] -> u8[8]
+    u8[8] v5 = cast([0x12345678, 0x87654321]);
+    assert(v5 == [0x12, 0x34, 0x56, 0x78, 0x87, 0x65, 0x43, 0x21]);
+
+    // u32 -> u16[2]
+    u16[2] v6 = cast(0x12345678);
+    assert(v6 == [0x1234, 0x5678]);
+
+    // u32[2] -> u16[4]
+    u16[4] v7 = cast([0x12345678, 0x87654321]);
+    assert(v7 == [0x1234, 0x5678, 0x8765, 0x4321]);
+
+    // u32 -> u64
+    u64 v8 = cast(0x12345678);
+    assert(v8 == 0x0000000012345678);
+
+    // u32[2] -> u64
+    u64 v9 = cast([0x12345678, 0x87654321]);
+    assert(v9 == 0x1234567887654321);
+
+    // u32[4] -> u64[2]
+    u64[2] v10 = cast([0x12345678, 0x00000000, 0x00000000, 0x87654321]);
+    assert(v10 == [0x1234567800000000, 0x0000000087654321]);
+
     return;
 }

zokrates_stdlib/tests/tests/utils/casts/u64.zok

@@ -12,6 +12,47 @@ from "utils/casts.zok" import cast;
 // u64[N] -> u32[P]
 
 def main() {
-    // TODO
+    // u64 -> bool[64]
+    bool[64] v0 = cast(0x0000FFFF0000FFFF);
+    assert(v0 == [...[false; 16], ...[true; 16], ...[false; 16], ...[true; 16]]);
+
+    // u64[2] -> bool[128]
+    bool[128] v1 = cast([0x0000000000000000, 0xFFFFFFFFFFFFFFFF]);
+    assert(v1 == [...[false; 64], ...[true; 64]]);
+
+    // u64 -> field
+    field v2 = cast(0x0000FFFF0000FFFF);
+    assert(v2 == 281470681808895);
+
+    // u64[2] -> field[2]
+    field[2] v3 = cast([0x0000FFFF0000FFFF, 0xFFFF0000FFFF0000]);
+    assert(v3 == [281470681808895, 18446462603027742720]);
+
+    // u64 -> u8[8]
+    u8[8] v4 = cast(0x0000FFFF0000FFFF);
+    assert(v4 == [0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0xFF, 0xFF]);
+
+    // u64[2] -> u8[16]
+    u8[16] v5 = cast([0x0000FFFF0000FFFF, 0xFFFF0000FFFF0000]);
+    assert(v5 == [
+        0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0xFF, 0xFF,
+        0xFF, 0xFF, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00
+    ]);
+
+    // u64 -> u16[4]
+    u16[4] v6 = cast(0x0000FFFF0000FFFF);
+    assert(v6 == [0x0000, 0xFFFF, 0x0000, 0xFFFF]);
+
+    // u64[2] -> u16[8]
+    u16[8] v7 = cast([0x0000FFFF0000FFFF, 0xFFFF0000FFFF0000]);
+    assert(v7 == [0x0000, 0xFFFF, 0x0000, 0xFFFF, 0xFFFF, 0x0000, 0xFFFF, 0x0000]);
+
+    // u64 -> u32[2]
+    u32[2] v8 = cast(0x0000FFFF0000FFFF);
+    assert(v8 == [0x0000FFFF, 0x0000FFFF]);
+
+    // u64[2] -> u32[4]
+    u32[4] v9 = cast([0x0000FFFF0000FFFF, 0xFFFF0000FFFF0000]);
+    assert(v9 == [0x0000FFFF, 0x0000FFFF, 0xFFFF0000, 0xFFFF0000]);
     return;
 }