def test_sub_access_non_vector():
sa = SubAccess(n("vc", uw(8)), u(2, w(3)), uw(8))
assert not check(sa)
sa = SubAccess(n("vc", bdl(a=(vec(uw(8), 10), True))),
u(2, w(3)), vec(uw(8), 10))
assert not check(sa)
def test_module_basis():
mod = DefModule("m", [OutputPort("p", uw(8))],
Connect(n("p", uw(8)), u(2, w(8))))
assert check(mod)
serialize_stmt_equal(
mod, 'module m :\n'
' output p : UInt<8>\n'
'\n'
' p <= UInt<8>("h2")')
mod = DefModule(
"m",
[InputPort("b", uw(8)), OutputPort("a", uw(8))],
Block([
DefNode("n", u(1, w(1))),
Conditionally(n("n", uw(1)), EmptyStmt(),
Connect(n("a", uw(8)), n("b", uw(8))))
]))
assert check(mod)
serialize_stmt_equal(
mod, 'module m :\n'
' input b : UInt<8>\n'
' output a : UInt<8>\n'
'\n'
' node n = UInt<1>("h1")\n'
' when n :\n'
' skip\n'
' else :\n'
' a <= b')
def test_memory_basis():
mem = DefMemory("m", vec(uw(8), 10))
assert check(mem)
serialize_stmt_equal(mem, 'cmem m : UInt<8>[10]')
mem = DefMemory("m", vec(bdl(a=(uw(8), False)), 10))
assert check(mem)
serialize_stmt_equal(mem, 'cmem m : {a : UInt<8>}[10]')
def test_read_port_mem_wrong():
mem_ref = n("m", bdl(a=(vec(uw(8), 10), False)))
mr = DefMemReadPort("mr", mem_ref, u(2, w(8)), n("clock", ClockType()))
assert not check(mr)
mem_ref = n("m", uw(9))
mr = DefMemReadPort("mr", mem_ref, n("a", uw(2)), n("clock", ClockType()))
assert not check(mr)
def test_read_port_clock_wrong():
mem_ref = n("m", vec(uw(8), 10))
mr = DefMemReadPort("mr", mem_ref, u(2, w(8)), n("clock", uw(1)))
assert not check(mr)
mem_ref = n("m", vec(bdl(a=(uw(8), False)), 10))
mr = DefMemReadPort("mr", mem_ref, n("a", uw(2)), u(0, w(1)))
assert not check(mr)
def test_write_port_clock_wrong():
mem_ref = n("m", vec(uw(8), 10))
mw = DefMemWritePort("mw", mem_ref, u(2, w(8)), n("clock", uw(1)))
assert not check(mw)
mem_ref = n("m", vec(bdl(a=(uw(8), False)), 10))
mw = DefMemWritePort("mw", mem_ref, n("a", uw(2)), u(0, w(1)))
assert not check(mw)
def test_sub_index_type_wrong():
vc = vec(uw(8), 10)
si = SubIndex(n("vc", vc), 5, sw(8))
assert not check(si)
vc = vec(vec(uw(8), 10), 20)
si = SubIndex(n("vc", vc), 19, vec(uw(8), 20))
assert not check(si)
def test_write_port_mem_wrong():
mem_ref = n("m", bdl(a=(vec(uw(8), 10), False)))
mw = DefMemWritePort("mw", mem_ref, u(2, w(8)), n("clock", ClockType()))
assert not check(mw)
mem_ref = n("m", uw(9))
mw = DefMemWritePort("mw", mem_ref, n("a", uw(2)), n("clock", ClockType()))
assert not check(mw)
def test_init_register_type_not_match():
r1 = DefInitRegister("r1", uw(8), n("clock", ClockType()), n("r", uw(1)),
s(5, w(8)))
assert not check(r1)
r2 = DefInitRegister("r2", uw(8), n("clock", ClockType()), u(0, w(1)),
s(5, w(8)))
assert not check(r2)
def test_sub_index_over_bound():
vc = vec(uw(8), 10)
si = SubIndex(n("vc", vc), 10, uw(8))
assert not check(si)
vc = vec(vec(uw(8), 10), 20)
si = SubIndex(n("vc", vc), -1, vec(uw(8), 10))
assert not check(si)
def test_register_basis():
r1 = DefRegister("r1", uw(8), n("clock", ClockType()))
assert check(r1)
serialize_stmt_equal(r1, 'reg r1 : UInt<8>, clock')
r2 = DefRegister("r2", vec(uw(8), 10), n("clock", ClockType()))
assert check(r2)
serialize_stmt_equal(r2, 'reg r2 : UInt<8>[10], clock')
def test_wire_basis():
wire = DefWire("w1", uw(8))
assert check(wire)
serialize_stmt_equal(wire, 'wire w1 : UInt<8>')
wire = DefWire("w2", bdl(a=(uw(8), True), b=(sw(8), False)))
assert check(wire)
serialize_stmt_equal(wire, 'wire w2 : {flip a : UInt<8>, b : SInt<8>}')
def test_sub_field_type_wrong():
bd = bdl(a=(uw(8), False), b=(sw(8), False))
sf = SubField(n("bd", bd), "a", sw(8))
assert not check(sf)
bd = bdl(a=(bdl(c=(uw(8), True)), False), b=(sw(8), False))
sf = SubField(n("bd", bd), "a", bdl(c=(uw(9), True)))
assert not check(sf)
def test_sub_field_non_exist():
bd = bdl(a=(uw(8), False), b=(sw(8), False))
sf = SubField(n("bd", bd), "c", uw(8))
assert not check(sf)
bd = bdl(a=(bdl(c=(uw(8), True)), False), b=(sw(8), False))
sf = SubField(n("bd", bd), "c", bdl(c=(uw(8), True)))
assert not check(sf)
def test_sub_access_idx_non_uint():
vc = vec(uw(8), 10)
sa = SubAccess(n("vc", vc), s(2, w(3)), uw(8))
assert not check(sa)
vc = vec(uw(8), 10)
sa = SubAccess(n("vc", vc), n("a", sw(8)), uw(8))
assert not check(sa)
def test_init_register_reset_wrong():
r1 = DefInitRegister("r1", uw(8), n("clock", ClockType()), n("r", sw(1)),
u(5, w(8)))
assert not check(r1)
r2 = DefInitRegister("r2", sw(8), n("clock", ClockType()), s(0, w(1)),
s(5, w(8)))
assert not check(r2)
def test_write_port_index_wrong():
mem_ref = n("m", vec(uw(8), 10))
mw = DefMemWritePort("mw", mem_ref, s(2, w(8)), n("clock", ClockType()))
assert not check(mw)
mem_ref = n("m", vec(bdl(a=(uw(8), False)), 10))
mw = DefMemWritePort("mw", mem_ref, n("a", vec(uw(1), 10)),
n("clock", ClockType()))
assert not check(mw)
def test_read_port_index_wrong():
mem_ref = n("m", vec(uw(8), 10))
mr = DefMemReadPort("mr", mem_ref, s(2, w(8)), n("clock", ClockType()))
assert not check(mr)
mem_ref = n("m", vec(bdl(a=(uw(8), False)), 10))
mr = DefMemReadPort("mr", mem_ref, n("a", vec(uw(1), 10)),
n("clock", ClockType()))
assert not check(mr)
def test_mux_tf_value_type_wrong():
mux = Mux(n("c", uw(1)), n("a", uw(7)), n("b", uw(8)), uw(8))
assert not check(mux)
mux = Mux(n("c", uw(1)), n("a", uw(8)), n("b", sw(8)), uw(8))
assert not check(mux)
mux = Mux(n("c", uw(1)), n("a", uw(8)), n("b", uw(8)), sw(8))
assert not check(mux)
def test_mux_basis():
mux = Mux(n("c", uw(1)), n("a", uw(8)), n("b", uw(8)), uw(8))
assert check(mux)
serialize_equal(mux, "mux(c, a, b)")
mux = Mux(u(1, w(1)), n("b", vec(sw(8), 10)), n("c", vec(sw(8), 10)),
vec(sw(8), 10))
assert check(mux)
serialize_equal(mux, 'mux(UInt<1>("h1"), b, c)')
def test_mux_cond_type_wrong():
mux = Mux(n("c", uw(2)), n("a", uw(8)), n("b", uw(8)), uw(8))
assert not check(mux)
mux = Mux(n("c", sw(1)), n("a", uw(8)), n("b", uw(8)), uw(8))
assert not check(mux)
mux = Mux(n("c", vec(uw(1), 1)), n("a", uw(8)), n("b", uw(8)), uw(8))
assert not check(mux)
def test_sub_index_basis():
vc = vec(uw(8), 10)
si = SubIndex(n("vc", vc), 5, uw(8))
assert check(si)
serialize_equal(si, "vc[5]")
vc = vec(vec(uw(8), 10), 20)
si = SubIndex(n("vc", vc), 19, vec(uw(8), 10))
assert check(si)
serialize_equal(si, "vc[19]")
def test_sub_field_basis():
bd = bdl(a=(uw(8), False), b=(sw(8), False))
sf = SubField(n("bd", bd), "a", uw(8))
assert check(sf)
serialize_equal(sf, "bd.a")
bd = bdl(a=(bdl(c=(uw(8), True)), False), b=(sw(8), False))
sf = SubField(n("bd", bd), "a", bdl(c=(uw(8), True)))
assert check(sf)
serialize_equal(sf, "bd.a")
def test_read_port_basis():
mem_ref = n("m", vec(uw(8), 10))
mr = DefMemReadPort("mr", mem_ref, u(2, w(8)), n("clock", ClockType()))
assert check(mr)
serialize_stmt_equal(mr, 'read mport mr = m[UInt<8>("h2")], clock')
mem_ref = n("m", vec(bdl(a=(uw(8), False)), 10))
mr = DefMemReadPort("mr", mem_ref, n("a", uw(2)), n("clock", ClockType()))
assert check(mr)
serialize_stmt_equal(mr, 'read mport mr = m[a], clock')
def test_sub_access_basis():
vc = vec(uw(8), 10)
sa = SubAccess(n("vc", vc), u(2, w(3)), uw(8))
assert check(sa)
serialize_equal(sa, 'vc[UInt<3>("h2")]')
vc = vec(uw(8), 10)
sa = SubAccess(n("vc", vc), n("a", uw(8)), uw(8))
assert check(sa)
serialize_equal(sa, 'vc[a]')
def test_write_port_basis():
mem_ref = n("m", vec(uw(8), 10))
mw = DefMemWritePort("mw", mem_ref, u(2, w(8)), n("clock", ClockType()))
assert check(mw)
serialize_stmt_equal(mw, 'write mport mw = m[UInt<8>("h2")], clock')
mem_ref = n("m", vec(bdl(a=(uw(8), False)), 10))
mw = DefMemWritePort("mw", mem_ref, n("a", uw(2)), n("clock", ClockType()))
assert check(mw)
serialize_stmt_equal(mw, 'write mport mw = m[a], clock')
def test_connect_type_wrong():
cn = Connect(n("a", uw(8)), n("b", sw(8)))
assert not check(cn)
cn = Connect(n("a", sw(8)), n("b", uw(8)))
assert not check(cn)
cn = Connect(n("a", uw(8)), s(20, w(8)))
assert not check(cn)
cn = Connect(n("a", sw(8)), n(-20, w(8)))
assert not check(cn)
def test_conditionally_type_wrong():
s1 = EmptyStmt()
s2 = Connect(n("a", uw(8)), n("b", uw(8)))
cn = Conditionally(n("a", sw(1)), s1, s2)
assert not check(cn)
s1 = Block([
Connect(n("a", uw(8)), n("b", uw(8))),
Connect(n("c", sw(8)), n("d", sw(8))),
])
s2 = EmptyStmt()
cn = Conditionally(u(1, w(2)), s1, s2)
assert not check(cn)
def test_init_register_basis():
r1 = DefInitRegister("r1", uw(8), n("clock", ClockType()), n("r", uw(1)),
u(5, w(8)))
assert check(r1)
serialize_stmt_equal(
r1, 'reg r1 : UInt<8>, clock with :\n'
' reset => (r, UInt<8>("h5"))')
r2 = DefInitRegister("r2", sw(8), n("clock", ClockType()), u(0, w(1)),
s(5, w(8)))
assert check(r2)
serialize_stmt_equal(
r2, 'reg r2 : SInt<8>, clock with :\n'
' reset => (UInt<1>("h0"), SInt<8>("h5"))')
def test_block_basis():
blk = Block([EmptyStmt()])
assert check(blk)
serialize_stmt_equal(blk, "skip")
blk = Block([DefNode("n", u(1, w(1))),
Conditionally(n("n", uw(1)),
EmptyStmt(),
Connect(n("a", uw(8)), n("b", uw(8))))
])
assert check(blk)
serialize_stmt_equal(blk, 'node n = UInt<1>("h1")\n'
'when n :\n'
' skip\n'
'else :\n'
' a <= b')
