Ejemplo n.º 1
0
    def test_value(self):
        operands, opcode_length = parse_operand_buffer([
            _get_opbyte(OpLen.WORD, OpType.VALUE),
            0xFF, 0xFF, 0xFF, 0xFF,
        ], 1)
        self.assertEqual(len(operands), 1)
        self.assertEqual(operands[0].oplen, OpLen.WORD)
        self.assertEqual(operands[0].optype, OpType.VALUE)
        self.assertIsNone(operands[0].opreg)
        self.assertEqual(operands[0].opvalue, 65535)
        self.assertIsNone(operands[0].opbase)
        self.assertIsNone(operands[0].opoffset)
        self.assertEqual(opcode_length, 4)

        operands, opcode_length = parse_operand_buffer([
            _get_opbyte(OpLen.BYTE, OpType.VALUE),
            0xFF, 0xFF, 0xFF, 0xFF,
        ], 1)
        self.assertEqual(len(operands), 1)
        self.assertEqual(operands[0].oplen, OpLen.BYTE)
        self.assertEqual(operands[0].optype, OpType.VALUE)
        self.assertIsNone(operands[0].opreg)
        self.assertEqual(operands[0].opvalue, 255)
        self.assertIsNone(operands[0].opbase)
        self.assertIsNone(operands[0].opoffset)
        self.assertEqual(opcode_length, 3)
Ejemplo n.º 2
0
    def test_value(self):
        operands, operand_buffer_indices, opcode_length = parse_operand_buffer([
            _get_opbyte(OpLen.WORD, OpType.VALUE),
            0xFF, 0xFF, 0xFF, 0xFF,
        ], 1)
        self.assertEqual(len(operands), 1)
        self.assertEqual(operands[0].oplen, OpLen.WORD)
        self.assertEqual(operands[0].optype, OpType.VALUE)
        self.assertIsNone(operands[0].opreg)
        self.assertEqual(operands[0].opvalue, 65535)
        self.assertIsNone(operands[0].opbase)
        self.assertIsNone(operands[0].opoffset)
        self.assertListEqual(operand_buffer_indices, [3])
        self.assertEqual(opcode_length, 4)

        operands, operand_buffer_indices, opcode_length = parse_operand_buffer([
            _get_opbyte(OpLen.BYTE, OpType.VALUE),
            0xFF, 0xFF, 0xFF, 0xFF,
        ], 1)
        self.assertEqual(len(operands), 1)
        self.assertEqual(operands[0].oplen, OpLen.BYTE)
        self.assertEqual(operands[0].optype, OpType.VALUE)
        self.assertIsNone(operands[0].opreg)
        self.assertEqual(operands[0].opvalue, 255)
        self.assertIsNone(operands[0].opbase)
        self.assertIsNone(operands[0].opoffset)
        self.assertListEqual(operand_buffer_indices, [2])
        self.assertEqual(opcode_length, 3)
Ejemplo n.º 3
0
    def test_abs_ref(self):
        operands, opcode_length = parse_operand_buffer([
            _get_opbyte(OpLen.WORD, OpType.ABS_REF_REG, 'BX'),
            0xFF, 0xFF, 0xFF, 0xFF,
        ], 1)
        self.assertEqual(len(operands), 1)
        self.assertEqual(operands[0].oplen, OpLen.WORD)
        self.assertEqual(operands[0].optype, OpType.ABS_REF_REG)
        self.assertEqual(operands[0].opreg, 'BX')
        self.assertIsNone(operands[0].opvalue)
        self.assertIsNone(operands[0].opbase)
        self.assertEqual(operands[0].opoffset, -1)
        self.assertEqual(opcode_length, 3)

        with self.assertRaises(InvalidRegisterCodeError):
            parse_operand_buffer([
                _get_opbyte(OpLen.WORD, OpType.ABS_REF_REG, 'AH'),
                0xFF, 0xFF, 0xFF, 0xFF,
            ], 1)
Ejemplo n.º 4
0
    def test_address(self):
        operands, opcode_length = parse_operand_buffer([
            _get_opbyte(OpLen.WORD, OpType.ADDRESS),
            0xFF, 0xFF, 0xFF, 0xFF,
        ], 1)
        self.assertEqual(len(operands), 1)
        self.assertEqual(operands[0].oplen, OpLen.WORD)
        self.assertEqual(operands[0].optype, OpType.ADDRESS)
        self.assertIsNone(operands[0].opreg)
        self.assertEqual(operands[0].opvalue, -1)
        self.assertIsNone(operands[0].opbase)
        self.assertIsNone(operands[0].opoffset)
        self.assertEqual(opcode_length, 4)

        with self.assertRaises(InvalidOperandError):
            parse_operand_buffer([
                _get_opbyte(OpLen.BYTE, OpType.ADDRESS),
                0xFF, 0xFF, 0xFF, 0xFF,
            ], 1)
