class UpdateTestCase(unittest.TestCase):
def setUp(self):
self.stream = Mock()
self.emulator = Emulator(self.stream, 43, 80)
def test_no_message(self):
# Arrange
self.stream.read_multiple = Mock(return_value=[])
# Act and assert
self.assertFalse(self.emulator.update())
def test_write(self):
# Arrange
self.stream.read_multiple = Mock(return_value=[
bytes.fromhex(
'01 c3 11 4b f0 1d f8 c8 c5 d3 d3 d6 40 e6 d6 d9 d3 c4')
])
# Act and assert
self.assertTrue(self.emulator.update())
self.assertIsInstance(self.emulator.cells[752], AttributeCell)
self.assertEqual(self.emulator.get_bytes(753, 763),
bytes.fromhex('c8 c5 d3 d3 d6 40 e6 d6 d9 d3 c4'))
def test_write_wrap(self):
# Arrange
self.stream.read_multiple = Mock(return_value=[
bytes.fromhex('01 c3 11 07 7c c1 c2 c3 c4 c5 c6 c7 c8')
])
# Act and assert
self.assertTrue(self.emulator.update())
self.assertEqual(self.emulator.get_bytes(0, 3),
bytes.fromhex('c5 c6 c7 c8'))
self.assertEqual(self.emulator.get_bytes(1916, 1919),
bytes.fromhex('c1 c2 c3 c4'))
def test_write_alarm(self):
# Arrange
self.emulator.alarm = Mock()
self.stream.read_multiple = Mock(return_value=[bytes.fromhex('01 c7')])
# Act
self.emulator.update()
# Assert
self.emulator.alarm.assert_called()
def test_read_buffer(self):
# Arrange
self.stream.read_multiple = Mock(
side_effect=[[SCREEN1], [bytes.fromhex('02')]])
self.emulator.update()
self.emulator.cursor_address = 505
for character in 'ABCDEFGHIJ'.encode('cp500'):
self.emulator.input(character)
self.assertEqual(self.emulator.cursor_address, 525)
self.emulator.aid(AID.ENTER)
self.stream.write.reset_mock()
# Act
self.emulator.update()
# Assert
self.stream.write.assert_called()
bytes_ = self.stream.write.mock_calls[0][1][0]
self.assertEqual(bytes_[:3], bytes.fromhex('7dc84d'))
self.assertEqual(
bytes_[3:944],
bytes.fromhex(
'e2d6d4c5e3c8c9d5c740c9d540e3c8c540c6c9d9e2e340d9d6e60000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000007e7e7e7e7e7e7e7e7e7e7e7e7e7e7e7e7e7e7e7e7e7e7e7e7e7e7e7e7e7e7e7e7e7e7e7e7e7e7e7e7e7e7e7e7e7e7e7e7e7e7e7e7e7e7e7e7e7e7e7e7e7e7e7e7e7e7e7e7e7e7e7e7e7e7e7e7e7e7e7e000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000d5d6d9d4c1d30000000000000000000000000000c9d5e3c5d5e2c500000000000000000000000000c8c9c4c4c5d50000000000000000000000000000d7d9d6e3c5c3e3c5c4000000000000000000001d60e7e7e7e7e7e7e7e7e7e70000000000000000001de8e7e7e7e7e7e7e7e7e7e70000000000000000001d6ce7e7e7e7e7e7e7e7e7e71d60000000000000000000e4d5d7d9d6e3c5c3e3c5c400000000000000001d410000000000c1c2c3c4c51df000000000000000001dc9c6c7c8c9d100000000001df000000000000000001d4c000000000000000000001df0000000000000000000d5e4d4c5d9c9c30000000000000000000000001d50000000000000000000001df000000000000000001dd8000000000000000000001df000000000000000001d5c000000000000000000001df0000000000000000000d7d9c5c6c9d3d3c5c4000000000000000000001d40e7e7e7e7e700000000001df000000000000000001dc8e7e7e7e7e700000000001df000000000000000001d4ce7e7e7e7e700000000001df0000000000000000000d4d6c4c9c6c9c5c400000000000000000000001dc1e7e7e7e7e700000000001df000000000000000001dc9e7e7e7e7e700000000001df000000000000000001d4de7e7e7e7e700000000001df00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000d5d640e2d2c9d70000000000000000000000001d40000000000000000000001d60'
))
self.assertTrue(all([byte == 0x00 for byte in bytes_[944:]]))
def test_nop(self):
# Arrange
self.stream.read_multiple = Mock(return_value=[bytes.fromhex('03')])
# Act
self.emulator.update()
def test_erase_write_screen1(self):
# Arrange
self.stream.read_multiple = Mock(return_value=[SCREEN1])
# Act
self.emulator.update()
# Assert
self.assertFalse(self.emulator.alternate)
self.assertEqual(self.emulator.cursor_address, 504)
fields = self.emulator.get_fields()
self.assertEqual(len(fields), 13)
self.assertEqual(fields[0][0], 500)
self.assertEqual(fields[0][1], 509)
self.assertFalse(fields[0][2].protected)
self.assertFalse(fields[0][2].numeric)
self.assertFalse(fields[0][2].intensified)
self.assertFalse(fields[0][2].hidden)
self.assertFalse(fields[0][2].modified)
self.assertEqual(fields[1][0], 520)
self.assertEqual(fields[1][1], 529)
self.assertFalse(fields[1][2].protected)
self.assertFalse(fields[1][2].numeric)
self.assertTrue(fields[1][2].intensified)
self.assertFalse(fields[1][2].hidden)
self.assertFalse(fields[1][2].modified)
self.assertEqual(fields[2][0], 540)
self.assertEqual(fields[2][1], 549)
self.assertFalse(fields[2][2].protected)
self.assertFalse(fields[2][2].numeric)
self.assertFalse(fields[2][2].intensified)
self.assertTrue(fields[2][2].hidden)
self.assertFalse(fields[2][2].modified)
self.assertEqual(fields[3][0], 580)
self.assertEqual(fields[3][1], 589)
self.assertFalse(fields[3][2].protected)
self.assertTrue(fields[3][2].numeric)
self.assertFalse(fields[3][2].intensified)
self.assertFalse(fields[3][2].hidden)
self.assertFalse(fields[3][2].modified)
self.assertEqual(fields[4][0], 600)
self.assertEqual(fields[4][1], 609)
self.assertFalse(fields[4][2].protected)
self.assertTrue(fields[4][2].numeric)
self.assertTrue(fields[4][2].intensified)
self.assertFalse(fields[4][2].hidden)
self.assertFalse(fields[4][2].modified)
self.assertEqual(fields[5][0], 620)
self.assertEqual(fields[5][1], 629)
self.assertFalse(fields[5][2].protected)
self.assertTrue(fields[5][2].numeric)
self.assertFalse(fields[5][2].intensified)
self.assertTrue(fields[5][2].hidden)
self.assertFalse(fields[5][2].modified)
self.assertEqual(fields[6][0], 660)
self.assertEqual(fields[6][1], 669)
self.assertEqual(fields[7][0], 680)
self.assertEqual(fields[7][1], 689)
self.assertEqual(fields[8][0], 700)
self.assertEqual(fields[8][1], 709)
self.assertEqual(fields[9][0], 740)
self.assertEqual(fields[9][1], 749)
self.assertFalse(fields[9][2].protected)
self.assertFalse(fields[9][2].numeric)
self.assertFalse(fields[9][2].intensified)
self.assertFalse(fields[9][2].hidden)
self.assertTrue(fields[9][2].modified)
self.assertEqual(fields[10][0], 760)
self.assertEqual(fields[10][1], 769)
self.assertFalse(fields[10][2].protected)
self.assertFalse(fields[10][2].numeric)
self.assertTrue(fields[10][2].intensified)
self.assertFalse(fields[10][2].hidden)
self.assertTrue(fields[11][2].modified)
self.assertEqual(fields[11][0], 780)
self.assertEqual(fields[11][1], 789)
self.assertFalse(fields[11][2].protected)
self.assertFalse(fields[11][2].numeric)
self.assertFalse(fields[11][2].intensified)
self.assertTrue(fields[11][2].hidden)
self.assertTrue(fields[11][2].modified)
self.assertEqual(fields[12][0], 900)
self.assertEqual(fields[12][1], 909)
def test_erase_write_screen2(self):
# Arrange
self.stream.read_multiple = Mock(return_value=[SCREEN2])
# Act
self.emulator.update()
# Assert
self.assertFalse(self.emulator.alternate)
fields = self.emulator.get_fields()
self.assertEqual(len(fields), 1)
self.assertEqual(fields[0][0], 1899)
self.assertEqual(fields[0][1], 20)
self.assertFalse(fields[0][2].protected)
self.assertFalse(fields[0][2].numeric)
self.assertFalse(fields[0][2].intensified)
self.assertFalse(fields[0][2].hidden)
self.assertFalse(fields[0][2].modified)
def test_read_modified(self):
# Arrange
self.stream.read_multiple = Mock(
side_effect=[[SCREEN1], [bytes.fromhex('06')]])
self.emulator.update()
self.emulator.cursor_address = 505
for character in 'ABCDEFGHIJ'.encode('cp500'):
self.emulator.input(character)
self.assertEqual(self.emulator.cursor_address, 525)
self.emulator.aid(AID.ENTER)
self.stream.write.reset_mock()
# Act
self.emulator.update()
# Assert
self.stream.write.assert_called_with(
bytes.fromhex(
'7dc84d11c7f4c1c2c3c4c511c8c8c6c7c8c9d1114be4e7e7e7e7e7114bf8e7e7e7e7e7114c4ce7e7e7e7e7'
))
def test_erase_write_alternate_screen1(self):
# Arrange
self.stream.read_multiple = Mock(
return_value=[bytes([0x0d, *SCREEN1[1:]])])
# Act
self.emulator.update()
# Assert
self.assertTrue(self.emulator.alternate)
fields = self.emulator.get_fields()
self.assertEqual(len(fields), 13)
def test_read_modified_all(self):
# Arrange
self.stream.read_multiple = Mock(
side_effect=[[SCREEN1], [bytes.fromhex('0e')]])
self.emulator.update()
self.emulator.cursor_address = 505
for character in 'ABCDEFGHIJ'.encode('cp500'):
self.emulator.input(character)
self.assertEqual(self.emulator.cursor_address, 525)
self.emulator.aid(AID.PA1)
self.stream.write.reset_mock()
# Act
self.emulator.update()
# Assert
self.stream.write.assert_called_with(
bytes.fromhex(
'6cc84d11c7f4c1c2c3c4c511c8c8c6c7c8c9d1114be4e7e7e7e7e7114bf8e7e7e7e7e7114c4ce7e7e7e7e7'
))
def test_erase_all_unprotected(self):
# Arrange
self.stream.read_multiple = Mock(
side_effect=[[SCREEN1], [bytes.fromhex('0f')]])
self.emulator.update()
self.emulator.cursor_address = 505
for character in 'ABCDEFGHIJ'.encode('cp500'):
self.emulator.input(character)
self.emulator.current_aid = AID.ENTER
self.emulator.keyboard_locked = True
self.assertEqual(self.emulator.cursor_address, 525)
fields = self.emulator.get_fields()
self.assertTrue(fields[0][2].modified)
self.assertEqual(self.emulator.get_bytes(fields[0][0], fields[0][1]),
bytes.fromhex('0000000000c1c2c3c4c5'))
self.assertTrue(fields[1][2].modified)
self.assertEqual(self.emulator.get_bytes(fields[1][0], fields[1][1]),
bytes.fromhex('c6c7c8c9d10000000000'))
# Act
self.emulator.update()
# Assert
fields = self.emulator.get_fields()
self.assertFalse(fields[0][2].modified)
self.assertEqual(self.emulator.get_bytes(fields[0][0], fields[0][1]),
bytes.fromhex('00000000000000000000'))
self.assertFalse(fields[1][2].modified)
self.assertEqual(self.emulator.get_bytes(fields[1][0], fields[1][1]),
bytes.fromhex('00000000000000000000'))
self.assertEqual(self.emulator.current_aid, AID.NONE)
self.assertFalse(self.emulator.keyboard_locked)
def test_write_structured_field_read_partition_query(self):
# Arrange
self.stream.read_multiple = Mock(
return_value=[bytes.fromhex('11 00 05 01 ff 02')])
# Act
self.emulator.update()
# Assert
self.stream.write.assert_called_with(
bytes.fromhex(
'88 00 0b 81 80 80 81 84 86 87 88 a6 00 17 81 81 01 00 00 50 00 2b 01 00 0a 02 e5 00 02 00 6f 09 0c 0d 70 00 08 81 84 01 0d 70 00 00 16 81 86 00 08 00 f4 f1 f1 f2 f2 f3 f3 f4 f4 f5 f5 f6 f6 f7 f7 00 0d 81 87 04 00 f0 f1 f1 f2 f2 f4 f4 00 06 81 88 00 01 00 11 81 a6 00 00 0b 01 00 00 50 00 18 00 50 00 2b'
))
class AidTestCase(unittest.TestCase):
def setUp(self):
self.stream = Mock()
self.stream.write = Mock()
self.emulator = Emulator(self.stream, 24, 80)
def test_screen1_short_read(self):
# Arrange
self.stream.read_multiple = Mock(return_value=[SCREEN1])
self.emulator.update()
self.emulator.cursor_address = 500
for character in 'ABCDEFGHIJKLMNO'.encode('cp500'):
self.emulator.input(character)
self.assertEqual(self.emulator.cursor_address, 525)
# Act
self.emulator.aid(AID.PA1)
# Assert
self.stream.write.assert_called_with(bytes.fromhex('6c'))
def test_screen1_long_read(self):
# Arrange
self.stream.read_multiple = Mock(return_value=[SCREEN1])
self.emulator.update()
self.emulator.cursor_address = 505
for character in 'ABCDEFGHIJ'.encode('cp500'):
self.emulator.input(character)
self.assertEqual(self.emulator.cursor_address, 525)
# Act
self.emulator.aid(AID.ENTER)
# Assert
self.stream.write.assert_called_with(
bytes.fromhex(
'7dc84d11c7f4c1c2c3c4c511c8c8c6c7c8c9d1114be4e7e7e7e7e7114bf8e7e7e7e7e7114c4ce7e7e7e7e7'
))
def test_screen2_long_read(self):
# Arrange
self.stream.read_multiple = Mock(return_value=[SCREEN2])
self.emulator.update()
self.emulator.cursor_address = 0
for character in (string.ascii_uppercase +
string.ascii_lowercase).encode('cp500'):
self.emulator.input(character)
self.assertEqual(self.emulator.cursor_address, 10)
# Act
self.emulator.aid(AID.ENTER)
# Assert
self.stream.write.assert_called_with(
bytes.fromhex(
'7d404a115d6be5e6e7e8e9818283848586878889919293949596979899a2a3a4a5a6a7a8a9d2d3d4d5d6d7d8d9e2e3e4'
))
def test_clear(self):
# Arrange
self.stream.read_multiple = Mock(return_value=[SCREEN1])
self.emulator.update()
self.emulator.cursor_address = 505
for character in 'ABCDEFGHIJ'.encode('cp500'):
self.emulator.input(character)
self.assertEqual(self.emulator.cursor_address, 525)
# Act
self.emulator.aid(AID.CLEAR)
# Assert
self.stream.write.assert_called_with(bytes.fromhex('6d'))
self.assertEqual(self.emulator.address, 0)
self.assertTrue(
all([
isinstance(cell, CharacterCell) and cell.byte == 0x00
for cell in self.emulator.cells
]))
self.assertEqual(self.emulator.cursor_address, 0)
class UpdateTestCase(unittest.TestCase):
def setUp(self):
self.stream = Mock()
self.emulator = Emulator(self.stream, 24, 80)
def test_no_message(self):
# Arrange
self.stream.read = Mock(return_value=None)
# Act and assert
self.assertFalse(self.emulator.update())
def test_write(self):
# Arrange
self.stream.read = Mock(return_value=bytes.fromhex(
'01 c3 11 4b f0 1d f8 c8 c5 d3 d3 d6 40 e6 d6 d9 d3 c4'))
# Act and assert
self.assertTrue(self.emulator.update())
self.assertIsInstance(self.emulator.cells[752], AttributeCell)
self.assertEqual(self.emulator.get_bytes(753, 763),
bytes.fromhex('c8 c5 d3 d3 d6 40 e6 d6 d9 d3 c4'))
def test_write_alarm(self):
# Arrange
self.emulator.alarm = Mock()
self.stream.read = Mock(return_value=bytes.fromhex('01 c7'))
# Act
self.emulator.update()
# Assert
self.emulator.alarm.assert_called()
def test_read_buffer(self):
# Arrange
self.stream.read = Mock(side_effect=[SCREEN1, bytes.fromhex('02')])
self.emulator.update()
self.emulator.cursor_address = 505
for character in 'ABCDEFGHIJ'.encode('cp500'):
self.emulator.input(character)
self.assertEqual(self.emulator.cursor_address, 525)
self.emulator.aid(AID.ENTER)
self.stream.write.reset_mock()
# Act
self.emulator.update()
# Assert
self.stream.write.assert_called()
bytes_ = self.stream.write.mock_calls[0][1][0]
self.assertEqual(bytes_[:3], bytes.fromhex('7d020d'))
self.assertEqual(
bytes_[3:944],
bytes.fromhex(
'e2d6d4c5e3c8c9d5c740c9d540e3c8c540c6c9d9e2e340d9d6e60000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000007e7e7e7e7e7e7e7e7e7e7e7e7e7e7e7e7e7e7e7e7e7e7e7e7e7e7e7e7e7e7e7e7e7e7e7e7e7e7e7e7e7e7e7e7e7e7e7e7e7e7e7e7e7e7e7e7e7e7e7e7e7e7e7e7e7e7e7e7e7e7e7e7e7e7e7e7e7e7e7e000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000d5d6d9d4c1d30000000000000000000000000000c9d5e3c5d5e2c500000000000000000000000000c8c9c4c4c5d50000000000000000000000000000d7d9d6e3c5c3e3c5c4000000000000000000001d60e7e7e7e7e7e7e7e7e7e70000000000000000001de8e7e7e7e7e7e7e7e7e7e70000000000000000001d6ce7e7e7e7e7e7e7e7e7e71d60000000000000000000e4d5d7d9d6e3c5c3e3c5c400000000000000001d400000000000c1c2c3c4c51df000000000000000001dc8c6c7c8c9d100000000001df000000000000000001d4c000000000000000000001df0000000000000000000d5e4d4c5d9c9c30000000000000000000000001d50000000000000000000001df000000000000000001dd8000000000000000000001df000000000000000001d5c000000000000000000001df0000000000000000000d7d9c5c6c9d3d3c5c4000000000000000000001d40e7e7e7e7e700000000001df000000000000000001dc8e7e7e7e7e700000000001df000000000000000001d4ce7e7e7e7e700000000001df0000000000000000000d4d6c4c9c6c9c5c400000000000000000000001dc1e7e7e7e7e700000000001df000000000000000001dc9e7e7e7e7e700000000001df000000000000000001d4de7e7e7e7e700000000001df00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000d5d640e2d2c9d70000000000000000000000001d40000000000000000000001d60'
))
self.assertTrue(all([byte == 0x00 for byte in bytes_[944:]]))
def test_nop(self):
# Arrange
self.stream.read = Mock(return_value=bytes.fromhex('03'))
# Act
self.emulator.update()
def test_erase_write_screen1(self):
# Arrange
self.stream.read = Mock(return_value=SCREEN1)
# Act
self.emulator.update()
# Assert
self.assertEqual(self.emulator.cursor_address, 504)
fields = self.emulator.get_fields()
self.assertEqual(len(fields), 13)
self.assertEqual(fields[0][0], 500)
self.assertEqual(fields[0][1], 509)
self.assertFalse(fields[0][2].protected)
self.assertFalse(fields[0][2].numeric)
self.assertFalse(fields[0][2].intensified)
self.assertFalse(fields[0][2].hidden)
self.assertFalse(fields[0][2].modified)
self.assertEqual(fields[1][0], 520)
self.assertEqual(fields[1][1], 529)
self.assertFalse(fields[1][2].protected)
self.assertFalse(fields[1][2].numeric)
self.assertTrue(fields[1][2].intensified)
self.assertFalse(fields[1][2].hidden)
self.assertFalse(fields[1][2].modified)
self.assertEqual(fields[2][0], 540)
self.assertEqual(fields[2][1], 549)
self.assertFalse(fields[2][2].protected)
self.assertFalse(fields[2][2].numeric)
self.assertFalse(fields[2][2].intensified)
self.assertTrue(fields[2][2].hidden)
self.assertFalse(fields[2][2].modified)
self.assertEqual(fields[3][0], 580)
self.assertEqual(fields[3][1], 589)
self.assertFalse(fields[3][2].protected)
self.assertTrue(fields[3][2].numeric)
self.assertFalse(fields[3][2].intensified)
self.assertFalse(fields[3][2].hidden)
self.assertFalse(fields[3][2].modified)
self.assertEqual(fields[4][0], 600)
self.assertEqual(fields[4][1], 609)
self.assertFalse(fields[4][2].protected)
self.assertTrue(fields[4][2].numeric)
self.assertTrue(fields[4][2].intensified)
self.assertFalse(fields[4][2].hidden)
self.assertFalse(fields[4][2].modified)
self.assertEqual(fields[5][0], 620)
self.assertEqual(fields[5][1], 629)
self.assertFalse(fields[5][2].protected)
self.assertTrue(fields[5][2].numeric)
self.assertFalse(fields[5][2].intensified)
self.assertTrue(fields[5][2].hidden)
self.assertFalse(fields[5][2].modified)
self.assertEqual(fields[6][0], 660)
self.assertEqual(fields[6][1], 669)
self.assertEqual(fields[7][0], 680)
self.assertEqual(fields[7][1], 689)
self.assertEqual(fields[8][0], 700)
self.assertEqual(fields[8][1], 709)
self.assertEqual(fields[9][0], 740)
self.assertEqual(fields[9][1], 749)
self.assertFalse(fields[9][2].protected)
self.assertFalse(fields[9][2].numeric)
self.assertFalse(fields[9][2].intensified)
self.assertFalse(fields[9][2].hidden)
self.assertTrue(fields[9][2].modified)
self.assertEqual(fields[10][0], 760)
self.assertEqual(fields[10][1], 769)
self.assertFalse(fields[10][2].protected)
self.assertFalse(fields[10][2].numeric)
self.assertTrue(fields[10][2].intensified)
self.assertFalse(fields[10][2].hidden)
self.assertTrue(fields[11][2].modified)
self.assertEqual(fields[11][0], 780)
self.assertEqual(fields[11][1], 789)
self.assertFalse(fields[11][2].protected)
self.assertFalse(fields[11][2].numeric)
self.assertFalse(fields[11][2].intensified)
self.assertTrue(fields[11][2].hidden)
self.assertTrue(fields[11][2].modified)
self.assertEqual(fields[12][0], 900)
self.assertEqual(fields[12][1], 909)
def test_erase_write_screen2(self):
# Arrange
self.stream.read = Mock(return_value=SCREEN2)
# Act
self.emulator.update()
# Assert
fields = self.emulator.get_fields()
self.assertEqual(len(fields), 1)
self.assertEqual(fields[0][0], 1899)
self.assertEqual(fields[0][1], 20)
self.assertFalse(fields[0][2].protected)
self.assertFalse(fields[0][2].numeric)
self.assertFalse(fields[0][2].intensified)
self.assertFalse(fields[0][2].hidden)
self.assertFalse(fields[0][2].modified)
def test_read_modified(self):
# Arrange
self.stream.read = Mock(side_effect=[SCREEN1, bytes.fromhex('06')])
self.emulator.update()
self.emulator.cursor_address = 505
for character in 'ABCDEFGHIJ'.encode('cp500'):
self.emulator.input(character)
self.assertEqual(self.emulator.cursor_address, 525)
self.emulator.aid(AID.ENTER)
self.stream.write.reset_mock()
# Act
self.emulator.update()
# Assert
self.stream.write.assert_called_with(
bytes.fromhex(
'7d020d1101f4c1c2c3c4c5110208c6c7c8c9d11102e4e7e7e7e7e71102f8e7e7e7e7e711030ce7e7e7e7e7'
))
def test_erase_write_alternate(self):
# Arrange
self.stream.read = Mock(return_value=bytes.fromhex('0d'))
# Act and assert
with self.assertRaises(NotImplementedError):
self.emulator.update()
def test_read_modified_all(self):
# Arrange
self.stream.read = Mock(side_effect=[SCREEN1, bytes.fromhex('0e')])
self.emulator.update()
self.emulator.cursor_address = 505
for character in 'ABCDEFGHIJ'.encode('cp500'):
self.emulator.input(character)
self.assertEqual(self.emulator.cursor_address, 525)
self.emulator.aid(AID.PA1)
self.stream.write.reset_mock()
# Act
self.emulator.update()
# Assert
self.stream.write.assert_called_with(
bytes.fromhex(
'6c020d1101f4c1c2c3c4c5110208c6c7c8c9d11102e4e7e7e7e7e71102f8e7e7e7e7e711030ce7e7e7e7e7'
))
def test_erase_all_unprotected(self):
# Arrange
self.stream.read = Mock(side_effect=[SCREEN1, bytes.fromhex('0f')])
self.emulator.update()
self.emulator.cursor_address = 505
for character in 'ABCDEFGHIJ'.encode('cp500'):
self.emulator.input(character)
self.emulator.current_aid = AID.ENTER
self.emulator.keyboard_locked = True
self.assertEqual(self.emulator.cursor_address, 525)
fields = self.emulator.get_fields()
self.assertTrue(fields[0][2].modified)
self.assertEqual(self.emulator.get_bytes(fields[0][0], fields[0][1]),
bytes.fromhex('0000000000c1c2c3c4c5'))
self.assertTrue(fields[1][2].modified)
self.assertEqual(self.emulator.get_bytes(fields[1][0], fields[1][1]),
bytes.fromhex('c6c7c8c9d10000000000'))
# Act
self.emulator.update()
# Assert
fields = self.emulator.get_fields()
self.assertFalse(fields[0][2].modified)
self.assertEqual(self.emulator.get_bytes(fields[0][0], fields[0][1]),
bytes.fromhex('00000000000000000000'))
self.assertFalse(fields[1][2].modified)
self.assertEqual(self.emulator.get_bytes(fields[1][0], fields[1][1]),
bytes.fromhex('00000000000000000000'))
self.assertEqual(self.emulator.current_aid, AID.NONE)
self.assertFalse(self.emulator.keyboard_locked)
def test_write_structured_field(self):
# Arrange
self.stream.read = Mock(return_value=bytes.fromhex('11'))
# Act and assert
with self.assertRaises(NotImplementedError):
self.emulator.update()
