def test_zword_bitwise_operations():
zw = ZWord.from_unsigned_int(0b1010_1010_1010_1010) << 1
assert zw.unsigned_int == 0b0101_0101_0101_0100
zw = ZWord.from_unsigned_int(0b0000_1111_0000_1111) << 4
assert zw.unsigned_int == 0b1111_0000_1111_0000
zw = ZWord.from_unsigned_int(0b0000_1111_1111_0000) >> 4
assert zw.unsigned_int == 0b0000_0000_1111_1111
zw = ZWord.from_unsigned_int(0b0001_0000) >> 1
assert zw.unsigned_int == 0b0000_1000
zw = ZWord.from_unsigned_int(0b1111_1111) & 0b0101_0101
assert zw.unsigned_int == 0b0101_0101
zw = ZWord.from_unsigned_int(0b1111_0000) | 0b0000_1111
assert zw.bytes == b'\x00\xff'
zw = ~ZWord.from_unsigned_int(0b0101_0101)
assert zw.unsigned_int == 0b1111_1111_1010_1010
zw = ~ZWord.from_unsigned_int(0b0000_1111)
assert zw.unsigned_int == 0b1111_1111_1111_0000
zw = ZWord.from_unsigned_int(0b1111_0000_1111_0000)
assert zw.is_bit_set(15) is True
assert zw.is_bit_set(0) is False
assert zw.is_bit_set(4) is True
assert zw.is_bit_clear(15) is False
assert zw.is_bit_clear(0) is True
assert zw.is_bit_clear(4) is False
assert ZWord.from_int(-1) == ZWord(b'\xff\xff')
assert ZWord.from_int(-1) != ZWord(b'\x00\x00')
def test_instantiate_zword():
zw = ZWord(bytes.fromhex('1234'))
assert zw.bytes == b'\x12\x34', 'Instantiate ZWord from bytes'
zw = ZWord(memoryview(bytes.fromhex('4242')))
assert zw.bytes == b'\x42\x42', 'Instantiate ZWord from memoryview'
zw = ZWord.from_int(-1)
assert zw.bytes == b'\xff\xff', 'Instantiate ZWord from int'
zw = ZWord.from_unsigned_int(0xf0f0)
assert zw.bytes == b'\xf0\xf0', 'Instantiate ZWord from unsigned int'
with pytest.raises(TypeError):
ZWord(22)
with pytest.raises(ValueError):
ZWord(b'\x12')
with pytest.raises(ValueError):
ZWord(b'')
with pytest.raises(ValueError):
ZWord.from_int(-32769)
with pytest.raises(ValueError):
ZWord.from_int(32768)
with pytest.raises(ValueError):
ZWord.from_unsigned_int(-1)
with pytest.raises(ValueError):
ZWord.from_unsigned_int(65536)
def test_stack_quetzal_chunk_with_routine_calls():
new_stack = ZMachineStack()
new_stack.push_routine_call(PC(0x1234), 2, ZByte.from_int(0),
*[ZWord.from_int(1),
ZWord.from_int(2)])
new_stack.push(ZWord.from_int(1955))
new_stack.push(ZWord.from_int(1985))
quetzal_stack = StacksQuetzalChunk.create(new_stack)
restored_stack_chunk, next_chunk = StacksQuetzalChunk.read(
quetzal_stack.bytes())
assert next_chunk == len(quetzal_stack.bytes())
assert restored_stack_chunk.saved_stack(
).frames == new_stack.frames, 'initial stack and saved stack are not the same'
def test_zword_to_zbyte_math():
zw = ZWord.from_int(129) + ZByte.from_int(127)
assert zw.bytes == b'\x01\x00', 'ZWord + ZByte'
zw = ZWord.from_int(0) - ZByte.from_int(127)
assert zw.int == -127, 'ZWord - ZByte'
zw = ZWord.from_int(-4) * ZByte.from_int(64)
assert zw.int == -256, 'ZWord * ZByte'
zw = ZWord.from_int(126) // ZByte.from_int(2)
assert zw.int == 63, 'ZWord/ZByte integer division'
with pytest.raises(ZMachineIllegalOperation, match='Divide by zero'):
ZWord.from_int(45) // ZByte.from_int(0)
with pytest.raises(ZMachineIllegalOperation):
ZWord.from_int(4) / ZByte.from_int(8)
def test_push_peek_and_pop(stack: ZMachineStack):
a = ZWord.from_int(42)
b = ZWord(bytes([0, 69]))
c = ZByte.from_int(-3)
stack.push(a)
stack.push(b)
stack.push(c)
assert stack.peek() == c.pad()
assert stack.pop() == c.pad()
assert stack.peek() == b
assert stack.pop() == b
assert stack.peek() == a
assert stack.pop() == a
def test_set_own_property_v3(zork_v3_obj_table: ZMachineObjectTable):
# Property #16 is a single-byte property
pair_of_hands = zork_v3_obj_table.object(1)
# Set with a single byte
pair_of_hands.properties.set(16, ZByte(b'\x42'))
assert ZByte(b'\x42') == pair_of_hands.properties.value(16), \
'a single byte property is set with a single byte value'
# Set with two bytes
pair_of_hands.properties.set(16, ZWord.from_int(-6))
assert ZByte.from_int(-6) == pair_of_hands.properties.value(16), \
'a single byte property is set with a two byte value'
# Property #18 is a two-byte property
zorkmid = zork_v3_obj_table.object(2)
zorkmid.properties.set(18, ZWord(b'\x12\x34'))
assert ZWord(b'\x12\x34') == zorkmid.properties.value(18)
def test_zbyte_to_zword_math():
zw = ZByte.from_int(0) + ZWord.from_int(256)
assert zw.bytes == b'\x01\x00', 'ZByte + ZWord'
zw = ZByte.from_int(0) - ZWord.from_int(129)
assert zw.int == -129, 'ZByte - ZWord'
zw = ZByte.from_int(-2) * ZWord.from_int(128)
assert zw.int == -256, 'ZByte * ZWord'
zw = ZByte.from_int(126) // ZWord.from_int(2)
assert zw.int == 63, 'ZByte/ZWord integer division'
with pytest.raises(ZMachineIllegalOperation, match='Divide by zero'):
ZByte.from_int(45) // ZWord.from_int(0)
with pytest.raises(ZMachineIllegalOperation):
ZByte.from_int(4) / ZWord.from_int(8)
zw = ZByte.from_int(127) % ZWord.from_int(2)
assert zw.int == 1
zw = ZByte.from_int(-128) % ZWord.from_int(2)
assert zw.int == 0
def test_zword_zword_math():
zw = ZWord.from_int(0) + ZWord.from_int(512)
assert zw.bytes == b'\x02\x00', 'ZWord + ZWord'
zw = ZWord.from_int(0) - ZWord.from_int(1)
assert zw.bytes == b'\xff\xff', 'ZWord - ZWord'
zw = ZWord.from_int(-32768) - ZWord.from_int(1)
assert zw.bytes == b'\x7f\xff', 'ZWord arithmetic truncation'
zw = ZWord.from_int(-2) * ZWord.from_int(8)
assert zw.int == -16, 'ZWord * ZWord'
zw = ZWord.from_int(32767) * ZWord.from_int(32767)
assert zw.bytes == b'\x00\x01', 'ZWord multiplication truncation'
zw = ZWord.from_int(3) // ZWord.from_int(2)
assert zw.bytes == b'\x00\x01', 'ZWord integer division'
with pytest.raises(ZMachineIllegalOperation, match='Divide by zero'):
ZWord.from_int(45) // ZWord.from_int(0)
with pytest.raises(ZMachineIllegalOperation):
ZWord.from_int(4) / ZWord.from_int(8)
zw = ZWord(b'\x00\x01').inc()
assert zw.bytes == b'\x00\x02'
zw = ZWord(b'\xff\xfe').inc()
assert zw.bytes == b'\xff\xff'
zw = ZWord(b'\xff\xff').inc()
assert zw.bytes == b'\x00\x00', 'Rollover on increment'
zw = ZWord.from_int(500).dec()
assert zw.int == 499
zw = ZWord(b'\xff\xff').dec()
assert zw.bytes == b'\xff\xfe'
zw = ZWord(b'\x00\x00').dec()
assert zw.bytes == b'\xff\xff', 'Rollover on decrement'
zw = ZWord.from_int(32767) % ZWord.from_int(2)
assert zw.int == 1
zw = ZWord.from_int(-32768) % ZWord.from_int(2)
assert zw.int == 0
def test_routine_calls(stack: ZMachineStack):
ret_a = PC(1234)
ret_var_a = ZByte.from_int(2)
a_locals = [
ZWord.from_int(1),
ZWord.from_int(2),
ZWord.from_int(3),
ZByte.from_int(4)
]
ret_b = PC(5678)
ret_var_b = ZByte.from_unsigned_int(45)
b_locals = [ZWord.from_int(42), ZWord.from_int(56)]
stack.push_routine_call(ret_a, len(a_locals), ret_var_a, *a_locals)
assert stack.local_var(0) == a_locals[0]
assert stack.local_var(1) == a_locals[1]
assert stack.local_var(2) == a_locals[2]
stack.set_local_var(3, ZWord.from_int(34))
assert stack.local_var(3) == ZWord.from_int(34)
stack.push(ZWord.from_int(69))
stack.push_routine_call(ret_b, len(b_locals), ret_var_b, *b_locals)
assert stack.local_var(0) == b_locals[0]
assert stack.local_var(1) == b_locals[1]
stack.push(ZWord.from_int(342))
ret_pc, ret_var = stack.pop_routine_call()
assert ret_pc == ret_b
assert ret_var == ret_var
# Now ensure the previous call's variables are still correct
assert stack.local_var(0) == a_locals[0]
assert stack.local_var(1) == a_locals[1]
assert stack.local_var(2) == a_locals[2]
assert stack.local_var(3) == ZWord.from_int(34)
assert stack.pop() == ZWord.from_int(69)
ret_pc, ret_var = stack.pop_routine_call()
assert ret_pc == ret_a
assert ret_var == ret_var_a