Ejemplo n.º 5
0
    def test_rel_ref(self):
        operands, operand_buffer_indices, opcode_length = parse_operand_buffer([
            _get_opbyte(OpLen.WORD, OpType.REL_REF_WORD),
            0xFF, 0xFF, 0xFF, 0xFF,
        ], 1)
        self.assertEqual(len(operands), 1)
        self.assertEqual(operands[0].oplen, OpLen.WORD)
        self.assertEqual(operands[0].optype, OpType.REL_REF_WORD)
        self.assertIsNone(operands[0].opreg)
        self.assertIsNone(operands[0].opvalue)
        self.assertEqual(operands[0].opbase, -1)
        self.assertIsNone(operands[0].opoffset)
        self.assertListEqual(operand_buffer_indices, [3])
        self.assertEqual(opcode_length, 4)

        operands, operand_buffer_indices, opcode_length = parse_operand_buffer([
            _get_opbyte(OpLen.WORD, OpType.REL_REF_WORD_BYTE),
            0xFF, 0xFF, 0xFF, 0xFF,
        ], 1)
        self.assertEqual(len(operands), 1)
        self.assertEqual(operands[0].oplen, OpLen.WORD)
        self.assertEqual(operands[0].optype, OpType.REL_REF_WORD_BYTE)
        self.assertIsNone(operands[0].opreg)
        self.assertIsNone(operands[0].opvalue)
        self.assertEqual(operands[0].opbase, -1)
        self.assertEqual(operands[0].opoffset, 255)
        self.assertListEqual(operand_buffer_indices, [4])
        self.assertEqual(opcode_length, 5)

        operands, operand_buffer_indices, opcode_length = parse_operand_buffer([
            _get_opbyte(OpLen.WORD, OpType.REL_REF_WORD_REG, 'BX'),
            0xFF, 0xFF, 0xFF, 0xFF,
        ], 1)
        self.assertEqual(len(operands), 1)
        self.assertEqual(operands[0].oplen, OpLen.WORD)
        self.assertEqual(operands[0].optype, OpType.REL_REF_WORD_REG)
        self.assertEqual(operands[0].opreg, 'BX')
        self.assertIsNone(operands[0].opvalue)
        self.assertEqual(operands[0].opbase, -1)
        self.assertIsNone(operands[0].opoffset)
        self.assertListEqual(operand_buffer_indices, [3])
        self.assertEqual(opcode_length, 4)
Ejemplo n.º 6
0
    def test_abs_ref(self):
        operands, operand_buffer_indices, opcode_length = parse_operand_buffer([
            _get_opbyte(OpLen.WORD, OpType.ABS_REF_REG, 'BX'),
            0xFF, 0xFF, 0xFF, 0xFF,
        ], 1)
        self.assertEqual(len(operands), 1)
        self.assertEqual(operands[0].oplen, OpLen.WORD)
        self.assertEqual(operands[0].optype, OpType.ABS_REF_REG)
        self.assertEqual(operands[0].opreg, 'BX')
        self.assertIsNone(operands[0].opvalue)
        self.assertIsNone(operands[0].opbase)
        self.assertEqual(operands[0].opoffset, -1)
        self.assertListEqual(operand_buffer_indices, [2])
        self.assertEqual(opcode_length, 3)

        with self.assertRaises(InvalidRegisterCodeError):
            parse_operand_buffer([
                _get_opbyte(OpLen.WORD, OpType.ABS_REF_REG, 'AH'),
                0xFF, 0xFF, 0xFF, 0xFF,
            ], 1)
Ejemplo n.º 7
0
    def test_address(self):
        operands, operand_buffer_indices, opcode_length = parse_operand_buffer([
            _get_opbyte(OpLen.WORD, OpType.ADDRESS),
            0xFF, 0xFF, 0xFF, 0xFF,
        ], 1)
        self.assertEqual(len(operands), 1)
        self.assertEqual(operands[0].oplen, OpLen.WORD)
        self.assertEqual(operands[0].optype, OpType.ADDRESS)
        self.assertIsNone(operands[0].opreg)
        self.assertEqual(operands[0].opvalue, -1)
        self.assertIsNone(operands[0].opbase)
        self.assertIsNone(operands[0].opoffset)
        self.assertListEqual(operand_buffer_indices, [3])
        self.assertEqual(opcode_length, 4)

        with self.assertRaises(InvalidOperandError):
            parse_operand_buffer([
                _get_opbyte(OpLen.BYTE, OpType.ADDRESS),
                0xFF, 0xFF, 0xFF, 0xFF,
            ], 1)
