bslathi19/taxi
1
0
Fork 0
mirror of https://github.com/fpganinja/taxi.git synced 2026-08-29 08:05:00 -07:00
Code Issues Packages Projects Releases Wiki Activity

eth: Update testbenches to use cocotb.parametrize

Browse Source 
Signed-off-by: Alex Forencich <alex@alexforencich.com>
This commit is contained in:
Alex Forencich
2026-08-17 12:57:55 -07:00
parent 32d838e602
commit cb7c8075f3
40 changed files with 1414 additions and 1486 deletions
Download Patch File Download Diff File Expand all files Collapse all files

80
src/eth/tb/taxi_axis_baser_rx_32/test_taxi_axis_baser_rx_32.py
View File

@@ -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__))

82
src/eth/tb/taxi_axis_baser_rx_64/test_taxi_axis_baser_rx_64.py
View File

@@ -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__))

96
src/eth/tb/taxi_axis_baser_tx_32/test_taxi_axis_baser_tx_32.py
View File

@@ -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__))

110
src/eth/tb/taxi_axis_baser_tx_64/test_taxi_axis_baser_tx_64.py
View File

@@ -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__))

80
src/eth/tb/taxi_axis_basex_rx_16/test_taxi_axis_basex_rx_16.py
View File

@@ -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__))

80
src/eth/tb/taxi_axis_basex_rx_8/test_taxi_axis_basex_rx_8.py
View File

@@ -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__))

96
src/eth/tb/taxi_axis_basex_tx_16/test_taxi_axis_basex_tx_16.py
View File

@@ -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__))

96
src/eth/tb/taxi_axis_basex_tx_8/test_taxi_axis_basex_tx_8.py
View File

@@ -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__))

56
src/eth/tb/taxi_axis_gmii_rx/test_taxi_axis_gmii_rx.py
View File

@@ -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__))

74
src/eth/tb/taxi_axis_gmii_tx/test_taxi_axis_gmii_tx.py
View File

@@ -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__))

48
src/eth/tb/taxi_axis_xgmii_rx_32/test_taxi_axis_xgmii_rx_32.py
View File

@@ -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__))

48
src/eth/tb/taxi_axis_xgmii_rx_64/test_taxi_axis_xgmii_rx_64.py
View File

@@ -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__))

72
src/eth/tb/taxi_axis_xgmii_tx_32/test_taxi_axis_xgmii_tx_32.py
View File

@@ -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__))

72
src/eth/tb/taxi_axis_xgmii_tx_64/test_taxi_axis_xgmii_tx_64.py
View File

@@ -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__))

87
src/eth/tb/taxi_eth_mac_10g/test_taxi_eth_mac_10g.py
View File

@@ -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__))

54
src/eth/tb/taxi_eth_mac_10g_fifo/test_taxi_eth_mac_10g_fifo.py
View File

@@ -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__))

123
src/eth/tb/taxi_eth_mac_1g/test_taxi_eth_mac_1g.py
View File

@@ -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__))

94
src/eth/tb/taxi_eth_mac_1g_basex_us/test_taxi_eth_mac_1g_basex_us.py
View File

@@ -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__))

54
src/eth/tb/taxi_eth_mac_1g_fifo/test_taxi_eth_mac_1g_fifo.py
View File

@@ -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__))

86
src/eth/tb/taxi_eth_mac_1g_gmii/test_taxi_eth_mac_1g_gmii.py
View File

@@ -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__))

47
src/eth/tb/taxi_eth_mac_1g_gmii_fifo/test_taxi_eth_mac_1g_gmii_fifo.py
View File

@@ -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__))

86
src/eth/tb/taxi_eth_mac_1g_rgmii/test_taxi_eth_mac_1g_rgmii.py
View File

@@ -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__))

47
src/eth/tb/taxi_eth_mac_1g_rgmii_fifo/test_taxi_eth_mac_1g_rgmii_fifo.py
View File

@@ -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__))

102
src/eth/tb/taxi_eth_mac_25g_us/test_taxi_eth_mac_25g_us.py
View File

@@ -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__))

83
src/eth/tb/taxi_eth_mac_mii/test_taxi_eth_mac_mii.py
View File

@@ -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__))

47
src/eth/tb/taxi_eth_mac_mii_fifo/test_taxi_eth_mac_mii_fifo.py
View File

@@ -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__))

126
src/eth/tb/taxi_eth_mac_phy_10g/test_taxi_eth_mac_phy_10g.py
View File

@@ -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__))

95
src/eth/tb/taxi_eth_mac_phy_10g_fifo/test_taxi_eth_mac_phy_10g_fifo.py
View File

@@ -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__))

109
src/eth/tb/taxi_eth_mac_phy_1g_basex/test_taxi_eth_mac_phy_1g_basex.py
View File

@@ -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__))

73
src/eth/tb/taxi_eth_mac_phy_1g_basex_fifo/test_taxi_eth_mac_phy_1g_basex_fifo.py
View File

@@ -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__))

48
src/eth/tb/taxi_eth_phy_10g/test_taxi_eth_phy_10g.py
View File

@@ -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__))

60
src/eth/tb/taxi_eth_phy_1g_basex/test_taxi_eth_phy_1g_basex.py
View File

@@ -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__))

38
src/eth/tb/taxi_gmii_basex_dec/test_taxi_gmii_basex_dec.py
View File

@@ -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__))

38
src/eth/tb/taxi_gmii_basex_enc/test_taxi_gmii_basex_enc.py
View File

@@ -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__))

82
src/eth/tb/taxi_mac_ctrl_rx/test_taxi_mac_ctrl_rx.py
View File

@@ -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__))

82
src/eth/tb/taxi_mac_ctrl_tx/test_taxi_mac_ctrl_tx.py
View File

@@ -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__))

11
src/eth/tb/taxi_mac_pause_ctrl_rx/test_taxi_mac_pause_ctrl_rx.py
View File

@@ -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__))

11
src/eth/tb/taxi_mac_pause_ctrl_tx/test_taxi_mac_pause_ctrl_tx.py
View File

@@ -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__))

63
src/eth/tb/taxi_xgmii_baser_dec/test_taxi_xgmii_baser_dec.py
View File

@@ -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__))

64
src/eth/tb/taxi_xgmii_baser_enc/test_taxi_xgmii_baser_enc.py
View File

@@ -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__))