diff --git a/src/eth/tb/taxi_axis_baser_rx_32/test_taxi_axis_baser_rx_32.py b/src/eth/tb/taxi_axis_baser_rx_32/test_taxi_axis_baser_rx_32.py index 4daa36c..2f73d5b 100644 --- a/src/eth/tb/taxi_axis_baser_rx_32/test_taxi_axis_baser_rx_32.py +++ b/src/eth/tb/taxi_axis_baser_rx_32/test_taxi_axis_baser_rx_32.py @@ -21,7 +21,6 @@ import cocotb from cocotb.clock import Clock from cocotb.triggers import RisingEdge from cocotb.utils import get_time_from_sim_steps -from cocotb.regression import TestFactory from cocotbext.eth import XgmiiFrame, PtpClockSimTime from cocotbext.axi import AxiStreamBus, AxiStreamSink @@ -145,6 +144,33 @@ class TB: self.stats[stat] += int(getattr(self.dut, stat).value) +def size_list(): + return list(range(60, 128)) + [512, 1514, 9214] + [60]*10 + [i for i in range(64, 73) for k in range(8)] + + +def incrementing_payload(length): + return bytearray(itertools.islice(itertools.cycle(range(256)), length)) + + +gbx_cfgs = [None] +usxgmii_speeds = [None] +if getattr(cocotb, 'top', None) is not None: + if cocotb.top.GBX_IF_EN.value: + gbx_cfgs.append((33, [32])) + gbx_cfgs.append((66, [64, 65])) + if cocotb.top.USXGMII_EN.value: + usxgmii_speeds.extend([2, 4, 5, 3, 10, 12, 13]) + + +@cocotb.test() +@cocotb.parametrize( + ("payload_lengths", [size_list]), + ("payload_data", [incrementing_payload]), + ("ifg", [0, 1, 11, 12]), + ("offset_start", [False, True]), + ("usxgmii_speed", usxgmii_speeds), + ("gbx_cfg", gbx_cfgs), +) async def run_test(dut, gbx_cfg=None, offset_start=False, usxgmii_speed=None, payload_lengths=None, payload_data=None, ifg=12): tb = TB(dut, gbx_cfg, usxgmii_speed) @@ -212,6 +238,12 @@ async def run_test(dut, gbx_cfg=None, offset_start=False, usxgmii_speed=None, pa await RisingEdge(dut.clk) +@cocotb.test() +@cocotb.parametrize( + ("ifg", [0, 1, 11, 12]), + ("usxgmii_speed", usxgmii_speeds), + ("gbx_cfg", gbx_cfgs), +) async def run_test_oversize(dut, gbx_cfg=None, usxgmii_speed=None, ifg=12): tb = TB(dut, gbx_cfg, usxgmii_speed) @@ -301,6 +333,11 @@ async def run_test_oversize(dut, gbx_cfg=None, usxgmii_speed=None, ifg=12): await RisingEdge(dut.clk) +@cocotb.test() +@cocotb.parametrize( + ("usxgmii_speed", usxgmii_speeds), + ("gbx_cfg", gbx_cfgs), +) async def run_test_os(dut, gbx_cfg=None, usxgmii_speed=None): tb = TB(dut, gbx_cfg, usxgmii_speed) @@ -328,47 +365,6 @@ async def run_test_os(dut, gbx_cfg=None, usxgmii_speed=None): await RisingEdge(dut.clk) -def size_list(): - return list(range(60, 128)) + [512, 1514, 9214] + [60]*10 + [i for i in range(64, 73) for k in range(8)] - - -def incrementing_payload(length): - return bytearray(itertools.islice(itertools.cycle(range(256)), length)) - - -def cycle_en(): - return itertools.cycle([0, 0, 0, 1]) - - -if getattr(cocotb, 'top', None) is not None: - - gbx_cfgs = [None] - - if cocotb.top.GBX_IF_EN.value: - gbx_cfgs.append((33, [32])) - gbx_cfgs.append((66, [64, 65])) - - factory = TestFactory(run_test) - factory.add_option("payload_lengths", [size_list]) - factory.add_option("payload_data", [incrementing_payload]) - factory.add_option("ifg", [0, 1, 11, 12]) - factory.add_option("offset_start", [False, True]) - factory.add_option("usxgmii_speed", [None, 2, 4, 5, 3, 10, 12, 13]) - factory.add_option("gbx_cfg", gbx_cfgs) - factory.generate_tests() - - factory = TestFactory(run_test_oversize) - factory.add_option("ifg", [0, 1, 11, 12]) - factory.add_option("usxgmii_speed", [None, 2, 4, 5, 3, 10, 12, 13]) - factory.add_option("gbx_cfg", gbx_cfgs) - factory.generate_tests() - - factory = TestFactory(run_test_os) - factory.add_option("usxgmii_speed", [None, 2, 4, 5, 3, 10, 12, 13]) - factory.add_option("gbx_cfg", gbx_cfgs) - factory.generate_tests() - - # cocotb-test tests_dir = os.path.abspath(os.path.dirname(__file__)) diff --git a/src/eth/tb/taxi_axis_baser_rx_64/test_taxi_axis_baser_rx_64.py b/src/eth/tb/taxi_axis_baser_rx_64/test_taxi_axis_baser_rx_64.py index 42ca703..a28d10c 100644 --- a/src/eth/tb/taxi_axis_baser_rx_64/test_taxi_axis_baser_rx_64.py +++ b/src/eth/tb/taxi_axis_baser_rx_64/test_taxi_axis_baser_rx_64.py @@ -21,7 +21,6 @@ import cocotb from cocotb.clock import Clock from cocotb.triggers import RisingEdge from cocotb.utils import get_time_from_sim_steps -from cocotb.regression import TestFactory from cocotbext.eth import XgmiiFrame, PtpClockSimTime from cocotbext.axi import AxiStreamBus, AxiStreamSink @@ -145,6 +144,32 @@ class TB: self.stats[stat] += int(getattr(self.dut, stat).value) +def size_list(): + return list(range(60, 128)) + [512, 1514, 9214] + [60]*10 + [i for i in range(64, 73) for k in range(8)] + + +def incrementing_payload(length): + return bytearray(itertools.islice(itertools.cycle(range(256)), length)) + + +gbx_cfgs = [None] +usxgmii_speeds = [None] +if getattr(cocotb, 'top', None) is not None: + if cocotb.top.GBX_IF_EN.value: + gbx_cfgs.append((33, [32])) + gbx_cfgs.append((66, [64, 65])) + if cocotb.top.USXGMII_EN.value: + usxgmii_speeds.extend([2, 4, 5, 3, 10, 12, 13]) + +@cocotb.test() +@cocotb.parametrize( + ("payload_lengths", [size_list]), + ("payload_data", [incrementing_payload]), + ("ifg", [0, 1, 11, 12]), + ("offset_start", [False, True]), + ("usxgmii_speed", usxgmii_speeds), + ("gbx_cfg", gbx_cfgs), +) async def run_test(dut, gbx_cfg=None, offset_start=False, usxgmii_speed=None, payload_lengths=None, payload_data=None, ifg=12): if dut.USXGMII_EN.value: @@ -217,6 +242,12 @@ async def run_test(dut, gbx_cfg=None, offset_start=False, usxgmii_speed=None, pa await RisingEdge(dut.clk) +@cocotb.test() +@cocotb.parametrize( + # ("ifg", [0, 1, 11, 12]), + ("usxgmii_speed", usxgmii_speeds), + ("gbx_cfg", gbx_cfgs), +) async def run_test_oversize(dut, gbx_cfg=None, usxgmii_speed=None, ifg=12): tb = TB(dut, gbx_cfg, usxgmii_speed) @@ -306,6 +337,11 @@ async def run_test_oversize(dut, gbx_cfg=None, usxgmii_speed=None, ifg=12): await RisingEdge(dut.clk) +@cocotb.test() +@cocotb.parametrize( + ("usxgmii_speed", usxgmii_speeds), + ("gbx_cfg", gbx_cfgs), +) async def run_test_os(dut, gbx_cfg=None, usxgmii_speed=None): tb = TB(dut, gbx_cfg, usxgmii_speed) @@ -333,50 +369,6 @@ async def run_test_os(dut, gbx_cfg=None, usxgmii_speed=None): await RisingEdge(dut.clk) -def size_list(): - return list(range(60, 128)) + [512, 1514, 9214] + [60]*10 + [i for i in range(64, 73) for k in range(8)] - - -def incrementing_payload(length): - return bytearray(itertools.islice(itertools.cycle(range(256)), length)) - - -def cycle_en(): - return itertools.cycle([0, 0, 0, 1]) - - -if getattr(cocotb, 'top', None) is not None: - - gbx_cfgs = [None] - - if cocotb.top.GBX_IF_EN.value: - gbx_cfgs.append((33, [32])) - gbx_cfgs.append((66, [64, 65])) - - factory = TestFactory(run_test) - factory.add_option("payload_lengths", [size_list]) - factory.add_option("payload_data", [incrementing_payload]) - factory.add_option("ifg", [0, 1, 11, 12]) - factory.add_option("offset_start", [False, True]) - if cocotb.top.USXGMII_EN.value: - factory.add_option("usxgmii_speed", [None, 2, 4, 5, 3, 10, 12, 13]) - factory.add_option("gbx_cfg", gbx_cfgs) - factory.generate_tests() - - factory = TestFactory(run_test_oversize) - # factory.add_option("ifg", [0, 1, 11, 12]) - if cocotb.top.USXGMII_EN.value: - factory.add_option("usxgmii_speed", [None, 2, 4, 5, 3, 10, 12, 13]) - factory.add_option("gbx_cfg", gbx_cfgs) - factory.generate_tests() - - factory = TestFactory(run_test_os) - if cocotb.top.USXGMII_EN.value: - factory.add_option("usxgmii_speed", [None, 2, 4, 5, 3, 10, 12, 13]) - factory.add_option("gbx_cfg", gbx_cfgs) - factory.generate_tests() - - # cocotb-test tests_dir = os.path.abspath(os.path.dirname(__file__)) diff --git a/src/eth/tb/taxi_axis_baser_tx_32/test_taxi_axis_baser_tx_32.py b/src/eth/tb/taxi_axis_baser_tx_32/test_taxi_axis_baser_tx_32.py index 9515bcd..2579e03 100644 --- a/src/eth/tb/taxi_axis_baser_tx_32/test_taxi_axis_baser_tx_32.py +++ b/src/eth/tb/taxi_axis_baser_tx_32/test_taxi_axis_baser_tx_32.py @@ -21,7 +21,6 @@ import cocotb from cocotb.clock import Clock from cocotb.triggers import RisingEdge from cocotb.utils import get_time_from_sim_steps -from cocotb.regression import TestFactory from cocotbext.eth import PtpClockSimTime from cocotbext.axi import AxiStreamBus, AxiStreamSource, AxiStreamSink, AxiStreamFrame @@ -150,6 +149,32 @@ class TB: self.stats[stat] += int(getattr(self.dut, stat).value) +def size_list(): + return list(range(16, 128)) + [512, 1514, 9214] + [60]*10 + [i for i in range(64, 73) for k in range(8)] + + +def incrementing_payload(length): + return bytearray(itertools.islice(itertools.cycle(range(256)), length)) + + +gbx_cfgs = [None] +usxgmii_speeds = [None] +if getattr(cocotb, 'top', None) is not None: + if cocotb.top.GBX_IF_EN.value: + gbx_cfgs.append((33, [32])) + gbx_cfgs.append((66, [64, 65])) + if cocotb.top.USXGMII_EN.value: + usxgmii_speeds.extend([2, 4, 5, 3, 10, 12, 13]) + + +@cocotb.test() +@cocotb.parametrize( + ("payload_lengths", [size_list]), + ("payload_data", [incrementing_payload]), + ("ifg", [12]), + ("usxgmii_speed", usxgmii_speeds), + ("gbx_cfg", gbx_cfgs), +) async def run_test(dut, gbx_cfg=None, usxgmii_speed=None, payload_lengths=None, payload_data=None, ifg=12): tb = TB(dut, gbx_cfg, usxgmii_speed) @@ -213,6 +238,12 @@ async def run_test(dut, gbx_cfg=None, usxgmii_speed=None, payload_lengths=None, await RisingEdge(dut.clk) +@cocotb.test() +@cocotb.parametrize( + ("ifg", [12]), + ("usxgmii_speed", usxgmii_speeds), + ("gbx_cfg", gbx_cfgs), +) async def run_test_underrun(dut, gbx_cfg=None, usxgmii_speed=None, ifg=12): tb = TB(dut, gbx_cfg, usxgmii_speed) @@ -275,6 +306,12 @@ async def run_test_underrun(dut, gbx_cfg=None, usxgmii_speed=None, ifg=12): await RisingEdge(dut.clk) +@cocotb.test() +@cocotb.parametrize( + ("ifg", [12]), + ("usxgmii_speed", usxgmii_speeds), + ("gbx_cfg", gbx_cfgs), +) async def run_test_error(dut, gbx_cfg=None, usxgmii_speed=None, ifg=12): tb = TB(dut, gbx_cfg, usxgmii_speed) @@ -329,6 +366,12 @@ async def run_test_error(dut, gbx_cfg=None, usxgmii_speed=None, ifg=12): await RisingEdge(dut.clk) +@cocotb.test() +@cocotb.parametrize( + ("ifg", [12]), + ("usxgmii_speed", usxgmii_speeds), + ("gbx_cfg", gbx_cfgs), +) async def run_test_oversize(dut, gbx_cfg=None, usxgmii_speed=None, ifg=12): tb = TB(dut, gbx_cfg, usxgmii_speed) @@ -418,6 +461,11 @@ async def run_test_oversize(dut, gbx_cfg=None, usxgmii_speed=None, ifg=12): await RisingEdge(dut.clk) +@cocotb.test() +@cocotb.parametrize( + ("usxgmii_speed", usxgmii_speeds), + ("gbx_cfg", gbx_cfgs), +) async def run_test_os(dut, gbx_cfg=None, usxgmii_speed=None): tb = TB(dut, gbx_cfg, usxgmii_speed) @@ -446,52 +494,6 @@ async def run_test_os(dut, gbx_cfg=None, usxgmii_speed=None): await RisingEdge(dut.clk) -def size_list(): - return list(range(16, 128)) + [512, 1514, 9214] + [60]*10 + [i for i in range(64, 73) for k in range(8)] - - -def incrementing_payload(length): - return bytearray(itertools.islice(itertools.cycle(range(256)), length)) - - -def cycle_en(): - return itertools.cycle([0, 0, 0, 1]) - - -if getattr(cocotb, 'top', None) is not None: - - gbx_cfgs = [None] - - if cocotb.top.GBX_IF_EN.value: - gbx_cfgs.append((33, [32])) - gbx_cfgs.append((66, [64, 65])) - - factory = TestFactory(run_test) - factory.add_option("payload_lengths", [size_list]) - factory.add_option("payload_data", [incrementing_payload]) - factory.add_option("ifg", [12]) - factory.add_option("usxgmii_speed", [None, 2, 4, 5, 3, 10, 12, 13]) - factory.add_option("gbx_cfg", gbx_cfgs) - factory.generate_tests() - - for test in [ - run_test_underrun, - run_test_error, - run_test_oversize - ]: - - factory = TestFactory(test) - factory.add_option("ifg", [12]) - factory.add_option("usxgmii_speed", [None, 2, 4, 5, 3, 10, 12, 13]) - factory.add_option("gbx_cfg", gbx_cfgs) - factory.generate_tests() - - factory = TestFactory(run_test_os) - factory.add_option("usxgmii_speed", [None, 2, 4, 5, 3, 10, 12, 13]) - factory.add_option("gbx_cfg", gbx_cfgs) - factory.generate_tests() - - # cocotb-test tests_dir = os.path.abspath(os.path.dirname(__file__)) diff --git a/src/eth/tb/taxi_axis_baser_tx_64/test_taxi_axis_baser_tx_64.py b/src/eth/tb/taxi_axis_baser_tx_64/test_taxi_axis_baser_tx_64.py index cab7837..a0ab13c 100644 --- a/src/eth/tb/taxi_axis_baser_tx_64/test_taxi_axis_baser_tx_64.py +++ b/src/eth/tb/taxi_axis_baser_tx_64/test_taxi_axis_baser_tx_64.py @@ -21,7 +21,6 @@ import cocotb from cocotb.clock import Clock from cocotb.triggers import RisingEdge from cocotb.utils import get_time_from_sim_steps -from cocotb.regression import TestFactory from cocotbext.eth import PtpClockSimTime from cocotbext.axi import AxiStreamBus, AxiStreamSource, AxiStreamSink, AxiStreamFrame @@ -150,6 +149,32 @@ class TB: self.stats[stat] += int(getattr(self.dut, stat).value) +def size_list(): + return list(range(16, 128)) + [512, 1514, 9214] + [60]*10 + [i for i in range(64, 73) for k in range(8)] + + +def incrementing_payload(length): + return bytearray(itertools.islice(itertools.cycle(range(256)), length)) + + +gbx_cfgs = [None] +usxgmii_speeds = [None] +if getattr(cocotb, 'top', None) is not None: + if cocotb.top.GBX_IF_EN.value: + gbx_cfgs.append((33, [32])) + gbx_cfgs.append((66, [64, 65])) + if cocotb.top.USXGMII_EN.value: + usxgmii_speeds.extend([2, 4, 5, 3, 10, 12, 13]) + + +@cocotb.test() +@cocotb.parametrize( + ("payload_lengths", [size_list]), + ("payload_data", [incrementing_payload]), + ("ifg", [12]), + ("usxgmii_speed", usxgmii_speeds), + ("gbx_cfg", gbx_cfgs), +) async def run_test(dut, gbx_cfg=None, usxgmii_speed=None, payload_lengths=None, payload_data=None, ifg=12): tb = TB(dut, gbx_cfg, usxgmii_speed) @@ -213,6 +238,13 @@ async def run_test(dut, gbx_cfg=None, usxgmii_speed=None, payload_lengths=None, await RisingEdge(dut.clk) +@cocotb.test() +@cocotb.parametrize( + ("payload_data", [incrementing_payload]), + ("ifg", [12]), + # ("usxgmii_speed", usxgmii_speeds), + ("gbx_cfg", gbx_cfgs), +) async def run_test_alignment(dut, gbx_cfg=None, usxgmii_speed=None, payload_data=None, ifg=12): enable_dic = int(dut.DIC_EN.value) @@ -322,6 +354,12 @@ async def run_test_alignment(dut, gbx_cfg=None, usxgmii_speed=None, payload_data await RisingEdge(dut.clk) +@cocotb.test() +@cocotb.parametrize( + ("ifg", [12]), + ("usxgmii_speed", usxgmii_speeds), + ("gbx_cfg", gbx_cfgs), +) async def run_test_underrun(dut, gbx_cfg=None, usxgmii_speed=None, ifg=12): tb = TB(dut, gbx_cfg, usxgmii_speed) @@ -384,6 +422,12 @@ async def run_test_underrun(dut, gbx_cfg=None, usxgmii_speed=None, ifg=12): await RisingEdge(dut.clk) +@cocotb.test() +@cocotb.parametrize( + ("ifg", [12]), + ("usxgmii_speed", usxgmii_speeds), + ("gbx_cfg", gbx_cfgs), +) async def run_test_error(dut, gbx_cfg=None, usxgmii_speed=None, ifg=12): tb = TB(dut, gbx_cfg, usxgmii_speed) @@ -438,6 +482,12 @@ async def run_test_error(dut, gbx_cfg=None, usxgmii_speed=None, ifg=12): await RisingEdge(dut.clk) +@cocotb.test() +@cocotb.parametrize( + ("ifg", [12]), + ("usxgmii_speed", usxgmii_speeds), + ("gbx_cfg", gbx_cfgs), +) async def run_test_oversize(dut, gbx_cfg=None, usxgmii_speed=None, ifg=12): tb = TB(dut, gbx_cfg, usxgmii_speed) @@ -527,6 +577,11 @@ async def run_test_oversize(dut, gbx_cfg=None, usxgmii_speed=None, ifg=12): await RisingEdge(dut.clk) +@cocotb.test() +@cocotb.parametrize( + ("usxgmii_speed", usxgmii_speeds), + ("gbx_cfg", gbx_cfgs), +) async def run_test_os(dut, gbx_cfg=None, usxgmii_speed=None): tb = TB(dut, gbx_cfg, usxgmii_speed) @@ -555,59 +610,6 @@ async def run_test_os(dut, gbx_cfg=None, usxgmii_speed=None): await RisingEdge(dut.clk) -def size_list(): - return list(range(16, 128)) + [512, 1514, 9214] + [60]*10 + [i for i in range(64, 73) for k in range(8)] - - -def incrementing_payload(length): - return bytearray(itertools.islice(itertools.cycle(range(256)), length)) - - -def cycle_en(): - return itertools.cycle([0, 0, 0, 1]) - - -if getattr(cocotb, 'top', None) is not None: - - gbx_cfgs = [None] - - if cocotb.top.GBX_IF_EN.value: - gbx_cfgs.append((33, [32])) - gbx_cfgs.append((66, [64, 65])) - - factory = TestFactory(run_test) - factory.add_option("payload_lengths", [size_list]) - factory.add_option("payload_data", [incrementing_payload]) - factory.add_option("ifg", [12]) - factory.add_option("usxgmii_speed", [None, 2, 4, 5, 3, 10, 12, 13]) - factory.add_option("gbx_cfg", gbx_cfgs) - factory.generate_tests() - - factory = TestFactory(run_test_alignment) - factory.add_option("payload_data", [incrementing_payload]) - factory.add_option("ifg", [12]) - # factory.add_option("usxgmii_speed", [None, 2, 4, 5, 3, 10, 12, 13]) - factory.add_option("gbx_cfg", gbx_cfgs) - factory.generate_tests() - - for test in [ - run_test_underrun, - run_test_error, - run_test_oversize - ]: - - factory = TestFactory(test) - factory.add_option("ifg", [12]) - factory.add_option("usxgmii_speed", [None, 2, 4, 5, 3, 10, 12, 13]) - factory.add_option("gbx_cfg", gbx_cfgs) - factory.generate_tests() - - factory = TestFactory(run_test_os) - factory.add_option("usxgmii_speed", [None, 2, 4, 5, 3, 10, 12, 13]) - factory.add_option("gbx_cfg", gbx_cfgs) - factory.generate_tests() - - # cocotb-test tests_dir = os.path.abspath(os.path.dirname(__file__)) diff --git a/src/eth/tb/taxi_axis_basex_rx_16/test_taxi_axis_basex_rx_16.py b/src/eth/tb/taxi_axis_basex_rx_16/test_taxi_axis_basex_rx_16.py index c45a293..74a7775 100644 --- a/src/eth/tb/taxi_axis_basex_rx_16/test_taxi_axis_basex_rx_16.py +++ b/src/eth/tb/taxi_axis_basex_rx_16/test_taxi_axis_basex_rx_16.py @@ -21,7 +21,6 @@ import cocotb from cocotb.clock import Clock from cocotb.triggers import RisingEdge from cocotb.utils import get_time_from_sim_steps -from cocotb.regression import TestFactory from cocotbext.eth import GmiiFrame, PtpClockSimTime from cocotbext.axi import AxiStreamBus, AxiStreamSink @@ -124,6 +123,34 @@ class TB: self.stats[stat] += int(getattr(self.dut, stat).value) +def size_list(): + return list(range(60, 128)) + [512, 1514, 9214] + [60]*10 + [i for i in range(64, 73) for k in range(8)] + + +def incrementing_payload(length): + return bytearray(itertools.islice(itertools.cycle(range(256)), length)) + + +gbx_cfgs = [None] +an_en = False +sgmii_speeds = [None] +if getattr(cocotb, 'top', None) is not None: + if cocotb.top.GBX_IF_EN.value: + gbx_cfgs.append((5, [4])) + an_en = bool(cocotb.top.AN_EN.value) + if cocotb.top.SGMII_EN.value: + sgmii_speeds.extend([1, 2]) + + +@cocotb.test() +@cocotb.parametrize( + ("payload_lengths", [size_list]), + ("payload_data", [incrementing_payload]), + ("ifg", [0, 1, 11, 12]), + ("pre_trunc", [False, True]), + ("sgmii_speed", sgmii_speeds), + ("gbx_cfg", gbx_cfgs), +) async def run_test(dut, gbx_cfg=None, sgmii_speed=None, payload_lengths=None, payload_data=None, ifg=12, pre_trunc=False): tb = TB(dut, gbx_cfg, sgmii_speed) @@ -191,6 +218,12 @@ async def run_test(dut, gbx_cfg=None, sgmii_speed=None, payload_lengths=None, pa await RisingEdge(dut.clk) +@cocotb.test() +@cocotb.parametrize( + ("ifg", [0, 1, 11, 12]), + ("sgmii_speed", sgmii_speeds), + ("gbx_cfg", gbx_cfgs), +) async def run_test_oversize(dut, gbx_cfg=None, sgmii_speed=None, ifg=12): tb = TB(dut, gbx_cfg, sgmii_speed) @@ -280,6 +313,11 @@ async def run_test_oversize(dut, gbx_cfg=None, sgmii_speed=None, ifg=12): await RisingEdge(dut.clk) +@cocotb.test(skip=(not an_en)) +@cocotb.parametrize( + ("sgmii_speed", sgmii_speeds), + ("gbx_cfg", gbx_cfgs), +) async def run_test_an(dut, gbx_cfg=None, sgmii_speed=None): tb = TB(dut, gbx_cfg, sgmii_speed) @@ -312,46 +350,6 @@ async def run_test_an(dut, gbx_cfg=None, sgmii_speed=None): await RisingEdge(dut.clk) -def size_list(): - return list(range(60, 128)) + [512, 1514, 9214] + [60]*10 + [i for i in range(64, 73) for k in range(8)] - - -def incrementing_payload(length): - return bytearray(itertools.islice(itertools.cycle(range(256)), length)) - - -def cycle_en(): - return itertools.cycle([0, 0, 0, 1]) - - -if getattr(cocotb, 'top', None) is not None: - - gbx_cfgs = [None] - - if cocotb.top.GBX_IF_EN.value: - gbx_cfgs.append((5, [4])) - - factory = TestFactory(run_test) - factory.add_option("payload_lengths", [size_list]) - factory.add_option("payload_data", [incrementing_payload]) - factory.add_option("ifg", [0, 1, 11, 12]) - factory.add_option("pre_trunc", [False, True]) - factory.add_option("sgmii_speed", [None, 1, 2]) - factory.add_option("gbx_cfg", gbx_cfgs) - factory.generate_tests() - - factory = TestFactory(run_test_oversize) - factory.add_option("ifg", [0, 1, 11, 12]) - factory.add_option("sgmii_speed", [None, 1, 2]) - factory.add_option("gbx_cfg", gbx_cfgs) - factory.generate_tests() - - factory = TestFactory(run_test_an) - factory.add_option("sgmii_speed", [None, 1, 2]) - factory.add_option("gbx_cfg", gbx_cfgs) - factory.generate_tests() - - # cocotb-test tests_dir = os.path.abspath(os.path.dirname(__file__)) diff --git a/src/eth/tb/taxi_axis_basex_rx_8/test_taxi_axis_basex_rx_8.py b/src/eth/tb/taxi_axis_basex_rx_8/test_taxi_axis_basex_rx_8.py index 64edf4e..7a8c513 100644 --- a/src/eth/tb/taxi_axis_basex_rx_8/test_taxi_axis_basex_rx_8.py +++ b/src/eth/tb/taxi_axis_basex_rx_8/test_taxi_axis_basex_rx_8.py @@ -21,7 +21,6 @@ import cocotb from cocotb.clock import Clock from cocotb.triggers import RisingEdge from cocotb.utils import get_time_from_sim_steps -from cocotb.regression import TestFactory from cocotbext.eth import GmiiFrame, PtpClockSimTime from cocotbext.axi import AxiStreamBus, AxiStreamSink @@ -124,6 +123,34 @@ class TB: self.stats[stat] += int(getattr(self.dut, stat).value) +def size_list(): + return list(range(60, 128)) + [512, 1514, 9214] + [60]*10 + [i for i in range(64, 73) for k in range(8)] + + +def incrementing_payload(length): + return bytearray(itertools.islice(itertools.cycle(range(256)), length)) + + +gbx_cfgs = [None] +an_en = False +sgmii_speeds = [None] +if getattr(cocotb, 'top', None) is not None: + if cocotb.top.GBX_IF_EN.value: + gbx_cfgs.append((5, [4])) + an_en = bool(cocotb.top.AN_EN.value) + if cocotb.top.SGMII_EN.value: + sgmii_speeds.extend([1, 2]) + + +@cocotb.test() +@cocotb.parametrize( + ("payload_lengths", [size_list]), + ("payload_data", [incrementing_payload]), + ("ifg", [0, 1, 11, 12]), + ("pre_trunc", [False, True]), + ("sgmii_speed", sgmii_speeds), + ("gbx_cfg", gbx_cfgs), +) async def run_test(dut, gbx_cfg=None, sgmii_speed=None, payload_lengths=None, payload_data=None, ifg=12, pre_trunc=False): tb = TB(dut, gbx_cfg, sgmii_speed) @@ -191,6 +218,12 @@ async def run_test(dut, gbx_cfg=None, sgmii_speed=None, payload_lengths=None, pa await RisingEdge(dut.clk) +@cocotb.test() +@cocotb.parametrize( + ("ifg", [0, 1, 11, 12]), + ("sgmii_speed", sgmii_speeds), + ("gbx_cfg", gbx_cfgs), +) async def run_test_oversize(dut, gbx_cfg=None, sgmii_speed=None, ifg=12): tb = TB(dut, gbx_cfg, sgmii_speed) @@ -280,6 +313,11 @@ async def run_test_oversize(dut, gbx_cfg=None, sgmii_speed=None, ifg=12): await RisingEdge(dut.clk) +@cocotb.test(skip=(not an_en)) +@cocotb.parametrize( + ("sgmii_speed", sgmii_speeds), + ("gbx_cfg", gbx_cfgs), +) async def run_test_an(dut, gbx_cfg=None, sgmii_speed=None): tb = TB(dut, gbx_cfg, sgmii_speed) @@ -312,46 +350,6 @@ async def run_test_an(dut, gbx_cfg=None, sgmii_speed=None): await RisingEdge(dut.clk) -def size_list(): - return list(range(60, 128)) + [512, 1514, 9214] + [60]*10 + [i for i in range(64, 73) for k in range(8)] - - -def incrementing_payload(length): - return bytearray(itertools.islice(itertools.cycle(range(256)), length)) - - -def cycle_en(): - return itertools.cycle([0, 0, 0, 1]) - - -if getattr(cocotb, 'top', None) is not None: - - gbx_cfgs = [None] - - if cocotb.top.GBX_IF_EN.value: - gbx_cfgs.append((5, [4])) - - factory = TestFactory(run_test) - factory.add_option("payload_lengths", [size_list]) - factory.add_option("payload_data", [incrementing_payload]) - factory.add_option("ifg", [0, 1, 11, 12]) - factory.add_option("pre_trunc", [False, True]) - factory.add_option("sgmii_speed", [None, 1, 2]) - factory.add_option("gbx_cfg", gbx_cfgs) - factory.generate_tests() - - factory = TestFactory(run_test_oversize) - factory.add_option("ifg", [0, 1, 11, 12]) - factory.add_option("sgmii_speed", [None, 1, 2]) - factory.add_option("gbx_cfg", gbx_cfgs) - factory.generate_tests() - - factory = TestFactory(run_test_an) - factory.add_option("sgmii_speed", [None, 1, 2]) - factory.add_option("gbx_cfg", gbx_cfgs) - factory.generate_tests() - - # cocotb-test tests_dir = os.path.abspath(os.path.dirname(__file__)) diff --git a/src/eth/tb/taxi_axis_basex_tx_16/test_taxi_axis_basex_tx_16.py b/src/eth/tb/taxi_axis_basex_tx_16/test_taxi_axis_basex_tx_16.py index f1625f9..83a1e8f 100644 --- a/src/eth/tb/taxi_axis_basex_tx_16/test_taxi_axis_basex_tx_16.py +++ b/src/eth/tb/taxi_axis_basex_tx_16/test_taxi_axis_basex_tx_16.py @@ -21,7 +21,6 @@ import cocotb from cocotb.clock import Clock from cocotb.triggers import RisingEdge from cocotb.utils import get_time_from_sim_steps -from cocotb.regression import TestFactory from cocotbext.eth import PtpClockSimTime from cocotbext.axi import AxiStreamBus, AxiStreamSource, AxiStreamSink, AxiStreamFrame @@ -128,6 +127,33 @@ class TB: self.stats[stat] += int(getattr(self.dut, stat).value) +def size_list(): + return list(range(16, 128)) + [512, 1514, 9214] + [60]*10 + [i for i in range(64, 73) for k in range(8)] + + +def incrementing_payload(length): + return bytearray(itertools.islice(itertools.cycle(range(256)), length)) + + +gbx_cfgs = [None] +an_en = False +sgmii_speeds = [None] +if getattr(cocotb, 'top', None) is not None: + if cocotb.top.GBX_IF_EN.value: + gbx_cfgs.append((5, [4])) + an_en = bool(cocotb.top.AN_EN.value) + if cocotb.top.SGMII_EN.value: + sgmii_speeds.extend([1, 2]) + + +@cocotb.test() +@cocotb.parametrize( + ("payload_lengths", [size_list]), + ("payload_data", [incrementing_payload]), + ("ifg", [12]), + ("sgmii_speed", sgmii_speeds), + ("gbx_cfg", gbx_cfgs), +) async def run_test(dut, gbx_cfg=None, sgmii_speed=None, payload_lengths=None, payload_data=None, ifg=12): tb = TB(dut, gbx_cfg, sgmii_speed) @@ -191,6 +217,12 @@ async def run_test(dut, gbx_cfg=None, sgmii_speed=None, payload_lengths=None, pa await RisingEdge(dut.clk) +@cocotb.test() +@cocotb.parametrize( + ("ifg", [12]), + ("sgmii_speed", sgmii_speeds), + ("gbx_cfg", gbx_cfgs), +) async def run_test_underrun(dut, gbx_cfg=None, sgmii_speed=None, ifg=12): tb = TB(dut, gbx_cfg, sgmii_speed) @@ -253,6 +285,12 @@ async def run_test_underrun(dut, gbx_cfg=None, sgmii_speed=None, ifg=12): await RisingEdge(dut.clk) +@cocotb.test() +@cocotb.parametrize( + ("ifg", [12]), + ("sgmii_speed", sgmii_speeds), + ("gbx_cfg", gbx_cfgs), +) async def run_test_error(dut, gbx_cfg=None, sgmii_speed=None, ifg=12): tb = TB(dut, gbx_cfg, sgmii_speed) @@ -307,6 +345,12 @@ async def run_test_error(dut, gbx_cfg=None, sgmii_speed=None, ifg=12): await RisingEdge(dut.clk) +@cocotb.test() +@cocotb.parametrize( + ("ifg", [12]), + ("sgmii_speed", sgmii_speeds), + ("gbx_cfg", gbx_cfgs), +) async def run_test_oversize(dut, gbx_cfg=None, sgmii_speed=None, ifg=12): tb = TB(dut, gbx_cfg, sgmii_speed) @@ -396,6 +440,11 @@ async def run_test_oversize(dut, gbx_cfg=None, sgmii_speed=None, ifg=12): await RisingEdge(dut.clk) +@cocotb.test(skip=(not an_en)) +@cocotb.parametrize( + ("sgmii_speed", sgmii_speeds), + ("gbx_cfg", gbx_cfgs), +) async def run_test_an(dut, gbx_cfg=None, sgmii_speed=None): tb = TB(dut, gbx_cfg, sgmii_speed) @@ -429,51 +478,6 @@ async def run_test_an(dut, gbx_cfg=None, sgmii_speed=None): await RisingEdge(dut.clk) -def size_list(): - return list(range(16, 128)) + [512, 1514, 9214] + [60]*10 + [i for i in range(64, 73) for k in range(8)] - - -def incrementing_payload(length): - return bytearray(itertools.islice(itertools.cycle(range(256)), length)) - - -def cycle_en(): - return itertools.cycle([0, 0, 0, 1]) - - -if getattr(cocotb, 'top', None) is not None: - - gbx_cfgs = [None] - - if cocotb.top.GBX_IF_EN.value: - gbx_cfgs.append((5, [4])) - - factory = TestFactory(run_test) - factory.add_option("payload_lengths", [size_list]) - factory.add_option("payload_data", [incrementing_payload]) - factory.add_option("ifg", [12]) - factory.add_option("sgmii_speed", [None, 1, 2]) - factory.add_option("gbx_cfg", gbx_cfgs) - factory.generate_tests() - - for test in [ - run_test_underrun, - run_test_error, - run_test_oversize - ]: - - factory = TestFactory(test) - factory.add_option("ifg", [12]) - factory.add_option("sgmii_speed", [None, 1, 2]) - factory.add_option("gbx_cfg", gbx_cfgs) - factory.generate_tests() - - factory = TestFactory(run_test_an) - factory.add_option("sgmii_speed", [None, 1, 2]) - factory.add_option("gbx_cfg", gbx_cfgs) - factory.generate_tests() - - # cocotb-test tests_dir = os.path.abspath(os.path.dirname(__file__)) diff --git a/src/eth/tb/taxi_axis_basex_tx_8/test_taxi_axis_basex_tx_8.py b/src/eth/tb/taxi_axis_basex_tx_8/test_taxi_axis_basex_tx_8.py index 7177934..85cc09a 100644 --- a/src/eth/tb/taxi_axis_basex_tx_8/test_taxi_axis_basex_tx_8.py +++ b/src/eth/tb/taxi_axis_basex_tx_8/test_taxi_axis_basex_tx_8.py @@ -21,7 +21,6 @@ import cocotb from cocotb.clock import Clock from cocotb.triggers import RisingEdge from cocotb.utils import get_time_from_sim_steps -from cocotb.regression import TestFactory from cocotbext.eth import PtpClockSimTime from cocotbext.axi import AxiStreamBus, AxiStreamSource, AxiStreamSink, AxiStreamFrame @@ -128,6 +127,33 @@ class TB: self.stats[stat] += int(getattr(self.dut, stat).value) +def size_list(): + return list(range(16, 128)) + [512, 1514, 9214] + [60]*10 + [i for i in range(64, 73) for k in range(8)] + + +def incrementing_payload(length): + return bytearray(itertools.islice(itertools.cycle(range(256)), length)) + + +gbx_cfgs = [None] +an_en = False +sgmii_speeds = [None] +if getattr(cocotb, 'top', None) is not None: + if cocotb.top.GBX_IF_EN.value: + gbx_cfgs.append((5, [4])) + an_en = bool(cocotb.top.AN_EN.value) + if cocotb.top.SGMII_EN.value: + sgmii_speeds.extend([1, 2]) + + +@cocotb.test() +@cocotb.parametrize( + ("payload_lengths", [size_list]), + ("payload_data", [incrementing_payload]), + ("ifg", [12]), + ("sgmii_speed", sgmii_speeds), + ("gbx_cfg", gbx_cfgs), +) async def run_test(dut, gbx_cfg=None, sgmii_speed=None, payload_lengths=None, payload_data=None, ifg=12): tb = TB(dut, gbx_cfg, sgmii_speed) @@ -191,6 +217,12 @@ async def run_test(dut, gbx_cfg=None, sgmii_speed=None, payload_lengths=None, pa await RisingEdge(dut.clk) +@cocotb.test() +@cocotb.parametrize( + ("ifg", [12]), + ("sgmii_speed", sgmii_speeds), + ("gbx_cfg", gbx_cfgs), +) async def run_test_underrun(dut, gbx_cfg=None, sgmii_speed=None, ifg=12): tb = TB(dut, gbx_cfg, sgmii_speed) @@ -253,6 +285,12 @@ async def run_test_underrun(dut, gbx_cfg=None, sgmii_speed=None, ifg=12): await RisingEdge(dut.clk) +@cocotb.test() +@cocotb.parametrize( + ("ifg", [12]), + ("sgmii_speed", sgmii_speeds), + ("gbx_cfg", gbx_cfgs), +) async def run_test_error(dut, gbx_cfg=None, sgmii_speed=None, ifg=12): tb = TB(dut, gbx_cfg, sgmii_speed) @@ -307,6 +345,12 @@ async def run_test_error(dut, gbx_cfg=None, sgmii_speed=None, ifg=12): await RisingEdge(dut.clk) +@cocotb.test() +@cocotb.parametrize( + ("ifg", [12]), + ("sgmii_speed", sgmii_speeds), + ("gbx_cfg", gbx_cfgs), +) async def run_test_oversize(dut, gbx_cfg=None, sgmii_speed=None, ifg=12): tb = TB(dut, gbx_cfg, sgmii_speed) @@ -396,6 +440,11 @@ async def run_test_oversize(dut, gbx_cfg=None, sgmii_speed=None, ifg=12): await RisingEdge(dut.clk) +@cocotb.test(skip=(not an_en)) +@cocotb.parametrize( + ("sgmii_speed", sgmii_speeds), + ("gbx_cfg", gbx_cfgs), +) async def run_test_an(dut, gbx_cfg=None, sgmii_speed=None): tb = TB(dut, gbx_cfg, sgmii_speed) @@ -429,51 +478,6 @@ async def run_test_an(dut, gbx_cfg=None, sgmii_speed=None): await RisingEdge(dut.clk) -def size_list(): - return list(range(16, 128)) + [512, 1514, 9214] + [60]*10 + [i for i in range(64, 73) for k in range(8)] - - -def incrementing_payload(length): - return bytearray(itertools.islice(itertools.cycle(range(256)), length)) - - -def cycle_en(): - return itertools.cycle([0, 0, 0, 1]) - - -if getattr(cocotb, 'top', None) is not None: - - gbx_cfgs = [None] - - if cocotb.top.GBX_IF_EN.value: - gbx_cfgs.append((5, [4])) - - factory = TestFactory(run_test) - factory.add_option("payload_lengths", [size_list]) - factory.add_option("payload_data", [incrementing_payload]) - factory.add_option("ifg", [12]) - factory.add_option("sgmii_speed", [None, 1, 2]) - factory.add_option("gbx_cfg", gbx_cfgs) - factory.generate_tests() - - for test in [ - run_test_underrun, - run_test_error, - run_test_oversize - ]: - - factory = TestFactory(test) - factory.add_option("ifg", [12]) - factory.add_option("sgmii_speed", [None, 1, 2]) - factory.add_option("gbx_cfg", gbx_cfgs) - factory.generate_tests() - - factory = TestFactory(run_test_an) - factory.add_option("sgmii_speed", [None, 1, 2]) - factory.add_option("gbx_cfg", gbx_cfgs) - factory.generate_tests() - - # cocotb-test tests_dir = os.path.abspath(os.path.dirname(__file__)) diff --git a/src/eth/tb/taxi_axis_gmii_rx/test_taxi_axis_gmii_rx.py b/src/eth/tb/taxi_axis_gmii_rx/test_taxi_axis_gmii_rx.py index bcd9d31..3e79acd 100644 --- a/src/eth/tb/taxi_axis_gmii_rx/test_taxi_axis_gmii_rx.py +++ b/src/eth/tb/taxi_axis_gmii_rx/test_taxi_axis_gmii_rx.py @@ -19,7 +19,6 @@ import cocotb from cocotb.clock import Clock from cocotb.triggers import RisingEdge from cocotb.utils import get_time_from_sim_steps -from cocotb.regression import TestFactory from cocotbext.eth import GmiiFrame, GmiiSource, PtpClockSimTime from cocotbext.axi import AxiStreamBus, AxiStreamSink @@ -110,6 +109,26 @@ class TB: await RisingEdge(self.dut.clk) +def size_list(): + return list(range(60, 128)) + [512, 1514] + [60]*10 + + +def incrementing_payload(length): + return bytearray(itertools.islice(itertools.cycle(range(256)), length)) + + +def cycle_en(): + return itertools.cycle([0, 0, 0, 1]) + + +@cocotb.test() +@cocotb.parametrize( + ("payload_lengths", [size_list]), + ("payload_data", [incrementing_payload]), + ("ifg", [12, 0]), + ("enable_gen", [None, cycle_en]), + ("mii_sel", [False, True]), +) async def run_test(dut, payload_lengths=None, payload_data=None, ifg=12, enable_gen=None, mii_sel=False): tb = TB(dut) @@ -180,6 +199,12 @@ async def run_test(dut, payload_lengths=None, payload_data=None, ifg=12, enable_ await RisingEdge(dut.clk) +@cocotb.test() +@cocotb.parametrize( + ("ifg", [12, 0]), + ("enable_gen", [None, cycle_en]), + ("mii_sel", [False, True]), +) async def run_test_oversize(dut, ifg=12, enable_gen=None, mii_sel=False): tb = TB(dut) @@ -274,35 +299,6 @@ async def run_test_oversize(dut, ifg=12, enable_gen=None, mii_sel=False): await RisingEdge(dut.clk) -def size_list(): - return list(range(60, 128)) + [512, 1514] + [60]*10 - - -def incrementing_payload(length): - return bytearray(itertools.islice(itertools.cycle(range(256)), length)) - - -def cycle_en(): - return itertools.cycle([0, 0, 0, 1]) - - -if getattr(cocotb, 'top', None) is not None: - - factory = TestFactory(run_test) - factory.add_option("payload_lengths", [size_list]) - factory.add_option("payload_data", [incrementing_payload]) - factory.add_option("ifg", [12, 0]) - factory.add_option("enable_gen", [None, cycle_en]) - factory.add_option("mii_sel", [False, True]) - factory.generate_tests() - - factory = TestFactory(run_test_oversize) - factory.add_option("ifg", [12, 0]) - factory.add_option("enable_gen", [None, cycle_en]) - factory.add_option("mii_sel", [False, True]) - factory.generate_tests() - - # cocotb-test tests_dir = os.path.abspath(os.path.dirname(__file__)) diff --git a/src/eth/tb/taxi_axis_gmii_tx/test_taxi_axis_gmii_tx.py b/src/eth/tb/taxi_axis_gmii_tx/test_taxi_axis_gmii_tx.py index b5ec470..f689533 100644 --- a/src/eth/tb/taxi_axis_gmii_tx/test_taxi_axis_gmii_tx.py +++ b/src/eth/tb/taxi_axis_gmii_tx/test_taxi_axis_gmii_tx.py @@ -19,7 +19,6 @@ import cocotb from cocotb.clock import Clock from cocotb.triggers import RisingEdge from cocotb.utils import get_time_from_sim_steps -from cocotb.regression import TestFactory from cocotbext.eth import GmiiSink, PtpClockSimTime from cocotbext.axi import AxiStreamBus, AxiStreamSource, AxiStreamSink, AxiStreamFrame @@ -108,6 +107,26 @@ class TB: await RisingEdge(self.dut.clk) +def size_list(): + return list(range(4, 128)) + [512, 1514] + [60]*10 + + +def incrementing_payload(length): + return bytearray(itertools.islice(itertools.cycle(range(256)), length)) + + +def cycle_en(): + return itertools.cycle([0, 0, 0, 1]) + + +@cocotb.test() +@cocotb.parametrize( + ("payload_lengths", [size_list]), + ("payload_data", [incrementing_payload]), + ("ifg", [12]), + ("enable_gen", [None, cycle_en]), + ("mii_sel", [False, True]), +) async def run_test(dut, payload_lengths=None, payload_data=None, ifg=12, enable_gen=None, mii_sel=False): tb = TB(dut) @@ -171,6 +190,12 @@ async def run_test(dut, payload_lengths=None, payload_data=None, ifg=12, enable_ await RisingEdge(dut.clk) +@cocotb.test() +@cocotb.parametrize( + ("ifg", [12]), + ("enable_gen", [None, cycle_en]), + ("mii_sel", [False, True]), +) async def run_test_underrun(dut, ifg=12, enable_gen=None, mii_sel=False): tb = TB(dut) @@ -239,6 +264,12 @@ async def run_test_underrun(dut, ifg=12, enable_gen=None, mii_sel=False): await RisingEdge(dut.clk) +@cocotb.test() +@cocotb.parametrize( + ("ifg", [12]), + ("enable_gen", [None, cycle_en]), + ("mii_sel", [False, True]), +) async def run_test_error(dut, ifg=12, enable_gen=None, mii_sel=False): tb = TB(dut) @@ -293,6 +324,12 @@ async def run_test_error(dut, ifg=12, enable_gen=None, mii_sel=False): await RisingEdge(dut.clk) +@cocotb.test() +@cocotb.parametrize( + ("ifg", [12]), + ("enable_gen", [None, cycle_en]), + ("mii_sel", [False, True]), +) async def run_test_oversize(dut, ifg=12, enable_gen=None, mii_sel=False): tb = TB(dut) @@ -382,41 +419,6 @@ async def run_test_oversize(dut, ifg=12, enable_gen=None, mii_sel=False): await RisingEdge(dut.clk) -def size_list(): - return list(range(4, 128)) + [512, 1514] + [60]*10 - - -def incrementing_payload(length): - return bytearray(itertools.islice(itertools.cycle(range(256)), length)) - - -def cycle_en(): - return itertools.cycle([0, 0, 0, 1]) - - -if getattr(cocotb, 'top', None) is not None: - - factory = TestFactory(run_test) - factory.add_option("payload_lengths", [size_list]) - factory.add_option("payload_data", [incrementing_payload]) - factory.add_option("ifg", [12]) - factory.add_option("enable_gen", [None, cycle_en]) - factory.add_option("mii_sel", [False, True]) - factory.generate_tests() - - for test in [ - run_test_underrun, - run_test_error, - run_test_oversize, - ]: - - factory = TestFactory(test) - factory.add_option("ifg", [12]) - factory.add_option("enable_gen", [None, cycle_en]) - factory.add_option("mii_sel", [False, True]) - factory.generate_tests() - - # cocotb-test tests_dir = os.path.abspath(os.path.dirname(__file__)) diff --git a/src/eth/tb/taxi_axis_xgmii_rx_32/test_taxi_axis_xgmii_rx_32.py b/src/eth/tb/taxi_axis_xgmii_rx_32/test_taxi_axis_xgmii_rx_32.py index 5af6953..f085e7e 100644 --- a/src/eth/tb/taxi_axis_xgmii_rx_32/test_taxi_axis_xgmii_rx_32.py +++ b/src/eth/tb/taxi_axis_xgmii_rx_32/test_taxi_axis_xgmii_rx_32.py @@ -19,7 +19,6 @@ import cocotb from cocotb.clock import Clock from cocotb.triggers import RisingEdge from cocotb.utils import get_time_from_sim_steps -from cocotb.regression import TestFactory from cocotbext.eth import XgmiiFrame, XgmiiSource, PtpClockSimTime from cocotbext.axi import AxiStreamBus, AxiStreamSink @@ -88,6 +87,20 @@ class TB: self.stats[stat] += int(getattr(self.dut, stat).value) +def size_list(): + return list(range(60, 128)) + [512, 1514, 9214] + [60]*10 + [i for i in range(64, 73) for k in range(8)] + + +def incrementing_payload(length): + return bytearray(itertools.islice(itertools.cycle(range(256)), length)) + + +@cocotb.test() +@cocotb.parametrize( + ("payload_lengths", [size_list]), + ("payload_data", [incrementing_payload]), + ("ifg", list(range(0, 13))), +) async def run_test(dut, payload_lengths=None, payload_data=None, ifg=12): tb = TB(dut) @@ -154,6 +167,10 @@ async def run_test(dut, payload_lengths=None, payload_data=None, ifg=12): await RisingEdge(dut.clk) +@cocotb.test() +@cocotb.parametrize( + ("ifg", list(range(0, 13))), +) async def run_test_oversize(dut, ifg=12): tb = TB(dut) @@ -244,6 +261,7 @@ async def run_test_oversize(dut, ifg=12): await RisingEdge(dut.clk) +@cocotb.test() async def run_test_os(dut): tb = TB(dut) @@ -271,34 +289,6 @@ async def run_test_os(dut): await RisingEdge(dut.clk) -def size_list(): - return list(range(60, 128)) + [512, 1514, 9214] + [60]*10 + [i for i in range(64, 73) for k in range(8)] - - -def incrementing_payload(length): - return bytearray(itertools.islice(itertools.cycle(range(256)), length)) - - -def cycle_en(): - return itertools.cycle([0, 0, 0, 1]) - - -if getattr(cocotb, 'top', None) is not None: - - factory = TestFactory(run_test) - factory.add_option("payload_lengths", [size_list]) - factory.add_option("payload_data", [incrementing_payload]) - factory.add_option("ifg", list(range(0, 13))) - factory.generate_tests() - - factory = TestFactory(run_test_oversize) - factory.add_option("ifg", list(range(0, 13))) - factory.generate_tests() - - factory = TestFactory(run_test_os) - factory.generate_tests() - - # cocotb-test tests_dir = os.path.abspath(os.path.dirname(__file__)) diff --git a/src/eth/tb/taxi_axis_xgmii_rx_64/test_taxi_axis_xgmii_rx_64.py b/src/eth/tb/taxi_axis_xgmii_rx_64/test_taxi_axis_xgmii_rx_64.py index 9c90666..e885944 100644 --- a/src/eth/tb/taxi_axis_xgmii_rx_64/test_taxi_axis_xgmii_rx_64.py +++ b/src/eth/tb/taxi_axis_xgmii_rx_64/test_taxi_axis_xgmii_rx_64.py @@ -19,7 +19,6 @@ import cocotb from cocotb.clock import Clock from cocotb.triggers import RisingEdge from cocotb.utils import get_time_from_sim_steps -from cocotb.regression import TestFactory from cocotbext.eth import XgmiiFrame, XgmiiSource, PtpClockSimTime from cocotbext.axi import AxiStreamBus, AxiStreamSink @@ -87,6 +86,20 @@ class TB: self.stats[stat] += int(getattr(self.dut, stat).value) +def size_list(): + return list(range(60, 128)) + [512, 1514, 9214] + [60]*10 + [i for i in range(64, 73) for k in range(8)] + + +def incrementing_payload(length): + return bytearray(itertools.islice(itertools.cycle(range(256)), length)) + + +@cocotb.test() +@cocotb.parametrize( + ("payload_lengths", [size_list]), + ("payload_data", [incrementing_payload]), + ("ifg", list(range(0, 13))), +) async def run_test(dut, payload_lengths=None, payload_data=None, ifg=12): tb = TB(dut) @@ -152,6 +165,10 @@ async def run_test(dut, payload_lengths=None, payload_data=None, ifg=12): await RisingEdge(dut.clk) +@cocotb.test() +@cocotb.parametrize( + ("ifg", list(range(0, 13))), +) async def run_test_oversize(dut, ifg=12): tb = TB(dut) @@ -241,6 +258,7 @@ async def run_test_oversize(dut, ifg=12): await RisingEdge(dut.clk) +@cocotb.test() async def run_test_os(dut): tb = TB(dut) @@ -268,34 +286,6 @@ async def run_test_os(dut): await RisingEdge(dut.clk) -def size_list(): - return list(range(60, 128)) + [512, 1514, 9214] + [60]*10 + [i for i in range(64, 73) for k in range(8)] - - -def incrementing_payload(length): - return bytearray(itertools.islice(itertools.cycle(range(256)), length)) - - -def cycle_en(): - return itertools.cycle([0, 0, 0, 1]) - - -if getattr(cocotb, 'top', None) is not None: - - factory = TestFactory(run_test) - factory.add_option("payload_lengths", [size_list]) - factory.add_option("payload_data", [incrementing_payload]) - factory.add_option("ifg", list(range(0, 13))) - factory.generate_tests() - - factory = TestFactory(run_test_oversize) - factory.add_option("ifg", list(range(0, 13))) - factory.generate_tests() - - factory = TestFactory(run_test_os) - factory.generate_tests() - - # cocotb-test tests_dir = os.path.abspath(os.path.dirname(__file__)) diff --git a/src/eth/tb/taxi_axis_xgmii_tx_32/test_taxi_axis_xgmii_tx_32.py b/src/eth/tb/taxi_axis_xgmii_tx_32/test_taxi_axis_xgmii_tx_32.py index e00b107..b025e86 100644 --- a/src/eth/tb/taxi_axis_xgmii_tx_32/test_taxi_axis_xgmii_tx_32.py +++ b/src/eth/tb/taxi_axis_xgmii_tx_32/test_taxi_axis_xgmii_tx_32.py @@ -20,7 +20,6 @@ import cocotb from cocotb.clock import Clock from cocotb.triggers import RisingEdge from cocotb.utils import get_time_from_sim_steps -from cocotb.regression import TestFactory from cocotbext.eth import XgmiiSink, PtpClockSimTime from cocotbext.axi import AxiStreamBus, AxiStreamSource, AxiStreamSink, AxiStreamFrame @@ -89,6 +88,20 @@ class TB: self.stats[stat] += int(getattr(self.dut, stat).value) +def size_list(): + return list(range(16, 128)) + [512, 1514, 9214] + [60]*10 + [i for i in range(64, 73) for k in range(8)] + + +def incrementing_payload(length): + return bytearray(itertools.islice(itertools.cycle(range(256)), length)) + + +@cocotb.test() +@cocotb.parametrize( + ("payload_lengths", [size_list]), + ("payload_data", [incrementing_payload]), + ("ifg", [12]), +) async def run_test(dut, payload_lengths=None, payload_data=None, ifg=12): tb = TB(dut) @@ -148,6 +161,11 @@ async def run_test(dut, payload_lengths=None, payload_data=None, ifg=12): await RisingEdge(dut.clk) +@cocotb.test() +@cocotb.parametrize( + ("payload_data", [incrementing_payload]), + ("ifg", [12]), +) async def run_test_alignment(dut, payload_data=None, ifg=12): enable_dic = int(dut.DIC_EN.value) @@ -253,6 +271,10 @@ async def run_test_alignment(dut, payload_data=None, ifg=12): await RisingEdge(dut.clk) +@cocotb.test() +@cocotb.parametrize( + ("ifg", [12]), +) async def run_test_underrun(dut, ifg=12): tb = TB(dut) @@ -312,6 +334,10 @@ async def run_test_underrun(dut, ifg=12): await RisingEdge(dut.clk) +@cocotb.test() +@cocotb.parametrize( + ("ifg", [12]), +) async def run_test_error(dut, ifg=12): tb = TB(dut) @@ -363,6 +389,10 @@ async def run_test_error(dut, ifg=12): await RisingEdge(dut.clk) +@cocotb.test() +@cocotb.parametrize( + ("ifg", [12]), +) async def run_test_oversize(dut, ifg=12): tb = TB(dut) @@ -449,6 +479,7 @@ async def run_test_oversize(dut, ifg=12): await RisingEdge(dut.clk) +@cocotb.test() async def run_test_os(dut): tb = TB(dut) @@ -477,45 +508,6 @@ async def run_test_os(dut): await RisingEdge(dut.clk) -def size_list(): - return list(range(16, 128)) + [512, 1514, 9214] + [60]*10 + [i for i in range(64, 73) for k in range(8)] - - -def incrementing_payload(length): - return bytearray(itertools.islice(itertools.cycle(range(256)), length)) - - -def cycle_en(): - return itertools.cycle([0, 0, 0, 1]) - - -if getattr(cocotb, 'top', None) is not None: - - factory = TestFactory(run_test) - factory.add_option("payload_lengths", [size_list]) - factory.add_option("payload_data", [incrementing_payload]) - factory.add_option("ifg", [12]) - factory.generate_tests() - - factory = TestFactory(run_test_alignment) - factory.add_option("payload_data", [incrementing_payload]) - factory.add_option("ifg", [12]) - factory.generate_tests() - - for test in [ - run_test_underrun, - run_test_error, - run_test_oversize - ]: - - factory = TestFactory(test) - factory.add_option("ifg", [12]) - factory.generate_tests() - - factory = TestFactory(run_test_os) - factory.generate_tests() - - # cocotb-test tests_dir = os.path.abspath(os.path.dirname(__file__)) diff --git a/src/eth/tb/taxi_axis_xgmii_tx_64/test_taxi_axis_xgmii_tx_64.py b/src/eth/tb/taxi_axis_xgmii_tx_64/test_taxi_axis_xgmii_tx_64.py index 71b880c..eb87e91 100644 --- a/src/eth/tb/taxi_axis_xgmii_tx_64/test_taxi_axis_xgmii_tx_64.py +++ b/src/eth/tb/taxi_axis_xgmii_tx_64/test_taxi_axis_xgmii_tx_64.py @@ -20,7 +20,6 @@ import cocotb from cocotb.clock import Clock from cocotb.triggers import RisingEdge from cocotb.utils import get_time_from_sim_steps -from cocotb.regression import TestFactory from cocotbext.eth import XgmiiSink, PtpClockSimTime from cocotbext.axi import AxiStreamBus, AxiStreamSource, AxiStreamSink, AxiStreamFrame @@ -88,6 +87,20 @@ class TB: self.stats[stat] += int(getattr(self.dut, stat).value) +def size_list(): + return list(range(16, 128)) + [512, 1514, 9214] + [60]*10 + [i for i in range(64, 73) for k in range(8)] + + +def incrementing_payload(length): + return bytearray(itertools.islice(itertools.cycle(range(256)), length)) + + +@cocotb.test() +@cocotb.parametrize( + ("payload_lengths", [size_list]), + ("payload_data", [incrementing_payload]), + ("ifg", [12]), +) async def run_test(dut, payload_lengths=None, payload_data=None, ifg=12): tb = TB(dut) @@ -146,6 +159,11 @@ async def run_test(dut, payload_lengths=None, payload_data=None, ifg=12): await RisingEdge(dut.clk) +@cocotb.test() +@cocotb.parametrize( + ("payload_data", [incrementing_payload]), + ("ifg", [12]), +) async def run_test_alignment(dut, payload_data=None, ifg=12): enable_dic = int(dut.DIC_EN.value) @@ -250,6 +268,10 @@ async def run_test_alignment(dut, payload_data=None, ifg=12): await RisingEdge(dut.clk) +@cocotb.test() +@cocotb.parametrize( + ("ifg", [12]), +) async def run_test_underrun(dut, ifg=12): tb = TB(dut) @@ -308,6 +330,10 @@ async def run_test_underrun(dut, ifg=12): await RisingEdge(dut.clk) +@cocotb.test() +@cocotb.parametrize( + ("ifg", [12]), +) async def run_test_error(dut, ifg=12): tb = TB(dut) @@ -358,6 +384,10 @@ async def run_test_error(dut, ifg=12): await RisingEdge(dut.clk) +@cocotb.test() +@cocotb.parametrize( + ("ifg", [12]), +) async def run_test_oversize(dut, ifg=12): tb = TB(dut) @@ -443,6 +473,7 @@ async def run_test_oversize(dut, ifg=12): await RisingEdge(dut.clk) +@cocotb.test() async def run_test_os(dut): tb = TB(dut) @@ -471,45 +502,6 @@ async def run_test_os(dut): await RisingEdge(dut.clk) -def size_list(): - return list(range(16, 128)) + [512, 1514, 9214] + [60]*10 + [i for i in range(64, 73) for k in range(8)] - - -def incrementing_payload(length): - return bytearray(itertools.islice(itertools.cycle(range(256)), length)) - - -def cycle_en(): - return itertools.cycle([0, 0, 0, 1]) - - -if getattr(cocotb, 'top', None) is not None: - - factory = TestFactory(run_test) - factory.add_option("payload_lengths", [size_list]) - factory.add_option("payload_data", [incrementing_payload]) - factory.add_option("ifg", [12]) - factory.generate_tests() - - factory = TestFactory(run_test_alignment) - factory.add_option("payload_data", [incrementing_payload]) - factory.add_option("ifg", [12]) - factory.generate_tests() - - for test in [ - run_test_underrun, - run_test_error, - run_test_oversize - ]: - - factory = TestFactory(test) - factory.add_option("ifg", [12]) - factory.generate_tests() - - factory = TestFactory(run_test_os) - factory.generate_tests() - - # cocotb-test tests_dir = os.path.abspath(os.path.dirname(__file__)) diff --git a/src/eth/tb/taxi_eth_mac_10g/test_taxi_eth_mac_10g.py b/src/eth/tb/taxi_eth_mac_10g/test_taxi_eth_mac_10g.py index 4b8a5a4..04ee878 100644 --- a/src/eth/tb/taxi_eth_mac_10g/test_taxi_eth_mac_10g.py +++ b/src/eth/tb/taxi_eth_mac_10g/test_taxi_eth_mac_10g.py @@ -24,7 +24,6 @@ import cocotb from cocotb.clock import Clock from cocotb.triggers import RisingEdge from cocotb.utils import get_time_from_sim_steps -from cocotb.regression import TestFactory from cocotbext.eth import XgmiiFrame, XgmiiSource, XgmiiSink, PtpClockSimTime from cocotbext.axi import AxiStreamBus, AxiStreamSource, AxiStreamSink, AxiStreamFrame @@ -158,6 +157,25 @@ class TB: self.ptp_td_source.set_ts_rel_sim_time() +def size_list(): + return list(range(60, 128)) + [512, 1514, 9214] + [60]*10 + + +def incrementing_payload(length): + return bytearray(itertools.islice(itertools.cycle(range(256)), length)) + + +pfc_en = False +if getattr(cocotb, 'top', None) is not None: + pfc_en = bool(cocotb.top.PFC_EN.value) + + +@cocotb.test() +@cocotb.parametrize( + ("payload_lengths", [size_list]), + ("payload_data", [incrementing_payload]), + ("ifg", [12, 0]), +) async def run_test_rx(dut, payload_lengths=None, payload_data=None, ifg=12): tb = TB(dut) @@ -210,6 +228,12 @@ async def run_test_rx(dut, payload_lengths=None, payload_data=None, ifg=12): await RisingEdge(dut.rx_clk) +@cocotb.test() +@cocotb.parametrize( + ("payload_lengths", [size_list]), + ("payload_data", [incrementing_payload]), + ("ifg", [12, 0]), +) async def run_test_tx(dut, payload_lengths=None, payload_data=None, ifg=12): tb = TB(dut) @@ -261,6 +285,11 @@ async def run_test_tx(dut, payload_lengths=None, payload_data=None, ifg=12): await RisingEdge(dut.tx_clk) +@cocotb.test() +@cocotb.parametrize( + ("payload_data", [incrementing_payload]), + ("ifg", [12]), +) async def run_test_tx_alignment(dut, payload_data=None, ifg=12): dic_en = int(cocotb.top.DIC_EN.value) @@ -358,6 +387,10 @@ async def run_test_tx_alignment(dut, payload_data=None, ifg=12): await RisingEdge(dut.tx_clk) +@cocotb.test() +@cocotb.parametrize( + ("ifg", [12]), +) async def run_test_tx_underrun(dut, ifg=12): tb = TB(dut) @@ -404,6 +437,10 @@ async def run_test_tx_underrun(dut, ifg=12): await RisingEdge(dut.tx_clk) +@cocotb.test() +@cocotb.parametrize( + ("ifg", [12]), +) async def run_test_tx_error(dut, ifg=12): tb = TB(dut) @@ -442,6 +479,10 @@ async def run_test_tx_error(dut, ifg=12): await RisingEdge(dut.tx_clk) +@cocotb.test(skip=(not pfc_en)) +@cocotb.parametrize( + ("ifg", [12]), +) async def run_test_lfc(dut, ifg=12): tb = TB(dut) @@ -591,6 +632,10 @@ async def run_test_lfc(dut, ifg=12): await RisingEdge(dut.tx_clk) +@cocotb.test(skip=(not pfc_en)) +@cocotb.parametrize( + ("ifg", [12]), +) async def run_test_pfc(dut, ifg=12): tb = TB(dut) @@ -730,46 +775,6 @@ async def run_test_pfc(dut, ifg=12): await RisingEdge(dut.tx_clk) -def size_list(): - return list(range(60, 128)) + [512, 1514, 9214] + [60]*10 - - -def incrementing_payload(length): - return bytearray(itertools.islice(itertools.cycle(range(256)), length)) - - -def cycle_en(): - return itertools.cycle([0, 0, 0, 1]) - - -if getattr(cocotb, 'top', None) is not None: - - for test in [run_test_rx, run_test_tx]: - - factory = TestFactory(test) - factory.add_option("payload_lengths", [size_list]) - factory.add_option("payload_data", [incrementing_payload]) - factory.add_option("ifg", [12, 0]) - factory.generate_tests() - - factory = TestFactory(run_test_tx_alignment) - factory.add_option("payload_data", [incrementing_payload]) - factory.add_option("ifg", [12]) - factory.generate_tests() - - for test in [run_test_tx_underrun, run_test_tx_error]: - - factory = TestFactory(test) - factory.add_option("ifg", [12]) - factory.generate_tests() - - if cocotb.top.PFC_EN.value: - for test in [run_test_lfc, run_test_pfc]: - factory = TestFactory(test) - factory.add_option("ifg", [12]) - factory.generate_tests() - - # cocotb-test tests_dir = os.path.abspath(os.path.dirname(__file__)) diff --git a/src/eth/tb/taxi_eth_mac_10g_fifo/test_taxi_eth_mac_10g_fifo.py b/src/eth/tb/taxi_eth_mac_10g_fifo/test_taxi_eth_mac_10g_fifo.py index ac57a28..8257340 100644 --- a/src/eth/tb/taxi_eth_mac_10g_fifo/test_taxi_eth_mac_10g_fifo.py +++ b/src/eth/tb/taxi_eth_mac_10g_fifo/test_taxi_eth_mac_10g_fifo.py @@ -21,7 +21,6 @@ import cocotb from cocotb.clock import Clock from cocotb.triggers import RisingEdge from cocotb.utils import get_time_from_sim_steps -from cocotb.regression import TestFactory from cocotbext.eth import XgmiiFrame, XgmiiSource, XgmiiSink, PtpClockSimTime from cocotbext.axi import AxiStreamBus, AxiStreamSource, AxiStreamSink, AxiStreamFrame @@ -113,6 +112,20 @@ class TB: self.ptp_td_source.set_ts_rel_sim_time() +def size_list(): + return list(range(60, 128)) + [512, 1514, 9214] + [60]*10 + + +def incrementing_payload(length): + return bytearray(itertools.islice(itertools.cycle(range(256)), length)) + + +@cocotb.test() +@cocotb.parametrize( + ("payload_lengths", [size_list]), + ("payload_data", [incrementing_payload]), + ("ifg", [12, 0]), +) async def run_test_rx(dut, payload_lengths=None, payload_data=None, ifg=12): tb = TB(dut) @@ -164,6 +177,12 @@ async def run_test_rx(dut, payload_lengths=None, payload_data=None, ifg=12): await RisingEdge(dut.logic_clk) +@cocotb.test() +@cocotb.parametrize( + ("payload_lengths", [size_list]), + ("payload_data", [incrementing_payload]), + ("ifg", [12, 0]), +) async def run_test_tx(dut, payload_lengths=None, payload_data=None, ifg=12): tb = TB(dut) @@ -214,6 +233,11 @@ async def run_test_tx(dut, payload_lengths=None, payload_data=None, ifg=12): await RisingEdge(dut.logic_clk) +@cocotb.test() +@cocotb.parametrize( + ("payload_data", [incrementing_payload]), + ("ifg", [12]), +) async def run_test_tx_alignment(dut, payload_data=None, ifg=12): dic_en = int(cocotb.top.DIC_EN.value) @@ -310,34 +334,6 @@ async def run_test_tx_alignment(dut, payload_data=None, ifg=12): await RisingEdge(dut.logic_clk) -def size_list(): - return list(range(60, 128)) + [512, 1514, 9214] + [60]*10 - - -def incrementing_payload(length): - return bytearray(itertools.islice(itertools.cycle(range(256)), length)) - - -def cycle_en(): - return itertools.cycle([0, 0, 0, 1]) - - -if getattr(cocotb, 'top', None) is not None: - - for test in [run_test_rx, run_test_tx]: - - factory = TestFactory(test) - factory.add_option("payload_lengths", [size_list]) - factory.add_option("payload_data", [incrementing_payload]) - factory.add_option("ifg", [12, 0]) - factory.generate_tests() - - factory = TestFactory(run_test_tx_alignment) - factory.add_option("payload_data", [incrementing_payload]) - factory.add_option("ifg", [12]) - factory.generate_tests() - - # cocotb-test tests_dir = os.path.abspath(os.path.dirname(__file__)) diff --git a/src/eth/tb/taxi_eth_mac_1g/test_taxi_eth_mac_1g.py b/src/eth/tb/taxi_eth_mac_1g/test_taxi_eth_mac_1g.py index 5813ae9..9405a1b 100644 --- a/src/eth/tb/taxi_eth_mac_1g/test_taxi_eth_mac_1g.py +++ b/src/eth/tb/taxi_eth_mac_1g/test_taxi_eth_mac_1g.py @@ -23,7 +23,6 @@ import cocotb from cocotb.clock import Clock from cocotb.triggers import RisingEdge from cocotb.utils import get_time_from_sim_steps -from cocotb.regression import TestFactory from cocotbext.eth import GmiiFrame, GmiiSource, GmiiSink, PtpClockSimTime from cocotbext.axi import AxiStreamBus, AxiStreamSource, AxiStreamSink, AxiStreamFrame @@ -172,6 +171,31 @@ class TB: await RisingEdge(self.dut.tx_clk) +def size_list(): + return list(range(60, 128)) + [512, 1514] + [60]*10 + + +def incrementing_payload(length): + return bytearray(itertools.islice(itertools.cycle(range(256)), length)) + + +def cycle_en(): + return itertools.cycle([0, 0, 0, 1]) + + +pfc_en = False +if getattr(cocotb, 'top', None) is not None: + pfc_en = bool(cocotb.top.PFC_EN.value) + + +@cocotb.test() +@cocotb.parametrize( + ("payload_lengths", [size_list]), + ("payload_data", [incrementing_payload]), + ("ifg", [12]), + ("enable_gen", [None, cycle_en]), + ("mii_sel", [False, True]), +) async def run_test_rx(dut, payload_lengths=None, payload_data=None, ifg=12, enable_gen=None, mii_sel=False): tb = TB(dut) @@ -223,6 +247,14 @@ async def run_test_rx(dut, payload_lengths=None, payload_data=None, ifg=12, enab await RisingEdge(dut.rx_clk) +@cocotb.test() +@cocotb.parametrize( + ("payload_lengths", [size_list]), + ("payload_data", [incrementing_payload]), + ("ifg", [12]), + ("enable_gen", [None, cycle_en]), + ("mii_sel", [False, True]), +) async def run_test_tx(dut, payload_lengths=None, payload_data=None, ifg=12, enable_gen=None, mii_sel=False): tb = TB(dut) @@ -271,6 +303,12 @@ async def run_test_tx(dut, payload_lengths=None, payload_data=None, ifg=12, enab await RisingEdge(dut.tx_clk) +@cocotb.test() +@cocotb.parametrize( + ("ifg", [12]), + ("enable_gen", [None, cycle_en]), + ("mii_sel", [False, True]), +) async def run_test_tx_underrun(dut, ifg=12, enable_gen=None, mii_sel=False): tb = TB(dut) @@ -329,6 +367,12 @@ async def run_test_tx_underrun(dut, ifg=12, enable_gen=None, mii_sel=False): await RisingEdge(dut.tx_clk) +@cocotb.test() +@cocotb.parametrize( + ("ifg", [12]), + ("enable_gen", [None, cycle_en]), + ("mii_sel", [False, True]), +) async def run_test_tx_error(dut, ifg=12, enable_gen=None, mii_sel=False): tb = TB(dut) @@ -373,6 +417,12 @@ async def run_test_tx_error(dut, ifg=12, enable_gen=None, mii_sel=False): await RisingEdge(dut.tx_clk) +@cocotb.test() +@cocotb.parametrize( + ("ifg", [12]), + ("enable_gen", [None, cycle_en]), + ("mii_sel", [False, True]), +) async def run_test_rx_oversize(dut, ifg=12, enable_gen=None, mii_sel=False): tb = TB(dut) @@ -418,6 +468,12 @@ async def run_test_rx_oversize(dut, ifg=12, enable_gen=None, mii_sel=False): await RisingEdge(dut.rx_clk) +@cocotb.test() +@cocotb.parametrize( + ("ifg", [12]), + ("enable_gen", [None, cycle_en]), + ("mii_sel", [False, True]), +) async def run_test_tx_oversize(dut, ifg=12, enable_gen=None, mii_sel=False): tb = TB(dut) @@ -462,6 +518,12 @@ async def run_test_tx_oversize(dut, ifg=12, enable_gen=None, mii_sel=False): await RisingEdge(dut.tx_clk) +@cocotb.test(skip=(not pfc_en)) +@cocotb.parametrize( + ("ifg", [12]), + ("enable_gen", [None, cycle_en]), + ("mii_sel", [False, True]), +) async def run_test_lfc(dut, ifg=12, enable_gen=None, mii_sel=True): tb = TB(dut) @@ -617,6 +679,12 @@ async def run_test_lfc(dut, ifg=12, enable_gen=None, mii_sel=True): await RisingEdge(dut.tx_clk) +@cocotb.test(skip=(not pfc_en)) +@cocotb.parametrize( + ("ifg", [12]), + ("enable_gen", [None, cycle_en]), + ("mii_sel", [False, True]), +) async def run_test_pfc(dut, ifg=12, enable_gen=None, mii_sel=True): tb = TB(dut) @@ -762,59 +830,6 @@ async def run_test_pfc(dut, ifg=12, enable_gen=None, mii_sel=True): await RisingEdge(dut.tx_clk) -def size_list(): - return list(range(60, 128)) + [512, 1514] + [60]*10 - - -def incrementing_payload(length): - return bytearray(itertools.islice(itertools.cycle(range(256)), length)) - - -def cycle_en(): - return itertools.cycle([0, 0, 0, 1]) - - -if getattr(cocotb, 'top', None) is not None: - - for test in [ - run_test_rx, - run_test_tx, - ]: - - factory = TestFactory(test) - factory.add_option("payload_lengths", [size_list]) - factory.add_option("payload_data", [incrementing_payload]) - factory.add_option("ifg", [12]) - factory.add_option("enable_gen", [None, cycle_en]) - factory.add_option("mii_sel", [False, True]) - factory.generate_tests() - - for test in [ - run_test_tx_underrun, - run_test_tx_error, - run_test_rx_oversize, - run_test_tx_oversize, - ]: - - factory = TestFactory(test) - factory.add_option("ifg", [12]) - factory.add_option("enable_gen", [None, cycle_en]) - factory.add_option("mii_sel", [False, True]) - factory.generate_tests() - - if cocotb.top.PFC_EN.value: - for test in [ - run_test_lfc, - run_test_pfc, - ]: - - factory = TestFactory(test) - factory.add_option("ifg", [12]) - factory.add_option("enable_gen", [None, cycle_en]) - factory.add_option("mii_sel", [False, True]) - factory.generate_tests() - - # cocotb-test tests_dir = os.path.abspath(os.path.dirname(__file__)) diff --git a/src/eth/tb/taxi_eth_mac_1g_basex_us/test_taxi_eth_mac_1g_basex_us.py b/src/eth/tb/taxi_eth_mac_1g_basex_us/test_taxi_eth_mac_1g_basex_us.py index c1f2495..e1f88fb 100644 --- a/src/eth/tb/taxi_eth_mac_1g_basex_us/test_taxi_eth_mac_1g_basex_us.py +++ b/src/eth/tb/taxi_eth_mac_1g_basex_us/test_taxi_eth_mac_1g_basex_us.py @@ -24,7 +24,6 @@ import cocotb from cocotb.clock import Clock from cocotb.triggers import RisingEdge, Timer from cocotb.utils import get_time_from_sim_steps -from cocotb.regression import TestFactory from cocotbext.eth import GmiiFrame, PtpClockSimTime from cocotbext.axi import AxiStreamBus, AxiStreamSource, AxiStreamSink, AxiStreamFrame @@ -202,6 +201,22 @@ class TB: self.ptp_td_source.set_ts_rel_sim_time() +def size_list(): + return list(range(60, 128)) + [512, 1514, 9214] + [60]*10 + + +def incrementing_payload(length): + return bytearray(itertools.islice(itertools.cycle(range(256)), length)) + + +pfc_en = False +an_en = False +if getattr(cocotb, 'top', None) is not None: + pfc_en = bool(cocotb.top.PFC_EN.value) + an_en = bool(cocotb.top.AN_EN.value) + + +@cocotb.test() async def run_test_regs(dut): tb = TB(dut) await tb.reset() @@ -220,6 +235,12 @@ async def run_test_regs(dut): await RisingEdge(dut.xcvr_ctrl_clk) +@cocotb.test() +@cocotb.parametrize( + ("payload_lengths", [size_list]), + ("payload_data", [incrementing_payload]), + ("ifg", [12, 0]), +) async def run_test_rx(dut, port=0, payload_lengths=None, payload_data=None, ifg=12): if dut.COMBINED_MAC_PCS.value: @@ -291,6 +312,12 @@ async def run_test_rx(dut, port=0, payload_lengths=None, payload_data=None, ifg= await RisingEdge(dut.xcvr_ctrl_clk) +@cocotb.test() +@cocotb.parametrize( + ("payload_lengths", [size_list]), + ("payload_data", [incrementing_payload]), + ("ifg", [12, 0]), +) async def run_test_tx(dut, port=0, payload_lengths=None, payload_data=None, ifg=12): if dut.COMBINED_MAC_PCS.value: @@ -356,6 +383,10 @@ async def run_test_tx(dut, port=0, payload_lengths=None, payload_data=None, ifg= await RisingEdge(dut.xcvr_ctrl_clk) +@cocotb.test() +@cocotb.parametrize( + ("ifg", [12]), +) async def run_test_tx_underrun(dut, port=0, ifg=12): tb = TB(dut) @@ -413,6 +444,10 @@ async def run_test_tx_underrun(dut, port=0, ifg=12): await RisingEdge(dut.xcvr_ctrl_clk) +@cocotb.test() +@cocotb.parametrize( + ("ifg", [12]), +) async def run_test_tx_error(dut, port=0, ifg=12): tb = TB(dut) @@ -462,6 +497,10 @@ async def run_test_tx_error(dut, port=0, ifg=12): await RisingEdge(dut.xcvr_ctrl_clk) +@cocotb.test(skip=(not pfc_en)) +@cocotb.parametrize( + ("ifg", [12]), +) async def run_test_lfc(dut, port=0, ifg=12): tb = TB(dut) @@ -626,6 +665,10 @@ async def run_test_lfc(dut, port=0, ifg=12): await RisingEdge(dut.xcvr_ctrl_clk) +@cocotb.test(skip=(not pfc_en)) +@cocotb.parametrize( + ("ifg", [12]), +) async def run_test_pfc(dut, port=0, ifg=12): tb = TB(dut) @@ -862,6 +905,10 @@ async def run_basex_an(tb, port=0, cfg=0x0020, sgmii=False): return None +@cocotb.test(skip=(not an_en)) +@cocotb.parametrize( + (("sgmii_en", "sgmii_auto"), [(False, False), (True, False), (False, True)]), +) async def run_test_an(dut, port=0, sgmii_en=False, sgmii_auto=False): tb = TB(dut) @@ -977,51 +1024,6 @@ async def run_test_an(dut, port=0, sgmii_en=False, sgmii_auto=False): await RisingEdge(dut.tx_clk[port]) -def size_list(): - return list(range(60, 128)) + [512, 1514, 9214] + [60]*10 - - -def incrementing_payload(length): - return bytearray(itertools.islice(itertools.cycle(range(256)), length)) - - -def cycle_en(): - return itertools.cycle([0, 0, 0, 1]) - - -if getattr(cocotb, 'top', None) is not None: - - factory = TestFactory(run_test_regs) - factory.generate_tests() - - for test in [run_test_rx, run_test_tx]: - - factory = TestFactory(test) - factory.add_option("payload_lengths", [size_list]) - factory.add_option("payload_data", [incrementing_payload]) - factory.add_option("ifg", [12, 0]) - factory.generate_tests() - - for test in [run_test_tx_underrun, run_test_tx_error]: - - factory = TestFactory(test) - factory.add_option("ifg", [12]) - factory.generate_tests() - - if cocotb.top.PFC_EN.value: - for test in [run_test_lfc, run_test_pfc]: - factory = TestFactory(test) - factory.add_option("ifg", [12]) - factory.generate_tests() - - if cocotb.top.AN_EN.value: - for test in [run_test_an]: - factory = TestFactory(test) - factory.add_option(("sgmii_en", "sgmii_auto"), - [(False, False), (True, False), (False, True)]) - factory.generate_tests() - - # cocotb-test tests_dir = os.path.abspath(os.path.dirname(__file__)) diff --git a/src/eth/tb/taxi_eth_mac_1g_fifo/test_taxi_eth_mac_1g_fifo.py b/src/eth/tb/taxi_eth_mac_1g_fifo/test_taxi_eth_mac_1g_fifo.py index af38863..a3c7f9f 100644 --- a/src/eth/tb/taxi_eth_mac_1g_fifo/test_taxi_eth_mac_1g_fifo.py +++ b/src/eth/tb/taxi_eth_mac_1g_fifo/test_taxi_eth_mac_1g_fifo.py @@ -18,7 +18,6 @@ import cocotb_test.simulator import cocotb from cocotb.clock import Clock from cocotb.triggers import RisingEdge -from cocotb.regression import TestFactory from cocotbext.eth import GmiiFrame, GmiiSource, GmiiSink from cocotbext.axi import AxiStreamBus, AxiStreamSource, AxiStreamSink @@ -124,6 +123,26 @@ class TB: await RisingEdge(self.dut.tx_clk) +def size_list(): + return list(range(60, 128)) + [512, 1514] + [60]*10 + + +def incrementing_payload(length): + return bytearray(itertools.islice(itertools.cycle(range(256)), length)) + + +def cycle_en(): + return itertools.cycle([0, 0, 0, 1]) + + +@cocotb.test() +@cocotb.parametrize( + ("payload_lengths", [size_list]), + ("payload_data", [incrementing_payload]), + ("ifg", [12]), + ("enable_gen", [None, cycle_en]), + ("mii_sel", [False, True]), +) async def run_test_rx(dut, payload_lengths=None, payload_data=None, ifg=12, enable_gen=None, mii_sel=False): tb = TB(dut) @@ -159,6 +178,14 @@ async def run_test_rx(dut, payload_lengths=None, payload_data=None, ifg=12, enab await RisingEdge(dut.logic_clk) +@cocotb.test() +@cocotb.parametrize( + ("payload_lengths", [size_list]), + ("payload_data", [incrementing_payload]), + ("ifg", [12]), + ("enable_gen", [None, cycle_en]), + ("mii_sel", [False, True]), +) async def run_test_tx(dut, payload_lengths=None, payload_data=None, ifg=12, enable_gen=None, mii_sel=False): tb = TB(dut) @@ -196,31 +223,6 @@ async def run_test_tx(dut, payload_lengths=None, payload_data=None, ifg=12, enab await RisingEdge(dut.logic_clk) -def size_list(): - return list(range(60, 128)) + [512, 1514] + [60]*10 - - -def incrementing_payload(length): - return bytearray(itertools.islice(itertools.cycle(range(256)), length)) - - -def cycle_en(): - return itertools.cycle([0, 0, 0, 1]) - - -if getattr(cocotb, 'top', None) is not None: - - for test in [run_test_rx, run_test_tx]: - - factory = TestFactory(test) - factory.add_option("payload_lengths", [size_list]) - factory.add_option("payload_data", [incrementing_payload]) - factory.add_option("ifg", [12]) - factory.add_option("enable_gen", [None, cycle_en]) - factory.add_option("mii_sel", [False, True]) - factory.generate_tests() - - # cocotb-test tests_dir = os.path.abspath(os.path.dirname(__file__)) diff --git a/src/eth/tb/taxi_eth_mac_1g_gmii/test_taxi_eth_mac_1g_gmii.py b/src/eth/tb/taxi_eth_mac_1g_gmii/test_taxi_eth_mac_1g_gmii.py index 421af9f..e9067fc 100644 --- a/src/eth/tb/taxi_eth_mac_1g_gmii/test_taxi_eth_mac_1g_gmii.py +++ b/src/eth/tb/taxi_eth_mac_1g_gmii/test_taxi_eth_mac_1g_gmii.py @@ -23,7 +23,6 @@ import cocotb from cocotb.clock import Clock from cocotb.triggers import RisingEdge from cocotb.utils import get_time_from_sim_steps -from cocotb.regression import TestFactory from cocotbext.eth import GmiiFrame, GmiiPhy, PtpClockSimTime from cocotbext.axi import AxiStreamBus, AxiStreamSource, AxiStreamSink, AxiStreamFrame @@ -125,6 +124,26 @@ class TB: await RisingEdge(self.dut.tx_clk) +def size_list(): + return list(range(60, 128)) + [512, 1514] + [60]*10 + + +def incrementing_payload(length): + return bytearray(itertools.islice(itertools.cycle(range(256)), length)) + + +pfc_en = False +if getattr(cocotb, 'top', None) is not None: + pfc_en = bool(cocotb.top.PFC_EN.value) + + +@cocotb.test() +@cocotb.parametrize( + ("payload_lengths", [size_list]), + ("payload_data", [incrementing_payload]), + ("ifg", [12]), + ("speed", [1000e6, 100e6, 10e6]), +) async def run_test_rx(dut, payload_lengths=None, payload_data=None, ifg=12, speed=1000e6): tb = TB(dut, speed) @@ -182,6 +201,13 @@ async def run_test_rx(dut, payload_lengths=None, payload_data=None, ifg=12, spee await RisingEdge(dut.rx_clk) +@cocotb.test() +@cocotb.parametrize( + ("payload_lengths", [size_list]), + ("payload_data", [incrementing_payload]), + ("ifg", [12]), + ("speed", [1000e6, 100e6, 10e6]), +) async def run_test_tx(dut, payload_lengths=None, payload_data=None, ifg=12, speed=1000e6): tb = TB(dut, speed) @@ -238,6 +264,11 @@ async def run_test_tx(dut, payload_lengths=None, payload_data=None, ifg=12, spee await RisingEdge(dut.tx_clk) +@cocotb.test() +@cocotb.parametrize( + ("ifg", [12]), + ("speed", [1000e6, 100e6, 10e6]), +) async def run_test_tx_underrun(dut, ifg=12, speed=1000e6): tb = TB(dut, speed) @@ -286,6 +317,11 @@ async def run_test_tx_underrun(dut, ifg=12, speed=1000e6): await RisingEdge(dut.tx_clk) +@cocotb.test() +@cocotb.parametrize( + ("ifg", [12]), + ("speed", [1000e6, 100e6, 10e6]), +) async def run_test_tx_error(dut, ifg=12, speed=1000e6): tb = TB(dut, speed) @@ -326,6 +362,11 @@ async def run_test_tx_error(dut, ifg=12, speed=1000e6): await RisingEdge(dut.tx_clk) +@cocotb.test(skip=(not pfc_en)) +@cocotb.parametrize( + ("ifg", [12]), + ("speed", [1000e6, 100e6, 10e6]), +) async def run_test_lfc(dut, ifg=12, speed=1000e6): tb = TB(dut, speed) @@ -478,6 +519,11 @@ async def run_test_lfc(dut, ifg=12, speed=1000e6): await RisingEdge(dut.tx_clk) +@cocotb.test(skip=(not pfc_en)) +@cocotb.parametrize( + ("ifg", [12]), + ("speed", [1000e6, 100e6, 10e6]), +) async def run_test_pfc(dut, ifg=12, speed=1000e6): tb = TB(dut, speed) @@ -620,44 +666,6 @@ async def run_test_pfc(dut, ifg=12, speed=1000e6): await RisingEdge(dut.tx_clk) -def size_list(): - return list(range(60, 128)) + [512, 1514] + [60]*10 - - -def incrementing_payload(length): - return bytearray(itertools.islice(itertools.cycle(range(256)), length)) - - -def cycle_en(): - return itertools.cycle([0, 0, 0, 1]) - - -if getattr(cocotb, 'top', None) is not None: - - for test in [run_test_rx, run_test_tx]: - - factory = TestFactory(test) - factory.add_option("payload_lengths", [size_list]) - factory.add_option("payload_data", [incrementing_payload]) - factory.add_option("ifg", [12]) - factory.add_option("speed", [1000e6, 100e6, 10e6]) - factory.generate_tests() - - for test in [run_test_tx_underrun, run_test_tx_error]: - - factory = TestFactory(test) - factory.add_option("ifg", [12]) - factory.add_option("speed", [1000e6, 100e6, 10e6]) - factory.generate_tests() - - if cocotb.top.PFC_EN.value: - for test in [run_test_lfc, run_test_pfc]: - factory = TestFactory(test) - factory.add_option("ifg", [12]) - factory.add_option("speed", [1000e6, 100e6, 10e6]) - factory.generate_tests() - - # cocotb-test tests_dir = os.path.abspath(os.path.dirname(__file__)) diff --git a/src/eth/tb/taxi_eth_mac_1g_gmii_fifo/test_taxi_eth_mac_1g_gmii_fifo.py b/src/eth/tb/taxi_eth_mac_1g_gmii_fifo/test_taxi_eth_mac_1g_gmii_fifo.py index e0f55e5..2bba17b 100644 --- a/src/eth/tb/taxi_eth_mac_1g_gmii_fifo/test_taxi_eth_mac_1g_gmii_fifo.py +++ b/src/eth/tb/taxi_eth_mac_1g_gmii_fifo/test_taxi_eth_mac_1g_gmii_fifo.py @@ -18,7 +18,6 @@ import cocotb_test.simulator import cocotb from cocotb.clock import Clock from cocotb.triggers import RisingEdge -from cocotb.regression import TestFactory from cocotbext.eth import GmiiFrame, GmiiPhy from cocotbext.axi import AxiStreamBus, AxiStreamSource, AxiStreamSink @@ -70,6 +69,21 @@ class TB: await RisingEdge(self.dut.gtx_clk) +def size_list(): + return list(range(60, 128)) + [512, 1514] + [60]*10 + + +def incrementing_payload(length): + return bytearray(itertools.islice(itertools.cycle(range(256)), length)) + + +@cocotb.test() +@cocotb.parametrize( + ("payload_lengths", [size_list]), + ("payload_data", [incrementing_payload]), + ("ifg", [12]), + ("speed", [1000e6, 100e6, 10e6]), +) async def run_test_rx(dut, payload_lengths=None, payload_data=None, ifg=12, speed=1000e6): tb = TB(dut, speed) @@ -109,6 +123,13 @@ async def run_test_rx(dut, payload_lengths=None, payload_data=None, ifg=12, spee await RisingEdge(dut.logic_clk) +@cocotb.test() +@cocotb.parametrize( + ("payload_lengths", [size_list]), + ("payload_data", [incrementing_payload]), + ("ifg", [12]), + ("speed", [1000e6, 100e6, 10e6]), +) async def run_test_tx(dut, payload_lengths=None, payload_data=None, ifg=12, speed=1000e6): tb = TB(dut, speed) @@ -150,30 +171,6 @@ async def run_test_tx(dut, payload_lengths=None, payload_data=None, ifg=12, spee await RisingEdge(dut.logic_clk) -def size_list(): - return list(range(60, 128)) + [512, 1514] + [60]*10 - - -def incrementing_payload(length): - return bytearray(itertools.islice(itertools.cycle(range(256)), length)) - - -def cycle_en(): - return itertools.cycle([0, 0, 0, 1]) - - -if getattr(cocotb, 'top', None) is not None: - - for test in [run_test_rx, run_test_tx]: - - factory = TestFactory(test) - factory.add_option("payload_lengths", [size_list]) - factory.add_option("payload_data", [incrementing_payload]) - factory.add_option("ifg", [12]) - factory.add_option("speed", [1000e6, 100e6, 10e6]) - factory.generate_tests() - - # cocotb-test tests_dir = os.path.abspath(os.path.dirname(__file__)) diff --git a/src/eth/tb/taxi_eth_mac_1g_rgmii/test_taxi_eth_mac_1g_rgmii.py b/src/eth/tb/taxi_eth_mac_1g_rgmii/test_taxi_eth_mac_1g_rgmii.py index 46ab755..2a83d61 100644 --- a/src/eth/tb/taxi_eth_mac_1g_rgmii/test_taxi_eth_mac_1g_rgmii.py +++ b/src/eth/tb/taxi_eth_mac_1g_rgmii/test_taxi_eth_mac_1g_rgmii.py @@ -23,7 +23,6 @@ import cocotb from cocotb.clock import Clock from cocotb.triggers import RisingEdge, Timer from cocotb.utils import get_time_from_sim_steps -from cocotb.regression import TestFactory from cocotbext.eth import GmiiFrame, RgmiiPhy, PtpClockSimTime from cocotbext.axi import AxiStreamBus, AxiStreamSource, AxiStreamSink, AxiStreamFrame @@ -137,6 +136,26 @@ class TB: await t +def size_list(): + return list(range(60, 128)) + [512, 1514] + [60]*10 + + +def incrementing_payload(length): + return bytearray(itertools.islice(itertools.cycle(range(256)), length)) + + +pfc_en = False +if getattr(cocotb, 'top', None) is not None: + pfc_en = bool(cocotb.top.PFC_EN.value) + + +@cocotb.test() +@cocotb.parametrize( + ("payload_lengths", [size_list]), + ("payload_data", [incrementing_payload]), + ("ifg", [12]), + ("speed", [1000e6, 100e6, 10e6]), +) async def run_test_rx(dut, payload_lengths=None, payload_data=None, ifg=12, speed=1000e6): tb = TB(dut, speed) @@ -194,6 +213,13 @@ async def run_test_rx(dut, payload_lengths=None, payload_data=None, ifg=12, spee await RisingEdge(dut.rx_clk) +@cocotb.test() +@cocotb.parametrize( + ("payload_lengths", [size_list]), + ("payload_data", [incrementing_payload]), + ("ifg", [12]), + ("speed", [1000e6, 100e6, 10e6]), +) async def run_test_tx(dut, payload_lengths=None, payload_data=None, ifg=12, speed=1000e6): tb = TB(dut, speed) @@ -235,6 +261,11 @@ async def run_test_tx(dut, payload_lengths=None, payload_data=None, ifg=12, spee await RisingEdge(dut.tx_clk) +@cocotb.test() +@cocotb.parametrize( + ("ifg", [12]), + ("speed", [1000e6, 100e6, 10e6]), +) async def run_test_tx_underrun(dut, ifg=12, speed=1000e6): tb = TB(dut, speed) @@ -289,6 +320,11 @@ async def run_test_tx_underrun(dut, ifg=12, speed=1000e6): await RisingEdge(dut.tx_clk) +@cocotb.test() +@cocotb.parametrize( + ("ifg", [12]), + ("speed", [1000e6, 100e6, 10e6]), +) async def run_test_tx_error(dut, ifg=12, speed=1000e6): tb = TB(dut, speed) @@ -329,6 +365,11 @@ async def run_test_tx_error(dut, ifg=12, speed=1000e6): await RisingEdge(dut.tx_clk) +@cocotb.test(skip=(not pfc_en)) +@cocotb.parametrize( + ("ifg", [12]), + ("speed", [1000e6, 100e6, 10e6]), +) async def run_test_lfc(dut, ifg=12, speed=1000e6): tb = TB(dut, speed) @@ -481,6 +522,11 @@ async def run_test_lfc(dut, ifg=12, speed=1000e6): await RisingEdge(dut.tx_clk) +@cocotb.test(skip=(not pfc_en)) +@cocotb.parametrize( + ("ifg", [12]), + ("speed", [1000e6, 100e6, 10e6]), +) async def run_test_pfc(dut, ifg=12, speed=1000e6): tb = TB(dut, speed) @@ -624,44 +670,6 @@ async def run_test_pfc(dut, ifg=12, speed=1000e6): await RisingEdge(dut.tx_clk) -def size_list(): - return list(range(60, 128)) + [512, 1514] + [60]*10 - - -def incrementing_payload(length): - return bytearray(itertools.islice(itertools.cycle(range(256)), length)) - - -def cycle_en(): - return itertools.cycle([0, 0, 0, 1]) - - -if getattr(cocotb, 'top', None) is not None: - - for test in [run_test_rx, run_test_tx]: - - factory = TestFactory(test) - factory.add_option("payload_lengths", [size_list]) - factory.add_option("payload_data", [incrementing_payload]) - factory.add_option("ifg", [12]) - factory.add_option("speed", [1000e6, 100e6, 10e6]) - factory.generate_tests() - - for test in [run_test_tx_underrun, run_test_tx_error]: - - factory = TestFactory(test) - factory.add_option("ifg", [12]) - factory.add_option("speed", [1000e6, 100e6, 10e6]) - factory.generate_tests() - - if cocotb.top.PFC_EN.value: - for test in [run_test_lfc, run_test_pfc]: - factory = TestFactory(test) - factory.add_option("ifg", [12]) - factory.add_option("speed", [1000e6, 100e6, 10e6]) - factory.generate_tests() - - # cocotb-test tests_dir = os.path.abspath(os.path.dirname(__file__)) diff --git a/src/eth/tb/taxi_eth_mac_1g_rgmii_fifo/test_taxi_eth_mac_1g_rgmii_fifo.py b/src/eth/tb/taxi_eth_mac_1g_rgmii_fifo/test_taxi_eth_mac_1g_rgmii_fifo.py index 2348a1b..3443643 100644 --- a/src/eth/tb/taxi_eth_mac_1g_rgmii_fifo/test_taxi_eth_mac_1g_rgmii_fifo.py +++ b/src/eth/tb/taxi_eth_mac_1g_rgmii_fifo/test_taxi_eth_mac_1g_rgmii_fifo.py @@ -18,7 +18,6 @@ import cocotb_test.simulator import cocotb from cocotb.clock import Clock from cocotb.triggers import RisingEdge, Timer -from cocotb.regression import TestFactory from cocotbext.eth import GmiiFrame, RgmiiPhy from cocotbext.axi import AxiStreamBus, AxiStreamSource, AxiStreamSink @@ -86,6 +85,21 @@ class TB: await t +def size_list(): + return list(range(60, 128)) + [512, 1514] + [60]*10 + + +def incrementing_payload(length): + return bytearray(itertools.islice(itertools.cycle(range(256)), length)) + + +@cocotb.test() +@cocotb.parametrize( + ("payload_lengths", [size_list]), + ("payload_data", [incrementing_payload]), + ("ifg", [12]), + ("speed", [1000e6, 100e6, 10e6]), +) async def run_test_rx(dut, payload_lengths=None, payload_data=None, ifg=12, speed=1000e6): tb = TB(dut, speed) @@ -125,6 +139,13 @@ async def run_test_rx(dut, payload_lengths=None, payload_data=None, ifg=12, spee await RisingEdge(dut.logic_clk) +@cocotb.test() +@cocotb.parametrize( + ("payload_lengths", [size_list]), + ("payload_data", [incrementing_payload]), + ("ifg", [12]), + ("speed", [1000e6, 100e6, 10e6]), +) async def run_test_tx(dut, payload_lengths=None, payload_data=None, ifg=12, speed=1000e6): tb = TB(dut, speed) @@ -166,30 +187,6 @@ async def run_test_tx(dut, payload_lengths=None, payload_data=None, ifg=12, spee await RisingEdge(dut.logic_clk) -def size_list(): - return list(range(60, 128)) + [512, 1514] + [60]*10 - - -def incrementing_payload(length): - return bytearray(itertools.islice(itertools.cycle(range(256)), length)) - - -def cycle_en(): - return itertools.cycle([0, 0, 0, 1]) - - -if getattr(cocotb, 'top', None) is not None: - - for test in [run_test_rx, run_test_tx]: - - factory = TestFactory(test) - factory.add_option("payload_lengths", [size_list]) - factory.add_option("payload_data", [incrementing_payload]) - factory.add_option("ifg", [12]) - factory.add_option("speed", [1000e6, 100e6, 10e6]) - factory.generate_tests() - - # cocotb-test tests_dir = os.path.abspath(os.path.dirname(__file__)) diff --git a/src/eth/tb/taxi_eth_mac_25g_us/test_taxi_eth_mac_25g_us.py b/src/eth/tb/taxi_eth_mac_25g_us/test_taxi_eth_mac_25g_us.py index 68f9812..cc2ec09 100644 --- a/src/eth/tb/taxi_eth_mac_25g_us/test_taxi_eth_mac_25g_us.py +++ b/src/eth/tb/taxi_eth_mac_25g_us/test_taxi_eth_mac_25g_us.py @@ -24,7 +24,6 @@ import cocotb from cocotb.clock import Clock from cocotb.triggers import RisingEdge, Timer from cocotb.utils import get_time_from_sim_steps -from cocotb.regression import TestFactory from cocotbext.eth import XgmiiFrame, PtpClockSimTime from cocotbext.axi import AxiStreamBus, AxiStreamSource, AxiStreamSink, AxiStreamFrame @@ -212,6 +211,24 @@ class TB: self.ptp_td_source.set_ts_rel_sim_time() +def size_list(): + return list(range(60, 128)) + [512, 1514, 9214] + [60]*10 + + +def incrementing_payload(length): + return bytearray(itertools.islice(itertools.cycle(range(256)), length)) + + +data_w = 64 +pfc_en = False +usxgmii_en = False +if getattr(cocotb, 'top', None) is not None: + data_w = int(cocotb.top.DATA_W.value) + pfc_en = bool(cocotb.top.PFC_EN.value) + usxgmii_en = bool(cocotb.top.USXGMII_EN.value) + + +@cocotb.test() async def run_test_regs(dut): tb = TB(dut) await tb.reset() @@ -230,6 +247,12 @@ async def run_test_regs(dut): await RisingEdge(dut.xcvr_ctrl_clk) +@cocotb.test() +@cocotb.parametrize( + ("payload_lengths", [size_list]), + ("payload_data", [incrementing_payload]), + ("ifg", [12, 0]), +) async def run_test_rx(dut, port=0, payload_lengths=None, payload_data=None, ifg=12): if dut.DATA_W.value == 64: @@ -310,6 +333,12 @@ async def run_test_rx(dut, port=0, payload_lengths=None, payload_data=None, ifg= await RisingEdge(dut.xcvr_ctrl_clk) +@cocotb.test() +@cocotb.parametrize( + ("payload_lengths", [size_list]), + ("payload_data", [incrementing_payload]), + ("ifg", [12, 0]), +) async def run_test_tx(dut, port=0, payload_lengths=None, payload_data=None, ifg=12): if dut.DATA_W.value == 64: @@ -382,6 +411,11 @@ async def run_test_tx(dut, port=0, payload_lengths=None, payload_data=None, ifg= await RisingEdge(dut.xcvr_ctrl_clk) +@cocotb.test(skip=(data_w != 64)) +@cocotb.parametrize( + ("payload_data", [incrementing_payload]), + ("ifg", [12]), +) async def run_test_tx_alignment(dut, port=0, payload_data=None, ifg=12): dic_en = int(cocotb.top.DIC_EN.value) @@ -499,6 +533,10 @@ async def run_test_tx_alignment(dut, port=0, payload_data=None, ifg=12): await RisingEdge(dut.xcvr_ctrl_clk) +@cocotb.test() +@cocotb.parametrize( + ("ifg", [12]), +) async def run_test_tx_underrun(dut, port=0, ifg=12): tb = TB(dut) @@ -605,6 +643,7 @@ async def run_test_tx_error(dut, port=0, ifg=12): await RisingEdge(dut.xcvr_ctrl_clk) +@cocotb.test() async def run_test_rx_frame_sync(dut): tb = TB(dut) @@ -648,6 +687,10 @@ async def run_test_rx_frame_sync(dut): await RisingEdge(dut.xcvr_ctrl_clk) +@cocotb.test(skip=(not pfc_en)) +@cocotb.parametrize( + ("ifg", [12]), +) async def run_test_lfc(dut, port=0, ifg=12): tb = TB(dut) @@ -812,6 +855,10 @@ async def run_test_lfc(dut, port=0, ifg=12): await RisingEdge(dut.xcvr_ctrl_clk) +@cocotb.test(skip=(not pfc_en)) +@cocotb.parametrize( + ("ifg", [12]), +) async def run_test_pfc(dut, port=0, ifg=12): tb = TB(dut) @@ -1061,6 +1108,7 @@ async def run_usxgmii_an(tb, port=0, cfg=0x0001): return None +@cocotb.test(skip=(not usxgmii_en)) async def run_test_usxgmii(dut, port=0): tb = TB(dut) @@ -1122,58 +1170,6 @@ async def run_test_usxgmii(dut, port=0): await RisingEdge(dut.tx_clk[port]) -def size_list(): - return list(range(60, 128)) + [512, 1514, 9214] + [60]*10 - - -def incrementing_payload(length): - return bytearray(itertools.islice(itertools.cycle(range(256)), length)) - - -def cycle_en(): - return itertools.cycle([0, 0, 0, 1]) - - -if getattr(cocotb, 'top', None) is not None: - - factory = TestFactory(run_test_regs) - factory.generate_tests() - - for test in [run_test_rx, run_test_tx]: - - factory = TestFactory(test) - factory.add_option("payload_lengths", [size_list]) - factory.add_option("payload_data", [incrementing_payload]) - factory.add_option("ifg", [12, 0]) - factory.generate_tests() - - if cocotb.top.DATA_W.value == 64: - factory = TestFactory(run_test_tx_alignment) - factory.add_option("payload_data", [incrementing_payload]) - factory.add_option("ifg", [12]) - factory.generate_tests() - - for test in [run_test_tx_underrun, run_test_tx_error]: - - factory = TestFactory(test) - factory.add_option("ifg", [12]) - factory.generate_tests() - - factory = TestFactory(run_test_rx_frame_sync) - factory.generate_tests() - - if cocotb.top.PFC_EN.value: - for test in [run_test_lfc, run_test_pfc]: - factory = TestFactory(test) - factory.add_option("ifg", [12]) - factory.generate_tests() - - if cocotb.top.USXGMII_EN.value: - for test in [run_test_usxgmii]: - factory = TestFactory(test) - factory.generate_tests() - - # cocotb-test tests_dir = os.path.abspath(os.path.dirname(__file__)) diff --git a/src/eth/tb/taxi_eth_mac_mii/test_taxi_eth_mac_mii.py b/src/eth/tb/taxi_eth_mac_mii/test_taxi_eth_mac_mii.py index e24c348..49fee8d 100644 --- a/src/eth/tb/taxi_eth_mac_mii/test_taxi_eth_mac_mii.py +++ b/src/eth/tb/taxi_eth_mac_mii/test_taxi_eth_mac_mii.py @@ -23,7 +23,6 @@ import cocotb from cocotb.clock import Clock from cocotb.triggers import RisingEdge from cocotb.utils import get_time_from_sim_steps -from cocotb.regression import TestFactory from cocotbext.eth import GmiiFrame, MiiPhy, PtpClockSimTime from cocotbext.axi import AxiStreamBus, AxiStreamSource, AxiStreamSink, AxiStreamFrame @@ -120,6 +119,26 @@ class TB: await RisingEdge(self.dut.tx_clk) +def size_list(): + return list(range(60, 128)) + [512, 1514] + [60]*10 + + +def incrementing_payload(length): + return bytearray(itertools.islice(itertools.cycle(range(256)), length)) + + +pfc_en = False +if getattr(cocotb, 'top', None) is not None: + pfc_en = bool(cocotb.top.PFC_EN.value) + + +@cocotb.test() +@cocotb.parametrize( + ("payload_lengths", [size_list]), + ("payload_data", [incrementing_payload]), + ("ifg", [12]), + ("speed", [100e6, 10e6]), +) async def run_test_rx(dut, payload_lengths=None, payload_data=None, ifg=12, speed=100e6): tb = TB(dut, speed) @@ -168,6 +187,13 @@ async def run_test_rx(dut, payload_lengths=None, payload_data=None, ifg=12, spee await RisingEdge(dut.rx_clk) +@cocotb.test() +@cocotb.parametrize( + ("payload_lengths", [size_list]), + ("payload_data", [incrementing_payload]), + ("ifg", [12]), + ("speed", [100e6, 10e6]), +) async def run_test_tx(dut, payload_lengths=None, payload_data=None, ifg=12, speed=100e6): tb = TB(dut, speed) @@ -202,6 +228,10 @@ async def run_test_tx(dut, payload_lengths=None, payload_data=None, ifg=12, spee await RisingEdge(dut.tx_clk) +@cocotb.test() +@cocotb.parametrize( + ("ifg", [12]), +) async def run_test_tx_underrun(dut, ifg=12): tb = TB(dut) @@ -250,6 +280,10 @@ async def run_test_tx_underrun(dut, ifg=12): await RisingEdge(dut.tx_clk) +@cocotb.test() +@cocotb.parametrize( + ("ifg", [12]), +) async def run_test_tx_error(dut, ifg=12): tb = TB(dut) @@ -290,6 +324,11 @@ async def run_test_tx_error(dut, ifg=12): await RisingEdge(dut.tx_clk) +@cocotb.test(skip=(not pfc_en)) +@cocotb.parametrize( + ("ifg", [12]), + ("speed", [100e6, 10e6]), +) async def run_test_lfc(dut, ifg=12, speed=1000e6): tb = TB(dut, speed) @@ -442,6 +481,11 @@ async def run_test_lfc(dut, ifg=12, speed=1000e6): await RisingEdge(dut.tx_clk) +@cocotb.test(skip=(not pfc_en)) +@cocotb.parametrize( + ("ifg", [12]), + ("speed", [100e6, 10e6]), +) async def run_test_pfc(dut, ifg=12, speed=1000e6): tb = TB(dut, speed) @@ -584,43 +628,6 @@ async def run_test_pfc(dut, ifg=12, speed=1000e6): await RisingEdge(dut.tx_clk) -def size_list(): - return list(range(60, 128)) + [512, 1514] + [60]*10 - - -def incrementing_payload(length): - return bytearray(itertools.islice(itertools.cycle(range(256)), length)) - - -def cycle_en(): - return itertools.cycle([0, 0, 0, 1]) - - -if getattr(cocotb, 'top', None) is not None: - - for test in [run_test_rx, run_test_tx]: - - factory = TestFactory(test) - factory.add_option("payload_lengths", [size_list]) - factory.add_option("payload_data", [incrementing_payload]) - factory.add_option("ifg", [12]) - factory.add_option("speed", [100e6, 10e6]) - factory.generate_tests() - - for test in [run_test_tx_underrun, run_test_tx_error]: - - factory = TestFactory(test) - factory.add_option("ifg", [12]) - factory.generate_tests() - - if cocotb.top.PFC_EN.value: - for test in [run_test_lfc, run_test_pfc]: - factory = TestFactory(test) - factory.add_option("ifg", [12]) - factory.add_option("speed", [100e6, 10e6]) - factory.generate_tests() - - # cocotb-test tests_dir = os.path.abspath(os.path.dirname(__file__)) diff --git a/src/eth/tb/taxi_eth_mac_mii_fifo/test_taxi_eth_mac_mii_fifo.py b/src/eth/tb/taxi_eth_mac_mii_fifo/test_taxi_eth_mac_mii_fifo.py index 16d813f..d3bc84a 100644 --- a/src/eth/tb/taxi_eth_mac_mii_fifo/test_taxi_eth_mac_mii_fifo.py +++ b/src/eth/tb/taxi_eth_mac_mii_fifo/test_taxi_eth_mac_mii_fifo.py @@ -18,7 +18,6 @@ import cocotb_test.simulator import cocotb from cocotb.clock import Clock from cocotb.triggers import RisingEdge -from cocotb.regression import TestFactory from cocotbext.eth import GmiiFrame, MiiPhy from cocotbext.axi import AxiStreamBus, AxiStreamSource, AxiStreamSink @@ -66,6 +65,21 @@ class TB: await RisingEdge(self.dut.logic_clk) +def size_list(): + return list(range(60, 128)) + [512, 1514] + [60]*10 + + +def incrementing_payload(length): + return bytearray(itertools.islice(itertools.cycle(range(256)), length)) + + +@cocotb.test() +@cocotb.parametrize( + ("payload_lengths", [size_list]), + ("payload_data", [incrementing_payload]), + ("ifg", [12]), + ("speed", [100e6, 10e6]), +) async def run_test_rx(dut, payload_lengths=None, payload_data=None, ifg=12, speed=100e6): tb = TB(dut, speed) @@ -95,6 +109,13 @@ async def run_test_rx(dut, payload_lengths=None, payload_data=None, ifg=12, spee await RisingEdge(dut.logic_clk) +@cocotb.test() +@cocotb.parametrize( + ("payload_lengths", [size_list]), + ("payload_data", [incrementing_payload]), + ("ifg", [12]), + ("speed", [100e6, 10e6]), +) async def run_test_tx(dut, payload_lengths=None, payload_data=None, ifg=12, speed=100e6): tb = TB(dut, speed) @@ -126,30 +147,6 @@ async def run_test_tx(dut, payload_lengths=None, payload_data=None, ifg=12, spee await RisingEdge(dut.logic_clk) -def size_list(): - return list(range(60, 128)) + [512, 1514] + [60]*10 - - -def incrementing_payload(length): - return bytearray(itertools.islice(itertools.cycle(range(256)), length)) - - -def cycle_en(): - return itertools.cycle([0, 0, 0, 1]) - - -if getattr(cocotb, 'top', None) is not None: - - for test in [run_test_rx, run_test_tx]: - - factory = TestFactory(test) - factory.add_option("payload_lengths", [size_list]) - factory.add_option("payload_data", [incrementing_payload]) - factory.add_option("ifg", [12]) - factory.add_option("speed", [100e6, 10e6]) - factory.generate_tests() - - # cocotb-test tests_dir = os.path.abspath(os.path.dirname(__file__)) diff --git a/src/eth/tb/taxi_eth_mac_phy_10g/test_taxi_eth_mac_phy_10g.py b/src/eth/tb/taxi_eth_mac_phy_10g/test_taxi_eth_mac_phy_10g.py index 6566bd7..2994934 100644 --- a/src/eth/tb/taxi_eth_mac_phy_10g/test_taxi_eth_mac_phy_10g.py +++ b/src/eth/tb/taxi_eth_mac_phy_10g/test_taxi_eth_mac_phy_10g.py @@ -24,7 +24,6 @@ import cocotb from cocotb.clock import Clock from cocotb.triggers import RisingEdge, Timer from cocotb.utils import get_time_from_sim_steps -from cocotb.regression import TestFactory from cocotbext.eth import XgmiiFrame, PtpClockSimTime from cocotbext.axi import AxiStreamBus, AxiStreamSource, AxiStreamSink, AxiStreamFrame @@ -182,6 +181,34 @@ class TB: self.ptp_td_source.set_ts_rel_sim_time() +def size_list(): + return list(range(60, 128)) + [512, 1514, 9214] + [60]*10 + + +def incrementing_payload(length): + return bytearray(itertools.islice(itertools.cycle(range(256)), length)) + + +gbx_cfgs = [None] +data_w = 64 +pfc_en = False +usxgmii_en = False +if getattr(cocotb, 'top', None) is not None: + if cocotb.top.RX_GBX_IF_EN.value: + gbx_cfgs.append((33, [32])) + gbx_cfgs.append((66, [64, 65])) + data_w = len(cocotb.top.serdes_tx_data) + pfc_en = bool(cocotb.top.PFC_EN.value) + usxgmii_en = bool(cocotb.top.USXGMII_EN.value) + + +@cocotb.test() +@cocotb.parametrize( + ("payload_lengths", [size_list]), + ("payload_data", [incrementing_payload]), + ("ifg", [12, 0]), + ("gbx_cfg", gbx_cfgs), +) async def run_test_rx(dut, gbx_cfg=None, payload_lengths=None, payload_data=None, ifg=12): if len(dut.serdes_rx_data) == 64: @@ -253,6 +280,13 @@ async def run_test_rx(dut, gbx_cfg=None, payload_lengths=None, payload_data=None await RisingEdge(dut.rx_clk) +@cocotb.test() +@cocotb.parametrize( + ("payload_lengths", [size_list]), + ("payload_data", [incrementing_payload]), + ("ifg", [12, 0]), + ("gbx_cfg", gbx_cfgs), +) async def run_test_tx(dut, gbx_cfg=None, payload_lengths=None, payload_data=None, ifg=12): if len(dut.serdes_tx_data) == 64: @@ -317,6 +351,12 @@ async def run_test_tx(dut, gbx_cfg=None, payload_lengths=None, payload_data=None await RisingEdge(dut.tx_clk) +@cocotb.test(skip=(data_w != 64)) +@cocotb.parametrize( + ("payload_data", [incrementing_payload]), + ("ifg", [12]), + ("gbx_cfg", gbx_cfgs), +) async def run_test_tx_alignment(dut, gbx_cfg=None, payload_data=None, ifg=12): if len(dut.serdes_tx_data) == 64: @@ -426,6 +466,11 @@ async def run_test_tx_alignment(dut, gbx_cfg=None, payload_data=None, ifg=12): await RisingEdge(dut.tx_clk) +@cocotb.test() +@cocotb.parametrize( + ("ifg", [12]), + ("gbx_cfg", gbx_cfgs), +) async def run_test_tx_underrun(dut, gbx_cfg=None, ifg=12): tb = TB(dut, gbx_cfg) @@ -520,6 +565,10 @@ async def run_test_tx_error(dut, gbx_cfg=None, ifg=12): await RisingEdge(dut.tx_clk) +@cocotb.test() +@cocotb.parametrize( + ("gbx_cfg", gbx_cfgs), +) async def run_test_rx_frame_sync(dut, gbx_cfg=None): tb = TB(dut, gbx_cfg) @@ -558,6 +607,11 @@ async def run_test_rx_frame_sync(dut, gbx_cfg=None): await RisingEdge(dut.rx_clk) +@cocotb.test(skip=(not pfc_en)) +@cocotb.parametrize( + ("ifg", [12]), + ("gbx_cfg", gbx_cfgs), +) async def run_test_lfc(dut, gbx_cfg=None, ifg=12): tb = TB(dut, gbx_cfg) @@ -716,6 +770,11 @@ async def run_test_lfc(dut, gbx_cfg=None, ifg=12): await RisingEdge(dut.tx_clk) +@cocotb.test(skip=(not pfc_en)) +@cocotb.parametrize( + ("ifg", [12]), + ("gbx_cfg", gbx_cfgs), +) async def run_test_pfc(dut, gbx_cfg=None, ifg=12): tb = TB(dut, gbx_cfg) @@ -956,6 +1015,10 @@ async def run_usxgmii_an(tb, cfg): return None +@cocotb.test(skip=(not usxgmii_en)) +@cocotb.parametrize( + ("gbx_cfg", gbx_cfgs), +) async def run_test_usxgmii(dut, gbx_cfg=None): tb = TB(dut, gbx_cfg) @@ -1010,67 +1073,6 @@ async def run_test_usxgmii(dut, gbx_cfg=None): await RisingEdge(dut.tx_clk) -def size_list(): - return list(range(60, 128)) + [512, 1514, 9214] + [60]*10 - - -def incrementing_payload(length): - return bytearray(itertools.islice(itertools.cycle(range(256)), length)) - - -def cycle_en(): - return itertools.cycle([0, 0, 0, 1]) - - -if getattr(cocotb, 'top', None) is not None: - - gbx_cfgs = [None] - - if cocotb.top.RX_GBX_IF_EN.value: - gbx_cfgs.append((33, [32])) - gbx_cfgs.append((66, [64, 65])) - - for test in [run_test_rx, run_test_tx]: - - factory = TestFactory(test) - factory.add_option("payload_lengths", [size_list]) - factory.add_option("payload_data", [incrementing_payload]) - factory.add_option("ifg", [12, 0]) - factory.add_option("gbx_cfg", gbx_cfgs) - factory.generate_tests() - - if len(cocotb.top.serdes_tx_data) == 64: - factory = TestFactory(run_test_tx_alignment) - factory.add_option("payload_data", [incrementing_payload]) - factory.add_option("ifg", [12]) - factory.add_option("gbx_cfg", gbx_cfgs) - factory.generate_tests() - - for test in [run_test_tx_underrun, run_test_tx_error]: - - factory = TestFactory(test) - factory.add_option("ifg", [12]) - factory.add_option("gbx_cfg", gbx_cfgs) - factory.generate_tests() - - factory = TestFactory(run_test_rx_frame_sync) - factory.add_option("gbx_cfg", gbx_cfgs) - factory.generate_tests() - - if cocotb.top.PFC_EN.value: - for test in [run_test_lfc, run_test_pfc]: - factory = TestFactory(test) - factory.add_option("ifg", [12]) - factory.add_option("gbx_cfg", gbx_cfgs) - factory.generate_tests() - - if cocotb.top.USXGMII_EN.value: - for test in [run_test_usxgmii]: - factory = TestFactory(test) - factory.add_option("gbx_cfg", gbx_cfgs) - factory.generate_tests() - - # cocotb-test tests_dir = os.path.abspath(os.path.dirname(__file__)) diff --git a/src/eth/tb/taxi_eth_mac_phy_10g_fifo/test_taxi_eth_mac_phy_10g_fifo.py b/src/eth/tb/taxi_eth_mac_phy_10g_fifo/test_taxi_eth_mac_phy_10g_fifo.py index f980106..ee3f860 100644 --- a/src/eth/tb/taxi_eth_mac_phy_10g_fifo/test_taxi_eth_mac_phy_10g_fifo.py +++ b/src/eth/tb/taxi_eth_mac_phy_10g_fifo/test_taxi_eth_mac_phy_10g_fifo.py @@ -21,7 +21,6 @@ import cocotb from cocotb.clock import Clock from cocotb.triggers import RisingEdge, Timer from cocotb.utils import get_time_from_sim_steps -from cocotb.regression import TestFactory from cocotbext.eth import XgmiiFrame, PtpClockSimTime from cocotbext.axi import AxiStreamBus, AxiStreamSource, AxiStreamSink, AxiStreamFrame @@ -150,6 +149,32 @@ class TB: self.ptp_td_source.set_ts_rel_sim_time() +def size_list(): + return list(range(60, 128)) + [512, 1514, 9214] + [60]*10 + + +def incrementing_payload(length): + return bytearray(itertools.islice(itertools.cycle(range(256)), length)) + + +gbx_cfgs = [None] +data_w = 64 +usxgmii_en = False +if getattr(cocotb, 'top', None) is not None: + if cocotb.top.RX_GBX_IF_EN.value: + gbx_cfgs.append((33, [32])) + gbx_cfgs.append((66, [64, 65])) + data_w = len(cocotb.top.serdes_tx_data) + usxgmii_en = bool(cocotb.top.USXGMII_EN.value) + + +@cocotb.test() +@cocotb.parametrize( + ("payload_lengths", [size_list]), + ("payload_data", [incrementing_payload]), + ("ifg", [12, 0]), + ("gbx_cfg", gbx_cfgs), +) async def run_test_rx(dut, gbx_cfg=None, payload_lengths=None, payload_data=None, ifg=12): if len(dut.serdes_rx_data) == 64: @@ -217,6 +242,13 @@ async def run_test_rx(dut, gbx_cfg=None, payload_lengths=None, payload_data=None await RisingEdge(dut.logic_clk) +@cocotb.test() +@cocotb.parametrize( + ("payload_lengths", [size_list]), + ("payload_data", [incrementing_payload]), + ("ifg", [12, 0]), + ("gbx_cfg", gbx_cfgs), +) async def run_test_tx(dut, gbx_cfg=None, payload_lengths=None, payload_data=None, ifg=12): if len(dut.serdes_tx_data) == 64: @@ -276,6 +308,12 @@ async def run_test_tx(dut, gbx_cfg=None, payload_lengths=None, payload_data=None await RisingEdge(dut.logic_clk) +@cocotb.test(skip=(data_w != 64)) +@cocotb.parametrize( + ("payload_data", [incrementing_payload]), + ("ifg", [12]), + ("gbx_cfg", gbx_cfgs), +) async def run_test_tx_alignment(dut, gbx_cfg=None, payload_data=None, ifg=12): if len(dut.serdes_tx_data) == 64: @@ -381,6 +419,10 @@ async def run_test_tx_alignment(dut, gbx_cfg=None, payload_data=None, ifg=12): await RisingEdge(dut.logic_clk) +@cocotb.test() +@cocotb.parametrize( + ("gbx_cfg", gbx_cfgs), +) async def run_test_rx_frame_sync(dut, gbx_cfg=None): tb = TB(dut, gbx_cfg) @@ -511,6 +553,10 @@ async def run_usxgmii_an(tb, cfg): return None +@cocotb.test(skip=(not usxgmii_en)) +@cocotb.parametrize( + ("gbx_cfg", gbx_cfgs), +) async def run_test_usxgmii(dut, gbx_cfg=None): tb = TB(dut, gbx_cfg) @@ -565,53 +611,6 @@ async def run_test_usxgmii(dut, gbx_cfg=None): await RisingEdge(dut.tx_clk) -def size_list(): - return list(range(60, 128)) + [512, 1514, 9214] + [60]*10 - - -def incrementing_payload(length): - return bytearray(itertools.islice(itertools.cycle(range(256)), length)) - - -def cycle_en(): - return itertools.cycle([0, 0, 0, 1]) - - -if getattr(cocotb, 'top', None) is not None: - - gbx_cfgs = [None] - - if cocotb.top.RX_GBX_IF_EN.value: - gbx_cfgs.append((33, [32])) - gbx_cfgs.append((66, [64, 65])) - - for test in [run_test_rx, run_test_tx]: - - factory = TestFactory(test) - factory.add_option("payload_lengths", [size_list]) - factory.add_option("payload_data", [incrementing_payload]) - factory.add_option("ifg", [12, 0]) - factory.add_option("gbx_cfg", gbx_cfgs) - factory.generate_tests() - - if len(cocotb.top.serdes_tx_data) == 64: - factory = TestFactory(run_test_tx_alignment) - factory.add_option("payload_data", [incrementing_payload]) - factory.add_option("ifg", [12]) - factory.add_option("gbx_cfg", gbx_cfgs) - factory.generate_tests() - - factory = TestFactory(run_test_rx_frame_sync) - factory.add_option("gbx_cfg", gbx_cfgs) - factory.generate_tests() - - if cocotb.top.USXGMII_EN.value: - for test in [run_test_usxgmii]: - factory = TestFactory(test) - factory.add_option("gbx_cfg", gbx_cfgs) - factory.generate_tests() - - # cocotb-test tests_dir = os.path.abspath(os.path.dirname(__file__)) diff --git a/src/eth/tb/taxi_eth_mac_phy_1g_basex/test_taxi_eth_mac_phy_1g_basex.py b/src/eth/tb/taxi_eth_mac_phy_1g_basex/test_taxi_eth_mac_phy_1g_basex.py index edc91dc..5236042 100644 --- a/src/eth/tb/taxi_eth_mac_phy_1g_basex/test_taxi_eth_mac_phy_1g_basex.py +++ b/src/eth/tb/taxi_eth_mac_phy_1g_basex/test_taxi_eth_mac_phy_1g_basex.py @@ -24,7 +24,6 @@ import cocotb from cocotb.clock import Clock from cocotb.triggers import RisingEdge, Timer from cocotb.utils import get_time_from_sim_steps -from cocotb.regression import TestFactory from cocotbext.eth import GmiiFrame, PtpClockSimTime from cocotbext.axi import AxiStreamBus, AxiStreamSource, AxiStreamSink, AxiStreamFrame @@ -181,6 +180,31 @@ class TB: self.ptp_td_source.set_ts_rel_sim_time() +def size_list(): + return list(range(60, 128)) + [512, 1514, 9214] + [60]*10 + + +def incrementing_payload(length): + return bytearray(itertools.islice(itertools.cycle(range(256)), length)) + + +gbx_cfgs = [None] +pfc_en = False +an_en = False +if getattr(cocotb, 'top', None) is not None: + if cocotb.top.RX_GBX_IF_EN.value: + gbx_cfgs.append((5, [4])) + pfc_en = cocotb.top.PFC_EN.value + an_en = cocotb.top.AN_EN.value + + +@cocotb.test() +@cocotb.parametrize( + ("payload_lengths", [size_list]), + ("payload_data", [incrementing_payload]), + ("ifg", [12, 0]), + ("gbx_cfg", gbx_cfgs), +) async def run_test_rx(dut, gbx_cfg=None, payload_lengths=None, payload_data=None, ifg=12): if len(dut.serdes_tx_data) == 16: @@ -249,6 +273,13 @@ async def run_test_rx(dut, gbx_cfg=None, payload_lengths=None, payload_data=None await RisingEdge(dut.rx_clk) +@cocotb.test() +@cocotb.parametrize( + ("payload_lengths", [size_list]), + ("payload_data", [incrementing_payload]), + ("ifg", [12, 0]), + ("gbx_cfg", gbx_cfgs), +) async def run_test_tx(dut, gbx_cfg=None, payload_lengths=None, payload_data=None, ifg=12): if len(dut.serdes_tx_data) == 16: @@ -312,6 +343,11 @@ async def run_test_tx(dut, gbx_cfg=None, payload_lengths=None, payload_data=None await RisingEdge(dut.tx_clk) +@cocotb.test() +@cocotb.parametrize( + ("ifg", [12]), + ("gbx_cfg", gbx_cfgs), +) async def run_test_tx_underrun(dut, gbx_cfg=None, ifg=12): tb = TB(dut, gbx_cfg) @@ -363,6 +399,11 @@ async def run_test_tx_underrun(dut, gbx_cfg=None, ifg=12): await RisingEdge(dut.tx_clk) +@cocotb.test() +@cocotb.parametrize( + ("ifg", [12]), + ("gbx_cfg", gbx_cfgs), +) async def run_test_tx_error(dut, gbx_cfg=None, ifg=12): tb = TB(dut, gbx_cfg) @@ -406,6 +447,11 @@ async def run_test_tx_error(dut, gbx_cfg=None, ifg=12): await RisingEdge(dut.tx_clk) +@cocotb.test(skip=(not pfc_en)) +@cocotb.parametrize( + ("ifg", [12]), + ("gbx_cfg", gbx_cfgs), +) async def run_test_lfc(dut, gbx_cfg=None, ifg=12): tb = TB(dut, gbx_cfg) @@ -564,6 +610,11 @@ async def run_test_lfc(dut, gbx_cfg=None, ifg=12): await RisingEdge(dut.tx_clk) +@cocotb.test(skip=(not pfc_en)) +@cocotb.parametrize( + ("ifg", [12]), + ("gbx_cfg", gbx_cfgs), +) async def run_test_pfc(dut, gbx_cfg=None, ifg=12): tb = TB(dut, gbx_cfg) @@ -791,6 +842,11 @@ async def run_basex_an(tb, cfg, sgmii=False): return None +@cocotb.test(skip=(not an_en)) +@cocotb.parametrize( + ("gbx_cfg", gbx_cfgs), + (("sgmii_en", "sgmii_auto"), [(False, False), (True, False), (False, True)]), +) async def run_test_an(dut, gbx_cfg=None, sgmii_en=False, sgmii_auto=False): tb = TB(dut, gbx_cfg) @@ -898,57 +954,6 @@ async def run_test_an(dut, gbx_cfg=None, sgmii_en=False, sgmii_auto=False): await RisingEdge(dut.tx_clk) -def size_list(): - return list(range(60, 128)) + [512, 1514, 9214] + [60]*10 - - -def incrementing_payload(length): - return bytearray(itertools.islice(itertools.cycle(range(256)), length)) - - -def cycle_en(): - return itertools.cycle([0, 0, 0, 1]) - - -if getattr(cocotb, 'top', None) is not None: - - gbx_cfgs = [None] - - if cocotb.top.RX_GBX_IF_EN.value: - gbx_cfgs.append((5, [4])) - - for test in [run_test_rx, run_test_tx]: - - factory = TestFactory(test) - factory.add_option("payload_lengths", [size_list]) - factory.add_option("payload_data", [incrementing_payload]) - factory.add_option("ifg", [12, 0]) - factory.add_option("gbx_cfg", gbx_cfgs) - factory.generate_tests() - - for test in [run_test_tx_underrun, run_test_tx_error]: - - factory = TestFactory(test) - factory.add_option("ifg", [12]) - factory.add_option("gbx_cfg", gbx_cfgs) - factory.generate_tests() - - if cocotb.top.PFC_EN.value: - for test in [run_test_lfc, run_test_pfc]: - factory = TestFactory(test) - factory.add_option("ifg", [12]) - factory.add_option("gbx_cfg", gbx_cfgs) - factory.generate_tests() - - if cocotb.top.AN_EN.value: - for test in [run_test_an]: - factory = TestFactory(test) - factory.add_option("gbx_cfg", gbx_cfgs) - factory.add_option(("sgmii_en", "sgmii_auto"), - [(False, False), (True, False), (False, True)]) - factory.generate_tests() - - # cocotb-test tests_dir = os.path.abspath(os.path.dirname(__file__)) diff --git a/src/eth/tb/taxi_eth_mac_phy_1g_basex_fifo/test_taxi_eth_mac_phy_1g_basex_fifo.py b/src/eth/tb/taxi_eth_mac_phy_1g_basex_fifo/test_taxi_eth_mac_phy_1g_basex_fifo.py index 3d201f6..89c0159 100644 --- a/src/eth/tb/taxi_eth_mac_phy_1g_basex_fifo/test_taxi_eth_mac_phy_1g_basex_fifo.py +++ b/src/eth/tb/taxi_eth_mac_phy_1g_basex_fifo/test_taxi_eth_mac_phy_1g_basex_fifo.py @@ -21,7 +21,6 @@ import cocotb from cocotb.clock import Clock from cocotb.triggers import RisingEdge, Timer from cocotb.utils import get_time_from_sim_steps -from cocotb.regression import TestFactory from cocotbext.eth import GmiiFrame, PtpClockSimTime from cocotbext.axi import AxiStreamBus, AxiStreamSource, AxiStreamSink, AxiStreamFrame @@ -149,6 +148,29 @@ class TB: self.ptp_td_source.set_ts_rel_sim_time() +def size_list(): + return list(range(60, 128)) + [512, 1514, 9214] + [60]*10 + + +def incrementing_payload(length): + return bytearray(itertools.islice(itertools.cycle(range(256)), length)) + + +gbx_cfgs = [None] +an_en = False +if getattr(cocotb, 'top', None) is not None: + if cocotb.top.RX_GBX_IF_EN.value: + gbx_cfgs.append((5, [4])) + an_en = cocotb.top.AN_EN.value + + +@cocotb.test() +@cocotb.parametrize( + ("payload_lengths", [size_list]), + ("payload_data", [incrementing_payload]), + ("ifg", [12, 0]), + ("gbx_cfg", gbx_cfgs), +) async def run_test_rx(dut, gbx_cfg=None, payload_lengths=None, payload_data=None, ifg=12): if len(dut.serdes_tx_data) == 64: @@ -213,6 +235,13 @@ async def run_test_rx(dut, gbx_cfg=None, payload_lengths=None, payload_data=None await RisingEdge(dut.logic_clk) +@cocotb.test() +@cocotb.parametrize( + ("payload_lengths", [size_list]), + ("payload_data", [incrementing_payload]), + ("ifg", [12, 0]), + ("gbx_cfg", gbx_cfgs), +) async def run_test_tx(dut, gbx_cfg=None, payload_lengths=None, payload_data=None, ifg=12): if len(dut.serdes_tx_data) == 16: @@ -350,6 +379,11 @@ async def run_basex_an(tb, cfg, sgmii=False): return None +@cocotb.test(skip=(not an_en)) +@cocotb.parametrize( + ("gbx_cfg", gbx_cfgs), + (("sgmii_en", "sgmii_auto"), [(False, False), (True, False), (False, True)]) +) async def run_test_an(dut, gbx_cfg=None, sgmii_en=False, sgmii_auto=False): tb = TB(dut, gbx_cfg) @@ -457,43 +491,6 @@ async def run_test_an(dut, gbx_cfg=None, sgmii_en=False, sgmii_auto=False): await RisingEdge(dut.tx_clk) -def size_list(): - return list(range(60, 128)) + [512, 1514, 9214] + [60]*10 - - -def incrementing_payload(length): - return bytearray(itertools.islice(itertools.cycle(range(256)), length)) - - -def cycle_en(): - return itertools.cycle([0, 0, 0, 1]) - - -if getattr(cocotb, 'top', None) is not None: - - gbx_cfgs = [None] - - if cocotb.top.RX_GBX_IF_EN.value: - gbx_cfgs.append((5, [4])) - - for test in [run_test_rx, run_test_tx]: - - factory = TestFactory(test) - factory.add_option("payload_lengths", [size_list]) - factory.add_option("payload_data", [incrementing_payload]) - factory.add_option("ifg", [12, 0]) - factory.add_option("gbx_cfg", gbx_cfgs) - factory.generate_tests() - - if cocotb.top.AN_EN.value: - for test in [run_test_an]: - factory = TestFactory(test) - factory.add_option("gbx_cfg", gbx_cfgs) - factory.add_option(("sgmii_en", "sgmii_auto"), - [(False, False), (True, False), (False, True)]) - factory.generate_tests() - - # cocotb-test tests_dir = os.path.abspath(os.path.dirname(__file__)) diff --git a/src/eth/tb/taxi_eth_phy_10g/test_taxi_eth_phy_10g.py b/src/eth/tb/taxi_eth_phy_10g/test_taxi_eth_phy_10g.py index 58aeb21..dda82ba 100644 --- a/src/eth/tb/taxi_eth_phy_10g/test_taxi_eth_phy_10g.py +++ b/src/eth/tb/taxi_eth_phy_10g/test_taxi_eth_phy_10g.py @@ -20,7 +20,6 @@ import pytest import cocotb from cocotb.clock import Clock from cocotb.triggers import RisingEdge -from cocotb.regression import TestFactory from cocotbext.eth import XgmiiSource, XgmiiSink, XgmiiFrame @@ -93,6 +92,20 @@ class TB: await RisingEdge(self.dut.tx_clk) +def size_list(): + return list(range(60, 128)) + [512, 1514, 9214] + [60]*10 + + +def incrementing_payload(length): + return bytearray(itertools.islice(itertools.cycle(range(256)), length)) + + +@cocotb.test() +@cocotb.parametrize( + ("payload_lengths", [size_list]), + ("payload_data", [incrementing_payload]), + ("ifg", [12]), +) async def run_test_rx(dut, payload_lengths=None, payload_data=None, ifg=12): tb = TB(dut) @@ -127,6 +140,12 @@ async def run_test_rx(dut, payload_lengths=None, payload_data=None, ifg=12): await RisingEdge(dut.rx_clk) +@cocotb.test() +@cocotb.parametrize( + ("payload_lengths", [size_list]), + ("payload_data", [incrementing_payload]), + ("ifg", [12]), +) async def run_test_tx(dut, payload_lengths=None, payload_data=None, ifg=12): tb = TB(dut) @@ -154,6 +173,7 @@ async def run_test_tx(dut, payload_lengths=None, payload_data=None, ifg=12): await RisingEdge(dut.tx_clk) +@cocotb.test() async def run_test_rx_frame_sync(dut): tb = TB(dut) @@ -192,32 +212,6 @@ async def run_test_rx_frame_sync(dut): await RisingEdge(dut.rx_clk) -def size_list(): - return list(range(60, 128)) + [512, 1514, 9214] + [60]*10 - - -def incrementing_payload(length): - return bytearray(itertools.islice(itertools.cycle(range(256)), length)) - - -def cycle_en(): - return itertools.cycle([0, 0, 0, 1]) - - -if getattr(cocotb, 'top', None) is not None: - - for test in [run_test_rx, run_test_tx]: - - factory = TestFactory(test) - factory.add_option("payload_lengths", [size_list]) - factory.add_option("payload_data", [incrementing_payload]) - factory.add_option("ifg", [12]) - factory.generate_tests() - - factory = TestFactory(run_test_rx_frame_sync) - factory.generate_tests() - - # cocotb-test tests_dir = os.path.abspath(os.path.dirname(__file__)) diff --git a/src/eth/tb/taxi_eth_phy_1g_basex/test_taxi_eth_phy_1g_basex.py b/src/eth/tb/taxi_eth_phy_1g_basex/test_taxi_eth_phy_1g_basex.py index bc5fc1e..35c350c 100644 --- a/src/eth/tb/taxi_eth_phy_1g_basex/test_taxi_eth_phy_1g_basex.py +++ b/src/eth/tb/taxi_eth_phy_1g_basex/test_taxi_eth_phy_1g_basex.py @@ -20,7 +20,6 @@ import pytest import cocotb from cocotb.clock import Clock from cocotb.triggers import RisingEdge, Timer -from cocotb.regression import TestFactory from cocotbext.eth import GmiiSource, GmiiSink, GmiiFrame @@ -103,6 +102,25 @@ class TB: await RisingEdge(self.dut.tx_clk) +def size_list(): + return list(range(60, 128)) + [512, 1514, 9214] + [60]*10 + + +def incrementing_payload(length): + return bytearray(itertools.islice(itertools.cycle(range(256)), length)) + + +an_en = False +if getattr(cocotb, 'top', None) is not None: + an_en = cocotb.top.AN_EN.value + + +@cocotb.test() +@cocotb.parametrize( + ("payload_lengths", [size_list]), + ("payload_data", [incrementing_payload]), + ("ifg", [12, 0]), +) async def run_test_rx(dut, payload_lengths=None, payload_data=None, ifg=12): tb = TB(dut) @@ -137,6 +155,12 @@ async def run_test_rx(dut, payload_lengths=None, payload_data=None, ifg=12): await RisingEdge(dut.rx_clk) +@cocotb.test() +@cocotb.parametrize( + ("payload_lengths", [size_list]), + ("payload_data", [incrementing_payload]), + ("ifg", [12, 0]), +) async def run_test_tx(dut, payload_lengths=None, payload_data=None, ifg=12): tb = TB(dut) @@ -243,6 +267,10 @@ async def run_basex_an(tb, cfg, sgmii=False): return None +@cocotb.test(skip=(not an_en)) +@cocotb.parametrize( + (("sgmii_en", "sgmii_auto"), [(False, False), (True, False), (False, True)]), +) async def run_test_an(dut, sgmii_en=False, sgmii_auto=False): tb = TB(dut) @@ -350,36 +378,6 @@ async def run_test_an(dut, sgmii_en=False, sgmii_auto=False): await RisingEdge(dut.tx_clk) -def size_list(): - return list(range(60, 128)) + [512, 1514, 9214] + [60]*10 - - -def incrementing_payload(length): - return bytearray(itertools.islice(itertools.cycle(range(256)), length)) - - -def cycle_en(): - return itertools.cycle([0, 0, 0, 1]) - - -if getattr(cocotb, 'top', None) is not None: - - for test in [run_test_rx, run_test_tx]: - - factory = TestFactory(test) - factory.add_option("payload_lengths", [size_list]) - factory.add_option("payload_data", [incrementing_payload]) - factory.add_option("ifg", [12]) - factory.generate_tests() - - if cocotb.top.AN_EN.value: - for test in [run_test_an]: - factory = TestFactory(test) - factory.add_option(("sgmii_en", "sgmii_auto"), - [(False, False), (True, False), (False, True)]) - factory.generate_tests() - - # cocotb-test tests_dir = os.path.abspath(os.path.dirname(__file__)) diff --git a/src/eth/tb/taxi_gmii_basex_dec/test_taxi_gmii_basex_dec.py b/src/eth/tb/taxi_gmii_basex_dec/test_taxi_gmii_basex_dec.py index 70219eb..06ee5d3 100644 --- a/src/eth/tb/taxi_gmii_basex_dec/test_taxi_gmii_basex_dec.py +++ b/src/eth/tb/taxi_gmii_basex_dec/test_taxi_gmii_basex_dec.py @@ -20,7 +20,6 @@ import pytest import cocotb from cocotb.clock import Clock from cocotb.triggers import RisingEdge -from cocotb.regression import TestFactory from cocotbext.eth import GmiiFrame, GmiiSink @@ -73,6 +72,21 @@ class TB: await RisingEdge(self.dut.clk) +def size_list(): + return list(range(60, 128)) + [512, 1514, 9214] + [60]*10 + [i for i in range(64, 73) for k in range(8)] + + +def incrementing_payload(length): + return bytearray(itertools.islice(itertools.cycle(range(256)), length)) + + +@cocotb.test() +@cocotb.parametrize( + ("payload_lengths", [size_list]), + ("payload_data", [incrementing_payload]), + ("ifg", list(range(0, 13))), + ("pre_trunc", [False, True]), +) async def run_test(dut, gbx_cfg=None, payload_lengths=None, payload_data=None, ifg=12, pre_trunc=8): tb = TB(dut, gbx_cfg) @@ -101,6 +115,7 @@ async def run_test(dut, gbx_cfg=None, payload_lengths=None, payload_data=None, i await RisingEdge(dut.clk) +@cocotb.test() async def run_test_an(dut, gbx_cfg=None): tb = TB(dut, gbx_cfg) @@ -133,27 +148,6 @@ async def run_test_an(dut, gbx_cfg=None): await RisingEdge(dut.clk) -def size_list(): - return list(range(60, 128)) + [512, 1514, 9214] + [60]*10 + [i for i in range(64, 73) for k in range(8)] - - -def incrementing_payload(length): - return bytearray(itertools.islice(itertools.cycle(range(256)), length)) - - -if getattr(cocotb, 'top', None) is not None: - - factory = TestFactory(run_test) - factory.add_option("payload_lengths", [size_list]) - factory.add_option("payload_data", [incrementing_payload]) - factory.add_option("ifg", list(range(0, 13))) - factory.add_option("pre_trunc", [False, True]) - factory.generate_tests() - - factory = TestFactory(run_test_an) - factory.generate_tests() - - # cocotb-test tests_dir = os.path.abspath(os.path.dirname(__file__)) diff --git a/src/eth/tb/taxi_gmii_basex_enc/test_taxi_gmii_basex_enc.py b/src/eth/tb/taxi_gmii_basex_enc/test_taxi_gmii_basex_enc.py index 0e25c1f..d865d24 100644 --- a/src/eth/tb/taxi_gmii_basex_enc/test_taxi_gmii_basex_enc.py +++ b/src/eth/tb/taxi_gmii_basex_enc/test_taxi_gmii_basex_enc.py @@ -20,7 +20,6 @@ import pytest import cocotb from cocotb.clock import Clock from cocotb.triggers import RisingEdge -from cocotb.regression import TestFactory from cocotbext.eth import GmiiFrame, GmiiSource @@ -79,6 +78,21 @@ class TB: await RisingEdge(self.dut.clk) +def size_list(): + return list(range(60, 128)) + [512, 1514, 9214] + [60]*10 + [i for i in range(64, 73) for k in range(8)] + + +def incrementing_payload(length): + return bytearray(itertools.islice(itertools.cycle(range(256)), length)) + + +@cocotb.test() +@cocotb.parametrize( + ("payload_lengths", [size_list]), + ("payload_data", [incrementing_payload]), + ("ifg", list(range(0, 13))), + ("pre_len", [8, 7]), +) async def run_test(dut, gbx_cfg=None, payload_lengths=None, payload_data=None, ifg=12, pre_len=8): tb = TB(dut, gbx_cfg) @@ -107,6 +121,7 @@ async def run_test(dut, gbx_cfg=None, payload_lengths=None, payload_data=None, i await RisingEdge(dut.clk) +@cocotb.test() async def run_test_an(dut, gbx_cfg=None): tb = TB(dut, gbx_cfg) @@ -140,27 +155,6 @@ async def run_test_an(dut, gbx_cfg=None): await RisingEdge(dut.clk) -def size_list(): - return list(range(60, 128)) + [512, 1514, 9214] + [60]*10 + [i for i in range(64, 73) for k in range(8)] - - -def incrementing_payload(length): - return bytearray(itertools.islice(itertools.cycle(range(256)), length)) - - -if getattr(cocotb, 'top', None) is not None: - - factory = TestFactory(run_test) - factory.add_option("payload_lengths", [size_list]) - factory.add_option("payload_data", [incrementing_payload]) - factory.add_option("ifg", list(range(0, 13))) - factory.add_option("pre_len", [8, 7]) - factory.generate_tests() - - factory = TestFactory(run_test_an) - factory.generate_tests() - - # cocotb-test tests_dir = os.path.abspath(os.path.dirname(__file__)) diff --git a/src/eth/tb/taxi_mac_ctrl_rx/test_taxi_mac_ctrl_rx.py b/src/eth/tb/taxi_mac_ctrl_rx/test_taxi_mac_ctrl_rx.py index 7bb05d1..fe8f398 100644 --- a/src/eth/tb/taxi_mac_ctrl_rx/test_taxi_mac_ctrl_rx.py +++ b/src/eth/tb/taxi_mac_ctrl_rx/test_taxi_mac_ctrl_rx.py @@ -22,7 +22,6 @@ import cocotb_test.simulator import cocotb from cocotb.clock import Clock from cocotb.triggers import RisingEdge -from cocotb.regression import TestFactory from cocotbext.axi import AxiStreamBus, AxiStreamSource, AxiStreamSink, AxiStreamFrame from cocotbext.axi.stream import define_stream @@ -104,6 +103,29 @@ class TB: return Ether(data) +def cycle_pause(): + return itertools.cycle([1, 1, 1, 0]) + + +def size_list(): + return list(range(1, 128)) + [512, 1514, 9214] + [60]*10 + + +def mcf_size_list(): + return list(range(1, 19)) + + +def incrementing_payload(length): + return bytes(itertools.islice(itertools.cycle(range(256)), length)) + + +@cocotb.test() +@cocotb.parametrize( + ("payload_lengths", [size_list]), + ("payload_data", [incrementing_payload]), + ("idle_inserter", [None, cycle_pause]), + ("backpressure_inserter", [None, cycle_pause]), +) async def run_test_data(dut, payload_lengths=None, payload_data=None, idle_inserter=None, backpressure_inserter=None): tb = TB(dut) @@ -152,6 +174,13 @@ async def run_test_data(dut, payload_lengths=None, payload_data=None, idle_inser await RisingEdge(dut.clk) +@cocotb.test() +@cocotb.parametrize( + ("payload_lengths", [mcf_size_list]), + ("payload_data", [incrementing_payload]), + ("idle_inserter", [None, cycle_pause]), + ("backpressure_inserter", [None, cycle_pause]), +) async def run_test_mcf(dut, payload_lengths=None, payload_data=None, idle_inserter=None, backpressure_inserter=None): tb = TB(dut) @@ -225,6 +254,7 @@ async def run_test_mcf(dut, payload_lengths=None, payload_data=None, idle_insert await RisingEdge(dut.clk) +@cocotb.test() async def run_test_tuser_assert(dut): tb = TB(dut) @@ -279,6 +309,7 @@ async def run_test_tuser_assert(dut): await RisingEdge(dut.clk) +@cocotb.test() async def run_test_mcf_filter(dut): tb = TB(dut) @@ -395,6 +426,11 @@ async def run_test_mcf_filter(dut): await RisingEdge(dut.clk) +@cocotb.test() +@cocotb.parametrize( + ("idle_inserter", [None, cycle_pause]), + ("backpressure_inserter", [None, cycle_pause]), +) async def run_stress_test(dut, idle_inserter=None, backpressure_inserter=None): tb = TB(dut) @@ -489,50 +525,6 @@ async def run_stress_test(dut, idle_inserter=None, backpressure_inserter=None): await RisingEdge(dut.clk) -def cycle_pause(): - return itertools.cycle([1, 1, 1, 0]) - - -def size_list(): - return list(range(1, 128)) + [512, 1514, 9214] + [60]*10 - - -def mcf_size_list(): - return list(range(1, 19)) - - -def incrementing_payload(length): - return bytes(itertools.islice(itertools.cycle(range(256)), length)) - - -if getattr(cocotb, 'top', None) is not None: - - factory = TestFactory(run_test_data) - factory.add_option("payload_lengths", [size_list]) - factory.add_option("payload_data", [incrementing_payload]) - factory.add_option("idle_inserter", [None, cycle_pause]) - factory.add_option("backpressure_inserter", [None, cycle_pause]) - factory.generate_tests() - - factory = TestFactory(run_test_mcf) - factory.add_option("payload_lengths", [mcf_size_list]) - factory.add_option("payload_data", [incrementing_payload]) - factory.add_option("idle_inserter", [None, cycle_pause]) - factory.add_option("backpressure_inserter", [None, cycle_pause]) - factory.generate_tests() - - factory = TestFactory(run_test_tuser_assert) - factory.generate_tests() - - factory = TestFactory(run_test_mcf_filter) - factory.generate_tests() - - factory = TestFactory(run_stress_test) - factory.add_option("idle_inserter", [None, cycle_pause]) - factory.add_option("backpressure_inserter", [None, cycle_pause]) - factory.generate_tests() - - # cocotb-test tests_dir = os.path.abspath(os.path.dirname(__file__)) diff --git a/src/eth/tb/taxi_mac_ctrl_tx/test_taxi_mac_ctrl_tx.py b/src/eth/tb/taxi_mac_ctrl_tx/test_taxi_mac_ctrl_tx.py index 02fa853..6f5ae5b 100644 --- a/src/eth/tb/taxi_mac_ctrl_tx/test_taxi_mac_ctrl_tx.py +++ b/src/eth/tb/taxi_mac_ctrl_tx/test_taxi_mac_ctrl_tx.py @@ -23,7 +23,6 @@ import cocotb_test.simulator import cocotb from cocotb.clock import Clock from cocotb.triggers import FallingEdge, RisingEdge, Event -from cocotb.regression import TestFactory from cocotbext.axi import AxiStreamBus, AxiStreamSource, AxiStreamSink, AxiStreamFrame from cocotbext.axi.stream import define_stream @@ -91,6 +90,29 @@ class TB: return Ether(bytes(rx_frame)) +def cycle_pause(): + return itertools.cycle([1, 1, 1, 0]) + + +def size_list(): + return list(range(1, 128)) + [512, 1514, 9214] + [60]*10 + + +def mcf_size_list(): + return list(range(1, 19)) + + +def incrementing_payload(length): + return bytes(itertools.islice(itertools.cycle(range(256)), length)) + + +@cocotb.test() +@cocotb.parametrize( + ("payload_lengths", [size_list]), + ("payload_data", [incrementing_payload]), + ("idle_inserter", [None, cycle_pause]), + ("backpressure_inserter", [None, cycle_pause]), +) async def run_test_data(dut, payload_lengths=None, payload_data=None, idle_inserter=None, backpressure_inserter=None): tb = TB(dut) @@ -140,6 +162,13 @@ async def run_test_data(dut, payload_lengths=None, payload_data=None, idle_inser await RisingEdge(dut.clk) +@cocotb.test() +@cocotb.parametrize( + ("payload_lengths", [mcf_size_list]), + ("payload_data", [incrementing_payload]), + ("idle_inserter", [None, cycle_pause]), + ("backpressure_inserter", [None, cycle_pause]), +) async def run_test_mcf(dut, payload_lengths=None, payload_data=None, idle_inserter=None, backpressure_inserter=None): tb = TB(dut) @@ -178,6 +207,7 @@ async def run_test_mcf(dut, payload_lengths=None, payload_data=None, idle_insert await RisingEdge(dut.clk) +@cocotb.test() async def run_test_tuser_assert(dut): tb = TB(dut) @@ -201,6 +231,7 @@ async def run_test_tuser_assert(dut): await RisingEdge(dut.clk) +@cocotb.test() async def run_arb_test(dut): tb = TB(dut) @@ -285,6 +316,11 @@ async def run_arb_test(dut): await RisingEdge(dut.clk) +@cocotb.test() +@cocotb.parametrize( + ("idle_inserter", [None, cycle_pause]), + ("backpressure_inserter", [None, cycle_pause]), +) async def run_stress_test(dut, idle_inserter=None, backpressure_inserter=None): tb = TB(dut) @@ -371,50 +407,6 @@ async def run_stress_test(dut, idle_inserter=None, backpressure_inserter=None): await RisingEdge(dut.clk) -def cycle_pause(): - return itertools.cycle([1, 1, 1, 0]) - - -def size_list(): - return list(range(1, 128)) + [512, 1514, 9214] + [60]*10 - - -def mcf_size_list(): - return list(range(1, 19)) - - -def incrementing_payload(length): - return bytes(itertools.islice(itertools.cycle(range(256)), length)) - - -if getattr(cocotb, 'top', None) is not None: - - factory = TestFactory(run_test_data) - factory.add_option("payload_lengths", [size_list]) - factory.add_option("payload_data", [incrementing_payload]) - factory.add_option("idle_inserter", [None, cycle_pause]) - factory.add_option("backpressure_inserter", [None, cycle_pause]) - factory.generate_tests() - - factory = TestFactory(run_test_mcf) - factory.add_option("payload_lengths", [mcf_size_list]) - factory.add_option("payload_data", [incrementing_payload]) - factory.add_option("idle_inserter", [None, cycle_pause]) - factory.add_option("backpressure_inserter", [None, cycle_pause]) - factory.generate_tests() - - factory = TestFactory(run_test_tuser_assert) - factory.generate_tests() - - factory = TestFactory(run_arb_test) - factory.generate_tests() - - factory = TestFactory(run_stress_test) - factory.add_option("idle_inserter", [None, cycle_pause]) - factory.add_option("backpressure_inserter", [None, cycle_pause]) - factory.generate_tests() - - # cocotb-test tests_dir = os.path.abspath(os.path.dirname(__file__)) diff --git a/src/eth/tb/taxi_mac_pause_ctrl_rx/test_taxi_mac_pause_ctrl_rx.py b/src/eth/tb/taxi_mac_pause_ctrl_rx/test_taxi_mac_pause_ctrl_rx.py index 9d16503..1b8eba7 100644 --- a/src/eth/tb/taxi_mac_pause_ctrl_rx/test_taxi_mac_pause_ctrl_rx.py +++ b/src/eth/tb/taxi_mac_pause_ctrl_rx/test_taxi_mac_pause_ctrl_rx.py @@ -21,7 +21,6 @@ import cocotb_test.simulator import cocotb from cocotb.clock import Clock from cocotb.triggers import RisingEdge -from cocotb.regression import TestFactory from cocotb.utils import get_sim_time from cocotbext.axi.stream import define_stream @@ -79,6 +78,7 @@ class TB: await self.mcf_source.send(mcf) +@cocotb.test() async def run_test_lfc(dut): tb = TB(dut) @@ -188,6 +188,7 @@ async def run_test_lfc(dut): await RisingEdge(dut.clk) +@cocotb.test() async def run_test_pfc(dut): tb = TB(dut) @@ -364,14 +365,6 @@ async def run_test_pfc(dut): await RisingEdge(dut.clk) -if getattr(cocotb, 'top', None) is not None: - - for test in [run_test_lfc, run_test_pfc]: - - factory = TestFactory(test) - factory.generate_tests() - - # cocotb-test tests_dir = os.path.abspath(os.path.dirname(__file__)) diff --git a/src/eth/tb/taxi_mac_pause_ctrl_tx/test_taxi_mac_pause_ctrl_tx.py b/src/eth/tb/taxi_mac_pause_ctrl_tx/test_taxi_mac_pause_ctrl_tx.py index 64d835f..838e372 100644 --- a/src/eth/tb/taxi_mac_pause_ctrl_tx/test_taxi_mac_pause_ctrl_tx.py +++ b/src/eth/tb/taxi_mac_pause_ctrl_tx/test_taxi_mac_pause_ctrl_tx.py @@ -20,7 +20,6 @@ import cocotb_test.simulator import cocotb from cocotb.clock import Clock from cocotb.triggers import RisingEdge -from cocotb.regression import TestFactory from cocotb.utils import get_sim_time from cocotbext.axi.stream import define_stream @@ -104,6 +103,7 @@ def check_lfc_frame(tb, pkt, quanta): assert q == quanta +@cocotb.test() async def run_test_lfc(dut): tb = TB(dut) @@ -177,6 +177,7 @@ def check_pfc_frame(tb, pkt, enable_mask, quanta_mask, quanta): assert q[k] == 0 +@cocotb.test() async def run_test_pfc(dut): tb = TB(dut) @@ -315,14 +316,6 @@ async def run_test_pfc(dut): await RisingEdge(dut.clk) -if getattr(cocotb, 'top', None) is not None: - - for test in [run_test_lfc, run_test_pfc]: - - factory = TestFactory(test) - factory.generate_tests() - - # cocotb-test tests_dir = os.path.abspath(os.path.dirname(__file__)) diff --git a/src/eth/tb/taxi_xgmii_baser_dec/test_taxi_xgmii_baser_dec.py b/src/eth/tb/taxi_xgmii_baser_dec/test_taxi_xgmii_baser_dec.py index 692c136..b108026 100644 --- a/src/eth/tb/taxi_xgmii_baser_dec/test_taxi_xgmii_baser_dec.py +++ b/src/eth/tb/taxi_xgmii_baser_dec/test_taxi_xgmii_baser_dec.py @@ -20,7 +20,6 @@ import cocotb_test.simulator import cocotb from cocotb.clock import Clock from cocotb.triggers import RisingEdge -from cocotb.regression import TestFactory from cocotbext.eth import XgmiiSink, XgmiiFrame @@ -74,6 +73,22 @@ class TB: await RisingEdge(self.dut.clk) +def size_list(): + return list(range(60, 128)) + [512, 1514, 9214] + [60]*10 + + +def incrementing_payload(length): + return bytearray(itertools.islice(itertools.cycle(range(256)), length)) + + +@cocotb.test() +@cocotb.parametrize( + ("payload_lengths", [size_list]), + ("payload_data", [incrementing_payload]), + ("ifg", list(range(13))), + ("enable_dic", [True, False]), + ("force_offset_start", [False, True]), +) async def run_test(dut, payload_lengths=None, payload_data=None, ifg=12, enable_dic=True, force_offset_start=False): @@ -103,6 +118,13 @@ async def run_test(dut, payload_lengths=None, payload_data=None, ifg=12, enable_ await RisingEdge(dut.clk) +@cocotb.test() +@cocotb.parametrize( + ("payload_data", [incrementing_payload]), + ("ifg", [12]), + ("enable_dic", [True, False]), + ("force_offset_start", [False, True]), +) async def run_test_alignment(dut, payload_data=None, ifg=12, enable_dic=True, force_offset_start=False): @@ -114,9 +136,12 @@ async def run_test_alignment(dut, payload_data=None, ifg=12, enable_dic=True, tb.source.enable_dic = enable_dic tb.source.force_offset_start = force_offset_start + await tb.reset() + for length in range(60, 92): - await tb.reset() + for k in range(10): + await RisingEdge(dut.clk) test_frames = [payload_data(length) for k in range(10)] start_lane = [] @@ -176,6 +201,7 @@ async def run_test_alignment(dut, payload_data=None, ifg=12, enable_dic=True, await RisingEdge(dut.clk) +@cocotb.test() async def run_test_os(dut): tb = TB(dut) @@ -204,39 +230,6 @@ async def run_test_os(dut): await RisingEdge(dut.clk) -def size_list(): - return list(range(60, 128)) + [512, 1514, 9214] + [60]*10 - - -def incrementing_payload(length): - return bytearray(itertools.islice(itertools.cycle(range(256)), length)) - - -def cycle_en(): - return itertools.cycle([0, 0, 0, 1]) - - -if getattr(cocotb, 'top', None) is not None: - - factory = TestFactory(run_test) - factory.add_option("payload_lengths", [size_list]) - factory.add_option("payload_data", [incrementing_payload]) - factory.add_option("ifg", [12]) - factory.add_option("enable_dic", [True, False]) - factory.add_option("force_offset_start", [False, True]) - factory.generate_tests() - - factory = TestFactory(run_test_alignment) - factory.add_option("payload_data", [incrementing_payload]) - factory.add_option("ifg", [12]) - factory.add_option("enable_dic", [True, False]) - factory.add_option("force_offset_start", [False, True]) - factory.generate_tests() - - factory = TestFactory(run_test_os) - factory.generate_tests() - - # cocotb-test tests_dir = os.path.abspath(os.path.dirname(__file__)) diff --git a/src/eth/tb/taxi_xgmii_baser_enc/test_taxi_xgmii_baser_enc.py b/src/eth/tb/taxi_xgmii_baser_enc/test_taxi_xgmii_baser_enc.py index c15ebab..8aeb06f 100644 --- a/src/eth/tb/taxi_xgmii_baser_enc/test_taxi_xgmii_baser_enc.py +++ b/src/eth/tb/taxi_xgmii_baser_enc/test_taxi_xgmii_baser_enc.py @@ -20,7 +20,6 @@ import cocotb_test.simulator import cocotb from cocotb.clock import Clock from cocotb.triggers import RisingEdge -from cocotb.regression import TestFactory from cocotbext.eth import XgmiiSource, XgmiiFrame @@ -79,6 +78,27 @@ class TB: await RisingEdge(self.dut.clk) +def size_list(): + return list(range(60, 128)) + [512, 1514, 9214] + [60]*10 + + +def incrementing_payload(length): + return bytearray(itertools.islice(itertools.cycle(range(256)), length)) + + +data_w = 64 +if getattr(cocotb, 'top', None) is not None: + data_w = len(cocotb.top.xgmii_txd) + + +@cocotb.test() +@cocotb.parametrize( + ("payload_lengths", [size_list]), + ("payload_data", [incrementing_payload]), + ("ifg", [12]), + ("enable_dic", [True, False]), + ("force_offset_start", [False, True]), +) async def run_test(dut, payload_lengths=None, payload_data=None, ifg=12, enable_dic=True, force_offset_start=False): @@ -108,6 +128,13 @@ async def run_test(dut, payload_lengths=None, payload_data=None, ifg=12, enable_ await RisingEdge(dut.clk) +@cocotb.test(skip=(data_w != 64)) +@cocotb.parametrize( + ("payload_data", [incrementing_payload]), + ("ifg", [12]), + ("enable_dic", [True, False]), + ("force_offset_start", [False, True]), +) async def run_test_alignment(dut, payload_data=None, ifg=12, enable_dic=True, force_offset_start=False): @@ -181,6 +208,7 @@ async def run_test_alignment(dut, payload_data=None, ifg=12, enable_dic=True, await RisingEdge(dut.clk) +@cocotb.test() async def run_test_os(dut): tb = TB(dut) @@ -222,40 +250,6 @@ async def run_test_os(dut): await RisingEdge(dut.clk) -def size_list(): - return list(range(60, 128)) + [512, 1514, 9214] + [60]*10 - - -def incrementing_payload(length): - return bytearray(itertools.islice(itertools.cycle(range(256)), length)) - - -def cycle_en(): - return itertools.cycle([0, 0, 0, 1]) - - -if getattr(cocotb, 'top', None) is not None: - - factory = TestFactory(run_test) - factory.add_option("payload_lengths", [size_list]) - factory.add_option("payload_data", [incrementing_payload]) - factory.add_option("ifg", [12]) - factory.add_option("enable_dic", [True, False]) - factory.add_option("force_offset_start", [False, True]) - factory.generate_tests() - - if len(cocotb.top.xgmii_txd) == 64: - factory = TestFactory(run_test_alignment) - factory.add_option("payload_data", [incrementing_payload]) - factory.add_option("ifg", [12]) - factory.add_option("enable_dic", [True, False]) - factory.add_option("force_offset_start", [False, True]) - factory.generate_tests() - - factory = TestFactory(run_test_os) - factory.generate_tests() - - # cocotb-test tests_dir = os.path.abspath(os.path.dirname(__file__))