add operator argument to unit tests

diff --git a/src/add/test_add.py b/src/add/test_add.py
index 69c5e4775e94117d7080bb947f9c16325c63b8a9..a79e247363b698f3584a09205411525c241882ec 100644 (file)
--- a/src/add/test_add.py
+++ b/src/add/test_add.py
@@ -1,7 +1,6 @@
-import sys
-import subprocess
 from random import randint
 from random import seed
+from operator import add
 
 from nmigen import Module, Signal
 from nmigen.compat.sim import run_simulation
@@ -54,7 +53,7 @@ def testbench(dut):
     #regression tests
     stimulus_a = [0x22cb525a, 0x40000000, 0x83e73d5c, 0xbf9b1e94, 0x34082401, 0x5e8ef81, 0x5c75da81, 0x2b017]
     stimulus_b = [0xadd79efa, 0xC0000000, 0x1c800000, 0xc038ed3a, 0xb328cd45, 0x114f3db, 0x2f642a39, 0xff3807ab]
-    yield from run_test(dut, stimulus_a, stimulus_b)
+    yield from run_test(dut, stimulus_a, stimulus_b, add)
     count += len(stimulus_a)
     print (count, "vectors passed")
 
@@ -62,80 +61,80 @@ def testbench(dut):
     from itertools import permutations
     stimulus_a = [i[0] for i in permutations([0x80000000, 0x00000000, 0x7f800000, 0xff800000, 0x7fc00000, 0xffc00000], 2)]
     stimulus_b = [i[1] for i in permutations([0x80000000, 0x00000000, 0x7f800000, 0xff800000, 0x7fc00000, 0xffc00000], 2)]
-    yield from run_test(dut, stimulus_a, stimulus_b)
+    yield from run_test(dut, stimulus_a, stimulus_b, add)
     count += len(stimulus_a)
     print (count, "vectors passed")
 
     #edge cases
     stimulus_a = [0x80000000 for i in range(1000)]
     stimulus_b = [randint(0, 1<<32) for i in range(1000)]
-    yield from run_test(dut, stimulus_a, stimulus_b)
+    yield from run_test(dut, stimulus_a, stimulus_b, add)
     count += len(stimulus_a)
     print (count, "vectors passed")
 
     stimulus_a = [0x00000000 for i in range(1000)]
     stimulus_b = [randint(0, 1<<32) for i in range(1000)]
-    yield from run_test(dut, stimulus_a, stimulus_b)
+    yield from run_test(dut, stimulus_a, stimulus_b, add)
     count += len(stimulus_a)
     print (count, "vectors passed")
 
     stimulus_b = [0x80000000 for i in range(1000)]
     stimulus_a = [randint(0, 1<<32) for i in range(1000)]
-    yield from run_test(dut, stimulus_a, stimulus_b)
+    yield from run_test(dut, stimulus_a, stimulus_b, add)
     count += len(stimulus_a)
     print (count, "vectors passed")
 
     stimulus_b = [0x00000000 for i in range(1000)]
     stimulus_a = [randint(0, 1<<32) for i in range(1000)]
-    yield from run_test(dut, stimulus_a, stimulus_b)
+    yield from run_test(dut, stimulus_a, stimulus_b, add)
     count += len(stimulus_a)
     print (count, "vectors passed")
 
     stimulus_a = [0x7F800000 for i in range(1000)]
     stimulus_b = [randint(0, 1<<32) for i in range(1000)]
-    yield from run_test(dut, stimulus_a, stimulus_b)
+    yield from run_test(dut, stimulus_a, stimulus_b, add)
     count += len(stimulus_a)
     print (count, "vectors passed")
 
     stimulus_a = [0xFF800000 for i in range(1000)]
     stimulus_b = [randint(0, 1<<32) for i in range(1000)]
-    yield from run_test(dut, stimulus_a, stimulus_b)
+    yield from run_test(dut, stimulus_a, stimulus_b, add)
     count += len(stimulus_a)
     print (count, "vectors passed")
 
     stimulus_b = [0x7F800000 for i in range(1000)]
     stimulus_a = [randint(0, 1<<32) for i in range(1000)]
-    yield from run_test(dut, stimulus_a, stimulus_b)
+    yield from run_test(dut, stimulus_a, stimulus_b, add)
     count += len(stimulus_a)
     print (count, "vectors passed")
 
     stimulus_b = [0xFF800000 for i in range(1000)]
     stimulus_a = [randint(0, 1<<32) for i in range(1000)]
-    yield from run_test(dut, stimulus_a, stimulus_b)
+    yield from run_test(dut, stimulus_a, stimulus_b, add)
     count += len(stimulus_a)
     print (count, "vectors passed")
 
     stimulus_a = [0x7FC00000 for i in range(1000)]
     stimulus_b = [randint(0, 1<<32) for i in range(1000)]
-    yield from run_test(dut, stimulus_a, stimulus_b)
+    yield from run_test(dut, stimulus_a, stimulus_b, add)
     count += len(stimulus_a)
     print (count, "vectors passed")
 
     stimulus_a = [0xFFC00000 for i in range(1000)]
     stimulus_b = [randint(0, 1<<32) for i in range(1000)]
-    yield from run_test(dut, stimulus_a, stimulus_b)
+    yield from run_test(dut, stimulus_a, stimulus_b, add)
     count += len(stimulus_a)
     print (count, "vectors passed")
 
     stimulus_b = [0x7FC00000 for i in range(1000)]
     stimulus_a = [randint(0, 1<<32) for i in range(1000)]
