Пример #1
0
    def test_op_relative_base(self):
        """
        Tests the relative base mode op code
        """
        e = ElfCPU()

        # Position
        e.load_string('9,5,204,1,99,6,7,777')
        e.interrupts = True
        # Step over relative mode op
        e.step()
        with self.assertRaises(OutputInterrupt):
            e.execute()
        self.assertEqual(e.output_buffer, 777)

        # Immediate
        e.reset()
        e.load_string('109,5,204,1,99,444,777')
        e.interrupts = True
        # Step over relative mode op
        e.step()
        with self.assertRaises(OutputInterrupt):
            e.execute()
        self.assertEqual(e.output_buffer, 777)

        # Relative
        e.reset()
        e.load_string('209,9,209,6,204,-2,99,5,333,4,6')
        e.interrupts = True
        e.debug = True
        with self.assertRaises(OutputInterrupt):
            e.execute()
        self.assertEqual(e.output_buffer, 333)
Пример #2
0
 def test_halt(self):
     """
     Tests for the halt op code
     """
     e = ElfCPU()
     e.load_string('1,0,0,0,99')
     e.step()
     self.assertFalse(e.is_halted)
     e.step()
     self.assertTrue(e.is_halted)
Пример #3
0
    def test_op_add(self):
        """
        Tests ADD op code
        [dst]:=[a]+[b]
        """
        e = ElfCPU()
        # Invalid address 123456789 for a
        e.load_string('1,123456789,0,0')
        with self.assertRaises(ProtectionFaultError):
            e.step()

        # Invalid address 123456789 for b
        e.load_string('1,0,123456789,0')
        with self.assertRaises(ProtectionFaultError):
            e.step()

        # Invalid address 123456789 for dst
        e.load_string('1,0,0,123456789')
        with self.assertRaises(ProtectionFaultError):
            e.step()

        # 1 + 1 = 2 @ address 0
        e.load_string('1,0,0,0,99')
        e.step()
        self.assertEqual(e.peek(0), 2)

        # 2**64 + 1 = 1 @ address 0 (overflow and wrap)
        #e.load_string('1,5,6,0,99,'+str(2**64)+',1')
        #e.step()
        #self.assertEqual(e.peek(0), 1)

        # [dst]:=a+[b]
        e.load_string('101,44,5,6,99,2,6')
        e.execute()
        self.assertEqual(e.peek(6), 46)

        # [dst]:=[a]+b
        e.load_string('1001,5,50,6,99,2,6')
        e.execute()
        self.assertEqual(e.peek(6), 52)

        # [dst]:=a+b
        e.load_string('1101,5,5,6,99,2,6')
        e.execute()
        self.assertEqual(e.peek(6), 10)

        # [dst]:=r[a]+b
        e.load_string('109,10,1201,0,5,7,99,7,3,3,5')
        e.execute()
        self.assertEqual(e.peek(7), 10)

        # [dst]:=a+r[b]
        e.load_string('109,10,2101,20,0,7,99,7,3,3,10')
        e.execute()
        self.assertEqual(e.peek(7), 30)

        # [dst]:=a+r[b]
        e.load_string('109,10,2101,20,0,7,99,7,3,3,10')
        e.execute()
        self.assertEqual(e.peek(7), 30)

        # r[dst]:=a+b
        e.load_string('109,10,21101,16,16,0,99,7,3,3,7')
        e.execute()
        self.assertEqual(e.peek(10), 32)
