add more tests

tests/testleopard.nim

@@ -4,43 +4,137 @@ import pkg/stew/byteutils
 
 import ../leopard
 
-suite "Leopard":
+suite "Parametrization":
-  const
+  test "Should not allow invalid buffer multiples":
-    testString = "Hello World!"
+    check:
+      LeoEncoder.init(63, 4, 2).error == "bufSize should be multiples of 64 bytes!"
+      LeoEncoder.init(65, 4, 2).error == "bufSize should be multiples of 64 bytes!"
 
-  test "Test simple Encode/Decode":
+  test "Should not allow invalid data/parity buffer counts":
+    check:
+      LeoEncoder.init(64, 1, 2).error ==
+      "number of parity buffers cannot exceed number of data buffers!"
+
+  test "Should not allow encoding with invalid data buffer counts":
     var
-      encoder = Leo.init(64, 16, 10, LeoCoderKind.Encoder).tryGet()
+      leo = LeoEncoder.init(64, 4, 2).tryGet()
-      decoder = Leo.init(64, 16, 10, LeoCoderKind.Decoder).tryGet()
+      data = newSeq[seq[byte]](3)
-      data = newSeq[seq[byte]](16)
+      parity = newSeq[seq[byte]](2)
-      parity = newSeq[seq[byte]](10)
-      recovered = newSeq[seq[byte]](16)
 
-    try:
+    check:
-      for i in 0..<16:
+      leo.encode(data, parity).error == "Number of data buffers should match!"
-        data[i] = newSeq[byte](64)
-        recovered[i] = newSeq[byte](64)
-        var
-          str = testString & " " & $i
 
-        copyMem(addr data[i][0], addr str[0], str.len)
+  test "Should not allow encoding with invalid parity buffer counts":
+    var
+      leo = LeoEncoder.init(64, 4, 2).tryGet()
+      data = newSeq[seq[byte]](4)
+      parity = newSeq[seq[byte]](3)
 
-      for i in 0..<10:
+    check:
-        parity[i] = newSeq[byte](64)
+      leo.encode(data, parity).error == "Number of parity buffers should match!"
 
-      encoder.encode(data, parity).tryGet()
+  test "Should not allow decoding with invalid data buffer counts":
+    var
+      leo = LeoDecoder.init(64, 4, 2).tryGet()
+      data = newSeq[seq[byte]](3)
+      parity = newSeq[seq[byte]](2)
+      recovered = newSeq[seq[byte]](3)
+
+    check:
+      leo.decode(data, parity, recovered).error == "Number of data buffers should match!"
+
+  test "Should not allow decoding with invalid data buffer counts":
+    var
+      leo = LeoDecoder.init(64, 4, 2).tryGet()
+      data = newSeq[seq[byte]](4)
+      parity = newSeq[seq[byte]](1)
+      recovered = newSeq[seq[byte]](3)
+
+    check:
+      leo.decode(data, parity, recovered).error == "Number of parity buffers should match!"
+
+  test "Should not allow decoding with invalid data buffer counts":
+    var
+      leo = LeoDecoder.init(64, 4, 2).tryGet()
+      data = newSeq[seq[byte]](4)
+      parity = newSeq[seq[byte]](2)
+      recovered = newSeq[seq[byte]](3)
+
+    check:
+      leo.decode(data, parity, recovered).error == "Number of recovered buffers should match buffers!"
+
+suite "Leopard Encode/Decode":
+  const
+    TestString = "Hello World!"
+    DataCount = 4
+    ParityCount = 2
+    BufferSize = 64
+
+  var
+    encoder: LeoEncoder
+    decoder: LeoDecoder
+    data: seq[seq[byte]]
+    parity: seq[seq[byte]]
+    recovered: seq[seq[byte]]
+
+  setup:
+    encoder = LeoEncoder.init(BufferSize, DataCount, ParityCount).tryGet()
+    decoder = LeoDecoder.init(BufferSize, DataCount, ParityCount).tryGet()
+    data = newSeq[seq[byte]](DataCount)
+    parity = newSeq[seq[byte]](ParityCount)
+    recovered = newSeq[seq[byte]](DataCount)
+
+  teardown:
+    encoder.free()
+    decoder.free()
+
+  test "Test 2 data loses out of 4 possible":
+    for i in 0..<DataCount:
+      data[i] = newSeq[byte](BufferSize)
+      recovered[i] = newSeq[byte](BufferSize)
+      var
+        str = TestString & " " & $i
+
+      copyMem(addr data[i][0], addr str[0], str.len)
+
+    for i in 0..<ParityCount:
+      parity[i] = newSeq[byte](BufferSize)
+
+    encoder.encode(data, parity).tryGet()
+
+    var
+      data1 = data[0]
+      data2 = data[1]
+
+    data[0].setLen(0)
+    data[1].setLen(0)
+
+    decoder.decode(data, parity, recovered).tryGet()
+
+    check recovered[0] == data1
+    check recovered[1] == data2
+
+  test "Test 1 data and 1 parity loss out of 4 possible":
+    for i in 0..<DataCount:
+      data[i] = newSeq[byte](BufferSize)
+      recovered[i] = newSeq[byte](BufferSize)
 
       var
-        data1 = data[0]
+        str = TestString & " " & $i
-        data2 = data[1]
 
-      data[0].setLen(0)
+      copyMem(addr data[i][0], addr str[0], str.len)
-      data[1].setLen(0)
 
-      decoder.decode(data, parity, recovered).tryGet()
+    for i in 0..<ParityCount:
+      parity[i] = newSeq[byte](BufferSize)
 
-      check recovered[0] == data1
+    encoder.encode(data, parity).tryGet()
-      check recovered[1] == data2
+
-    finally:
+    var
-      encoder.free()
+      data1 = data[0]
-      decoder.free()
+
+    data[0].setLen(0)
+    parity[0].setLen(0)
+
+    decoder.decode(data, parity, recovered).tryGet()
+
+    check recovered[0] == data1