Esempio n. 1
0
    def test_wmem():
        #wmem
        vm = VirtualMachine()
        sys.stdout = io.StringIO()

        vm.run(bytestr=b'\x10\x00\x04\x00\x05\x00\x00\x00\x05\x00\xef\xbe')
        log.vomit(vm.mem[:10])
        assert (vm.mem[4] == 5)
Esempio n. 2
0
    def test_push():
        # Push
        vm = VirtualMachine()
        sys.stdout = io.StringIO()

        vm.run(bytestr=b'\x02\x00\x04\x00\x00\x00')
        log.vomit(vm.stack)
        assert (vm.stack[0] == 4)
Esempio n. 3
0
    def test_mod():
        # mod
        vm = VirtualMachine()
        sys.stdout = io.StringIO()

        vm.run(bytestr=b'\x0b\x00\x07\x00\x04\x00\x05\x00\x10\x00\x05\x00')
        log.vomit(vm.mem[:10])
        assert (vm.mem[7] == 1)
Esempio n. 4
0
    def test_not():
        # not
        vm = VirtualMachine()
        sys.stdout = io.StringIO()

        vm.run(bytestr=b'\x0e\x00\x04\x00\x04\x00\x00\x00\xff\x00')
        log.vomit(vm.mem[:10])
        assert (vm.mem[4] == 0x7f00)
Esempio n. 5
0
    def test_andb():
        # andb
        vm = VirtualMachine()
        sys.stdout = io.StringIO()

        vm.run(bytestr=b'\x0c\x00\x07\x00\x04\x00\x05\x00\x01\x00\x03\x00')
        log.vomit(vm.mem[:10])
        assert (vm.mem[7] == 1)
Esempio n. 6
0
    def test_mult():
        # mult
        vm = VirtualMachine()
        sys.stdout = io.StringIO()

        vm.run(bytestr=b'\x0a\x00\x07\x00\x04\x00\x05\x00\x05\x00\x05\x00')
        log.vomit(vm.mem[:10])
        assert (vm.mem[7] == 0x19)
Esempio n. 7
0
    def test_add():
        # add
        vm = VirtualMachine()
        sys.stdout = io.StringIO()

        vm.run(bytestr=b'\x09\x00\x07\x00\x04\x00\x05\x00\xcf\x00\x01\x00')
        log.vomit(vm.mem[:10])
        assert (vm.mem[7] == 0xd0)
Esempio n. 8
0
    def test_pop():
        # Pop
        vm = VirtualMachine()
        sys.stdout = io.StringIO()

        vm.run(bytestr=b'\x02\x00\x04\x00\x02\x00\x05\x00\x03\x00')
        log.vomit(vm.stack)
        assert (vm.stack[0] == 4)
        assert (len(vm.stack) == 1)
Esempio n. 9
0
    def test_noop():
        # No halt test
        vm = VirtualMachine()
        sys.stdout = io.StringIO()

        vm.run(bytestr=b'\x15\x00\x15\x00\x15\x00')
        res = sys.stdout.getvalue()
        log.vomit(res)
        assert (res == '')
Esempio n. 10
0
    def test_jmp():
        # jump
        vm = VirtualMachine()
        sys.stdout = io.StringIO()

        vm.run(bytestr=b'\x06\x00\xcf\x00\x01\x00\x06\x00\xff\x00\x00\x00')
        log.vomit(vm.mem[:10])
        assert (vm.mem[6] == 0)
        assert (vm.pc == 0xd0)
Esempio n. 11
0
    def test_in():
        #in
        vm = VirtualMachine()
        sys.stdout = io.StringIO()

        vm.run(
            bytestr=b'\x14\x00\x07\x00\x14\x00\x08\x00\x14\x00\x09\x00\x00\x00'
        )
        log.vomit(vm.mem[:10])
        assert (vm.mem[3] != 0)
Esempio n. 12
0
    def test_ret():
        #ret
        vm = VirtualMachine()
        sys.stdout = io.StringIO()

        vm.run(bytestr=b'\x15\x00\x11\x00\x05\x00\x00\x00\x00\x00\x12\x00')
        log.vomit(vm.pc)
        log.vomit(vm.stack)
        assert (vm.pc == 4)
        assert (vm.stack == [])
Esempio n. 13
0
    def test_orb():
        # or bitwise
        vm = VirtualMachine()
        sys.stdout = io.StringIO()

        vm.run(
            bytestr=b'\x0d\x00\x07\x00\x05\x00\x06\x00\x00\x00\x01\x00\x03\x00'
        )
        log.vomit(vm.mem[:10])
        assert (vm.mem[7] == 3)
Esempio n. 14
0
    def test_call():
        #call
        vm = VirtualMachine()
        sys.stdout = io.StringIO()

        vm.run(bytestr=b'\x15\x00\x11\x00\x20\x00')
        log.vomit(vm.pc)
        log.vomit(vm.stack)
        assert (vm.pc == 0x0021)
        assert (vm.stack == [3])
Esempio n. 15
0
    def test_gt():
        # greater than
        vm = VirtualMachine()
        sys.stdout = io.StringIO()

        vm.run(
            bytestr=b'\x05\x00\x04\x00\x05\x00\x06\x00\x00\x00\x01\x02\x00\x02'
        )
        log.vomit(vm.mem[:10])
        assert (vm.mem[4] == 1)
Esempio n. 16
0
    def test_jf():
        # jump zero
        vm = VirtualMachine()
        sys.stdout = io.StringIO()

        vm.run(
            bytestr=b'\x08\x00\x01\x00\xcf\x00\x01\x00\x07\x00\xff\x00\x00\x00'
        )
        log.vomit(vm.mem[:10])
        assert (vm.mem[7] == 0xff)
        assert (vm.pc == 7)
Esempio n. 17
0
    def test_set():
        # Set registers
        vm = VirtualMachine()
        sys.stdout = io.StringIO()

        vm.run(
            bytestr=b'\x01\x00\x00\x80\x02\x00\x01\x00\x01\x80\x02\x00\x00\x00'
        )
        log.vomit(vm.registers)
        assert (vm.registers[0] == 2)
        assert (vm.registers[1] == 2)
Esempio n. 18
0
    def test_halt():
        # Test writing 5 A's with a halt
        vm = VirtualMachine()

        sys.stdout = io.StringIO()
        vm.run(
            bytestr=
            b'\x13\x00A\x00\x13\x00A\x00\x13\x00A\x00\x13\x00A\x00\x13\x00A\x00\x00\x00'
        )
        res = sys.stdout.getvalue()
        log.vomit(res)
        assert (res == 'AAAAA')
Esempio n. 19
0
    def test_out():
        # Test writing Abc with noops and a halt
        vm = VirtualMachine()

        sys.stdout = io.StringIO()

        vm.run(
            bytestr=
            b'\x13\x00A\x00\x13\x00b\x00\x13\x00c\x00\x15\x00\x15\x00\x15\x00\x00\x00'
        )
        res = sys.stdout.getvalue()
        log.vomit(res)
        assert (res == 'Abc')
Esempio n. 20
0
def run(args):
    vm = VirtualMachine(state_file=args.load, memsize=0x7600)
    signal(SIGINT, sigint(vm))
    vm.run(file=args.file)