Пример #4
0
    def test_op_input(self):
        """
        Tests input op code

        Use unittest.mock.patch to fake the input value
        """
        e = ElfCPU()

        # Interrupts off
        e.load_string('103,3,99,-1')
        e.interrupts = False
        with patch('builtins.input', return_value='1234'):
            e.execute()
            self.assertEqual(e.peek(3), 1234)

        # Interrupts on IMMEDIATE MODE
        e.load_string('103,5,103,5,99,-1')
        e.interrupts = True
        with self.assertRaises(InputInterrupt):
            e.step()

        # Should be back at pc = 0
        self.assertEqual(e.pc, 0)

        # Load input
        e.input_buffer = 567

        # Loading again overflows
        with self.assertRaises(InputOverflow):
            e.input_buffer = 123

        # Execute the input instruction
        e.step()
        self.assertEqual(e.peek(5), 567)

        # Exec next input instruction
        with self.assertRaises(InputInterrupt):
            e.step()

        e.input_buffer = 987

        # Execute until end
        e.execute()
        self.assertEqual(e.peek(5), 987)

        ######################################################
        # Interrupts on RELATIVE MODE
        e.load_string('109,10,203,0,203,1,203,-1,99,102,100,101')
        e.interrupts = True

        # step past the relative base op code
        e.step()

        with self.assertRaises(InputInterrupt):
            e.step()

        # Should be back at pc = 2 (after relative base op code)
        self.assertEqual(e.pc, 2)

        # Load input
        e.input_buffer = 567

        # Loading again overflows
        with self.assertRaises(InputOverflow):
            e.input_buffer = 123

        # Execute the input instruction
        e.step()
        self.assertEqual(e.peek(10), 567)

        # Exec next input instruction
        with self.assertRaises(InputInterrupt):
            e.step()

        e.input_buffer = 987

        # Step to execute this input
        e.step()
        self.assertEqual(e.peek(11), 987)

        # Exec next input instruction
        with self.assertRaises(InputInterrupt):
            e.step()

        e.input_buffer = 456

        # Execute until end
        e.execute()
        self.assertEqual(e.peek(9), 456)

        ######################################################
        # Interrupts on POSITIONAL MODE
        e.load_string('3,7,3,8,3,9,99,1,3,5')
        e.interrupts = True

        with self.assertRaises(InputInterrupt):
            e.step()

        # Should be back at pc = 0
        self.assertEqual(e.pc, 0)

        # Load input
        e.input_buffer = 345

        # Loading again overflows
        with self.assertRaises(InputOverflow):
            e.input_buffer = 123

        # Execute the input instruction
        e.step()
        self.assertEqual(e.peek(7), 345)

        # Exec next input instruction
        with self.assertRaises(InputInterrupt):
            e.step()

        e.input_buffer = 765

        # Step to execute this input
        e.step()
        self.assertEqual(e.peek(8), 765)

        # Exec next input instruction
        with self.assertRaises(InputInterrupt):
            e.step()

        e.input_buffer = 555

        # Execute until end
        e.execute()
        self.assertEqual(e.peek(9), 555)
Пример #5
0
    def test_op_mul(self):
        """
        Tests MUL op code
        [dst]:=[a]*[b]
        """
        e = ElfCPU()
        # Invalid address 123456789 for a
        e.load_string('2,123456789,0,0')
        with self.assertRaises(ProtectionFaultError):
            e.step()

        # Invalid address 123456789 for b
        e.load_string('2,0,123456789,0')
        with self.assertRaises(ProtectionFaultError):
            e.step()

        # Invalid address 123456789 for dst
        e.load_string('2,0,0,123456789')
        with self.assertRaises(ProtectionFaultError):
            e.step()

        # [dst]:=[a]*[b]
        e.load_string('2,0,0,0,99')
        e.step()
        self.assertEqual(e.peek(0), 4)

        # [dst]:=a*[b]
        e.load_string('102,44,5,6,99,2,6')
        e.execute()
        self.assertEqual(e.peek(6), 88)

        # [dst]:=[a]*b
        e.load_string('1002,5,50,6,99,2,6')
        e.execute()
        self.assertEqual(e.peek(6), 100)

        # [dst]:=a*b
        e.load_string('1102,5,5,6,99,2,6')
        e.execute()
        self.assertEqual(e.peek(6), 25)

        # [dst]:=r[a]*b
        e.load_string('109,10,1202,0,4,7,99,7,3,3,4')
        e.execute()
        self.assertEqual(e.peek(7), 16)

        # [dst]:=a*r[b]
        e.load_string('109,10,2102,7,0,7,99,7,3,3,2')
        e.execute()
        self.assertEqual(e.peek(7), 14)

        # [dst]:=r[a]*r[b]
        e.load_string('109,10,2202,0,1,7,99,7,3,3,2,6')
        e.execute()
        self.assertEqual(e.peek(7), 12)

        # dst:=a*b
        e.load_string('11102,6,6,0,99')
        e.execute()
        self.assertEqual(e.peek(0), 36)

        # r[dst]:=a*b
        e.load_string('109,7,21102,8,3,0,99,1')
        e.execute()
        self.assertEqual(e.peek(7), 24)