def expect(self, port, value):
"""
Expect the current value of `port` to be `value`
"""
if not isinstance(value, (actions.Peek, PortWrapper, LoopIndex)):
value = make_value(port, value)
self.actions.append(actions.Expect(port, value))
def expect(self, port, value, strict=None, **kwargs):
"""
Expect the current value of `port` to be `value`
"""
def recurse(port):
if isinstance(value, dict):
for k, v in value.items():
self.expect(getattr(port, k), v)
else:
for p, v in zip(port, value):
self.expect(p, v, strict, **kwargs)
if self.is_recursive_type(port):
recurse(port)
elif isinstance(port, SelectPath) and \
(self.is_recursive_type(port[-1])):
recurse(port[-1])
else:
# set defaults
if strict is None:
strict = self.expect_strict_default
# implement expect
if not isinstance(
value,
(actions.Peek, PortWrapper, LoopIndex, expression.Expression)):
value = make_value(port, value)
self.actions.append(actions.Expect(port, value, **kwargs))
def poke(self, port, value, delay=None):
"""
Set `port` to be `value`
"""
# set defaults
if delay is None:
delay = self.poke_delay_default
def recurse(port):
if isinstance(value, dict):
for k, v in value.items():
self.poke(getattr(port, k), v)
else:
for p, v in zip(port, value):
self.poke(p, v, delay)
# implement poke
if self.is_recursive_type(port):
recurse(port)
elif isinstance(port, SelectPath) and \
(self.is_recursive_type(port[-1])):
recurse(port[-1])
else:
if not isinstance(
value,
(LoopIndex, actions.FileRead, expression.Expression)):
value = make_value(port, value)
self.actions.append(actions.Poke(port, value, delay=delay))
def expect(self, port, value):
"""
Expect the current value of `port` to be `value`
"""
is_peek = isinstance(value, actions.Peek)
is_port_wrapper = isinstance(value, PortWrapper)
if not (is_peek or is_port_wrapper):
value = make_value(port, value)
self.actions.append(actions.Expect(port, value))
def poke(self, port, value):
"""
Set `port` to be `value`
"""
if isinstance(port, m.TupleType):
for p, v in zip(port, value):
self.poke(p, v)
else:
value = make_value(port, value)
self.actions.append(actions.Poke(port, value))
def poke(self, port, value):
"""
Set `port` to be `value`
"""
if isinstance(port, m.TupleType):
for p, v in zip(port, value):
self.poke(p, v)
else:
if not isinstance(value, (LoopIndex, actions.FileRead)):
value = make_value(port, value)
self.actions.append(actions.Poke(port, value))
def _expect(self, port, value, strict=None, caller=None, **kwargs):
# implement expect
if not isinstance(value, (actions.Peek, PortWrapper, actions.FileRead,
LoopIndex, expression.Expression)):
type_ = get_port_type(port)
value = make_value(type_, value)
self.actions.append(
actions.Expect(port=port,
value=value,
strict=strict,
caller=caller,
**kwargs))
def __eval(self):
self.vectors.append(self.vectors[-1].copy())
for port in self.circuit.interface.ports.values():
if port.is_input():
index = self.port_to_index[port]
self.vectors[-1][index] = make_value(type(port), AnyValue)
def __empty_vector(self):
ports = self.circuit.interface.ports
return [make_value(type(port), AnyValue) for port in ports.values()]
def test_all():
# Bit type.
assert make_value(type(Foo.a), BitVector[1](0)) == BitVector[1](0)
assert make_value(type(Foo.a), 0) == BitVector[1](0)
assert make_value(type(Foo.a), 1) == BitVector[1](1)
assert make_value(type(Foo.a), AnyValue) == AnyValue
assert make_value(type(Foo.a), UnknownValue) == UnknownValue
with pytest.raises(NotImplementedError) as pytest_e:
make_value(type(Foo.a), 2)
assert False
assert pytest_e.type == NotImplementedError
# NOTE(rsetaluri): For the following 3 tests we use arbitray values as input
# into the bit-vectors. The tests should pass for any number.
# Bits type.
assert make_value(type(Foo.b), BitVector[8](5)) == BitVector[8](5)
assert make_value(type(Foo.b), 17) == BitVector[8](17)
assert make_value(type(Foo.b), AnyValue) == AnyValue
assert make_value(type(Foo.b), UnknownValue) == UnknownValue
# Array(Bit) type. Should be the same as above.
assert make_value(type(Foo.c), BitVector[12](83)) == BitVector[12](83)
assert make_value(type(Foo.c), 23) == BitVector[12](23)
assert make_value(type(Foo.c), AnyValue) == AnyValue
assert make_value(type(Foo.c), UnknownValue) == UnknownValue
# Array(Array(Bit)) type.
assert make_value(type(Foo.d), 894) == Array([BitVector[20](894)] * 16, 16)
assert make_value(type(Foo.d), AnyValue) == Array([AnyValue] * 16, 16)
assert make_value(type(Foo.d), UnknownValue) == \
Array([UnknownValue] * 16, 16)
def test_all():
# Bit type.
assert make_value(Foo.a, BitVector(0, 1)) == BitVector(0, 1)
assert make_value(Foo.a, 0) == BitVector(0, 1)
assert make_value(Foo.a, 1) == BitVector(1, 1)
assert make_value(Foo.a, AnyValue) == AnyValue
assert make_value(Foo.a, UnknownValue) == UnknownValue
with pytest.raises(NotImplementedError) as pytest_e:
make_value(Foo.a, 2)
assert False
assert pytest_e.type == NotImplementedError
# NOTE(rsetaluri): For the following 3 tests we use arbitray values as input
# into the bit-vectors. The tests should pass for any number.
# Bits type.
assert make_value(Foo.b, BitVector(5, 8)) == BitVector(5, 8)
assert make_value(Foo.b, 17) == BitVector(17, 8)
assert make_value(Foo.b, AnyValue) == AnyValue
assert make_value(Foo.b, UnknownValue) == UnknownValue
# Array(Bit) type. Should be the same as above.
assert make_value(Foo.c, BitVector(83, 12)) == BitVector(83, 12)
assert make_value(Foo.c, 23) == BitVector(23, 12)
assert make_value(Foo.c, AnyValue) == AnyValue
assert make_value(Foo.c, UnknownValue) == UnknownValue
# Array(Array(Bit)) type.
assert make_value(Foo.d, 894) == Array([BitVector(894, 20)] * 16, 16)
assert make_value(Foo.d, AnyValue) == Array([AnyValue] * 16, 16)
assert make_value(Foo.d, UnknownValue) == Array([UnknownValue] * 16, 16)
def _poke(self, port, value, delay=None):
if not isinstance(
value, (LoopIndex, actions.FileRead, expression.Expression)):
type_ = get_port_type(port)
value = make_value(type_, value)
self.actions.append(actions.Poke(port, value, delay=delay))
def poke(self, port, value):
"""
Set `port` to be `value`
"""
value = make_value(port, value)
self.actions.append(actions.Poke(port, value))