Ejemplo n.º 8
0
    def test_rel_ref(self):
        operands, opcode_length = parse_operand_buffer([
            _get_opbyte(OpLen.WORD, OpType.REL_REF_WORD),
            0xFF, 0xFF, 0xFF, 0xFF,
        ], 1)
        self.assertEqual(len(operands), 1)
        self.assertEqual(operands[0].oplen, OpLen.WORD)
        self.assertEqual(operands[0].optype, OpType.REL_REF_WORD)
        self.assertIsNone(operands[0].opreg)
        self.assertIsNone(operands[0].opvalue)
        self.assertEqual(operands[0].opbase, -1)
        self.assertIsNone(operands[0].opoffset)
        self.assertEqual(opcode_length, 4)

        operands, opcode_length = parse_operand_buffer([
            _get_opbyte(OpLen.WORD, OpType.REL_REF_WORD_BYTE),
            0xFF, 0xFF, 0xFF, 0xFF,
        ], 1)
        self.assertEqual(len(operands), 1)
        self.assertEqual(operands[0].oplen, OpLen.WORD)
        self.assertEqual(operands[0].optype, OpType.REL_REF_WORD_BYTE)
        self.assertIsNone(operands[0].opreg)
        self.assertIsNone(operands[0].opvalue)
        self.assertEqual(operands[0].opbase, -1)
        self.assertEqual(operands[0].opoffset, 255)
        self.assertEqual(opcode_length, 5)

        operands, opcode_length = parse_operand_buffer([
            _get_opbyte(OpLen.WORD, OpType.REL_REF_WORD_REG, 'BX'),
            0xFF, 0xFF, 0xFF, 0xFF,
        ], 1)
        self.assertEqual(len(operands), 1)
        self.assertEqual(operands[0].oplen, OpLen.WORD)
        self.assertEqual(operands[0].optype, OpType.REL_REF_WORD_REG)
        self.assertEqual(operands[0].opreg, 'BX')
        self.assertIsNone(operands[0].opvalue)
        self.assertEqual(operands[0].opbase, -1)
        self.assertIsNone(operands[0].opoffset)
        self.assertEqual(opcode_length, 4)
Ejemplo n.º 9
0
 def test_multiple_operands(self):
     operands, opcode_length = parse_operand_buffer([
         _get_opbyte(OpLen.WORD, OpType.REGISTER, 'BX'),
         _get_opbyte(OpLen.WORD, OpType.VALUE),
         0xFF, 0xFF, 0xFF, 0xFF,
     ], 2)
     self.assertEqual(len(operands), 2)
     self.assertEqual(operands[0].oplen, OpLen.WORD)
     self.assertEqual(operands[0].optype, OpType.REGISTER)
     self.assertEqual(operands[0].opreg, 'BX')
     self.assertIsNone(operands[0].opvalue)
     self.assertIsNone(operands[0].opbase)
     self.assertIsNone(operands[0].opoffset)
     self.assertEqual(operands[1].oplen, OpLen.WORD)
     self.assertEqual(operands[1].optype, OpType.VALUE)
     self.assertIsNone(operands[1].opreg)
     self.assertEqual(operands[1].opvalue, 65535)
     self.assertIsNone(operands[1].opbase)
     self.assertIsNone(operands[1].opoffset)
     self.assertEqual(opcode_length, 5)
Ejemplo n.º 10
0
 def test_multiple_operands(self):
     operands, operand_buffer_indices, opcode_length = parse_operand_buffer([
         _get_opbyte(OpLen.WORD, OpType.REGISTER, 'BX'),
         _get_opbyte(OpLen.WORD, OpType.VALUE),
         0xFF, 0xFF, 0xFF, 0xFF,
     ], 2)
     self.assertEqual(len(operands), 2)
     self.assertEqual(operands[0].oplen, OpLen.WORD)
     self.assertEqual(operands[0].optype, OpType.REGISTER)
     self.assertEqual(operands[0].opreg, 'BX')
     self.assertIsNone(operands[0].opvalue)
     self.assertIsNone(operands[0].opbase)
     self.assertIsNone(operands[0].opoffset)
     self.assertEqual(operands[1].oplen, OpLen.WORD)
     self.assertEqual(operands[1].optype, OpType.VALUE)
     self.assertIsNone(operands[1].opreg)
     self.assertEqual(operands[1].opvalue, 65535)
     self.assertIsNone(operands[1].opbase)
     self.assertIsNone(operands[1].opoffset)
     self.assertListEqual(operand_buffer_indices, [1, 4])
     self.assertEqual(opcode_length, 5)
