adding more comprehensive tests

tests/helpers.nim

@@ -0,0 +1,113 @@
+import std/random
+
+import pkg/stew/results
+import ../leopard
+
+proc randomCRCPacket*(data: var openArray[byte]) =
+  if data.len < 16:
+    data[0] = rand(data.len).byte
+    for i in 1..<data.len:
+      data[i] = data[0]
+  else:
+    let
+      len: uint32 = data.len.uint32
+
+    copyMem(addr data[0], unsafeAddr len, sizeof(len))
+    var
+      crc = data.len.uint32
+
+    for i in 8..<data.len:
+      let v = rand(data.len).byte
+      data[i] = v
+      crc = (crc shl 3) and (crc shr (32 - 3))
+      crc += v
+
+    copyMem(addr data[4], unsafeAddr crc, sizeof(crc))
+
+proc checkCRCPacket*(data: openArray[byte]): bool =
+  if data.len < 16:
+    for d in data[1..data.high]:
+      if d != data[0]:
+        raise (ref Defect)(msg: "Packet don't match")
+  else:
+    var
+      crc = data.len.uint32
+      packCrc: uint32
+      packSize: uint32
+
+    copyMem(addr packSize, unsafeAddr data[0], sizeof(packSize))
+    if packSize != data.len.uint:
+      raise (ref Defect)(msg: "Packet size don't match!")
+
+    for i in 4..<data.len:
+      let v = data[i]
+      crc = (crc shl 3) and (crc shr (32 - 3))
+      crc += v
+
+    copyMem(addr packCrc, unsafeAddr data[4], sizeof(packCrc))
+
+    if packCrc == crc:
+      return true
+
+proc dropRandomIdx*(bufs: var openArray[seq[byte]], dropCount: int) =
+  var
+    count = 0
+    dups: seq[int]
+    size = bufs.len
+
+  while count < dropCount:
+    let i = rand(0..<size)
+    if dups.find(i) == -1:
+      dups.add(i)
+      bufs[i].setLen(0)
+      count.inc
+
+proc testPackets*(
+  buffers,
+  parity,
+  bufSize,
+  dataLosses: int,
+  parityLosses: int): Result[void, cstring] =
+
+  var
+    dataBuf = newSeqOfCap[seq[byte]](buffers)
+    parityBuf = newSeqOfCap[seq[byte]](parity)
+    recoveredBuf = newSeqOfCap[seq[byte]](buffers)
+    encoder: LeoEncoder
+    decoder: LeoDecoder
+
+  try:
+    encoder = ? LeoEncoder.init(bufSize, buffers, parity)
+    decoder = ? LeoDecoder.init(bufSize, buffers, parity)
+
+    for _ in 0..<buffers:
+      var
+        dataSeq = newSeq[byte](bufSize)
+
+      randomCRCPacket(dataSeq)
+      dataBuf.add(dataSeq)
+
+      recoveredBuf.add(newSeq[byte](bufSize))
+
+    for _ in 0..<parity:
+      parityBuf.add(newSeq[byte](bufSize))
+
+    encoder.encode(dataBuf, parityBuf).tryGet()
+
+    if dataLosses > 0:
+      dropRandomIdx(dataBuf, dataLosses)
+
+    if parityLosses > 0:
+      dropRandomIdx(parityBuf, parityLosses)
+
+    decoder.decode(dataBuf, parityBuf, recoveredBuf).tryGet()
+
+    for i, d in dataBuf:
+      if d.len <= 0:
+        if not checkCRCPacket(recoveredBuf[i]):
+          return err(("Check failed for packet " & $i).cstring)
+  finally:
+    encoder.free()
+    decoder.free()
+
+  ok()

tests/testleopard.nim

@@ -1,7 +1,13 @@
+import std/random
+import std/sets
+
 import pkg/unittest2
 import pkg/stew/results
 
 import ../leopard
+import ./helpers
+
+randomize()
 
 suite "Leopard Parametrization":
   test "Should not allow invalid buffer multiples":
@@ -135,8 +141,23 @@ suite "Leopard simple Encode/Decode":
     parity[0].setLen(0)
 
     decoder.decode(data, parity, recovered).tryGet()
-
     check recovered[0] == data1
 
 suite "Leopard Encode/Decode":
-  discard
+  test "bufSize = 4096, K = 800, M = 200 - drop data = 200 data":
+    testPackets(800, 200, 4096, 200, 0).tryGet()
+
+  test "bufSize = 4096, K = 800, M = 200 - drop parity = 200":
+    testPackets(800, 200, 4096, 0, 200).tryGet()
+
+  test "bufSize = 4096, K = 800, M = 200 - drop data = 100, drop parity = 100":
+    testPackets(800, 200, 4096, 0, 200).tryGet()
+
+  test "bufSize = 4096, K = 8000, M = 2000 - drop data = 2000":
+    testPackets(8000, 2000, 4096, 2000, 0).tryGet()
+
+  test "bufSize = 4096, K = 8000, M = 2000 - drop parity = 2000":
+    testPackets(8000, 2000, 4096, 0, 2000).tryGet()
+
+  test "bufSize = 4096, K = 8000, M = 2000 - drop data = 1000, parity = 1000":
+    testPackets(8000, 2000, 4096, 1000, 1000).tryGet()