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)
# back to a known state
dut.restart <= 1
yield RisingEdge(dut.clk)
dut.restart <= 0
yield read_and_check(dut, burps=burps)
try:
running_cocotb = True
depth = int(os.environ['cocotb_param_depth'], 10)
except KeyError:
running_cocotb = False
if running_cocotb:
tf_data = TF(check_data)
tf_data.add_option('burps', [False, True])
tf_data.add_option('dummy', [0] * 5)
tf_data.generate_tests()
tf_restart = TF(check_restart)
tf_restart.add_option('burps', [False, True])
tf_restart.add_option('dummy', [0] * 5)
tf_restart.generate_tests()
@pytest.mark.parametrize("width, depth", [
(8, 8),
])
def test_core(width, depth):
core = CircularROM(width=width, init=mem_init[:depth])
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()
input_width = len(input_stream.bus.data)
size = 200
for _ in range(3):
data = [(random.getrandbits(input_width),
random.randint(0, input_width-1)) for _ in range(size)]
cocotb.fork(input_stream.send(data, burps=burps_in))
rcv = yield output_stream.recv(burps=burps_out)
for idata, odata in zip(data, rcv):
data = idata[0]
shift = idata[1]
shifted = data << shift
expected = shifted % (2**input_width) + (shifted >> input_width)
assert expected == odata[0]
assert idata[1] == odata[1]
tf_test = TF(check_data)
tf_test.add_option('burps_in', [False, True])
tf_test.add_option('burps_out', [False, True])
tf_test.generate_tests()
@pytest.mark.parametrize("width", [12, 24, 48])
def test_main(width):
shifter = PipelinedBarrelShifter(width)
ports = [shifter.input[f] for f in shifter.input.fields]
ports += [shifter.output[f] for f in shifter.output.fields]
run(shifter, 'cores_nmigen.test.test_shifter', ports=ports, vcd_file=None)
data_packets = int(ceil(len(dut.input_data) / len(dut.s_axi__RDATA)))
n = 0
sniffed_data = []
while data_avail:
tmp_value = 0
for i in range(data_packets):
rd = yield axi_lite.read_reg(0xc + i * 0x4)
tmp_value |= ((rd & (2**32 - 1)) << (32 * i))
sniffed_data.append(tmp_value)
rd = yield axi_lite.read_reg(0x8)
data_avail = (rd >> 31) & 0x1
assert n < FIFO_DEPTH, f'Read {n+1} values when fifo depth is {FIFO_DEPTH}'
n += 1
assert count >= len(sniffed_data), f'{count} < {len(sniffed_data)}'
assert subfinder(buff, sniffed_data), f'{sniffed_data} not in {buff}'
tf_check_data = TF(check_data)
tf_check_data.add_option('', [0] * 3) # dummy variable to force repetition of test (pytest could be used but it would regenerate the core each time)
tf_check_data.generate_tests()
@pytest.mark.parametrize("width", [8, 32, 40, 64])
def test_datapath_sniffer(width):
core = DatapathSniffer(width=width, depth=FIFO_DEPTH, domain_data='data', domain_axi='axi')
ports = core.get_ports()
run(core, 'nmigen_datapath_sniffer.tests.test_datapath_sniffer', ports=ports, vcd_file=f'./output.vcd')
m_axis.init_master()
s_axis.init_slave()
yield reset(dut)
cocotb.fork(m_axis.monitor())
cocotb.fork(m_axis.send(wr_data, burps=burps_in))
yield RisingEdge(dut.clk)
rd_data = yield s_axis.recv(burps=burps_out)
assert wr_data == m_axis.buffer, f'{wr_data} != {m_axis.buffer}'
assert rd_data == expected, f'{expected}\n!=\n{rd_data}'
tf = TF(check_data)
tf.add_option('burps_in', [False, True])
tf.add_option('burps_out', [False, True])
tf.add_option('dummy', [0] * 5)
tf.generate_tests()
@pytest.mark.parametrize("latency", [1, 4, 5])
def test_main_wrapper(latency):
core = StreamWrapper(wrapped_core=ExampleCore(16, latency),
input_stream=DataStream(16, direction='sink', name='input'),
output_stream=DataStream(16, direction='source', name='output'),
input_map={'data': 'data_i'},
output_map={'data': 'data_o'},
latency=latency)
ports = core.get_ports()
yield init_test(dut)
for (r_name, r_dir, r_addr, r_fields), r_value in zip(regs_ro, data):
for f_name, f_size, f_offset in r_fields:
setattr(dut, f_name, unmask(r_value, f_size, f_offset))
yield RisingEdge(dut.clk)
for (r_name, r_dir, r_addr, r_fields), r_value in zip(regs_ro, data):
rd = yield axi_lite.read_reg(r_addr)
assert rd == r_value, f'{hex(rd)} == {hex(r_value)}'
tf_test_rw = TF(check_rw_regs)
tf_test_rw.generate_tests()
tf_test_ro = TF(check_ro_regs)
tf_test_ro.generate_tests()
def test_axi_lite_device():
core = AxiLiteDevice(addr_w=5, data_w=32, registers=regs)
ports = [core.axi_lite[f] for f in core.axi_lite.fields]
ports += [core.registers[f] for f in core.registers.fields]
run(core,
'cores_nmigen.test.test_axi_lite',
ports=ports,
vcd_file='./test_axi_lite_device.vcd')
def data_check(dut, driver):
yield init_test(dut)
a_stream = driver(dut, 'a_', dut.clk)
b_stream = driver(dut, 'b_', dut.clk)
r_stream = driver(dut, 'r_', dut.clk)
a_width = len(a_stream.bus.TDATA)
b_width = len(a_stream.bus.TDATA)
a_data = [random.getrandbits(a_width) for _ in range(20)]
b_data = [random.getrandbits(b_width) for _ in range(20)]
cocotb.fork(a_stream.send(a_data))
cocotb.fork(b_stream.send(b_data))
r_data = yield r_stream.recv()
for a, b, r in zip(a_data, b_data, r_data):
assert a + b == r
tf_random_len = TF(data_check)
tf_random_len.add_option('driver', [AxiStreamDriver, AxiStreamDriverBurps])
tf_random_len.generate_tests()
def test_axis():
m = Adder(10, 'sync', AxiStream)
ports = []
for i in [m.a, m.b, m.r]:
ports += [i[f] for f in i.fields]
run(m, 'adder.tests.test_axis', ports=ports, vcd_file='axis.vcd')