Ejemplo n.º 11
0
    def test_register(self):
        operands, operand_buffer_indices, opcode_length = parse_operand_buffer([
            _get_opbyte(OpLen.WORD, OpType.REGISTER, 'BX'),
            0xFF, 0xFF, 0xFF, 0xFF,
        ], 1)
        self.assertEqual(len(operands), 1)
        self.assertEqual(operands[0].oplen, OpLen.WORD)
        self.assertEqual(operands[0].optype, OpType.REGISTER)
        self.assertEqual(operands[0].opreg, 'BX')
        self.assertIsNone(operands[0].opvalue)
        self.assertIsNone(operands[0].opbase)
        self.assertIsNone(operands[0].opoffset)
        self.assertListEqual(operand_buffer_indices, [1])
        self.assertEqual(opcode_length, 2)

        operands, operand_buffer_indices, opcode_length = parse_operand_buffer([
            _get_opbyte(OpLen.BYTE, OpType.REGISTER, 'AH'),
            0xFF, 0xFF, 0xFF, 0xFF,
        ], 1)
        self.assertEqual(len(operands), 1)
        self.assertEqual(operands[0].oplen, OpLen.BYTE)
        self.assertEqual(operands[0].optype, OpType.REGISTER)
        self.assertEqual(operands[0].opreg, 'AH')
        self.assertIsNone(operands[0].opvalue)
        self.assertIsNone(operands[0].opbase)
        self.assertIsNone(operands[0].opoffset)
        self.assertListEqual(operand_buffer_indices, [1])
        self.assertEqual(opcode_length, 2)

        with self.assertRaises(InvalidRegisterCodeError):
            parse_operand_buffer([
                _get_opbyte(OpLen.BYTE, OpType.REGISTER, 'BX'),
                0xFF, 0xFF, 0xFF, 0xFF,
            ], 1)
        with self.assertRaises(InvalidRegisterNameError):
            parse_operand_buffer([
                _get_opbyte(OpLen.WORD, OpType.REGISTER, 'XX'),
                0xFF, 0xFF, 0xFF, 0xFF,
            ], 1)
Ejemplo n.º 12
0
    def test_register(self):
        operands, opcode_length = parse_operand_buffer([
            _get_opbyte(OpLen.WORD, OpType.REGISTER, 'BX'),
            0xFF, 0xFF, 0xFF, 0xFF,
        ], 1)
        self.assertEqual(len(operands), 1)
        self.assertEqual(operands[0].oplen, OpLen.WORD)
        self.assertEqual(operands[0].optype, OpType.REGISTER)
        self.assertEqual(operands[0].opreg, 'BX')
        self.assertIsNone(operands[0].opvalue)
        self.assertIsNone(operands[0].opbase)
        self.assertIsNone(operands[0].opoffset)
        self.assertEqual(opcode_length, 2)

        operands, opcode_length = parse_operand_buffer([
            _get_opbyte(OpLen.BYTE, OpType.REGISTER, 'AH'),
            0xFF, 0xFF, 0xFF, 0xFF,
        ], 1)
        self.assertEqual(len(operands), 1)
        self.assertEqual(operands[0].oplen, OpLen.BYTE)
        self.assertEqual(operands[0].optype, OpType.REGISTER)
        self.assertEqual(operands[0].opreg, 'AH')
        self.assertIsNone(operands[0].opvalue)
        self.assertIsNone(operands[0].opbase)
        self.assertIsNone(operands[0].opoffset)
        self.assertEqual(opcode_length, 2)

        with self.assertRaises(InvalidRegisterCodeError):
            parse_operand_buffer([
                _get_opbyte(OpLen.BYTE, OpType.REGISTER, 'BX'),
                0xFF, 0xFF, 0xFF, 0xFF,
            ], 1)
        with self.assertRaises(InvalidRegisterNameError):
            parse_operand_buffer([
                _get_opbyte(OpLen.WORD, OpType.REGISTER, 'XX'),
                0xFF, 0xFF, 0xFF, 0xFF,
            ], 1)
Ejemplo n.º 13
0
 def test_not_enough_buffer(self):
     with self.assertRaises(InsufficientOperandBufferError):
         parse_operand_buffer([
             _get_opbyte(OpLen.WORD, OpType.VALUE),
             0xFF,
         ], 1)
Ejemplo n.º 14
0
 def test_not_enough_buffer(self):
     with self.assertRaises(InsufficientOperandBufferError):
         parse_operand_buffer([
             _get_opbyte(OpLen.WORD, OpType.VALUE),
             0xFF,
         ], 1)