From c9c5ef1995f6ff66b738b054ff05ceb224706a67 Mon Sep 17 00:00:00 2001 From: Alex Forencich Date: Fri, 14 Aug 2026 22:35:12 -0700 Subject: [PATCH] axi: Update testbenches to use cocotb.parametrize Signed-off-by: Alex Forencich --- .../taxi_axi_adapter/test_taxi_axi_adapter.py | 58 ++++++++------- .../test_taxi_axi_axil_adapter.py | 58 ++++++++------- .../test_taxi_axi_crossbar.py | 72 ++++++++++-------- .../test_taxi_axi_crossbar_1s.py | 66 +++++++++-------- .../taxi_axi_dp_ram/test_taxi_axi_dp_ram.py | 73 ++++++++++--------- .../tb/taxi_axi_fifo/test_taxi_axi_fifo.py | 58 ++++++++------- .../test_taxi_axi_interconnect.py | 72 ++++++++++-------- .../test_taxi_axi_interconnect_1s.py | 66 +++++++++-------- src/axi/tb/taxi_axi_ram/test_taxi_axi_ram.py | 58 ++++++++------- .../test_taxi_axi_register.py | 60 ++++++++------- .../test_taxi_axil_adapter.py | 38 +++++----- .../test_taxi_axil_apb_adapter.py | 38 +++++----- .../test_taxi_axil_axi_adapter.py | 38 +++++----- .../test_taxi_axil_crossbar.py | 60 ++++++++------- .../test_taxi_axil_crossbar_1s.py | 54 +++++++------- .../taxi_axil_dp_ram/test_taxi_axil_dp_ram.py | 58 +++++++-------- .../test_taxi_axil_interconnect.py | 60 ++++++++------- .../test_taxi_axil_interconnect_1s.py | 50 +++++++------ .../tb/taxi_axil_ram/test_taxi_axil_ram.py | 38 +++++----- .../test_taxi_axil_register.py | 38 +++++----- 20 files changed, 603 insertions(+), 510 deletions(-) diff --git a/src/axi/tb/taxi_axi_adapter/test_taxi_axi_adapter.py b/src/axi/tb/taxi_axi_adapter/test_taxi_axi_adapter.py index 65704fa..9a44cbf 100644 --- a/src/axi/tb/taxi_axi_adapter/test_taxi_axi_adapter.py +++ b/src/axi/tb/taxi_axi_adapter/test_taxi_axi_adapter.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.axi import AxiBus, AxiMaster, AxiRam @@ -65,7 +64,25 @@ class TB(object): await RisingEdge(self.dut.clk) -async def run_test_write(dut, data_in=None, idle_inserter=None, backpressure_inserter=None, size=None): +max_burst_size = 0 + +if getattr(cocotb, 'top', None) is not None: + data_width = len(cocotb.top.s_axi.wdata) + byte_lanes = data_width // 8 + max_burst_size = (byte_lanes-1).bit_length() + + +def cycle_pause(): + return itertools.cycle([1, 1, 1, 0]) + + +@cocotb.test() +@cocotb.parametrize( + ("idle_inserter", [None, cycle_pause]), + ("backpressure_inserter", [None, cycle_pause]), + ("size", [None]+list(range(max_burst_size))), +) +async def run_test_write(dut, idle_inserter=None, backpressure_inserter=None, size=None): tb = TB(dut) @@ -100,7 +117,13 @@ async def run_test_write(dut, data_in=None, idle_inserter=None, backpressure_ins await RisingEdge(dut.clk) -async def run_test_read(dut, data_in=None, idle_inserter=None, backpressure_inserter=None, size=None): +@cocotb.test() +@cocotb.parametrize( + ("idle_inserter", [None, cycle_pause]), + ("backpressure_inserter", [None, cycle_pause]), + ("size", [None]+list(range(max_burst_size))), +) +async def run_test_read(dut, idle_inserter=None, backpressure_inserter=None, size=None): tb = TB(dut) @@ -131,6 +154,11 @@ async def run_test_read(dut, data_in=None, idle_inserter=None, backpressure_inse 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) @@ -167,30 +195,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]) - - -if getattr(cocotb, 'top', None) is not None: - - data_width = len(cocotb.top.s_axi.wdata) - byte_lanes = data_width // 8 - max_burst_size = (byte_lanes-1).bit_length() - - for test in [run_test_write, run_test_read]: - - factory = TestFactory(test) - factory.add_option("idle_inserter", [None, cycle_pause]) - factory.add_option("backpressure_inserter", [None, cycle_pause]) - factory.add_option("size", [None]+list(range(max_burst_size))) - 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/axi/tb/taxi_axi_axil_adapter/test_taxi_axi_axil_adapter.py b/src/axi/tb/taxi_axi_axil_adapter/test_taxi_axi_axil_adapter.py index 635e851..03e84cf 100644 --- a/src/axi/tb/taxi_axi_axil_adapter/test_taxi_axi_axil_adapter.py +++ b/src/axi/tb/taxi_axi_axil_adapter/test_taxi_axi_axil_adapter.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.axi import AxiBus, AxiLiteBus, AxiMaster, AxiLiteRam @@ -65,7 +64,25 @@ class TB(object): await RisingEdge(self.dut.clk) -async def run_test_write(dut, data_in=None, idle_inserter=None, backpressure_inserter=None, size=None): +max_burst_size = 0 + +if getattr(cocotb, 'top', None) is not None: + data_width = len(cocotb.top.s_axi.wdata) + byte_lanes = data_width // 8 + max_burst_size = (byte_lanes-1).bit_length() + + +def cycle_pause(): + return itertools.cycle([1, 1, 1, 0]) + + +@cocotb.test() +@cocotb.parametrize( + ("idle_inserter", [None, cycle_pause]), + ("backpressure_inserter", [None, cycle_pause]), + ("size", [None]+list(range(max_burst_size))), +) +async def run_test_write(dut, idle_inserter=None, backpressure_inserter=None, size=None): tb = TB(dut) @@ -100,7 +117,13 @@ async def run_test_write(dut, data_in=None, idle_inserter=None, backpressure_ins await RisingEdge(dut.clk) -async def run_test_read(dut, data_in=None, idle_inserter=None, backpressure_inserter=None, size=None): +@cocotb.test() +@cocotb.parametrize( + ("idle_inserter", [None, cycle_pause]), + ("backpressure_inserter", [None, cycle_pause]), + ("size", [None]+list(range(max_burst_size))), +) +async def run_test_read(dut, idle_inserter=None, backpressure_inserter=None, size=None): tb = TB(dut) @@ -131,6 +154,11 @@ async def run_test_read(dut, data_in=None, idle_inserter=None, backpressure_inse 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) @@ -167,30 +195,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]) - - -if getattr(cocotb, 'top', None) is not None: - - data_width = len(cocotb.top.s_axi.wdata) - byte_lanes = data_width // 8 - max_burst_size = (byte_lanes-1).bit_length() - - for test in [run_test_write, run_test_read]: - - factory = TestFactory(test) - factory.add_option("idle_inserter", [None, cycle_pause]) - factory.add_option("backpressure_inserter", [None, cycle_pause]) - factory.add_option("size", [None]+list(range(max_burst_size))) - 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/axi/tb/taxi_axi_crossbar/test_taxi_axi_crossbar.py b/src/axi/tb/taxi_axi_crossbar/test_taxi_axi_crossbar.py index 0533a51..30e8483 100644 --- a/src/axi/tb/taxi_axi_crossbar/test_taxi_axi_crossbar.py +++ b/src/axi/tb/taxi_axi_crossbar/test_taxi_axi_crossbar.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.axi import AxiBus, AxiMaster, AxiRam @@ -75,7 +74,32 @@ class TB(object): await RisingEdge(self.dut.clk) -async def run_test_write(dut, data_in=None, idle_inserter=None, backpressure_inserter=None, size=None, s=0, m=0): +s_count = 1 +m_count = 1 +max_burst_size = 0 + +if getattr(cocotb, 'top', None) is not None: + s_count = len(cocotb.top.s_axi) + m_count = len(cocotb.top.m_axi) + + data_width = len(cocotb.top.s_axi[0].wdata) + byte_lanes = data_width // 8 + max_burst_size = (byte_lanes-1).bit_length() + + +def cycle_pause(): + return itertools.cycle([1, 1, 1, 0]) + + +@cocotb.test() +@cocotb.parametrize( + ("idle_inserter", [None, cycle_pause]), + ("backpressure_inserter", [None, cycle_pause]), + ("size", [None]+list(range(max_burst_size))), + ("s", range(min(s_count, 2))), + ("m", range(min(m_count, 2))), +) +async def run_test_write(dut, idle_inserter=None, backpressure_inserter=None, size=None, s=0, m=0): tb = TB(dut) @@ -111,7 +135,15 @@ async def run_test_write(dut, data_in=None, idle_inserter=None, backpressure_ins await RisingEdge(dut.clk) -async def run_test_read(dut, data_in=None, idle_inserter=None, backpressure_inserter=None, size=None, s=0, m=0): +@cocotb.test() +@cocotb.parametrize( + ("idle_inserter", [None, cycle_pause]), + ("backpressure_inserter", [None, cycle_pause]), + ("size", [None]+list(range(max_burst_size))), + ("s", range(min(s_count, 2))), + ("m", range(min(m_count, 2))), +) +async def run_test_read(dut, idle_inserter=None, backpressure_inserter=None, size=None, s=0, m=0): tb = TB(dut) @@ -143,6 +175,11 @@ async def run_test_read(dut, data_in=None, idle_inserter=None, backpressure_inse 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) @@ -180,35 +217,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]) - - -if getattr(cocotb, 'top', None) is not None: - - s_count = len(cocotb.top.s_axi) - m_count = len(cocotb.top.m_axi) - - data_w = len(cocotb.top.s_axi[0].wdata) - byte_lanes = data_w // 8 - max_burst_size = (byte_lanes-1).bit_length() - - for test in [run_test_write, run_test_read]: - - factory = TestFactory(test) - factory.add_option("idle_inserter", [None, cycle_pause]) - factory.add_option("backpressure_inserter", [None, cycle_pause]) - factory.add_option("size", [None]+list(range(max_burst_size))) - factory.add_option("s", range(min(s_count, 2))) - factory.add_option("m", range(min(m_count, 2))) - 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/axi/tb/taxi_axi_crossbar_1s/test_taxi_axi_crossbar_1s.py b/src/axi/tb/taxi_axi_crossbar_1s/test_taxi_axi_crossbar_1s.py index a4604a8..0089aca 100644 --- a/src/axi/tb/taxi_axi_crossbar_1s/test_taxi_axi_crossbar_1s.py +++ b/src/axi/tb/taxi_axi_crossbar_1s/test_taxi_axi_crossbar_1s.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.axi import AxiBus, AxiMaster, AxiRam @@ -73,7 +72,29 @@ class TB(object): await RisingEdge(self.dut.clk) -async def run_test_write(dut, data_in=None, idle_inserter=None, backpressure_inserter=None, size=None, m=0): +m_count = 1 +max_burst_size = 0 + +if getattr(cocotb, 'top', None) is not None: + m_count = len(cocotb.top.m_axi) + + data_width = len(cocotb.top.s_axi.wdata) + byte_lanes = data_width // 8 + max_burst_size = (byte_lanes-1).bit_length() + + +def cycle_pause(): + return itertools.cycle([1, 1, 1, 0]) + + +@cocotb.test() +@cocotb.parametrize( + ("idle_inserter", [None, cycle_pause]), + ("backpressure_inserter", [None, cycle_pause]), + ("size", [None]+list(range(max_burst_size))), + ("m", range(min(m_count, 2))), +) +async def run_test_write(dut, idle_inserter=None, backpressure_inserter=None, size=None, m=0): tb = TB(dut) @@ -109,7 +130,14 @@ async def run_test_write(dut, data_in=None, idle_inserter=None, backpressure_ins await RisingEdge(dut.clk) -async def run_test_read(dut, data_in=None, idle_inserter=None, backpressure_inserter=None, size=None, m=0): +@cocotb.test() +@cocotb.parametrize( + ("idle_inserter", [None, cycle_pause]), + ("backpressure_inserter", [None, cycle_pause]), + ("size", [None]+list(range(max_burst_size))), + ("m", range(min(m_count, 2))), +) +async def run_test_read(dut, idle_inserter=None, backpressure_inserter=None, size=None, m=0): tb = TB(dut) @@ -141,6 +169,11 @@ async def run_test_read(dut, data_in=None, idle_inserter=None, backpressure_inse 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) @@ -178,33 +211,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]) - - -if getattr(cocotb, 'top', None) is not None: - - m_count = len(cocotb.top.m_axi) - - data_w = len(cocotb.top.s_axi.wdata) - byte_lanes = data_w // 8 - max_burst_size = (byte_lanes-1).bit_length() - - for test in [run_test_write, run_test_read]: - - factory = TestFactory(test) - factory.add_option("idle_inserter", [None, cycle_pause]) - factory.add_option("backpressure_inserter", [None, cycle_pause]) - factory.add_option("size", [None]+list(range(max_burst_size))) - factory.add_option("m", range(min(m_count, 2))) - 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/axi/tb/taxi_axi_dp_ram/test_taxi_axi_dp_ram.py b/src/axi/tb/taxi_axi_dp_ram/test_taxi_axi_dp_ram.py index 1bf4a74..77e26c5 100644 --- a/src/axi/tb/taxi_axi_dp_ram/test_taxi_axi_dp_ram.py +++ b/src/axi/tb/taxi_axi_dp_ram/test_taxi_axi_dp_ram.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.axi import AxiBus, AxiMaster @@ -69,7 +68,26 @@ class TB(object): await RisingEdge(self.dut.a_clk) -async def run_test_write(dut, port=0, data_in=None, idle_inserter=None, backpressure_inserter=None, size=None): +max_burst_size = 0 + +if getattr(cocotb, 'top', None) is not None: + data_width = len(cocotb.top.s_axi_a.wdata) + byte_lanes = data_width // 8 + max_burst_size = (byte_lanes-1).bit_length() + + +def cycle_pause(): + return itertools.cycle([1, 1, 1, 0]) + + +@cocotb.test() +@cocotb.parametrize( + ("idle_inserter", [None, cycle_pause]), + ("backpressure_inserter", [None, cycle_pause]), + ("size", [None]+list(range(max_burst_size))), + ("port", [0, 1]), +) +async def run_test_write(dut, port=0, idle_inserter=None, backpressure_inserter=None, size=None): tb = TB(dut) @@ -103,7 +121,14 @@ async def run_test_write(dut, port=0, data_in=None, idle_inserter=None, backpres await RisingEdge(dut.a_clk) -async def run_test_read(dut, port=0, data_in=None, idle_inserter=None, backpressure_inserter=None, size=None): +@cocotb.test() +@cocotb.parametrize( + ("idle_inserter", [None, cycle_pause]), + ("backpressure_inserter", [None, cycle_pause]), + ("size", [None]+list(range(max_burst_size))), + ("port", [0, 1]), +) +async def run_test_read(dut, port=0, idle_inserter=None, backpressure_inserter=None, size=None): tb = TB(dut) @@ -135,7 +160,12 @@ async def run_test_read(dut, port=0, data_in=None, idle_inserter=None, backpress await RisingEdge(dut.a_clk) -async def run_test_arb(dut, data_in=None, idle_inserter=None, backpressure_inserter=None): +@cocotb.test() +@cocotb.parametrize( + ("idle_inserter", [None, cycle_pause]), + ("backpressure_inserter", [None, cycle_pause]), +) +async def run_test_arb(dut, idle_inserter=None, backpressure_inserter=None): tb = TB(dut) @@ -164,6 +194,11 @@ async def run_test_arb(dut, data_in=None, idle_inserter=None, backpressure_inser await RisingEdge(dut.a_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) @@ -200,36 +235,6 @@ async def run_stress_test(dut, idle_inserter=None, backpressure_inserter=None): await RisingEdge(dut.a_clk) -def cycle_pause(): - return itertools.cycle([1, 1, 1, 0]) - - -if getattr(cocotb, 'top', None) is not None: - - data_width = len(cocotb.top.s_axi_a.wdata) - byte_lanes = data_width // 8 - max_burst_size = (byte_lanes-1).bit_length() - - for test in [run_test_write, run_test_read]: - - factory = TestFactory(test) - factory.add_option("idle_inserter", [None, cycle_pause]) - factory.add_option("backpressure_inserter", [None, cycle_pause]) - factory.add_option("size", [None]+list(range(max_burst_size))) - factory.add_option("port", [0, 1]) - factory.generate_tests() - - factory = TestFactory(run_test_arb) - factory.add_option("idle_inserter", [None, cycle_pause]) - factory.add_option("backpressure_inserter", [None, cycle_pause]) - 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/axi/tb/taxi_axi_fifo/test_taxi_axi_fifo.py b/src/axi/tb/taxi_axi_fifo/test_taxi_axi_fifo.py index 6487ca7..f8deb58 100644 --- a/src/axi/tb/taxi_axi_fifo/test_taxi_axi_fifo.py +++ b/src/axi/tb/taxi_axi_fifo/test_taxi_axi_fifo.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.axi import AxiBus, AxiMaster, AxiRam @@ -65,7 +64,25 @@ class TB(object): await RisingEdge(self.dut.clk) -async def run_test_write(dut, data_in=None, idle_inserter=None, backpressure_inserter=None, size=None): +max_burst_size = 0 + +if getattr(cocotb, 'top', None) is not None: + data_width = len(cocotb.top.s_axi.wdata) + byte_lanes = data_width // 8 + max_burst_size = (byte_lanes-1).bit_length() + + +def cycle_pause(): + return itertools.cycle([1, 1, 1, 0]) + + +@cocotb.test() +@cocotb.parametrize( + ("idle_inserter", [None, cycle_pause]), + ("backpressure_inserter", [None, cycle_pause]), + ("size", [None]+list(range(max_burst_size))), +) +async def run_test_write(dut, idle_inserter=None, backpressure_inserter=None, size=None): tb = TB(dut) @@ -100,7 +117,13 @@ async def run_test_write(dut, data_in=None, idle_inserter=None, backpressure_ins await RisingEdge(dut.clk) -async def run_test_read(dut, data_in=None, idle_inserter=None, backpressure_inserter=None, size=None): +@cocotb.test() +@cocotb.parametrize( + ("idle_inserter", [None, cycle_pause]), + ("backpressure_inserter", [None, cycle_pause]), + ("size", [None]+list(range(max_burst_size))), +) +async def run_test_read(dut, idle_inserter=None, backpressure_inserter=None, size=None): tb = TB(dut) @@ -131,6 +154,11 @@ async def run_test_read(dut, data_in=None, idle_inserter=None, backpressure_inse 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) @@ -168,30 +196,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]) - - -if getattr(cocotb, 'top', None) is not None: - - data_width = len(cocotb.top.s_axi.wdata) - byte_lanes = data_width // 8 - max_burst_size = (byte_lanes-1).bit_length() - - for test in [run_test_write, run_test_read]: - - factory = TestFactory(test) - factory.add_option("idle_inserter", [None, cycle_pause]) - factory.add_option("backpressure_inserter", [None, cycle_pause]) - factory.add_option("size", [None]+list(range(max_burst_size))) - 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/axi/tb/taxi_axi_interconnect/test_taxi_axi_interconnect.py b/src/axi/tb/taxi_axi_interconnect/test_taxi_axi_interconnect.py index 093af56..e859d35 100644 --- a/src/axi/tb/taxi_axi_interconnect/test_taxi_axi_interconnect.py +++ b/src/axi/tb/taxi_axi_interconnect/test_taxi_axi_interconnect.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.axi import AxiBus, AxiMaster, AxiRam @@ -69,7 +68,32 @@ class TB(object): await RisingEdge(self.dut.clk) -async def run_test_write(dut, data_in=None, idle_inserter=None, backpressure_inserter=None, size=None, s=0, m=0): +s_count = 1 +m_count = 1 +max_burst_size = 0 + +if getattr(cocotb, 'top', None) is not None: + s_count = len(cocotb.top.s_axi) + m_count = len(cocotb.top.m_axi) + + data_width = len(cocotb.top.s_axi[0].wdata) + byte_lanes = data_width // 8 + max_burst_size = (byte_lanes-1).bit_length() + + +def cycle_pause(): + return itertools.cycle([1, 1, 1, 0]) + + +@cocotb.test() +@cocotb.parametrize( + ("idle_inserter", [None, cycle_pause]), + ("backpressure_inserter", [None, cycle_pause]), + ("size", [None]+list(range(max_burst_size))), + ("s", range(min(s_count, 2))), + ("m", range(min(m_count, 2))), +) +async def run_test_write(dut, idle_inserter=None, backpressure_inserter=None, size=None, s=0, m=0): tb = TB(dut) @@ -105,7 +129,15 @@ async def run_test_write(dut, data_in=None, idle_inserter=None, backpressure_ins await RisingEdge(dut.clk) -async def run_test_read(dut, data_in=None, idle_inserter=None, backpressure_inserter=None, size=None, s=0, m=0): +@cocotb.test() +@cocotb.parametrize( + ("idle_inserter", [None, cycle_pause]), + ("backpressure_inserter", [None, cycle_pause]), + ("size", [None]+list(range(max_burst_size))), + ("s", range(min(s_count, 2))), + ("m", range(min(m_count, 2))), +) +async def run_test_read(dut, idle_inserter=None, backpressure_inserter=None, size=None, s=0, m=0): tb = TB(dut) @@ -137,6 +169,11 @@ async def run_test_read(dut, data_in=None, idle_inserter=None, backpressure_inse 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) @@ -174,35 +211,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]) - - -if getattr(cocotb, 'top', None) is not None: - - s_count = len(cocotb.top.s_axi) - m_count = len(cocotb.top.m_axi) - - data_w = len(cocotb.top.s_axi[0].wdata) - byte_lanes = data_w // 8 - max_burst_size = (byte_lanes-1).bit_length() - - for test in [run_test_write, run_test_read]: - - factory = TestFactory(test) - factory.add_option("idle_inserter", [None, cycle_pause]) - factory.add_option("backpressure_inserter", [None, cycle_pause]) - factory.add_option("size", [None]+list(range(max_burst_size))) - factory.add_option("s", range(min(s_count, 2))) - factory.add_option("m", range(min(m_count, 2))) - 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/axi/tb/taxi_axi_interconnect_1s/test_taxi_axi_interconnect_1s.py b/src/axi/tb/taxi_axi_interconnect_1s/test_taxi_axi_interconnect_1s.py index 85a7ef9..cdee177 100644 --- a/src/axi/tb/taxi_axi_interconnect_1s/test_taxi_axi_interconnect_1s.py +++ b/src/axi/tb/taxi_axi_interconnect_1s/test_taxi_axi_interconnect_1s.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.axi import AxiBus, AxiMaster, AxiRam @@ -67,7 +66,29 @@ class TB(object): await RisingEdge(self.dut.clk) -async def run_test_write(dut, data_in=None, idle_inserter=None, backpressure_inserter=None, size=None, m=0): +m_count = 1 +max_burst_size = 0 + +if getattr(cocotb, 'top', None) is not None: + m_count = len(cocotb.top.m_axi) + + data_width = len(cocotb.top.s_axi.wdata) + byte_lanes = data_width // 8 + max_burst_size = (byte_lanes-1).bit_length() + + +def cycle_pause(): + return itertools.cycle([1, 1, 1, 0]) + + +@cocotb.test() +@cocotb.parametrize( + ("idle_inserter", [None, cycle_pause]), + ("backpressure_inserter", [None, cycle_pause]), + ("size", [None]+list(range(max_burst_size))), + ("m", range(min(m_count, 2))), +) +async def run_test_write(dut, idle_inserter=None, backpressure_inserter=None, size=None, m=0): tb = TB(dut) @@ -103,7 +124,14 @@ async def run_test_write(dut, data_in=None, idle_inserter=None, backpressure_ins await RisingEdge(dut.clk) -async def run_test_read(dut, data_in=None, idle_inserter=None, backpressure_inserter=None, size=None, m=0): +@cocotb.test() +@cocotb.parametrize( + ("idle_inserter", [None, cycle_pause]), + ("backpressure_inserter", [None, cycle_pause]), + ("size", [None]+list(range(max_burst_size))), + ("m", range(min(m_count, 2))), +) +async def run_test_read(dut, idle_inserter=None, backpressure_inserter=None, size=None, m=0): tb = TB(dut) @@ -135,6 +163,11 @@ async def run_test_read(dut, data_in=None, idle_inserter=None, backpressure_inse 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) @@ -172,33 +205,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]) - - -if getattr(cocotb, 'top', None) is not None: - - m_count = len(cocotb.top.m_axi) - - data_w = len(cocotb.top.s_axi.wdata) - byte_lanes = data_w // 8 - max_burst_size = (byte_lanes-1).bit_length() - - for test in [run_test_write, run_test_read]: - - factory = TestFactory(test) - factory.add_option("idle_inserter", [None, cycle_pause]) - factory.add_option("backpressure_inserter", [None, cycle_pause]) - factory.add_option("size", [None]+list(range(max_burst_size))) - factory.add_option("m", range(min(m_count, 2))) - 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/axi/tb/taxi_axi_ram/test_taxi_axi_ram.py b/src/axi/tb/taxi_axi_ram/test_taxi_axi_ram.py index 8d774bb..175a2fc 100644 --- a/src/axi/tb/taxi_axi_ram/test_taxi_axi_ram.py +++ b/src/axi/tb/taxi_axi_ram/test_taxi_axi_ram.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.axi import AxiBus, AxiMaster @@ -59,7 +58,25 @@ class TB(object): await RisingEdge(self.dut.clk) -async def run_test_write(dut, data_in=None, idle_inserter=None, backpressure_inserter=None, size=None): +max_burst_size = 0 + +if getattr(cocotb, 'top', None) is not None: + data_width = len(cocotb.top.s_axi.wdata) + byte_lanes = data_width // 8 + max_burst_size = (byte_lanes-1).bit_length() + + +def cycle_pause(): + return itertools.cycle([1, 1, 1, 0]) + + +@cocotb.test() +@cocotb.parametrize( + ("idle_inserter", [None, cycle_pause]), + ("backpressure_inserter", [None, cycle_pause]), + ("size", [None]+list(range(max_burst_size))), +) +async def run_test_write(dut, idle_inserter=None, backpressure_inserter=None, size=None): tb = TB(dut) @@ -92,7 +109,13 @@ async def run_test_write(dut, data_in=None, idle_inserter=None, backpressure_ins await RisingEdge(dut.clk) -async def run_test_read(dut, data_in=None, idle_inserter=None, backpressure_inserter=None, size=None): +@cocotb.test() +@cocotb.parametrize( + ("idle_inserter", [None, cycle_pause]), + ("backpressure_inserter", [None, cycle_pause]), + ("size", [None]+list(range(max_burst_size))), +) +async def run_test_read(dut, idle_inserter=None, backpressure_inserter=None, size=None): tb = TB(dut) @@ -123,6 +146,11 @@ async def run_test_read(dut, data_in=None, idle_inserter=None, backpressure_inse 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) @@ -159,30 +187,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]) - - -if getattr(cocotb, 'top', None) is not None: - - data_width = len(cocotb.top.s_axi.wdata) - byte_lanes = data_width // 8 - max_burst_size = (byte_lanes-1).bit_length() - - for test in [run_test_write, run_test_read]: - - factory = TestFactory(test) - factory.add_option("idle_inserter", [None, cycle_pause]) - factory.add_option("backpressure_inserter", [None, cycle_pause]) - factory.add_option("size", [None]+list(range(max_burst_size))) - 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/axi/tb/taxi_axi_register/test_taxi_axi_register.py b/src/axi/tb/taxi_axi_register/test_taxi_axi_register.py index 9a8c483..29c0e9a 100644 --- a/src/axi/tb/taxi_axi_register/test_taxi_axi_register.py +++ b/src/axi/tb/taxi_axi_register/test_taxi_axi_register.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.axi import AxiBus, AxiMaster, AxiRam @@ -65,7 +64,25 @@ class TB(object): await RisingEdge(self.dut.clk) -async def run_test_write(dut, data_in=None, idle_inserter=None, backpressure_inserter=None, size=None): +max_burst_size = 0 + +if getattr(cocotb, 'top', None) is not None: + data_width = len(cocotb.top.s_axi.wdata) + byte_lanes = data_width // 8 + max_burst_size = (byte_lanes-1).bit_length() + + +def cycle_pause(): + return itertools.cycle([1, 1, 1, 0]) + + +@cocotb.test() +@cocotb.parametrize( + ("idle_inserter", [None, cycle_pause]), + ("backpressure_inserter", [None, cycle_pause]), + ("size", [None]+list(range(max_burst_size))), +) +async def run_test_write(dut, idle_inserter=None, backpressure_inserter=None, size=None): tb = TB(dut) @@ -100,7 +117,13 @@ async def run_test_write(dut, data_in=None, idle_inserter=None, backpressure_ins await RisingEdge(dut.clk) -async def run_test_read(dut, data_in=None, idle_inserter=None, backpressure_inserter=None, size=None): +@cocotb.test() +@cocotb.parametrize( + ("idle_inserter", [None, cycle_pause]), + ("backpressure_inserter", [None, cycle_pause]), + ("size", [None]+list(range(max_burst_size))), +) +async def run_test_read(dut, idle_inserter=None, backpressure_inserter=None, size=None): tb = TB(dut) @@ -131,6 +154,11 @@ async def run_test_read(dut, data_in=None, idle_inserter=None, backpressure_inse 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) @@ -161,36 +189,12 @@ async def run_stress_test(dut, idle_inserter=None, backpressure_inserter=None): workers.append(cocotb.start_soon(worker(tb.axi_master, k*0x1000, 0x1000, count=16))) while workers: - await workers.pop(0) + await workers.pop(0).join() await RisingEdge(dut.clk) await RisingEdge(dut.clk) -def cycle_pause(): - return itertools.cycle([1, 1, 1, 0]) - - -if getattr(cocotb, 'top', None) is not None: - - data_width = len(cocotb.top.s_axi.wdata) - byte_lanes = data_width // 8 - max_burst_size = (byte_lanes-1).bit_length() - - for test in [run_test_write, run_test_read]: - - factory = TestFactory(test) - factory.add_option("idle_inserter", [None, cycle_pause]) - factory.add_option("backpressure_inserter", [None, cycle_pause]) - factory.add_option("size", [None]+list(range(max_burst_size))) - 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/axi/tb/taxi_axil_adapter/test_taxi_axil_adapter.py b/src/axi/tb/taxi_axil_adapter/test_taxi_axil_adapter.py index 1bd2348..055709f 100644 --- a/src/axi/tb/taxi_axil_adapter/test_taxi_axil_adapter.py +++ b/src/axi/tb/taxi_axil_adapter/test_taxi_axil_adapter.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.axi import AxiLiteBus, AxiLiteMaster, AxiLiteRam @@ -65,7 +64,16 @@ class TB(object): await RisingEdge(self.dut.clk) -async def run_test_write(dut, data_in=None, idle_inserter=None, backpressure_inserter=None): +def cycle_pause(): + return itertools.cycle([1, 1, 1, 0]) + + +@cocotb.test() +@cocotb.parametrize( + ("idle_inserter", [None, cycle_pause]), + ("backpressure_inserter", [None, cycle_pause]), +) +async def run_test_write(dut, idle_inserter=None, backpressure_inserter=None): tb = TB(dut) @@ -96,7 +104,12 @@ async def run_test_write(dut, data_in=None, idle_inserter=None, backpressure_ins await RisingEdge(dut.clk) -async def run_test_read(dut, data_in=None, idle_inserter=None, backpressure_inserter=None): +@cocotb.test() +@cocotb.parametrize( + ("idle_inserter", [None, cycle_pause]), + ("backpressure_inserter", [None, cycle_pause]), +) +async def run_test_read(dut, idle_inserter=None, backpressure_inserter=None): tb = TB(dut) @@ -123,6 +136,11 @@ async def run_test_read(dut, data_in=None, idle_inserter=None, backpressure_inse 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) @@ -159,20 +177,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]) - - -if getattr(cocotb, 'top', None) is not None: - - for test in [run_test_write, run_test_read, run_stress_test]: - - factory = TestFactory(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/axi/tb/taxi_axil_apb_adapter/test_taxi_axil_apb_adapter.py b/src/axi/tb/taxi_axil_apb_adapter/test_taxi_axil_apb_adapter.py index 82834f6..1a3dfcb 100644 --- a/src/axi/tb/taxi_axil_apb_adapter/test_taxi_axil_apb_adapter.py +++ b/src/axi/tb/taxi_axil_apb_adapter/test_taxi_axil_apb_adapter.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.axi import AxiLiteBus, AxiLiteMaster, ApbBus, ApbRam @@ -61,7 +60,16 @@ class TB(object): await RisingEdge(self.dut.clk) -async def run_test_write(dut, data_in=None, idle_inserter=None, backpressure_inserter=None): +def cycle_pause(): + return itertools.cycle([1, 1, 1, 0]) + + +@cocotb.test() +@cocotb.parametrize( + ("idle_inserter", [None, cycle_pause]), + ("backpressure_inserter", [None, cycle_pause]), +) +async def run_test_write(dut, idle_inserter=None, backpressure_inserter=None): tb = TB(dut) @@ -92,7 +100,12 @@ async def run_test_write(dut, data_in=None, idle_inserter=None, backpressure_ins await RisingEdge(dut.clk) -async def run_test_read(dut, data_in=None, idle_inserter=None, backpressure_inserter=None): +@cocotb.test() +@cocotb.parametrize( + ("idle_inserter", [None, cycle_pause]), + ("backpressure_inserter", [None, cycle_pause]), +) +async def run_test_read(dut, idle_inserter=None, backpressure_inserter=None): tb = TB(dut) @@ -119,6 +132,11 @@ async def run_test_read(dut, data_in=None, idle_inserter=None, backpressure_inse 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) @@ -155,20 +173,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]) - - -if getattr(cocotb, 'top', None) is not None: - - for test in [run_test_write, run_test_read, run_stress_test]: - - factory = TestFactory(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/axi/tb/taxi_axil_axi_adapter/test_taxi_axil_axi_adapter.py b/src/axi/tb/taxi_axil_axi_adapter/test_taxi_axil_axi_adapter.py index a907639..b90d736 100644 --- a/src/axi/tb/taxi_axil_axi_adapter/test_taxi_axil_axi_adapter.py +++ b/src/axi/tb/taxi_axil_axi_adapter/test_taxi_axil_axi_adapter.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.axi import AxiBus, AxiLiteBus, AxiLiteMaster, AxiRam @@ -65,7 +64,16 @@ class TB(object): await RisingEdge(self.dut.clk) -async def run_test_write(dut, data_in=None, idle_inserter=None, backpressure_inserter=None): +def cycle_pause(): + return itertools.cycle([1, 1, 1, 0]) + + +@cocotb.test() +@cocotb.parametrize( + ("idle_inserter", [None, cycle_pause]), + ("backpressure_inserter", [None, cycle_pause]), +) +async def run_test_write(dut, idle_inserter=None, backpressure_inserter=None): tb = TB(dut) @@ -96,7 +104,12 @@ async def run_test_write(dut, data_in=None, idle_inserter=None, backpressure_ins await RisingEdge(dut.clk) -async def run_test_read(dut, data_in=None, idle_inserter=None, backpressure_inserter=None): +@cocotb.test() +@cocotb.parametrize( + ("idle_inserter", [None, cycle_pause]), + ("backpressure_inserter", [None, cycle_pause]), +) +async def run_test_read(dut, idle_inserter=None, backpressure_inserter=None): tb = TB(dut) @@ -123,6 +136,11 @@ async def run_test_read(dut, data_in=None, idle_inserter=None, backpressure_inse 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) @@ -159,20 +177,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]) - - -if getattr(cocotb, 'top', None) is not None: - - for test in [run_test_write, run_test_read, run_stress_test]: - - factory = TestFactory(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/axi/tb/taxi_axil_crossbar/test_taxi_axil_crossbar.py b/src/axi/tb/taxi_axil_crossbar/test_taxi_axil_crossbar.py index e9a7c9f..2677429 100644 --- a/src/axi/tb/taxi_axil_crossbar/test_taxi_axil_crossbar.py +++ b/src/axi/tb/taxi_axil_crossbar/test_taxi_axil_crossbar.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.axi import AxiLiteBus, AxiLiteMaster, AxiLiteRam @@ -69,7 +68,26 @@ class TB(object): await RisingEdge(self.dut.clk) -async def run_test_write(dut, data_in=None, idle_inserter=None, backpressure_inserter=None, s=0, m=0): +s_count = 1 +m_count = 1 + +if getattr(cocotb, 'top', None) is not None: + s_count = len(cocotb.top.s_axil) + m_count = len(cocotb.top.m_axil) + + +def cycle_pause(): + return itertools.cycle([1, 1, 1, 0]) + + +@cocotb.test() +@cocotb.parametrize( + ("idle_inserter", [None, cycle_pause]), + ("backpressure_inserter", [None, cycle_pause]), + ("s", range(min(s_count, 2))), + ("m", range(min(m_count, 2))), +) +async def run_test_write(dut, idle_inserter=None, backpressure_inserter=None, s=0, m=0): tb = TB(dut) @@ -101,7 +119,14 @@ async def run_test_write(dut, data_in=None, idle_inserter=None, backpressure_ins await RisingEdge(dut.clk) -async def run_test_read(dut, data_in=None, idle_inserter=None, backpressure_inserter=None, s=0, m=0): +@cocotb.test() +@cocotb.parametrize( + ("idle_inserter", [None, cycle_pause]), + ("backpressure_inserter", [None, cycle_pause]), + ("s", range(min(s_count, 2))), + ("m", range(min(m_count, 2))), +) +async def run_test_read(dut, idle_inserter=None, backpressure_inserter=None, s=0, m=0): tb = TB(dut) @@ -129,6 +154,11 @@ async def run_test_read(dut, data_in=None, idle_inserter=None, backpressure_inse 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) @@ -166,30 +196,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]) - - -if getattr(cocotb, 'top', None) is not None: - - s_count = len(cocotb.top.s_axil) - m_count = len(cocotb.top.m_axil) - - for test in [run_test_write, run_test_read]: - - factory = TestFactory(test) - factory.add_option("idle_inserter", [None, cycle_pause]) - factory.add_option("backpressure_inserter", [None, cycle_pause]) - factory.add_option("s", range(min(s_count, 2))) - factory.add_option("m", range(min(m_count, 2))) - 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/axi/tb/taxi_axil_crossbar_1s/test_taxi_axil_crossbar_1s.py b/src/axi/tb/taxi_axil_crossbar_1s/test_taxi_axil_crossbar_1s.py index ca62048..bda06bc 100644 --- a/src/axi/tb/taxi_axil_crossbar_1s/test_taxi_axil_crossbar_1s.py +++ b/src/axi/tb/taxi_axil_crossbar_1s/test_taxi_axil_crossbar_1s.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.axi import AxiLiteBus, AxiLiteMaster, AxiLiteRam @@ -67,7 +66,23 @@ class TB(object): await RisingEdge(self.dut.clk) -async def run_test_write(dut, data_in=None, idle_inserter=None, backpressure_inserter=None, m=0): +m_count = 1 + +if getattr(cocotb, 'top', None) is not None: + m_count = len(cocotb.top.m_axil) + + +def cycle_pause(): + return itertools.cycle([1, 1, 1, 0]) + + +@cocotb.test() +@cocotb.parametrize( + ("idle_inserter", [None, cycle_pause]), + ("backpressure_inserter", [None, cycle_pause]), + ("m", range(min(m_count, 2))), +) +async def run_test_write(dut, idle_inserter=None, backpressure_inserter=None, m=0): tb = TB(dut) @@ -99,7 +114,13 @@ async def run_test_write(dut, data_in=None, idle_inserter=None, backpressure_ins await RisingEdge(dut.clk) -async def run_test_read(dut, data_in=None, idle_inserter=None, backpressure_inserter=None, m=0): +@cocotb.test() +@cocotb.parametrize( + ("idle_inserter", [None, cycle_pause]), + ("backpressure_inserter", [None, cycle_pause]), + ("m", range(min(m_count, 2))), +) +async def run_test_read(dut, idle_inserter=None, backpressure_inserter=None, m=0): tb = TB(dut) @@ -127,6 +148,11 @@ async def run_test_read(dut, data_in=None, idle_inserter=None, backpressure_inse 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) @@ -164,28 +190,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]) - - -if getattr(cocotb, 'top', None) is not None: - - m_count = len(cocotb.top.m_axil) - - for test in [run_test_write, run_test_read]: - - factory = TestFactory(test) - factory.add_option("idle_inserter", [None, cycle_pause]) - factory.add_option("backpressure_inserter", [None, cycle_pause]) - factory.add_option("m", range(min(m_count, 2))) - 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/axi/tb/taxi_axil_dp_ram/test_taxi_axil_dp_ram.py b/src/axi/tb/taxi_axil_dp_ram/test_taxi_axil_dp_ram.py index 7061e57..9d6990a 100644 --- a/src/axi/tb/taxi_axil_dp_ram/test_taxi_axil_dp_ram.py +++ b/src/axi/tb/taxi_axil_dp_ram/test_taxi_axil_dp_ram.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.axi import AxiLiteBus, AxiLiteMaster @@ -69,7 +68,17 @@ class TB(object): await RisingEdge(self.dut.a_clk) -async def run_test_write(dut, port=0, data_in=None, idle_inserter=None, backpressure_inserter=None): +def cycle_pause(): + return itertools.cycle([1, 1, 1, 0]) + + +@cocotb.test() +@cocotb.parametrize( + ("idle_inserter", [None, cycle_pause]), + ("backpressure_inserter", [None, cycle_pause]), + ("port", [0, 1]), +) +async def run_test_write(dut, port=0, idle_inserter=None, backpressure_inserter=None): tb = TB(dut) @@ -99,7 +108,13 @@ async def run_test_write(dut, port=0, data_in=None, idle_inserter=None, backpres await RisingEdge(dut.a_clk) -async def run_test_read(dut, port=0, data_in=None, idle_inserter=None, backpressure_inserter=None): +@cocotb.test() +@cocotb.parametrize( + ("idle_inserter", [None, cycle_pause]), + ("backpressure_inserter", [None, cycle_pause]), + ("port", [0, 1]), +) +async def run_test_read(dut, port=0, idle_inserter=None, backpressure_inserter=None): tb = TB(dut) @@ -127,7 +142,12 @@ async def run_test_read(dut, port=0, data_in=None, idle_inserter=None, backpress await RisingEdge(dut.a_clk) -async def run_test_arb(dut, data_in=None, idle_inserter=None, backpressure_inserter=None): +@cocotb.test() +@cocotb.parametrize( + ("idle_inserter", [None, cycle_pause]), + ("backpressure_inserter", [None, cycle_pause]), +) +async def run_test_arb(dut, idle_inserter=None, backpressure_inserter=None): tb = TB(dut) @@ -156,6 +176,11 @@ async def run_test_arb(dut, data_in=None, idle_inserter=None, backpressure_inser await RisingEdge(dut.a_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) @@ -192,31 +217,6 @@ async def run_stress_test(dut, idle_inserter=None, backpressure_inserter=None): await RisingEdge(dut.a_clk) -def cycle_pause(): - return itertools.cycle([1, 1, 1, 0]) - - -if getattr(cocotb, 'top', None) is not None: - - for test in [run_test_write, run_test_read]: - - factory = TestFactory(test) - factory.add_option("idle_inserter", [None, cycle_pause]) - factory.add_option("backpressure_inserter", [None, cycle_pause]) - factory.add_option("port", [0, 1]) - factory.generate_tests() - - factory = TestFactory(run_test_arb) - factory.add_option("idle_inserter", [None, cycle_pause]) - factory.add_option("backpressure_inserter", [None, cycle_pause]) - 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/axi/tb/taxi_axil_interconnect/test_taxi_axil_interconnect.py b/src/axi/tb/taxi_axil_interconnect/test_taxi_axil_interconnect.py index 9e9e736..77e2a43 100644 --- a/src/axi/tb/taxi_axil_interconnect/test_taxi_axil_interconnect.py +++ b/src/axi/tb/taxi_axil_interconnect/test_taxi_axil_interconnect.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.axi import AxiLiteBus, AxiLiteMaster, AxiLiteRam @@ -69,7 +68,26 @@ class TB(object): await RisingEdge(self.dut.clk) -async def run_test_write(dut, data_in=None, idle_inserter=None, backpressure_inserter=None, s=0, m=0): +s_count = 1 +m_count = 1 + +if getattr(cocotb, 'top', None) is not None: + s_count = len(cocotb.top.s_axil) + m_count = len(cocotb.top.m_axil) + + +def cycle_pause(): + return itertools.cycle([1, 1, 1, 0]) + + +@cocotb.test() +@cocotb.parametrize( + ("idle_inserter", [None, cycle_pause]), + ("backpressure_inserter", [None, cycle_pause]), + ("s", range(min(s_count, 2))), + ("m", range(min(m_count, 2))), +) +async def run_test_write(dut, idle_inserter=None, backpressure_inserter=None, s=0, m=0): tb = TB(dut) @@ -101,7 +119,14 @@ async def run_test_write(dut, data_in=None, idle_inserter=None, backpressure_ins await RisingEdge(dut.clk) -async def run_test_read(dut, data_in=None, idle_inserter=None, backpressure_inserter=None, s=0, m=0): +@cocotb.test() +@cocotb.parametrize( + ("idle_inserter", [None, cycle_pause]), + ("backpressure_inserter", [None, cycle_pause]), + ("s", range(min(s_count, 2))), + ("m", range(min(m_count, 2))), +) +async def run_test_read(dut, idle_inserter=None, backpressure_inserter=None, s=0, m=0): tb = TB(dut) @@ -129,6 +154,11 @@ async def run_test_read(dut, data_in=None, idle_inserter=None, backpressure_inse 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) @@ -166,30 +196,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]) - - -if getattr(cocotb, 'top', None) is not None: - - s_count = len(cocotb.top.s_axil) - m_count = len(cocotb.top.m_axil) - - for test in [run_test_write, run_test_read]: - - factory = TestFactory(test) - factory.add_option("idle_inserter", [None, cycle_pause]) - factory.add_option("backpressure_inserter", [None, cycle_pause]) - factory.add_option("s", range(min(s_count, 2))) - factory.add_option("m", range(min(m_count, 2))) - 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/axi/tb/taxi_axil_interconnect_1s/test_taxi_axil_interconnect_1s.py b/src/axi/tb/taxi_axil_interconnect_1s/test_taxi_axil_interconnect_1s.py index bcecf1a..1b2fd13 100644 --- a/src/axi/tb/taxi_axil_interconnect_1s/test_taxi_axil_interconnect_1s.py +++ b/src/axi/tb/taxi_axil_interconnect_1s/test_taxi_axil_interconnect_1s.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.axi import AxiLiteBus, AxiLiteMaster, AxiLiteRam @@ -67,6 +66,22 @@ class TB(object): await RisingEdge(self.dut.clk) +m_count = 1 + +if getattr(cocotb, 'top', None) is not None: + m_count = len(cocotb.top.m_axil) + + +def cycle_pause(): + return itertools.cycle([1, 1, 1, 0]) + + +@cocotb.test() +@cocotb.parametrize( + ("idle_inserter", [None, cycle_pause]), + ("backpressure_inserter", [None, cycle_pause]), + ("m", range(min(m_count, 2))), +) async def run_test_write(dut, data_in=None, idle_inserter=None, backpressure_inserter=None, m=0): tb = TB(dut) @@ -99,6 +114,12 @@ async def run_test_write(dut, data_in=None, idle_inserter=None, backpressure_ins await RisingEdge(dut.clk) +@cocotb.test() +@cocotb.parametrize( + ("idle_inserter", [None, cycle_pause]), + ("backpressure_inserter", [None, cycle_pause]), + ("m", range(min(m_count, 2))), +) async def run_test_read(dut, data_in=None, idle_inserter=None, backpressure_inserter=None, m=0): tb = TB(dut) @@ -127,6 +148,11 @@ async def run_test_read(dut, data_in=None, idle_inserter=None, backpressure_inse 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) @@ -164,28 +190,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]) - - -if getattr(cocotb, 'top', None) is not None: - - m_count = len(cocotb.top.m_axil) - - for test in [run_test_write, run_test_read]: - - factory = TestFactory(test) - factory.add_option("idle_inserter", [None, cycle_pause]) - factory.add_option("backpressure_inserter", [None, cycle_pause]) - factory.add_option("m", range(min(m_count, 2))) - 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/axi/tb/taxi_axil_ram/test_taxi_axil_ram.py b/src/axi/tb/taxi_axil_ram/test_taxi_axil_ram.py index 34e6a0f..e6a5ee2 100644 --- a/src/axi/tb/taxi_axil_ram/test_taxi_axil_ram.py +++ b/src/axi/tb/taxi_axil_ram/test_taxi_axil_ram.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.axi import AxiLiteBus, AxiLiteMaster @@ -59,7 +58,16 @@ class TB(object): await RisingEdge(self.dut.clk) -async def run_test_write(dut, data_in=None, idle_inserter=None, backpressure_inserter=None): +def cycle_pause(): + return itertools.cycle([1, 1, 1, 0]) + + +@cocotb.test() +@cocotb.parametrize( + ("idle_inserter", [None, cycle_pause]), + ("backpressure_inserter", [None, cycle_pause]), +) +async def run_test_write(dut, idle_inserter=None, backpressure_inserter=None): tb = TB(dut) @@ -88,7 +96,12 @@ async def run_test_write(dut, data_in=None, idle_inserter=None, backpressure_ins await RisingEdge(dut.clk) -async def run_test_read(dut, data_in=None, idle_inserter=None, backpressure_inserter=None): +@cocotb.test() +@cocotb.parametrize( + ("idle_inserter", [None, cycle_pause]), + ("backpressure_inserter", [None, cycle_pause]), +) +async def run_test_read(dut, idle_inserter=None, backpressure_inserter=None): tb = TB(dut) @@ -115,6 +128,11 @@ async def run_test_read(dut, data_in=None, idle_inserter=None, backpressure_inse 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) @@ -151,20 +169,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]) - - -if getattr(cocotb, 'top', None) is not None: - - for test in [run_test_write, run_test_read, run_stress_test]: - - factory = TestFactory(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/axi/tb/taxi_axil_register/test_taxi_axil_register.py b/src/axi/tb/taxi_axil_register/test_taxi_axil_register.py index b3bbe03..f44d2ec 100644 --- a/src/axi/tb/taxi_axil_register/test_taxi_axil_register.py +++ b/src/axi/tb/taxi_axil_register/test_taxi_axil_register.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.axi import AxiLiteBus, AxiLiteMaster, AxiLiteRam @@ -65,7 +64,16 @@ class TB(object): await RisingEdge(self.dut.clk) -async def run_test_write(dut, data_in=None, idle_inserter=None, backpressure_inserter=None): +def cycle_pause(): + return itertools.cycle([1, 1, 1, 0]) + + +@cocotb.test() +@cocotb.parametrize( + ("idle_inserter", [None, cycle_pause]), + ("backpressure_inserter", [None, cycle_pause]), +) +async def run_test_write(dut, idle_inserter=None, backpressure_inserter=None): tb = TB(dut) @@ -96,7 +104,12 @@ async def run_test_write(dut, data_in=None, idle_inserter=None, backpressure_ins await RisingEdge(dut.clk) -async def run_test_read(dut, data_in=None, idle_inserter=None, backpressure_inserter=None): +@cocotb.test() +@cocotb.parametrize( + ("idle_inserter", [None, cycle_pause]), + ("backpressure_inserter", [None, cycle_pause]), +) +async def run_test_read(dut, idle_inserter=None, backpressure_inserter=None): tb = TB(dut) @@ -123,6 +136,11 @@ async def run_test_read(dut, data_in=None, idle_inserter=None, backpressure_inse 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) @@ -159,20 +177,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]) - - -if getattr(cocotb, 'top', None) is not None: - - for test in [run_test_write, run_test_read, run_stress_test]: - - factory = TestFactory(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__))