update comments

[ieee754fpu.git] / src / add / unit_test_double.py

diff --git a/src/add/unit_test_double.py b/src/add/unit_test_double.py
index b5a48a20365f4def45aaa5165f8156ccdd9f4deb..8cc097f2a2fe1ebdad669d0bdd531d92d796d85a 100644 (file)
--- a/src/add/unit_test_double.py
+++ b/src/add/unit_test_double.py
@@ -1,3 +1,7 @@
+import sys
+from random import randint
+from random import seed
+
 from sfpy import Float64
 
 def get_mantissa(x):
@@ -63,14 +67,14 @@ def check_case(dut, a, b, z):
     assert out_z == z, "Output z 0x%x not equal to expected 0x%x" % (out_z, z)
 
 
-def run_test(dut, stimulus_a, stimulus_b):
+def run_test(dut, stimulus_a, stimulus_b, op):
 
     expected_responses = []
     actual_responses = []
     for a, b in zip(stimulus_a, stimulus_b):
         af = Float64.from_bits(a)
         bf = Float64.from_bits(b)
-        z = af + bf
+        z = op(af, bf)
         expected_responses.append(z.get_bits())
         #print (af, bf, z)
         actual = yield from get_case(dut, a, b)
@@ -114,3 +118,110 @@ def run_test(dut, stimulus_a, stimulus_b):
 
             sys.exit(0)
 
+
+def run_corner_cases(dut, count, op):
+    #corner cases
+    from itertools import permutations
+    stimulus_a = [i[0] for i in permutations([
+        0x8000000000000000,
+        0x0000000000000000,
+        0x7ff8000000000000,
+        0xfff8000000000000,
+        0x7ff0000000000000,
+        0xfff0000000000000
+    ], 2)]
+    stimulus_b = [i[1] for i in permutations([
+        0x8000000000000000,
+        0x0000000000000000,
+        0x7ff8000000000000,
+        0xfff8000000000000,
+        0x7ff0000000000000,
+        0xfff0000000000000
+    ], 2)]
+    yield from run_test(dut, stimulus_a, stimulus_b, op)
+    count += len(stimulus_a)
+    print (count, "vectors passed")
+
+
+def run_edge_cases(dut, count, op):
+    #edge cases
+    stimulus_a = [0x8000000000000000 for i in range(1000)]
+    stimulus_b = [randint(0, 1<<64)  for i in range(1000)]
+    yield from run_test(dut, stimulus_a, stimulus_b, op)
+    count += len(stimulus_a)
+    print (count, "vectors passed")
+
+    stimulus_a = [0x0000000000000000 for i in range(1000)]
+    stimulus_b = [randint(0, 1<<64)  for i in range(1000)]
+    yield from run_test(dut, stimulus_a, stimulus_b, op)
+    count += len(stimulus_a)
+    print (count, "vectors passed")
+
+    stimulus_b = [0x8000000000000000 for i in range(1000)]
+    stimulus_a = [randint(0, 1<<64)  for i in range(1000)]
+    yield from run_test(dut, stimulus_a, stimulus_b, op)
+    count += len(stimulus_a)
+    print (count, "vectors passed")
+
+    stimulus_b = [0x0000000000000000 for i in range(1000)]
+    stimulus_a = [randint(0, 1<<64)  for i in range(1000)]
+    yield from run_test(dut, stimulus_a, stimulus_b, op)
+    count += len(stimulus_a)
+    print (count, "vectors passed")
+
+    stimulus_a = [0x7FF8000000000000 for i in range(1000)]
+    stimulus_b = [randint(0, 1<<64)  for i in range(1000)]
+    yield from run_test(dut, stimulus_a, stimulus_b, op)
+    count += len(stimulus_a)
+    print (count, "vectors passed")
+
+    stimulus_a = [0xFFF8000000000000 for i in range(1000)]
+    stimulus_b = [randint(0, 1<<64)  for i in range(1000)]
+    yield from run_test(dut, stimulus_a, stimulus_b, op)
+    count += len(stimulus_a)
+    print (count, "vectors passed")
+
+    stimulus_b = [0x7FF8000000000000 for i in range(1000)]
+    stimulus_a = [randint(0, 1<<64) for i in range(1000)]
+    yield from run_test(dut, stimulus_a, stimulus_b, op)
+    count += len(stimulus_a)
+    print (count, "vectors passed")
+
+    stimulus_b = [0xFFF8000000000000 for i in range(1000)]
+    stimulus_a = [randint(0, 1<<64) for i in range(1000)]
+    yield from run_test(dut, stimulus_a, stimulus_b, op)
+    count += len(stimulus_a)
+    print (count, "vectors passed")
+
+    stimulus_a = [0x7FF0000000000000 for i in range(1000)]
+    stimulus_b = [randint(0, 1<<64)  for i in range(1000)]
+    yield from run_test(dut, stimulus_a, stimulus_b, op)
+    count += len(stimulus_a)
+    print (count, "vectors passed")
+
+    stimulus_a = [0xFFF0000000000000 for i in range(1000)]
+    stimulus_b = [randint(0, 1<<64)  for i in range(1000)]
+    yield from run_test(dut, stimulus_a, stimulus_b, op)
+    count += len(stimulus_a)
+    print (count, "vectors passed")
+
+    stimulus_b = [0x7FF0000000000000 for i in range(1000)]
+    stimulus_a = [randint(0, 1<<64)  for i in range(1000)]
+    yield from run_test(dut, stimulus_a, stimulus_b, op)
+    count += len(stimulus_a)
+    print (count, "vectors passed")
+
+    stimulus_b = [0xFFF0000000000000 for i in range(1000)]
+    stimulus_a = [randint(0, 1<<64)  for i in range(1000)]
+    yield from run_test(dut, stimulus_a, stimulus_b, op)
+    count += len(stimulus_a)
+    print (count, "vectors passed")
+
+    #seed(0)
+    for i in range(100000):
+        stimulus_a = [randint(0, 1<<64) for i in range(1000)]
+        stimulus_b = [randint(0, 1<<64) for i in range(1000)]
+        yield from run_test(dut, stimulus_a, stimulus_b, op)
+        count += 1000
+        print (count, "random vectors passed")
+