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')