-    yield from run_test(dut, stimulus_a, stimulus_b)
+    yield from run_test(dut, stimulus_a, stimulus_b, add)
     count += len(stimulus_a)
     print (count, "vectors passed")
 
     stimulus_b = [0xFFC00000 for i in range(1000)]
     stimulus_a = [randint(0, 1<<32) for i in range(1000)]
-    yield from run_test(dut, stimulus_a, stimulus_b)
+    yield from run_test(dut, stimulus_a, stimulus_b, add)
     count += len(stimulus_a)
     print (count, "vectors passed")
 
@@ -143,7 +142,7 @@ def testbench(dut):
     for i in range(100000):
         stimulus_a = [randint(0, 1<<32) for i in range(1000)]
         stimulus_b = [randint(0, 1<<32) for i in range(1000)]
-        yield from run_test(dut, stimulus_a, stimulus_b)
+        yield from run_test(dut, stimulus_a, stimulus_b, add)
         count += 1000
         print (count, "random vectors passed")
 

diff --git a/src/add/test_add64.py b/src/add/test_add64.py
index ecb5dcc2ffaf577e45a832c87f1acabe255c76c2..75c68bde25e967808d155555c2be1fe29c32bedf 100644 (file)
--- a/src/add/test_add64.py
+++ b/src/add/test_add64.py
@@ -1,5 +1,6 @@
 from nmigen import Module, Signal
 from nmigen.compat.sim import run_simulation
+from operator import add
 
 from nmigen_add_experiment import FPADD
 
@@ -29,7 +30,7 @@ def testbench(dut):
     #regression tests
     stimulus_a = [0x3ff00000000000c5, 0xff80000000000000]
     stimulus_b = [0xbd28a404211fb72b, 0x7f80000000000000]
-    yield from run_test(dut, stimulus_a, stimulus_b)
+    yield from run_test(dut, stimulus_a, stimulus_b, add)
     count += len(stimulus_a)
     print (count, "vectors passed")
 
@@ -51,80 +52,80 @@ def testbench(dut):
         0x7ff0000000000000,
         0xfff0000000000000
     ], 2)]
-    yield from run_test(dut, stimulus_a, stimulus_b)
+    yield from run_test(dut, stimulus_a, stimulus_b, add)
     count += len(stimulus_a)
     print (count, "vectors passed")
 
     #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)
+    yield from run_test(dut, stimulus_a, stimulus_b, add)
     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)
+    yield from run_test(dut, stimulus_a, stimulus_b, add)
     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)
+    yield from run_test(dut, stimulus_a, stimulus_b, add)
     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)
+    yield from run_test(dut, stimulus_a, stimulus_b, add)
     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)
+    yield from run_test(dut, stimulus_a, stimulus_b, add)
     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)
+    yield from run_test(dut, stimulus_a, stimulus_b, add)
     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)
+    yield from run_test(dut, stimulus_a, stimulus_b, add)
     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)
+    yield from run_test(dut, stimulus_a, stimulus_b, add)
     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)
+    yield from run_test(dut, stimulus_a, stimulus_b, add)
     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)
+    yield from run_test(dut, stimulus_a, stimulus_b, add)
     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)
+    yield from run_test(dut, stimulus_a, stimulus_b, add)
     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)
+    yield from run_test(dut, stimulus_a, stimulus_b, add)
     count += len(stimulus_a)
     print (count, "vectors passed")
 
@@ -132,7 +133,7 @@ def testbench(dut):
     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)
+        yield from run_test(dut, stimulus_a, stimulus_b, add)
         count += 1000
         print (count, "random vectors passed")
 

diff --git a/src/add/test_div.py b/src/add/test_div.py
index 803111231c98a9e991a46c7505076b66b731e528..85160e91f64b020c0831e8aeadfec5038e976cde 100644 (file)
--- a/src/add/test_div.py
+++ b/src/add/test_div.py
@@ -13,6 +13,7 @@ from unit_test_single import (get_mantissa, get_exponent, get_sign, is_nan,
 
 
 def testbench(dut):
+    yield from check_case(dut, 0xbf9b1e94, 0xc038ed3a, 0xc0833e42)
     yield from check_case(dut, 0x40000000, 0x3F800000, 0x40000000)
     yield from check_case(dut, 0x3F800000, 0x40000000, 0x3F000000)
     yield from check_case(dut, 0x3F800000, 0x40400000, 0x3EAAAAAB)

diff --git a/src/add/unit_test_double.py b/src/add/unit_test_double.py
index 3d69d8e0374cdbffe16679194eed2297e2bb0ec3..25df4b9f9a64d508bebf6e4d06a7b5f061d117e6 100644 (file)
--- a/src/add/unit_test_double.py
+++ b/src/add/unit_test_double.py
@@ -64,14 +64,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)

diff --git a/src/add/unit_test_single.py b/src/add/unit_test_single.py
index ca33efb141193bdccb3315c05b22f67d6773b3fd..a68907bacb8432c18ca1cdd07ee333f90834022f 100644 (file)
--- a/src/add/unit_test_single.py
+++ b/src/add/unit_test_single.py
@@ -64,14 +64,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 = Float32.from_bits(a)
         bf = Float32.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)