assert tb.status_error_uncor_asserted
await RisingEdge(dut.clk)
await RisingEdge(dut.clk)
def cycle_pause():
return itertools.cycle([1, 1, 1, 0])
if cocotb.SIM_NAME:
for test in [run_test_write, run_test_bad_ops]:
factory = TestFactory(test)
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("axis_pcie_data_width", [64, 128, 256, 512])
def test_pcie_us_axi_master_wr(request, axis_pcie_data_width):
dut = "pcie_us_axi_master_wr"
module = os.path.splitext(os.path.basename(__file__))[0]
toplevel = dut
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, 0])
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_axis_baser_rx_64(request):
dut = "axis_baser_rx_64"
module = os.path.splitext(os.path.basename(__file__))[0]
def size_list():
data_width = 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:
ports = len(cocotb.top.axis_demux_inst.m_axis_tvalid)
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.add_option("port", list(range(ports)))
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("tdest_route", [0, 1])
@pytest.mark.parametrize("data_width", [8, 16, 32])
@pytest.mark.parametrize("ports", [4])
@cocotb.coroutine
def run_test(dut, index=0):
len_data = int((N + INPUT_WIDTH + KEY_WIDTH) / 8)
with (open(abs_path_file_storage, "rb+")) as storage_file:
'''
msg = random.randint(0,(2**24)-1)
key = random.randint(0,(2**24)-1)
hmac_impl = hmac_spongent.HMAC_Sponegnt(key,N,c,r,R)
expected_value = hmac_impl.generate_MAC(msg,64)
'''
storage_file.seek((index * len_data))
msg = int.from_bytes(storage_file.read(int(INPUT_WIDTH / 8)),
byteorder='little')
key = int.from_bytes(storage_file.read(int(KEY_WIDTH / 8)),
byteorder='little')
expected_result = int.from_bytes(storage_file.read(int(N / 8)),
byteorder='little')
setup_function(dut, key, msg)
yield rst_function_test(dut)
yield hmac_test(dut, expected_result)
n = 100
factory = TestFactory(run_test)
factory.add_option("index", range(0,
n)) #array de 10 int aleatorios entre 0 y 31
factory.generate_tests()
return bytearray(itertools.islice(itertools.cycle(range(1, 256)), length))
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'))
def test_axis_cobs_decode(request):
dut = "axis_cobs_decode"
module = os.path.splitext(os.path.basename(__file__))[0]
def cycle_pause():
return itertools.cycle([1, 1, 1, 0])
def size_list():
return list(range(1, 129))
def incrementing_payload(length):
return bytes(itertools.islice(itertools.cycle(range(1, 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.generate_tests()
factory = TestFactory(run_test_pad)
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'))
@cocotb.coroutine
def mux_function_test(dut, an_gen_i):
dut.an_gen_i.value = an_gen_i
expected_value = calculate_expected_result(an_gen_i)
yield Timer(1000)
if (dut.an.value.integer != expected_value):
raise TestFailure("Error mux,wrong value = %s, expected = %s" %
hex(int(dut.an.value)) % hex(expected_value))
print("Expected value = {0}, Value = {1}".format(hex(expected_value),
hex(int(dut.an.value))))
def calculate_expected_result(an_gen):
return (0xFF ^ (0x1 << an_gen))
@cocotb.coroutine
def run_test(dut, ctrl_i=0):
yield rst_function_test(dut)
yield mux_function_test(dut, ctrl_i)
n = 10
factory = TestFactory(run_test)
factory.add_option("ctrl_i", np.random.randint(
low=0, high=8, size=n)) #array de 10 int aleatorios entre 0 y 15
factory.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()
# Override the driver's ARLEN value, forcing a wrong one
await RisingEdge(dut.clk)
arlen = burst_length - 1 + length_delta
getattr(dut, AXI_PREFIX + '_ARLEN').value = arlen
await axim.read(address, burst_length)
raise TestFailure("Mismatch between ARLEN value ({}) and number "
"of read words ({}), but the driver did not "
"raise an exception".format(arlen, burst_length))
except AXIReadBurstLengthMismatch:
pass
single_beat = TestFactory(test_single_beat)
single_beat.add_option('driver', (AXI4Master, AXI4LiteMaster))
single_beat.add_option('address_latency', (0, ))
single_beat.add_option('data_latency', (0, ))
single_beat.generate_tests()
single_beat_with_latency = TestFactory(test_single_beat)
single_beat_with_latency.add_option('driver', (AXI4Master, ))
single_beat_with_latency.add_option('address_latency', (0, 5))
single_beat_with_latency.add_option('data_latency', (1, 10))
single_beat_with_latency.generate_tests(postfix="_latency")
incr_burst = TestFactory(test_incr_burst)
incr_burst.add_option('return_rresp', (True, False))
incr_burst.add_option('size', (None, ))
incr_burst.generate_tests()
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
await tb.reset()
dut.m_axis_tready <= 1;
if backpressure_inserter is not None:
tb.backpressure.start(backpressure_inserter())
# Send in the packets
for transaction in data_in(Sha.blocks512(codec)):
tb.s_axis.bus.tuser <= BinaryValue(80*'0'+little_endian_codec(codec)+32*'0')
await tb.s_axis.send(transaction)
# 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)
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", [0x12,0x13,0x09,0x10])
factory.add_option("data_in", [random_message])
factory.add_option("backpressure_inserter",
[None, random_50_percent]) # Throtle tready: random_50_percent
factory.generate_tests()
cocotb.fork(Clock(dut.clk, 100).start())
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()
Tests of cocotb.regression.TestFactory functionality
"""
from collections.abc import Coroutine
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"),
}
class TestClass(Coroutine):
await workers.pop(0).join()
await RisingEdge(dut.clk)
await RisingEdge(dut.clk)
def cycle_pause():
return itertools.cycle([1, 1, 1, 0])
if cocotb.SIM_NAME:
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.generate_tests()
for test in [run_test_write_words, run_test_read_words]:
factory = TestFactory(test)
factory.generate_tests()
factory = TestFactory(run_stress_test)
factory.generate_tests()
# cocotb-test
tests_dir = os.path.dirname(__file__)
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])
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 test_axis_gmii_tx(request):
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):
"""
Generate a JSON wavedrom diagram of a trace
@cocotb.coroutine
def process_image(dut, filename="", debug=False, threshold=0.22):
"""Run an image file through the jpeg encoder and compare the result"""
cocotb.fork(Clock(dut.clk, 100).start())
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()
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()
assert q.get_nowait() == k
else:
for k in range(QUEUE_SIZE):
assert q.get_nowait() == k
assert q.qsize() == 0
assert q.empty()
assert not q.full()
# underflow
with pytest.raises(QueueEmpty):
q.get_nowait()
factory = TestFactory(run_queue_nonblocking_test)
factory.add_option("queue_type", [Queue, PriorityQueue, LifoQueue])
factory.generate_tests()
@cocotb.test()
async def test_queue_contention(dut):
NUM_PUTTERS = 20
QUEUE_SIZE = 10
q = Queue(maxsize=QUEUE_SIZE)
async def putter(lst, item):
await q.put(item)
lst.append(item)
async def getter(lst, item):
return itertools.cycle([1, 1, 1, 0])
if cocotb.SIM_NAME:
s_count = int(os.getenv("PARAM_S_COUNT"))
m_count = int(os.getenv("PARAM_M_COUNT"))
data_width = int(os.getenv("PARAM_DATA_WIDTH"))
byte_width = data_width // 8
max_burst_size = (byte_width-1).bit_length()
for test in [run_test_write, run_test_read]:
factory = TestFactory(test)
factory.add_option("idle_inserter", [None, cycle_pause])
factory.add_option("backpressure_inserter", [None, cycle_pause])
# factory.add_option("size", [None]+list(range(max_burst_size)))
factory.add_option("s", range(min(s_count, 2)))
factory.add_option("m", range(min(m_count, 2)))
factory.generate_tests()
factory = TestFactory(run_stress_test)
factory.generate_tests()
# cocotb-test
tests_dir = os.path.abspath(os.path.dirname(__file__))
rtl_dir = os.path.abspath(os.path.join(tests_dir, '..', '..', 'rtl'))
]
for i in samples:
await ff_driver.write(i, exit_full=False)
assert (value := await ff_driver.write(
samples[0],
exit_full=True)) == "FULL", "AFIFO not signaling full correctly"
# Testing FIFO empty flag
await reset_dut(dut)
assert (value := await
ff_driver.read(exit_empty=True
)) == "EMPTY", "AFIFO not signaling empty correctly"
if cocotb.SIM_NAME:
factory = TestFactory(run_test)
factory.add_option('config_clock', [0, 1])
factory.generate_tests()
#@pytest.mark.skipif(os.getenv("SIM") != "verilator", reason="Verilator is the only supported")
@pytest.mark.parametrize("slots", [2, 4, 8, 16, 32, 64, 128])
def test_fifo_async(slots):
tests_dir = os.path.dirname(os.path.abspath(__file__))
rtl_dir = tests_dir
dut = "async_gp_fifo"
module = os.path.splitext(os.path.basename(__file__))[0]
toplevel = dut
verilog_sources = [
os.path.join(rtl_dir, f"../{dut}.sv"),
]
parameters = {}
output_w = len(dut.output)
n_inputs = num_inputs(dut)
yield init_test(dut)
wr_data = []
for _ in range(test_size):
wr_data.append([signed_random(width_i) for _ in range(n_inputs)])
expected = [sum(x) for x in wr_data]
cocotb.fork(send(dut, wr_data))
rd_data = yield recv(dut)
assert len(rd_data) >= len(wr_data)
assert subfinder(rd_data, expected), f'{expected} not in {rd_data}'
tf_test_data = TF(check_data)
tf_test_data.add_option('dummy', [0] * 5)
tf_test_data.generate_tests()
@pytest.mark.parametrize("width_i, stages", [(8, 4), (8, 2), (8, 1),])
def test_main(width_i, stages):
core = TreeAdderSigned(width_i=width_i,
n_stages=stages,
reg_in=True, reg_out=True)
ports = core.get_ports()
vcd_file = vcd_only_if_env(f'./test_adder_i{width_i}_s{stages}.vcd')
run(core, 'cnn.tests.test_tree_operations', ports=ports, vcd_file=vcd_file)
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, [isaTestsBase, isaTestsMemory, isaTestsMulDiv])))
factory.generate_tests()
if(dut.counter_o != 16):
raise TestFailure("""Error WAIT_74_CYC, wrong counter_o value = {0}, expected value = {1}""".format(int(dut.counter_o.value),16))
@cocotb.coroutine
def n_cycles_clock(dut,n):
for i in range(0,n):
yield RisingEdge(dut.clk)
yield FallingEdge(dut.clk)
@cocotb.test()
def run_test(dut,n=0):
setup_function(dut)
yield from_reset_to_idle(dut)
n = 10
factory = TestFactory(run_test)
factory.add_option("n", np.random.randint(low=0,high=(2**32)-1,size=n)) #array de 10 int aleatorios entre 0 y 31
factory.generate_tests()
def create_matrix(func, rows, cols):
return [func(DATA_WIDTH) for row in range(rows) for col in range(cols)]
def create_a(func):
return create_matrix(func, A_ROWS, A_COLUMNS_B_ROWS)
def create_b(func):
return create_matrix(func, A_COLUMNS_B_ROWS, B_COLUMNS)
def gen_a(num_samples=NUM_SAMPLES, func=getrandbits):
"""Generate random matrix data for A"""
for _ in range(num_samples):
yield create_a(func)
def gen_b(num_samples=NUM_SAMPLES, func=getrandbits):
"""Generate random matrix data for B"""
for _ in range(num_samples):
yield create_b(func)
factory = TestFactory(test_multiply)
factory.add_option('a_data', [gen_a])
factory.add_option('b_data', [gen_b])
factory.generate_tests()
await event.wait()
if cocotb.SIM_NAME:
for test in [
run_test_rc_mem,
run_test_config,
run_test_enumerate,
]:
factory = TestFactory(test)
factory.generate_tests()
factory = TestFactory(run_test_ep_mem)
factory.add_option("ep_index", range(4))
factory.generate_tests()
factory = TestFactory(run_test_p2p_dma)
factory.add_option("ep1_index", [0, 1])
factory.add_option("ep2_index", [2, 3])
factory.generate_tests()
factory = TestFactory(run_test_dma)
factory.add_option("ep_index", range(4))
factory.generate_tests()
factory = TestFactory(run_test_msi)
factory.add_option("ep_index", range(4))
factory.generate_tests()
yield RisingEdge(dut.clk)
yield FallingEdge(dut.clk)
@cocotb.coroutine
def run_test(dut, text=0):
#text = random.randint(0,(2**32)-1)
salt = 0x123456789ABCDEF0
count = 50
user_password = 0xAAAA
kdf_impl = keyDerivationFunction.KDF(count, salt, user_password)
expected_value = kdf_impl.generate_derivate_key()
first_value = (user_password << 96) + (salt << 32) + count
setup_function(dut, salt, count, user_password)
yield rst_function_test(dut, first_value)
yield kdf_test(dut, expected_value)
n = 1
factory = TestFactory(run_test)
factory.add_option("text", np.random.randint(low=0, high=(2**32) - 1, size=n))
#factory.add_option("c", np.random.randint(low=0,high=(2**32)-1,size=n)) #array de 10 int aleatorios entre 0 y 31
factory.generate_tests()
@cocotb.coroutine
def run_test_single(dut, input_data):
tb = NormalizeTestbench(dut)
yield tb.initialize()
op = input_data
x, y, z = op
result = normalize_vector_operation(pack_vector(x, y, z))
yield tb.clock_input(op)
yield tb.flush_pipeline()
yield tb.clock_assert_result(unpack_vector(result))
tests = TestFactory(run_test_single)
tests.add_option('input_data', inputs)
generate_tests_for(tests)
@cocotb.test()
def pipeline_test(dut):
tb = NormalizeTestbench(dut)
yield tb.initialize()
for i in range(min(fixed_w, len(inputs))):
yield tb.clock_input(inputs[i])
yield tb.flush_pipeline()
for i in range(min(fixed_w, len(inputs))):
x, y, z = inputs[i]
yield RisingEdge(dut.read_clk)
@cocotb.coroutine
def check_data(dut, period_ns_w, period_ns_r, burps_in, burps_out, dummy=0):
length = 200
yield init_test(dut, period_ns_w, period_ns_r)
input_stream = DataStreamDriver(dut, 'input_', dut.write_clk)
output_stream = DataStreamDriver(dut, 'output_', dut.read_clk)
data = [random.getrandbits(len(input_stream.bus.data)) for _ in range(length)]
cocotb.fork(input_stream.send(data, burps=burps_in))
rcv = yield output_stream.recv(burps=burps_out)
assert data == rcv, f'\n{data}\n!=\n{rcv}'
tf_check = TF(check_data)
tf_check.add_option('period_ns_w', [10])
tf_check.add_option('period_ns_r', [10, 22, 3])
tf_check.add_option('burps_in', [False, True])
tf_check.add_option('burps_out', [False, True])
tf_check.add_option('dummy', [0] * 3)
tf_check.generate_tests(postfix='_cdc')
@pytest.mark.parametrize("width, depth", [(random.randint(2, 20), random.randint(2, 10))])
def test_main(width, depth):
fifo = StreamFifoCDC(input_stream=DataStream(width, 'sink', name='input'),
output_stream=DataStream(width, 'source', name='output'),
depth=depth,
r_domain='read',
w_domain='write')
ports = [fifo.input[f] for f in fifo.input.fields]
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'))
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", [1000e6, 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_1g_gmii_fifo(request):
dut = "eth_mac_1g_gmii_fifo"
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))
if cocotb.SIM_NAME:
for test in [run_test_tx, run_test_rx]:
factory = TestFactory(test)
factory.add_option("payload_lengths", [size_list])
factory.add_option("payload_data", [incrementing_payload])
factory.add_option("speed", [10e9, 1e9])
factory.generate_tests()
# cocotb-test
tests_dir = os.path.dirname(__file__)
def test_eth_mac(request):
dut = "test_eth_mac"
module = os.path.splitext(os.path.basename(__file__))[0]
toplevel = dut
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
"""
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 cycle_pause():
return itertools.cycle([1, 1, 1, 0])
if cocotb.SIM_NAME:
data_width = int(os.getenv("PARAM_AXI_DATA_WIDTH"))
byte_width = data_width // 8
max_burst_size = (byte_width-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.dirname(__file__)
rtl_dir = os.path.abspath(os.path.join(tests_dir, '..', '..', 'rtl'))
@pytest.mark.parametrize("axil_data_width", [8, 16, 32])
"""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()
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()
