def test_to_tuple_from_tuple():
assert RelocatableValue.to_tuple(5) == (5, )
assert RelocatableValue.from_tuple((5, )) == 5
x = RelocatableValue(1, 2)
assert RelocatableValue.to_tuple(x) == (1, 2)
assert RelocatableValue.from_tuple((1, 2)) == x
def extend_additional_data(self,
data,
relocate_callback,
data_is_trusted=True):
for addr, signature in data:
self.signatures[relocate_callback(
RelocatableValue.from_tuple(addr))] = signature
def test_validated_memory_dict():
memory = MemoryDict()
memory_validator = ValidatedMemoryDict(memory=memory)
def rule_identical_pairs(mem, addr):
"""
Validates that the values in address pairs (i, i+1), where i is even, are identical.
"""
offset_diff = (-1) ** (addr.offset % 2)
other_addr = RelocatableValue.from_tuple((addr.segment_index, addr.offset + offset_diff))
if other_addr in mem:
assert mem[addr] == mem[other_addr]
return {addr, other_addr}
return set()
def rule_constant_value(mem, addr, constant):
assert mem[addr] == constant, \
f'Expected value in address {addr} to be {constant}, got {mem[addr]}.'
return {addr}
memory_validator.add_validation_rule(1, lambda memory, addr: set())
memory_validator.add_validation_rule(2, lambda memory, addr: {addr})
memory_validator.add_validation_rule(3, rule_identical_pairs)
memory_validator.add_validation_rule(4, rule_constant_value, 0)
addr0 = RelocatableValue.from_tuple((1, 0))
addr1 = RelocatableValue.from_tuple((2, 0))
addr2 = RelocatableValue.from_tuple((3, 0))
addr3 = RelocatableValue.from_tuple((3, 1))
addr4 = RelocatableValue.from_tuple((4, 0))
# Test validated_addresses update.
memory_validator[addr0] = 0
assert memory_validator._ValidatedMemoryDict__validated_addresses == set()
memory_validator[addr1] = 0
assert memory_validator._ValidatedMemoryDict__validated_addresses == {addr1}
# Test validation rule application.
memory_validator[addr2] = 1
assert memory_validator._ValidatedMemoryDict__validated_addresses == {addr1}
memory_validator[addr3] = 1
assert memory_validator._ValidatedMemoryDict__validated_addresses == {addr1, addr2, addr3}
with pytest.raises(
AssertionError, match='Expected value in address 4:0 to be 0, got 1.'):
memory_validator[addr4] = 1
def rule_identical_pairs(mem, addr):
"""
Validates that the values in address pairs (i, i+1), where i is even, are identical.
"""
offset_diff = (-1) ** (addr.offset % 2)
other_addr = RelocatableValue.from_tuple((addr.segment_index, addr.offset + offset_diff))
if other_addr in mem:
assert mem[addr] == mem[other_addr]
return {addr, other_addr}
return set()
def _deserialize(self, value, attr, data, **kwargs):
return {
RelocatableValue.from_tuple(x): RelocatableValue.from_tuple(y)
for x, y in value
}
def _deserialize(self, value, attr, data, **kwargs):
return RelocatableValue.from_tuple(value)
def extend_additional_data(self, data, relocate_callback, data_is_trusted=True):
if not data_is_trusted:
return
for addr in data:
self.verified_addresses.add(relocate_callback(RelocatableValue.from_tuple(addr)))
def extend_additional_data(self, data, relocate_callback):
for addr in data:
self.verified_addresses.add(
relocate_callback(RelocatableValue.from_tuple(addr)))
