len(test_data) +
16) == b'\xaa' * 8 + test_data + b'\xaa' * 8
cur_tag = (cur_tag + 1) % tag_count
await RisingEdge(dut.clk)
await RisingEdge(dut.clk)
def cycle_pause():
return itertools.cycle([1, 1, 1, 0])
if cocotb.SIM_NAME:
factory = TestFactory(run_test_read)
factory.add_option(("idle_inserter", "backpressure_inserter"),
[(None, None), (cycle_pause, cycle_pause)])
factory.generate_tests()
# cocotb-test
tests_dir = os.path.dirname(__file__)
rtl_dir = os.path.abspath(os.path.join(tests_dir, '..', '..', 'rtl'))
@pytest.mark.parametrize("pcie_offset",
list(range(4)) + list(range(4096 - 4, 4096)))
@pytest.mark.parametrize("axis_pcie_data_width", [64, 128, 256, 512])
def test_pcie_us_axi_dma_rd(request, axis_pcie_data_width, pcie_offset):
dut = "pcie_us_axi_dma_rd"
expected = calc_expected(width, wr_data, leak)
assert len(
m_axis.buffer) == test_size, f'{len(m_axis.buffer)} != {test_size}'
assert len(s_axis.buffer) == len(
expected), f'{len(s_axis.buffer)} != {len(expected)}'
assert rd_data == expected, f'\n{rd_data}\n!=\n{expected}'
try:
running_cocotb = True
leak = int(os.environ['coco_param_leak'], 10)
except KeyError as e:
running_cocotb = False
if running_cocotb:
tf_test_data = TF(check_data)
tf_test_data.add_option('leak', [leak])
tf_test_data.add_option('burps_in', [False, True])
tf_test_data.add_option('burps_out', [False, True])
tf_test_data.generate_tests()
@pytest.mark.timeout(10)
@pytest.mark.parametrize("width, leak", [
(8, 0),
(8, 1),
(8, 7),
(8, 8),
])
def test_main(width, leak):
os.environ['coco_param_leak'] = str(leak)
signal <= 0
yield Timer(5000) # ps
signal <= 1
yield Timer(5000) # ps
# ==============================================================================
@cocotb.coroutine
def run_test(dut):
"""Setup testbench and run a test."""
cocotb.fork(clock_gen(dut.c))
tb = DFF_TB(dut, BinaryValue(0,1))
clkedge = RisingEdge(dut.c)
# Apply random input data by input_gen via BitDriver for 100 clock cycle.
tb.start()
for i in range(100):
yield clkedge
# Stop generation of input data. One more clock cycle is needed to capture
# the resulting output of the DUT.
tb.stop()
yield clkedge
# Print result of scoreboard.
raise tb.scoreboard.result
# ==============================================================================
# Register test.
factory = TestFactory(run_test)
factory.generate_tests()
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 cocotb.SIM_NAME:
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()
# cocotb-test
tests_dir = os.path.abspath(os.path.dirname(__file__))
rtl_dir = os.path.abspath(os.path.join(tests_dir, '..', '..', 'rtl'))
lib_dir = os.path.abspath(os.path.join(rtl_dir, '..', 'lib'))
axis_rtl_dir = os.path.abspath(os.path.join(lib_dir, 'axis', 'rtl'))
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 cocotb.SIM_NAME:
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()
# cocotb-test
if (dut.s != expected_s):
raise TestFailure(
"""Error sum value,wrong value = {0}, expected value is {1}""".
format(hex(int(dut.s.value)), hex(expected_s)))
if (dut.c != expected_c):
raise TestFailure(
"""Error carry value,wrong value = {0}, expected value is {1}""".
format(hex(int(dut.c.value)), hex(expected_c)))
@cocotb.coroutine
def run_test(dut, a=0, b=0):
print(hex(a))
print(hex(b))
expected_s = (a + b) & ((2**32) - 1)
expected_c = ((a + b) >> 32) & 0x01
setup_function(dut, a, b)
yield calculate_result(dut, expected_s, expected_c)
n = 10
factory = TestFactory(run_test)
factory.add_option("a", np.random.randint(low=0, high=(2**32) - 1, size=n))
factory.add_option("b", np.random.randint(low=0, high=(2**32) - 1, size=n))
factory.generate_tests()
def O5(self):
return eval(self.init.binstr[-1 - self.inputs.integer])
@property
def O6(self):
return eval(self.init.binstr[-1 - self.inputs.integer])
@cocotb.coroutine
def lut_basic_test(dut, inputs):
"""Test for LUT options"""
yield Timer(1)
for i in range(6):
setattr(dut, 'A%d' % (i + 1), inputs & (1 << i))
yield Timer(1)
model = LutModel(dut.INIT.value, inputs)
if dut.O5 != model.O5 or dut.O6 != model.O6:
raise TestFailure('No match (dut:model) O5(%d:%d) O6(%d:%d)' % \
(dut.O5, model.O5, dut.O6, model.O6))
else:
dut._log.info('Match')
factory = TestFactory(lut_basic_test)
input_permutations = range(2**6)
factory.add_option("inputs", input_permutations)
factory.generate_tests()
def nonzero_incrementing_payload_zero_framed(length):
return bytearray(
[0] + list(itertools.islice(itertools.cycle(range(1, 256)), length)) +
[0])
def prbs_payload(length):
gen = prbs31()
return bytearray([next(gen) for x in range(length)])
if cocotb.SIM_NAME:
factory = TestFactory(run_test)
factory.add_option("payload_lengths", [size_list])
factory.add_option("payload_data", [
zero_payload, nonzero_incrementing_payload,
nonzero_incrementing_payload_zero_framed, prbs_payload
])
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.dirname(__file__)
rtl_dir = os.path.abspath(os.path.join(tests_dir, '..', '..', 'rtl'))
"""Run an image file through the jpeg encoder and compare the result"""
cocotb.fork(Clock(dut.clk, 100).start())
#Overwriting debug (original) with the one from env
debug = os.getenv('COCOTB_DEBUG') # None/1
driver = ImageDriver(dut)
monitor = JpegMonitor(dut)
if debug: # pragma: no cover
driver.log.setLevel(logging.DEBUG)
monitor.log.setLevel(logging.DEBUG)
stimulus = Image.open(filename)
yield driver.send(stimulus)
output = yield monitor.wait_for_recv()
if debug: # pragma: no cover
output.save(filename + "_process.jpg")
difference = compare(stimulus, output)
dut.log.info("Compressed image differs to original by %f%%" % (difference))
if difference > threshold: # pragma: no cover
raise TestFailure("Resulting image file was too different (%f > %f)" %
(difference, threshold))
tf = TestFactory(process_image)
tf.add_option("filename", [os.path.join('test_images', f)
for f in os.listdir('test_images')])
tf.generate_tests()
if errors:
raise TestFailure("Error bounds exceeded.")
else:
raise TestSuccess("Test finished OK.")
def start(self):
self.drive_coro = cocotb.fork(self.drive_fft())
self.read_coro = cocotb.fork(self.read_fft())
@cocotb.coroutine
def join(self):
yield self.drive_coro.join()
yield self.read_coro.join()
@cocotb.coroutine
def fft_test(dut, stimulus=FFTStimulus.STIM_SIN, mode=FFTMode.MODE_FFT, plot=False):
error_spec = {}
error_spec["offset"] = 3
error_spec["rms"] = 6
error_spec["gain"] = 3
tb = FFTTestBench(dut, stimulus, mode, plot, error_spec_lsb=error_spec, num_ffts=10)
yield init_dut(dut)
tb.start()
yield tb.join()
tf = TestFactory(fft_test)
tf.add_option("stimulus", FFTStimulus)
tf.add_option("mode", FFTMode)
tf.generate_tests()
import operator
from cocotb.regression import TestFactory
from spinal.RiscvTester.RiscvTester import isaTestsMemory, isaTestsMulDiv, isaTestsBase, testIsa
factory = TestFactory(testIsa)
factory.add_option("iHexPath", map(lambda x : "../" + x,reduce(operator.add, [isaTestsBase, isaTestsMemory, isaTestsMulDiv])))
factory.generate_tests()
for index, values in enumerate(data_generator(bits=len(dut.in1))):
expected.append(sorted(values))
yield RisingEdge(dut.clk)
dut.in1 = values[0]
dut.in2 = values[1]
dut.in3 = values[2]
dut.in4 = values[3]
dut.in5 = values[4]
yield ReadOnly()
expect = expected.pop(0)
if expect is None: continue
got = [int(dut.out5), int(dut.out4), int(dut.out3),
int(dut.out2), int(dut.out1)]
if got != expect:
dut.log.error('Expected %s' % expect)
dut.log.error('Got %s' % got)
raise TestFailure("Output didn't match")
dut.log.info('Sucessfully sent %d cycles of data' % (index + 1))
# Generate permutations of the test
tests = TestFactory(run_test)
tests.add_option('data_generator', [random_data, corner_cases])
tests.generate_tests()
def random_packet_sizes(min_size=1, max_size=150, npackets=10):
"""random string data of a random length"""
for i in range(npackets):
yield get_bytes(random.randint(min_size, max_size), random_data())
@cocotb.coroutine
def randomly_switch_config(csr):
"""Twiddle the byteswapping config register"""
while True:
yield csr.write(0, random.randint(0, 1))
factory = TestFactory(run_test)
factory.add_option("data_in",
[random_packet_sizes])
factory.add_option("config_coroutine",
[None, randomly_switch_config])
factory.add_option("idle_inserter",
[None, wave, intermittent_single_cycles, random_50_percent])
factory.add_option("backpressure_inserter",
[None, wave, intermittent_single_cycles, random_50_percent])
factory.generate_tests()
import cocotb.wavedrom
@cocotb.test()
def wavedrom_test(dut):
self.stopped = True
async def run_test(dut):
"""Setup testbench and run a test."""
cocotb.fork(Clock(dut.c, 10, 'us').start(start_high=False))
tb = DFF_TB(dut, init_val=BinaryValue(0))
clkedge = RisingEdge(dut.c)
# Apply random input data by input_gen via BitDriver for 100 clock cycles.
tb.start()
for _ in range(100):
await clkedge
# Stop generation of input data. One more clock cycle is needed to capture
# the resulting output of the DUT.
tb.stop()
await clkedge
# Print result of scoreboard.
raise tb.scoreboard.result
# Register the test.
factory = TestFactory(run_test)
factory.generate_tests()
set_top_level("dff", "entity", "lib")
# TODO: Fragmentation is not implemented, so expect truncated packets
tb.expect_memwrite(DMA_WND_START, header + endian_swap(payload[:224]))
await with_timeout(tb.data_tx.send(payload, channel=channel), 1000, 'ns')
await RisingEdge(dut.clk)
cntr = await tb.csr.read(0x6) # csr_c2h_staging_counter
assert cntr == 1, 'expected csr_c2h_staging_counter to be incremented to 1'
await Timer(1000, 'ns')
assert tb.dut.irq_c2h_avail == 1, 'expected irq_c2h_avail to be high'
wptr = await tb.csr.read(0x2b) # c2h_dma_card_write_ptr
await tb.csr.write(0x2a, wptr) # c2h_dma_host_read_ptr
await Timer(100, 'ns')
assert tb.dut.irq_c2h_avail == 0, 'expected irq_c2h_avail to be reset'
raise tb.scoreboard.result
c2h_factory = TestFactory(run_c2h_dma_test)
# TODO:
# - Add packet fragmentation
c2h_factory.add_option('dwords', [1, 8, 15, 100, 512])
c2h_factory.add_option('channel', [0, 3])
c2h_factory.generate_tests()
@cocotb.test()
async def test_c2h_dma_pressure(dut):
"""Test C2H DMA pressure."""
clock = Clock(dut.clk, 10, units='ns')
cocotb.fork(clock.start())
tb = TestC2H(dut)
channel = 2
await tb.reset()
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 cocotb.SIM_NAME:
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__))
rtl_dir = os.path.abspath(os.path.join(tests_dir, '..', '..', 'rtl'))
lib_dir = os.path.abspath(os.path.join(rtl_dir, '..', 'lib'))
axis_rtl_dir = os.path.abspath(os.path.join(lib_dir, 'axis', 'rtl'))
def test_eth_mac_mii(request):
async def run_test(dut, config_clock):
MAX_WIDTH = int(os.environ['PARAM_DATA_WIDTH'])
TEST_RUNS = int(os.environ['TEST_RUNS'])
await setup_dut(dut, config_clock)
await reset_dut(dut)
for i in range(TEST_RUNS):
data = 2**random.randint(0,MAX_WIDTH)-1
dut.async_i.setimmediatevalue(data)
await ClockCycles(dut.clk_sync, 3)
print(f"Expected ["+str(data)+"], dut.sync_o.value ["+str(dut.sync_o.value)+"]")
assert data == dut.sync_o.value, "Unexpected 3FF behavior!"
if cocotb.SIM_NAME:
factory = TestFactory(run_test)
factory.add_option('config_clock', [0, 1])
factory.generate_tests()
@pytest.mark.parametrize("width",[1,2,4,8])
def test_3ff(width):
tests_dir = os.path.dirname(os.path.abspath(__file__))
rtl_dir = tests_dir
dut = "cdc_3ff_sync"
module = os.path.splitext(os.path.basename(__file__))[0]
toplevel = dut
verilog_sources = [
os.path.join(rtl_dir, f"../src/{dut}.sv"),
]
parameters = {}
parameters['DATA_WIDTH'] = width
import operator
from cocotb.regression import TestFactory
from spinal.RiscvTester.RiscvTester import isaTestsMemory, isaTestsMulDiv, isaTestsBase, testIsa
from cocotblib.misc import cocotbXHack
cocotbXHack()
factory = TestFactory(testIsa)
factory.add_option("iHexPath", reduce(operator.add, [isaTestsBase, isaTestsMemory, isaTestsMulDiv]))
factory.generate_tests()
# Copyright cocotb contributors
# Licensed under the Revised BSD License, see LICENSE for details.
# SPDX-License-Identifier: BSD-3-Clause
"""
Tests of cocotb.regression.TestFactory functionality
"""
import cocotb
from cocotb.regression import TestFactory
testfactory_test_args = set()
async def run_testfactory_test(dut, arg1, arg2, arg3):
testfactory_test_args.add((arg1, arg2, arg3))
factory = TestFactory(run_testfactory_test)
factory.add_option("arg1", ["a1v1", "a1v2"])
factory.add_option(("arg2", "arg3"), [("a2v1", "a3v1"), ("a2v2", "a3v2")])
factory.generate_tests()
@cocotb.test()
async def test_testfactory_verify_args(dut):
assert testfactory_test_args == {
("a1v1", "a2v1", "a3v1"),
("a1v2", "a2v1", "a3v1"),
("a1v1", "a2v2", "a3v2"),
("a1v2", "a2v2", "a3v2"),
}
raise tb.scoreboard.result
def random_packet_sizes(min_size=1, max_size=150, npackets=10):
"""random string data of a random length"""
for i in range(npackets):
yield get_bytes(random.randint(min_size, max_size), random_data())
async def randomly_switch_config(csr):
"""Twiddle the byteswapping config register"""
while True:
await csr.write(0, random.randint(0, 1))
factory = TestFactory(run_test)
factory.add_option("data_in", [random_packet_sizes])
factory.add_option("config_coroutine", [None, randomly_switch_config])
factory.add_option("idle_inserter",
[None, wave, intermittent_single_cycles, random_50_percent])
factory.add_option("backpressure_inserter",
[None, wave, intermittent_single_cycles, random_50_percent])
factory.generate_tests()
import cocotb.wavedrom
@cocotb.test()
async def wavedrom_test(dut):
"""
Generate a JSON wavedrom diagram of a trace and save it to wavedrom.json
make_fvec(3.125, 3.125, 3.125),
0,
),
( # Scalar 1
fixed_from_float(1),
make_fvec(1.25, 3.125, 0),
make_fvec(1.25, 3.125, 0),
0,
),
( # 32
fixed_from_float(16),
make_fvec(-1.96484375, 2.03515625, 2.0),
make_fvec(-31.4375, 32.5625, 32.0),
0,
),
]
@cocotb.coroutine
def run_test(dut, input_data):
tb = ScalarMulTestbench(dut)
op1, op2, result, overflow = input_data
tb.set_inputs(op1, op2)
yield tb.assert_result(result, overflow)
tests = TestFactory(run_test)
tests.add_option('input_data', inputs)
generate_tests_for(tests)
import operator
from cocotb.regression import TestFactory
from spinal.RiscvTester.RiscvTester import isaTestsMemory, isaTestsMulDiv, isaTestsBase, testIsa
from cocotblib.misc import cocotbXHack
cocotbXHack()
factory = TestFactory(testIsa)
factory.add_option(
"iHexPath",
reduce(operator.add, [isaTestsBase, isaTestsMemory, isaTestsMulDiv]))
factory.generate_tests()
def cycle_pause():
return itertools.cycle([1, 1, 1, 0])
def size_list():
return list(range(1, 128)) + [512, 1500, 9200] + [46] * 10
def incrementing_payload(length):
return bytes(itertools.islice(itertools.cycle(range(256)), length))
if cocotb.SIM_NAME:
factory = TestFactory(run_test)
factory.add_option("pkt_type", [Ether, IP, UDP, TCP])
factory.add_option("payload_lengths", [size_list])
factory.add_option("payload_data", [incrementing_payload])
factory.add_option("idle_inserter", [None, cycle_pause])
factory.generate_tests()
# cocotb-test
tests_dir = os.path.dirname(__file__)
rtl_dir = os.path.abspath(os.path.join(tests_dir, '..', '..', 'rtl'))
lib_dir = os.path.abspath(os.path.join(rtl_dir, '..', 'lib'))
axi_rtl_dir = os.path.abspath(os.path.join(lib_dir, 'axi', 'rtl'))
axis_rtl_dir = os.path.abspath(os.path.join(lib_dir, 'axis', 'rtl'))
eth_rtl_dir = os.path.abspath(os.path.join(lib_dir, 'eth', 'rtl'))
pcie_rtl_dir = os.path.abspath(os.path.join(lib_dir, 'pcie', 'rtl'))
await RisingEdge(dut.clk)
def cycle_pause():
return itertools.cycle([1, 1, 1, 0])
if cocotb.SIM_NAME:
data_width = len(cocotb.top.s_axi_wdata)
byte_lanes = data_width // 8
max_burst_size = (byte_lanes-1).bit_length()
for test in [run_test_write, run_test_read]:
factory = TestFactory(test)
factory.add_option("idle_inserter", [None, cycle_pause])
factory.add_option("backpressure_inserter", [None, cycle_pause])
factory.add_option("size", [None]+list(range(max_burst_size)))
factory.generate_tests()
factory = TestFactory(run_stress_test)
factory.generate_tests()
# cocotb-test
tests_dir = os.path.abspath(os.path.dirname(__file__))
rtl_dir = os.path.abspath(os.path.join(tests_dir, '..', '..', 'rtl'))
await tb.reset()
dut.m_axis_tready <= 1
if backpressure_inserter is not None:
tb.backpressure.start(backpressure_inserter())
dut._log.info('Send Wt parsed from message')
# Send in the packets
for transaction in format_wt(codec):
tb.s_axis.bus.tuser <= BinaryValue(80*'0'+little_endian_codec(codec)+32*'0')
#transaction = format_wt_message(transaction, sha_type=sha_type)
await tb.s_axis.send(transaction)
dut._log.info('Wait for last outgoing transaction to be monitored')
# Wait for last transmission
while not (dut.m_axis_tlast.value and dut.m_axis_tvalid.value and dut.m_axis_tready.value):
await RisingEdge(dut.axis_aclk)
for _ in range(3):
await RisingEdge(dut.axis_aclk)
dut._log.info("DUT testbench finished!")
raise tb.scoreboard.result
factory = TestFactory(run_test)
factory.add_option('codec', [0x12,0x13,0x09,0x10])
factory.add_option('data_in', [format_wt])
#factory.add_option('H_in', [random_hash_stream])
factory.generate_tests()
def size_list():
data_width = max(len(cocotb.top.m_axis_tdata),
len(cocotb.top.s_axis_tdata))
byte_width = data_width // 8
return list(range(1, byte_width * 4 + 1)) + [512] + [1] * 64
def incrementing_payload(length):
return bytearray(itertools.islice(itertools.cycle(range(256)), length))
if cocotb.SIM_NAME:
factory = TestFactory(run_test)
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()
for test in [
run_test_tuser_assert, run_test_init_sink_pause,
run_test_init_sink_pause_reset, run_test_overflow
]:
factory = TestFactory(test)
factory.generate_tests()
factory = TestFactory(run_stress_test)
r = [random.getrandbits(width_a) for _ in range(15)]
yield m_axis.send(r, burps=burps_in)
yield s_axis.recv(1, burps=burps_out)
m_axis.buffer[:] = []
s_axis.buffer[:] = []
rom.buffer[:] = []
data_in = [random.getrandbits(width_a) for _ in range(test_size)]
cocotb.fork(m_axis.send(data_in, burps_in))
yield s_axis.recv(test_size, burps_out)
check_output(m_axis.buffer, rom.buffer, s_axis.buffer, shift=shift)
tf_test_random = TF(check_data)
tf_test_random.add_option('burps_in', [False, True])
tf_test_random.add_option('burps_out', [False, True])
tf_test_random.add_option('dummy', [0] * 5)
tf_test_random.add_option('profile', ['random'])
tf_test_random.generate_tests(postfix='_random')
tf_test_limit = TF(check_data)
tf_test_limit.add_option('profile', ['limit'])
tf_test_limit.generate_tests(postfix='_limit')
tf_test_multiple = TF(check_multiple)
tf_test_multiple.add_option('burps_in', [False, True])
tf_test_multiple.add_option('burps_out', [False, True])
tf_test_multiple.add_option('dummy', [0] * 5)
tf_test_multiple.generate_tests()
import cocotb
from cocotb.regression import TestFactory
from cocotb.triggers import NullTrigger
testfactory_test_names = set()
testfactory_test_args = set()
prefix = "".join(random.choices(string.ascii_letters, k=4))
postfix = "".join(random.choices(string.ascii_letters, k=4))
async def run_testfactory_test(dut, arg1, arg2, arg3):
testfactory_test_names.add(cocotb.regression_manager._test.__qualname__)
testfactory_test_args.add((arg1, arg2, arg3))
factory = TestFactory(run_testfactory_test)
factory.add_option("arg1", ["a1v1", "a1v2"])
factory.add_option(("arg2", "arg3"), [("a2v1", "a3v1"), ("a2v2", "a3v2")])
factory.generate_tests(prefix=prefix, postfix=postfix)
@cocotb.test()
async def test_testfactory_verify_args(dut):
assert testfactory_test_args == {
("a1v1", "a2v1", "a3v1"),
("a1v2", "a2v1", "a3v1"),
("a1v1", "a2v2", "a3v2"),
("a1v2", "a2v2", "a3v2"),
}
assert testfactory_test_names == {
f"{prefix}run_testfactory_test{postfix}_{i:03}"
format(hex(int(dut.Mo[1].value)), hex(expected_Mo[1])))
if (dut.Si[0] != expected_Si[0]):
raise TestFailure(
"""Error Si_0 value,wrong value = {0}, expected value is {1}""".
format(hex(int(dut.Si[0].value)), hex(expected_Si[0])))
if (dut.Si[1] != expected_Si[1]):
raise TestFailure(
"""Error Si_1 value,wrong value = {0}, expected value is {1}""".
format(hex(int(dut.Si[1].value)), hex(expected_Si[1])))
@cocotb.coroutine
def run_test(dut, key=0):
key = random.randint(0, (2**128) - 1)
#print(hex(key))
#key = 0
twofish_SW = twofish.Twofish(key)
expected_Me = twofish_SW.M_e
expected_Mo = twofish_SW.M_o
expected_Si = twofish_SW.S_i
setup_function(dut, key)
yield calculate_values(dut, expected_Me, expected_Mo, expected_Si)
n = 1
factory = TestFactory(run_test)
factory.add_option("key", np.random.randint(
low=0, high=(2**32) - 1, size=n)) #array de 10 int aleatorios entre 0 y 31
factory.generate_tests()
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 cocotb.SIM_NAME:
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__))
rtl_dir = os.path.abspath(os.path.join(tests_dir, '..', '..', 'rtl'))
lib_dir = os.path.abspath(os.path.join(rtl_dir, '..', 'lib'))
if backpressure_inserter is not None:
tb.backpressure.start(backpressure_inserter())
# Send in the packets
for transaction in data_in():
tb.s_axis.bus.tuser <= BinaryValue(80 * '0' +
little_endian_codec(codec) +
32 * '0')
await tb.s_axis.send(transaction, tuser=get_bytes(16, random_data()))
# Wait for last transmission
await RisingEdge(dut.axis_aclk)
while not (dut.m_axis_tlast.value and dut.m_axis_tvalid.value
and dut.m_axis_tready.value):
await RisingEdge(dut.axis_aclk)
for _ in range(3):
await RisingEdge(dut.axis_aclk)
dut._log.info("DUT testbench finished!")
raise tb.scoreboard.result
# Register the test.
factory = TestFactory(run_test)
factory.add_option("codec", [0x11, 0x12, 0x13])
factory.add_option("data_in", [random_message])
factory.add_option("backpressure_inserter", [None, random_50_percent])
factory.generate_tests()
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 cocotb.SIM_NAME:
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__))
rtl_dir = os.path.abspath(os.path.join(tests_dir, '..', '..', 'rtl'))
lib_dir = os.path.abspath(os.path.join(rtl_dir, '..', 'lib'))
axis_rtl_dir = os.path.abspath(os.path.join(lib_dir, 'axis', 'rtl'))
iv = int.from_bytes(storage_file.read(16), byteorder='little')
print(hex(key))
print(hex(iv))
setup_function(dut, key, iv, 0, 0)
yield rst_function_test(dut)
for j in range(0, n_blocks):
print(j)
plaintext = int.from_bytes(storage_file.read(16),
byteorder='little')
ciphertext = int.from_bytes(storage_file.read(16),
byteorder='little')
if (index == 0):
yield enc_dec_test(dut, j, plaintext, ciphertext)
else:
yield enc_dec_test(dut, j, ciphertext, plaintext)
yield rst_function_test(dut)
n_blocks = int.from_bytes(storage_file.read(4), byteorder='little')
n = 2
factory = TestFactory(run_test)
factory.add_option("index", range(0,
n)) #array de 10 int aleatorios entre 0 y 31
factory.generate_tests()
await RisingEdge(dut.clk)
def cycle_pause():
return itertools.cycle([1, 1, 1, 0])
if cocotb.SIM_NAME:
data_width = len(cocotb.top.s_axi_wdata)
byte_lanes = data_width // 8
max_burst_size = (byte_lanes - 1).bit_length()
for test in [run_test_write, run_test_read]:
factory = TestFactory(test)
factory.add_option("idle_inserter", [None, cycle_pause])
factory.add_option("backpressure_inserter", [None, cycle_pause])
factory.add_option("size", [None] + list(range(max_burst_size)))
factory.generate_tests()
factory = TestFactory(run_stress_test)
factory.generate_tests()
# cocotb-test
tests_dir = os.path.abspath(os.path.dirname(__file__))
rtl_dir = os.path.abspath(os.path.join(tests_dir, '..', '..', 'rtl'))
@pytest.mark.parametrize("delay", [0, 1])
for c in range(0, 5):
yield RisingEdge(dut.clk)
for c in range(0, 5):
cnt = random.getrandbits(32)
yield drv.set_count(cnt, ClockCycles(dut.clk, hold_cycles))
exp = {
"name": "set count",
}
for w in range(0, wait_cycles):
exp["cntdwn"] = BinaryValue(cnt, bits=32, bigEndian=False)
yield tb.expect(exp)
yield RisingEdge(dut.clk)
cnt = cnt + 1
random.seed(time.time())
clk_t = 2000
exit_on_fail = True
fact = TestFactory(tmr_test_set_count)
fact.add_option("hold_cycles", [1, 2, 3, 10])
fact.add_option("wait_cycles", [1, 2, 3, 10])
fact.generate_tests()
fact = TestFactory(tmr_test_alarm)
fact.add_option("lapse", [1, 2, 3, 10, 100])
fact.add_option("lapse_cycles", [1, 2, 3, 10])
fact.generate_tests()
def size_list():
return list(range(1, 16)) + [128]
def incrementing_payload(length):
return bytearray(itertools.islice(itertools.cycle(range(256)), length))
def prbs_payload(length):
gen = prbs31()
return bytearray([next(gen) for x in range(length)])
if cocotb.SIM_NAME:
factory = TestFactory(run_test)
factory.add_option("payload_lengths", [size_list])
factory.add_option("payload_data", [incrementing_payload, prbs_payload])
factory.generate_tests()
# cocotb-test
tests_dir = os.path.abspath(os.path.dirname(__file__))
rtl_dir = os.path.abspath(os.path.join(tests_dir, '..', '..', 'rtl'))
def test_uart_tx(request):
dut = "uart_tx"
module = os.path.splitext(os.path.basename(__file__))[0]
toplevel = dut
import operator
from cocotb.regression import TestFactory
from spinal.RiscvTester.RiscvTester import isaTestsMemory, isaTestsMulDiv, isaTestsBase, testIsa
from cocotblib.misc import cocotbXHack
cocotbXHack()
factory = TestFactory(testIsa)
factory.add_option("iHexPath", map(lambda x : "../" + x,reduce(operator.add, [["../Pinsec/hex/dhrystone.hex"]])))
factory.generate_tests()
