def test_wrap(self): # Arrange self.stream = Mock() self.emulator = Emulator(self.stream, 24, 80) self.stream.read_multiple = Mock(return_value=[SCREEN2]) self.emulator.update() fields = self.emulator.get_fields() self.assertEqual(len(fields), 1) self.assertEqual(fields[0][0], 1899) self.assertEqual(fields[0][1], 20) self.assertEqual(self.emulator.cursor_address, 0) # Act for character in (string.ascii_uppercase + string.ascii_lowercase).encode('cp500'): self.emulator.input(character) # Assert self.assertEqual(self.emulator.cursor_address, 10) text = self.emulator.get_bytes(fields[0][0], fields[0][1]).decode('cp500') self.assertEqual(text, 'VWXYZabcdefghijklmnopqrstuvwxyzKLMNOPQRSTU')
def setUp(self): self.stream = Mock() self.emulator = Emulator(self.stream, 24, 80) self.stream.read = Mock(return_value=SCREEN1) self.emulator.update()
def setUp(self): self.stream = create_autospec(Telnet, instance=True) self.emulator = Emulator(self.stream, 24, 80) self.stream.read_multiple = Mock(return_value=[SCREEN1]) self.emulator.update()
def setUp(self): self.stream = Mock() self.emulator = Emulator(self.stream, 24, 80) self.stream.read_multiple = Mock(return_value=[SCREEN1]) self.emulator.update()
def setUp(self): self.stream = Mock() self.stream.read = Mock(return_value=SCREEN3) self.emulator = Emulator(self.stream, 24, 80) self.emulator.update() self.emulator.cursor_address = 0
class NewlineTestCase(unittest.TestCase): def setUp(self): self.stream = Mock() self.stream.read_multiple = Mock(return_value=[SCREEN3]) self.emulator = Emulator(self.stream, 24, 80) self.emulator.update() self.emulator.cursor_address = 0 def test_blank_screen(self): # Arrange self.emulator = Emulator(None, 24, 80) self.assertEqual(self.emulator.cursor_address, 0) # Act self.emulator.newline() # Assert self.assertEqual(self.emulator.cursor_address, 0) def test_next_line(self): for address in [0, 1, 20]: with self.subTest(address=address): # Arrange self.emulator.cursor_address = address # Act self.emulator.newline() # Assert self.assertEqual(self.emulator.cursor_address, 80) def test_first_field_on_next_line(self): # Arrange self.emulator.cursor_address = 400 # Act self.emulator.newline() # Assert self.assertEqual(self.emulator.cursor_address, 504) def test_wrap(self): # Arrange self.emulator.cursor_address = 504 # Act self.emulator.newline() # Assert self.assertEqual(self.emulator.cursor_address, 4)
def test_blank_screen(self): # Arrange self.emulator = Emulator(None, 24, 80) self.assertEqual(self.emulator.cursor_address, 0) # Act self.emulator.home() # Assert self.assertEqual(self.emulator.cursor_address, 0)
class HomeTestCase(unittest.TestCase): def setUp(self): self.stream = Mock() self.stream.read_multiple = Mock(return_value=[SCREEN1]) self.emulator = Emulator(self.stream, 24, 80) self.emulator.update() self.emulator.cursor_address = 0 def test_blank_screen(self): # Arrange self.emulator = Emulator(None, 24, 80) self.assertEqual(self.emulator.cursor_address, 0) # Act self.emulator.home() # Assert self.assertEqual(self.emulator.cursor_address, 0) def test(self): for address in [0, 498, 499, 500, 505, 510]: with self.subTest(address=address): # Arrange self.emulator.cursor_address = address # Act self.emulator.home() # Assert self.assertEqual(self.emulator.cursor_address, 500)
class CursorDownTestCase(unittest.TestCase): def setUp(self): self.emulator = Emulator(None, 24, 80) def test_first_row(self): # Arrange self.emulator.cursor_address = 20 # Act self.emulator.cursor_down() # Assert self.assertEqual(self.emulator.cursor_address, 100) def test_last_row(self): # Arrange self.emulator.cursor_address = 1860 # Act self.emulator.cursor_down() # Assert self.assertEqual(self.emulator.cursor_address, 20)
class CursorRightTestCase(unittest.TestCase): def setUp(self): self.emulator = Emulator(None, 24, 80) def test_first_cell(self): # Arrange self.emulator.cursor_address = 0 # Act self.emulator.cursor_right() # Assert self.assertEqual(self.emulator.cursor_address, 1) def test_last_cell(self): # Arrange self.emulator.cursor_address = 1919 # Act self.emulator.cursor_right() # Assert self.assertEqual(self.emulator.cursor_address, 0) def test_fast(self): # Arrange self.emulator.cursor_address = 0 # Act self.emulator.cursor_right(2) # Assert self.assertEqual(self.emulator.cursor_address, 2) def test_invalid_rate(self): for rate in [-1, 0, 3]: with self.subTest(rate=rate): with self.assertRaisesRegex(ValueError, 'Invalid rate'): self.emulator.cursor_right(rate)
class DupTestCase(unittest.TestCase): def setUp(self): self.stream = Mock() self.emulator = Emulator(self.stream, 24, 80) self.stream.read_multiple = Mock(return_value=[SCREEN1]) self.emulator.update() def test_attribute_cell(self): # Arrange self.emulator.cursor_address = 499 # Act and assert with self.assertRaises(ProtectedCellOperatorError): self.emulator.dup() def test_protected_cell(self): # Arrange self.emulator.cursor_address = 420 # Act and assert with self.assertRaises(ProtectedCellOperatorError): self.emulator.dup() def test_first_field_character(self): # Arrange self.emulator.cursor_address = 500 # Act self.emulator.dup() # Assert self.assertEqual(self.emulator.cursor_address, 520) self.assertTrue(self.emulator.cells[499].attribute.modified) self.assertEqual(self.emulator.cells[500].byte, 0x1c)
class IsFormattedTestCase(unittest.TestCase): def setUp(self): self.stream = Mock() self.emulator = Emulator(self.stream, 24, 80) def test_formatted(self): # Arrange self.stream.read_multiple = Mock(return_value=[SCREEN1]) self.emulator.update() # Act and assert self.assertTrue(self.emulator.is_formatted()) def test_unformatted(self): # Arrange self.stream.read_multiple = Mock(return_value=[SCREEN4]) self.emulator.update() # Act and assert self.assertFalse(self.emulator.is_formatted())
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)
def setUp(self): self.stream = create_autospec(Telnet, instance=True) self.stream.write = Mock() self.emulator = Emulator(self.stream, 24, 80)
class InputTestCase(unittest.TestCase): def setUp(self): self.stream = Mock() self.emulator = Emulator(self.stream, 24, 80) self.stream.read_multiple = Mock(return_value=[SCREEN1]) self.emulator.update() def test_attribute_cell(self): # Arrange self.emulator.cursor_address = 499 # Act and assert with self.assertRaises(ProtectedCellOperatorError): self.emulator.input(0xe7) def test_protected_cell(self): # Arrange self.emulator.cursor_address = 420 # Act and assert with self.assertRaises(ProtectedCellOperatorError): self.emulator.input(0xe7) def test_alphanumeric(self): # Arrange self.emulator.cursor_address = 500 self.assertFalse(self.emulator.cells[499].attribute.modified) # Act self.emulator.input(0xe7) # Assert self.assertEqual(self.emulator.cursor_address, 501) self.assertTrue(self.emulator.cells[499].attribute.modified) self.assertEqual(self.emulator.cells[500].byte, 0xe7) def test_skip(self): # Arrange self.emulator.cursor_address = 500 self.assertTrue(self.emulator.cells[510].attribute.skip) # Act for _ in range(10): self.emulator.input(0xe7) # Assert self.assertEqual(self.emulator.cursor_address, 520) def test_no_skip(self): # Arrange self.emulator.cursor_address = 900 self.assertFalse(self.emulator.cells[910].attribute.skip) # Act for _ in range(10): self.emulator.input(0xe7) # Assert self.assertEqual(self.emulator.cursor_address, 911) def test_wrap(self): # Arrange self.stream = Mock() self.emulator = Emulator(self.stream, 24, 80) self.stream.read_multiple = Mock(return_value=[SCREEN2]) self.emulator.update() fields = self.emulator.get_fields() self.assertEqual(len(fields), 1) self.assertEqual(fields[0][0], 1899) self.assertEqual(fields[0][1], 20) self.assertEqual(self.emulator.cursor_address, 0) # Act for character in (string.ascii_uppercase + string.ascii_lowercase).encode('cp500'): self.emulator.input(character) # Assert self.assertEqual(self.emulator.cursor_address, 10) text = self.emulator.get_bytes(fields[0][0], fields[0][1]).decode('cp500') self.assertEqual(text, 'VWXYZabcdefghijklmnopqrstuvwxyzKLMNOPQRSTU') def test_insert(self): # Arrange self.emulator.cursor_address = 500 self.emulator.input(0xc1) self.emulator.input(0xc4) self.emulator.input(0xc5) self.emulator.cursor_address = 504 self.emulator.input(0xc6) self.emulator.input(0xc7) self.emulator.input(0x40) self.emulator.input(0xc8) self.assertEqual(self.emulator.get_bytes(500, 509), bytes.fromhex('c1 c4 c5 00 c6 c7 40 c8 00 00')) self.emulator.cursor_address = 501 # Act self.emulator.input(0xc2, insert=True) self.emulator.input(0xc3, insert=True) # Assert self.assertEqual(self.emulator.cursor_address, 503) self.assertEqual(self.emulator.get_bytes(500, 509), bytes.fromhex('c1 c2 c3 c4 c5 c6 c7 40 c8 00')) def test_insert_overflow(self): # Arrange self.emulator.cursor_address = 505 self.emulator.input(0xc1) self.emulator.input(0xc2) self.emulator.input(0xc3) self.emulator.input(0xc4) self.emulator.input(0xc5) self.emulator.cursor_address = 505 # Act and assert with self.assertRaises(FieldOverflowOperatorError): self.emulator.input(0xc1, insert=True)
def setUp(self): self.emulator = Emulator(None, 24, 80)
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()
class EraseEndOfFieldTestCase(unittest.TestCase): def setUp(self): self.stream = Mock() self.emulator = Emulator(self.stream, 24, 80) self.stream.read_multiple = Mock(return_value=[SCREEN1]) self.emulator.update() def test_attribute_cell(self): # Arrange self.emulator.cursor_address = 499 # Act and assert with self.assertRaises(ProtectedCellOperatorError): self.emulator.erase_end_of_field() def test_protected_cell(self): # Arrange self.emulator.cursor_address = 420 # Act and assert with self.assertRaises(ProtectedCellOperatorError): self.emulator.erase_end_of_field() def test_from_middle(self): # Arrange address = 660 for character in 'ABCDEFGHIJ'.encode('cp500'): self.emulator.cells[address].byte = character address += 1 self.emulator.cursor_address = 665 self.assertFalse(self.emulator.cells[659].attribute.modified) # Act self.emulator.erase_end_of_field() # Assert self.assertEqual(self.emulator.cursor_address, 665) self.assertTrue(self.emulator.cells[659].attribute.modified) self.assertEqual(self.emulator.get_bytes(660, 669), bytes.fromhex('c1c2c3c4c50000000000')) def test_from_start(self): # Arrange address = 660 for character in 'ABCDEFGHIJ'.encode('cp500'): self.emulator.cells[address].byte = character address += 1 self.emulator.cursor_address = 660 self.assertFalse(self.emulator.cells[659].attribute.modified) # Act self.emulator.erase_end_of_field() # Assert self.assertEqual(self.emulator.cursor_address, 660) self.assertTrue(self.emulator.cells[659].attribute.modified) self.assertEqual(self.emulator.get_bytes(660, 669), bytes.fromhex('00000000000000000000'))
def test(self): # Arrange stream = Mock() emulator = Emulator(stream, 24, 80) stream.read_multiple = Mock(return_value=[SCREEN1]) emulator.update() emulator.cursor_address = 505 for character in 'ABCDEFGHIJ'.encode('cp500'): emulator.input(character) fields = emulator.get_fields() self.assertTrue(fields[0][2].modified) self.assertEqual(emulator.get_bytes(fields[0][0], fields[0][1]), bytes.fromhex('0000000000c1c2c3c4c5')) self.assertTrue(fields[1][2].modified) self.assertEqual(emulator.get_bytes(fields[1][0], fields[1][1]), bytes.fromhex('c6c7c8c9d10000000000')) # Act emulator.erase_input() # Assert fields = emulator.get_fields() self.assertFalse(fields[0][2].modified) self.assertEqual(emulator.get_bytes(fields[0][0], fields[0][1]), bytes.fromhex('00000000000000000000')) self.assertFalse(fields[1][2].modified) self.assertEqual(emulator.get_bytes(fields[1][0], fields[1][1]), bytes.fromhex('00000000000000000000'))
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 TabTestCase(unittest.TestCase): def setUp(self): self.stream = Mock() self.stream.read_multiple = Mock(return_value=[SCREEN1]) self.emulator = Emulator(self.stream, 24, 80) self.emulator.update() self.emulator.cursor_address = 0 def test_blank_screen(self): # Arrange self.emulator = Emulator(None, 24, 80) self.assertEqual(self.emulator.cursor_address, 0) # Act self.emulator.tab() # Assert self.assertEqual(self.emulator.cursor_address, 0) def test_forward(self): for address in [0, 498, 499]: with self.subTest(address=address): # Arrange self.emulator.cursor_address = address # Act self.emulator.tab() # Assert self.assertEqual(self.emulator.cursor_address, 500) def test_forward_to_next_field(self): # Arrange self.emulator.cursor_address = 500 # Act self.emulator.tab() # Assert self.assertEqual(self.emulator.cursor_address, 520) def test_backward(self): for address in [520, 519, 510]: with self.subTest(address=address): # Arrange self.emulator.cursor_address = address # Act self.emulator.tab(direction=-1) # Assert self.assertEqual(self.emulator.cursor_address, 500) def test_backward_to_start_of_field(self): # Arrange self.emulator.cursor_address = 505 # Act self.emulator.tab(direction=-1) # Assert self.assertEqual(self.emulator.cursor_address, 500) def test_wrap_forward(self): # Arrange self.emulator.cursor_address = 900 # Act self.emulator.tab() # Assert self.assertEqual(self.emulator.cursor_address, 500) def test_wrap_backward(self): # Arrange self.emulator.cursor_address = 500 # Act self.emulator.tab(direction=-1) # Assert self.assertEqual(self.emulator.cursor_address, 900)
def setUp(self): self.stream = create_autospec(Telnet, instance=True) self.emulator = Emulator(self.stream, 43, 80)
class BackspaceTestCase(unittest.TestCase): def setUp(self): self.stream = Mock() self.emulator = Emulator(self.stream, 24, 80) self.stream.read_multiple = Mock(return_value=[SCREEN1]) self.emulator.update() def test_attribute_cell(self): # Arrange self.emulator.cursor_address = 499 # Act and assert with self.assertRaises(ProtectedCellOperatorError): self.emulator.backspace() def test_protected_cell(self): # Arrange self.emulator.cursor_address = 420 # Act and assert with self.assertRaises(ProtectedCellOperatorError): self.emulator.backspace() def test_first_field_character(self): # Arrange self.emulator.cursor_address = 660 self.assertFalse(self.emulator.cells[659].attribute.modified) # Act self.emulator.backspace() # Assert self.assertEqual(self.emulator.cursor_address, 660) self.assertFalse(self.emulator.cells[659].attribute.modified) self.assertEqual(self.emulator.cells[660].byte, 0xe7) def test_from_middle_to_start(self): # Arrange address = 660 for character in 'ABCDEFGHIJ'.encode('cp500'): self.emulator.cells[address].byte = character address += 1 self.emulator.cursor_address = 665 self.assertFalse(self.emulator.cells[659].attribute.modified) # Act for _ in range(5): self.emulator.backspace() # Assert self.assertEqual(self.emulator.cursor_address, 660) self.assertTrue(self.emulator.cells[659].attribute.modified) self.assertEqual(self.emulator.get_bytes(660, 669), bytes.fromhex('c6c7c8c9d10000000000')) def test_from_end_to_start(self): # Arrange address = 660 for character in 'ABCDEFGHIJ'.encode('cp500'): self.emulator.cells[address].byte = character address += 1 self.emulator.cursor_address = 669 self.assertFalse(self.emulator.cells[659].attribute.modified) # Act for _ in range(10): self.emulator.backspace() # Assert self.assertEqual(self.emulator.cursor_address, 660) self.assertTrue(self.emulator.cells[659].attribute.modified) self.assertEqual(self.emulator.get_bytes(660, 669), bytes.fromhex('d1000000000000000000'))
def setUp(self): self.stream = Mock() self.emulator = Emulator(self.stream, 43, 80)
def setUp(self): self.stream = Mock() self.stream.write = Mock() self.emulator = Emulator(self.stream, 24, 80)
class DeleteTestCase(unittest.TestCase): def setUp(self): self.stream = create_autospec(Telnet, instance=True) self.emulator = Emulator(self.stream, 24, 80) self.stream.read_multiple = Mock(return_value=[SCREEN1]) self.emulator.update() def test_attribute_cell(self): # Arrange self.emulator.cursor_address = 499 # Act and assert with self.assertRaises(ProtectedCellOperatorError): self.emulator.delete() def test_protected_cell(self): # Arrange self.emulator.cursor_address = 420 # Act and assert with self.assertRaises(ProtectedCellOperatorError): self.emulator.delete() def test_from_middle_to_end(self): # Arrange address = 660 for character in 'ABCDEFGHIJ'.encode('ibm037'): self.emulator.cells[address].byte = character address += 1 self.emulator.cursor_address = 665 self.assertFalse(self.emulator.cells[659].attribute.modified) # Act for _ in range(5): self.emulator.delete() # Assert self.assertEqual(self.emulator.cursor_address, 665) self.assertTrue(self.emulator.cells[659].attribute.modified) self.assertEqual(self.emulator.get_bytes(660, 669), bytes.fromhex('c1c2c3c4c50000000000')) def test_from_start_to_end(self): # Arrange address = 660 for character in 'ABCDEFGHIJ'.encode('ibm037'): self.emulator.cells[address].byte = character address += 1 self.emulator.cursor_address = 660 self.assertFalse(self.emulator.cells[659].attribute.modified) # Act for _ in range(10): self.emulator.delete() # Assert self.assertEqual(self.emulator.cursor_address, 660) self.assertTrue(self.emulator.cells[659].attribute.modified) self.assertEqual(self.emulator.get_bytes(660, 669), bytes.fromhex('00000000000000000000'))