def test_br_3(self): vm.flags = 0b010 # Zero vm.mem[0] = 0b0000011000001010 # BRpz 10 vm.mem[4] = 0b1111000000100101 # HALT (TRAP 0x25) vm.mem[11] = 0b1111000000100101 # HALT (TRAP 0x25) vm.run() self.assertTrue(vm.pc == 12)
def test_add(self): vm.reg[2] = 23 vm.reg[4] = 90 vm.reg[7] = 4 vm.mem[0] = 0b0001111010000100 # ADD R7, R2, R4 vm.run() self.assertTrue(vm.reg[7] == (23+90))
def test_and(self): vm.reg[0] = 0b1010111001101010 vm.reg[1] = 0b0111010111011100 vm.mem[0] = 0b0101011000000001 # AND R3, R0, R1 vm.run() self.assertTrue(vm.reg[3] == 0b0010010001001000)
def test_br_1(self): vm.flags = 0b001 # Positive vm.mem[0] = 0b0000001000001010 # BRp 10 vm.mem[4] = 0b1111000000100101 # HALT (TRAP 0x25) vm.mem[11] = 0b1111000000100101 # HALT (TRAP 0x25) vm.run() self.assertTrue(vm.pc == 12)
def test_br_2(self): vm.flags = 0b000 # No Flags Set vm.mem[0] = 0b0000001000001010 # BRp 10 vm.mem[4] = 0b1111000000100101 # HALT (TRAP 0x25) vm.mem[11] = 0b1111000000100101 # HALT (TRAP 0x25) vm.run() self.assertTrue(vm.pc == 5)
def test_jmp(self): vm.reg[3] = 7 vm.mem[0] = 0b1100000011000000 # JMP R3 vm.mem[4] = 0b1111000000100101 # HALT (TRAP 0x25) vm.mem[7] = 0b1111000000100101 # HALT (TRAP 0x25) vm.run() self.assertTrue(vm.pc == 8)
def test_jsr(self): vm.reg[7] = 0b100 vm.mem[20] = 0b0100100000101000 # JSR #40 vm.mem[61] = 0b1111000000100101 # HALT (TRAP 0x25) vm.run() self.assertTrue(vm.pc == 62) self.assertTrue(vm.reg[7] == 21)
def test_st(self): vm.reg[6] = -9000 & 0xFFFF vm.mem[4] = 0b0011110000011001 # ST R6, #25 vm.mem[5] = 0b1111000000100101 # HALT (TRAP 0x25) vm.run() self.assertTrue(vm.mem[30] == (-9000 & 0xFFFF))
def test_str(self): vm.reg[3] = -20 & 0xFFFF vm.reg[5] = 0 vm.mem[20] = 0b0111101011011001 # STR R5, R3, #25 vm.run() self.assertTrue(vm.mem[5] == 0)
def test_and_setcc(self): vm.reg[1] = 0b1010111001101010 vm.mem[1] = 0b0101011001110010 # AND R3, R1, #-14 vm.run() f = BitField(vm.flags, 3) self.assertTrue(f[0] == 0) # Positive self.assertTrue(f[1] == 0) # Zero self.assertTrue(f[2] == 1) # Negative
def test_br_4(self): vm.mem[0] = 0b0001000000111011 # ADD R0, R0, #-5 vm.mem[1] = 0b0000100000001010 # BRn 10 vm.mem[4] = 0b1111000000100101 # HALT (TRAP 0x25) vm.mem[12] = 0b1111000000100101 # HALT (TRAP 0x25) vm.run() self.assertTrue(vm.pc == 13)
def test_jsrr(self): vm.reg[4] = 42 vm.reg[7] = 0b100 vm.mem[20] = 0b0100000100000000 # JSRR R4 vm.mem[63] = 0b1111000000100101 # HALT (TRAP 0x25) vm.run() self.assertTrue(vm.pc == 64) self.assertTrue(vm.reg[7] == 21)
def test_not(self): vm.flags = 0b000 vm.reg[4] = 0b0111111111001110 vm.mem[0] = 0b1001010100111111 # NOT R2, R4 vm.run() self.assertTrue(vm.reg[2] == 0b1000000000110001) self.assertTrue(vm.flags == 0b100) # Negative
def test_ld(self): vm.flags = 0b000 vm.mem[4] = -400 & 0xFFFF vm.mem[0] = 0b0100100000100111 # JSR #39 vm.mem[40] = 0b0010011111011011 # LD R3, -37 vm.run() self.assertTrue(vm.reg[3] == (-400 & 0xFFFF)) self.assertTrue(vm.flags == 0b100) # Negative
def test_add_setcc(self): vm.reg[0] = 44 vm.reg[1] = 56 vm.mem[0] = 0b0001101000000001 # ADD R5, R0, R1 vm.run() f = BitField(vm.flags, 3) self.assertTrue(f[0] == 1) # Positive self.assertTrue(f[1] == 0) # Zero self.assertTrue(f[2] == 0) # Negative
def test_add_immediate(self): vm.reg[0] = 44 vm.mem[0] = 0b0001100000101111 # ADD R4, R0, #15 vm.reg[1] = -23 & 0xFFFF vm.mem[1] = 0b0001101001110000 # ADD R5, R1, #-16 vm.run() self.assertTrue(vm.reg[4] == (44 + 15)) self.assertTrue(vm.reg[5] == ((-23 - 16) & 0xFFFF))
def test_lea(self): vm.flags = 0b000 vm.mem[0] = 0b1110010011100110 # LEA R2, #230 vm.mem[4] = 0b1110001100000001 # LEA R1, #-255 vm.run() self.assertTrue(vm.reg[2] == 231) self.assertTrue(vm.reg[1] == ((5 - 255) & 0xFFFF)) self.assertTrue(vm.flags == 0b100) # Negative
def test_and_immediate(self): vm.reg[0] = 0b1010111001101010 vm.mem[0] = 0b0101010000100111 # AND R2, R0, #7 vm.reg[1] = 0b1010111001101010 vm.mem[1] = 0b0101011001110010 # AND R3, R1, #-14 vm.run() self.assertTrue(vm.reg[2] == 0b0000000000000010) self.assertTrue(vm.reg[3] == 0b1010111001100010)
def test_sti(self): vm.mem[5] = 40 vm.reg[7] = 80 vm.mem[0] = 0b0000111000010011 # BRnzp #19 vm.mem[20] = 0b1011111111110000 # STI R7, #-16 vm.mem[21] = 0b1111000000100101 # HALT (TRAP 0x25) vm.run() self.assertTrue(vm.mem[40] == 80)
def test_ldr(self): vm.flags = 0b000 vm.mem[80] = 0 vm.reg[5] = 65 vm.mem[0] = 0b0110001101001111 # LDR R1, R5, #15 vm.mem[2] = 0b1111000000100101 # HALT (TRAP 0x25) vm.run() self.assertTrue(vm.reg[1] == 0) self.assertTrue(vm.flags == 0b010) # Zero
def test_ldi(self): vm.flags = 0b000 vm.mem[70] = 80 vm.mem[80] = -20 & 0xFFFF vm.mem[0] = 0b1010100001000101 # LDI R4, 69 vm.mem[20] = 0b1111000000100101 # HALT (TRAP 0x25) vm.run() self.assertTrue(vm.reg[4] == (-20 & 0xFFFF)) self.assertTrue(vm.flags == 0b100) # Negative
def test_add_negative(self): vm.reg[2] = -23 & 0xFFFF vm.reg[4] = 10 vm.reg[7] = 10 vm.mem[0] = 0b0001111010000100 # ADD R7, R2, R4 vm.reg[0] = -99 & 0xFFFF vm.reg[3] = -2 & 0xFFFF vm.mem[1] = 0b0001101000000011 # ADD R5, R0, R3 vm.run() self.assertTrue(vm.reg[7] == ((-23+10) & 0xFFFF)) self.assertTrue(vm.reg[5] == ((-99-2) & 0xFFFF))
def test_trap_0x21_out(self): capture = StringIO() save_stdout = sys.stdout sys.stdout = capture vm.reg[0] = ord('J') vm.mem[0] = 0b1111000000100001 # TRAP 0x21 (OUT) vm.mem[1] = 0b0001000000100001 # ADD R0, R0, #1 vm.mem[2] = 0b1111000000100001 # TRAP 0x21 (OUT) vm.run() sys.stdout = save_stdout self.assertTrue(capture.getvalue() == "JK")
def createVm(self, vmParams, vmRecover=False): with self.vmContainerLock: self.log.info("vmContainerLock acquired by vm %s", vmParams['vmId']) try: if not vmRecover: if vmParams['vmId'] in self.vmContainer: self.log.warning('vm %s already exists' % vmParams['vmId']) return errCode['exist'] vm = Vm(self, vmParams, vmRecover) self.vmContainer[vmParams['vmId']] = vm finally: container_len = len(self.vmContainer) vm.run() self.log.debug("Total desktops after creation of %s is %d" % (vmParams['vmId'], container_len)) return {'status': doneCode, 'vmList': vm.status()}
def createVm(self, vmParams): with self.vmContainerLock: self.log.info("vmContainerLock acquired by vm %s", vmParams['vmId']) try: if 'recover' not in vmParams: if vmParams['vmId'] in self.vmContainer: self.log.warning('vm %s already exists' % vmParams['vmId']) return errCode['exist'] vm = Vm(self, vmParams) self.vmContainer[vmParams['vmId']] = vm finally: container_len = len(self.vmContainer) vm.run() self.log.debug("Total desktops after creation of %s is %d" % (vmParams['vmId'], container_len)) return {'status': doneCode, 'vmList': vm.status()}
def test_trap_0x24_putsp(self): capture = StringIO() save_stdout = sys.stdout sys.stdout = capture vm.mem[10] = ord('A') + (ord('p') << 8) vm.mem[11] = ord('p') + (ord('l') << 8) vm.mem[12] = ord('e') vm.mem[13] = 0x0 vm.mem[14] = ord('A') + (ord('p') << 8) vm.mem[15] = ord('p') + (ord('l') << 8) vm.mem[16] = ord('e') + (ord('s') << 8) vm.mem[17] = 0x0 vm.mem[0] = 0b1110000000001001 # LEA R0, #9 vm.mem[1] = 0b1111000000100100 # TRAP 0x24 (PUTSP) vm.mem[2] = 0b1110000000001011 # LEA R0, #11 vm.mem[3] = 0b1111000000100100 # TRAP 0x23 (PUTSP) vm.mem[4] = 0b1111000000100101 # HALT (TRAP 0x25) vm.run() sys.stdout = save_stdout self.assertTrue(capture.getvalue()[:12] == "Apple\0Apples")
# Print x GLOAD, 1, PRINT, PUSH, 32, OUTCHAR, # Increment x GLOAD, 1, PUSH, 1, ADD, GSTORE, 1, # Jump to start of loop JMP, 8, HALT, ] if __name__ == '__main__': run(POWER_OF_TWO) print() run(HELLO_WORLD) print() run(LOOP)
(vm.IMM, 3, i.a.type.offset), (vm.ADD, 3, i.a.type.basereg), (vm.LOAD, 4, 3), (vm.PRNT, 4, 0) ] return code if __name__ == '__main__': code = generate( *il_gen.generate( Parser().parse(''' _add = func(a, b) { reflect = func(x) { print x y = x + 5 return y - 5 } return reflect(a) + reflect(b) } add = func(f, a, b) { return f(a, b) } print add(_add, 18, 37) ''', lexer=Lexer()) ) ) #print code vm.run(code)
def test_initial_change_should_be_zero(): assert "잔액은 0원입니다" == run("잔액")
def run(s): out = cStringIO.StringIO() vm.run(vm_gen.generate(*il_gen.generate(Parser().parse(s, lexer=Lexer()))), out) r = out.getvalue() del out return r
tmp = a[i] a[i] = a[j] a[j] = tmp i = i + 1 j = j - 1 end end if i < r then qsort(a, i, r) end if l < j then qsort(a, l, j) end return a end print("Hello, Lua!") print(fibonacci(16)) -- test function call items({a=1, b=2, c=3}) -- test table c1 = newCounter() c2 = newCounter() print(c1(), c1(), c2(), c1(), c2()) -- test closure print(max(1, 100, max(1000, 10))) local a = {1,4,7,2,5,8,3,6,9} -- test qsort qsort(a, 1, #a) print(a) ''' run(code)
def test_unknown_command(): init() assert "알 수 없는 명령입니다" == run("웅앵")
def test_accumulation_of_change(): init() run("동전 100") run("동전 100") assert "잔액은 200원입니다" == run("잔액")
import argparse from parser import parse from prettyprinter import prettyprint from translater import translate from vm import HammyVM, init, run parser = argparse.ArgumentParser(description='Hammy interpreter') parser.add_argument('-p', '--prettyprint', action='store_true') parser.add_argument('-d', '--decompile', action='store_true') parser.add_argument('-t', '--trace', action='store_true') parser.add_argument('file', nargs='?') args = parser.parse_args() if args.file: src = open(args.file).read() else: src = sys.stdin.read() vm = HammyVM() init(vm) ast = parse(src) if ast is not None: if args.prettyprint: print 'Parsed code:' print(prettyprint(ast)) print if args.decompile: print 'Bytecode:' func = translate(ast, args.decompile) run(vm, func, args.trace)
def test_insert_coin_and_check(): init() assert "100원을 넣었습니다" == run("동전 100") assert "잔액은 100원입니다" == run("잔액")