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()