From a1801e26a079e47747c922cfb8ae6b5f7be1a504 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Mamy=20Andr=C3=A9-Ratsimbazafy?= <mamy_github@numforge.co>
Date: Sun, 16 Feb 2020 19:08:19 +0100
Subject: [PATCH] Now passing finite field test vs GMP

---
 tests/test_finite_fields_vs_gmp.nim |   4 +-
 tests/test_io_fields.nim            | 106 ++++++++++++++++++++++++++++
 tests/test_io_fields.nim.cfg        |   2 +
 3 files changed, 109 insertions(+), 3 deletions(-)
 create mode 100644 tests/test_io_fields.nim
 create mode 100644 tests/test_io_fields.nim.cfg

diff --git a/tests/test_finite_fields_vs_gmp.nim b/tests/test_finite_fields_vs_gmp.nim
index b3f583a..839b244 100644
--- a/tests/test_finite_fields_vs_gmp.nim
+++ b/tests/test_finite_fields_vs_gmp.nim
@@ -31,7 +31,7 @@ macro randomTests(numTests: static int, curveSym, body: untyped): untyped =
   result = newStmtList()
 
   for _ in 0 ..< numTests:
-    let curve = RNG.rand(Curve.low .. Curve.high)
+    let curve = RNG.rand([BN254, BLS12_381])
 
     result.add quote do:
       block:
@@ -68,8 +68,6 @@ proc main() =
     # echo "--------------------------------------------------------------------------------"
     echo "Testing: random input on ", $curve
 
-    static: echo typeof(CurveParams[curve])
-
     const bits = CurveParams[curve][0]
 
     # Generate random value in the range 0 ..< 2^(bits-1)
diff --git a/tests/test_io_fields.nim b/tests/test_io_fields.nim
new file mode 100644
index 0000000..3688ed9
--- /dev/null
+++ b/tests/test_io_fields.nim
@@ -0,0 +1,106 @@
+# Constantine
+# Copyright (c) 2018-2019    Status Research & Development GmbH
+# Copyright (c) 2020-Present Mamy André-Ratsimbazafy
+# Licensed and distributed under either of
+#   * MIT license (license terms in the root directory or at http://opensource.org/licenses/MIT).
+#   * Apache v2 license (license terms in the root directory or at http://www.apache.org/licenses/LICENSE-2.0).
+# at your option. This file may not be copied, modified, or distributed except according to those terms.
+
+import  unittest, random,
+        ../constantine/io/[io_bigints, io_fields],
+        ../constantine/config/curves,
+        ../constantine/config/common,
+        ../constantine/math/[bigints_checked, finite_fields]
+
+randomize(0xDEADBEEF) # Random seed for reproducibility
+type T = BaseType
+
+proc main() =
+  suite "IO - Finite fields":
+    test "Parsing and serializing round-trip on uint64":
+      block:
+        # "Little-endian" - 0
+        let x = 0'u64
+        let x_bytes = cast[array[8, byte]](x)
+        var f: Fq[Mersenne61]
+        f.fromUint(x)
+
+        var r_bytes: array[8, byte]
+        serializeRawUint(r_bytes, f, littleEndian)
+        check: x_bytes == r_bytes
+
+      block:
+        # "Little-endian" - 1
+        let x = 1'u64
+        let x_bytes = cast[array[8, byte]](x)
+        var f: Fq[Mersenne61]
+        f.fromUint(x)
+
+        var r_bytes: array[8, byte]
+        serializeRawUint(r_bytes, f, littleEndian)
+        check: x_bytes == r_bytes
+
+      block:
+        # "Little-endian" - 2^31
+        let x = 1'u64 shl 31
+        let x_bytes = cast[array[8, byte]](x)
+        var f: Fq[Mersenne61]
+        f.fromUint(x)
+
+        var r_bytes: array[8, byte]
+        serializeRawUint(r_bytes, f, littleEndian)
+        check: x_bytes == r_bytes
+
+      block:
+        # "Little-endian" - 2^32
+        let x = 1'u64 shl 32
+        let x_bytes = cast[array[8, byte]](x)
+        var f: Fq[Mersenne61]
+        f.fromUint(x)
+
+        var r_bytes: array[8, byte]
+        serializeRawUint(r_bytes, f, littleEndian)
+        check: x_bytes == r_bytes
+
+      # Mersenne 127 ---------------------------------
+      block:
+        # "Little-endian" - 2^63
+        let x = 1'u64 shl 63
+        let x_bytes = cast[array[8, byte]](x)
+        var f: Fq[Mersenne127]
+        f.fromUint(x)
+
+        var r_bytes: array[16, byte]
+        serializeRawUint(r_bytes, f, littleEndian)
+        check: x_bytes == r_bytes[0 ..< 8]
+
+      block: # "Little-endian" - single random
+        let x = uint64 rand(0..high(int))
+        let x_bytes = cast[array[8, byte]](x)
+        var f: Fq[Mersenne127]
+        f.fromUint(x)
+
+        var r_bytes: array[16, byte]
+        serializeRawUint(r_bytes, f, littleEndian)
+        check: x_bytes == r_bytes[0 ..< 8]
+
+      block: # "Little-endian" - 10 random cases
+        for _ in 0 ..< 10:
+          let x = uint64 rand(0..high(int))
+          let x_bytes = cast[array[8, byte]](x)
+          var f: Fq[Mersenne127]
+          f.fromUint(x)
+
+          var r_bytes: array[16, byte]
+          serializeRawUint(r_bytes, f, littleEndian)
+          check: x_bytes == r_bytes[0 ..< 8]
+
+    test "Round trip on large constant":
+      block: # 2^126
+        const p = "0x40000000000000000000000000000000"
+        let x = Fq[Mersenne127].fromBig BigInt[127].fromHex(p)
+        let hex = x.toHex(bigEndian)
+
+        check: p == hex
+
+main()
diff --git a/tests/test_io_fields.nim.cfg b/tests/test_io_fields.nim.cfg
new file mode 100644
index 0000000..92fac8a
--- /dev/null
+++ b/tests/test_io_fields.nim.cfg
@@ -0,0 +1,2 @@
+-d:testingCurves
+-d:debugConstantine