infernal-interpreter/tests/tests.py

import os, sys, inspect
import traceback
sys.path.insert(1, os.path.join(sys.path[0], '..'))

import infernal

################################################################################

tests = []

def add_test(name, result, register, code):
    tests.append((name, result, register, code))

def printf (str, *args):
    print(str.format(*args))

def execute_tests():
    print("Executing tests!")
    total_tests = 0
    failed_tests = 0
    error_tests = 0
    for name, result, register, code in tests:
        total_tests += 1
        line_nr = None
        try:
            emu = infernal.Emulator(code)
            emu.setStack("junk...", "calling eip")
            emu.setRegs( rip = 0, rbp = 'old bp')
        except infernal.CodeParseException as e:
            error_tests += 1
            printf("Encountered error when parsing {}, at line {}: {}",
                    name, e.line_nr, e.str)
        try:
            for line_nr in emu:
                pass
            if isinstance(result, BaseException):
                printf("Error should have happened in {}, but did not", name)
                failed_tests += 1
            output = emu.getVal(register)
            if output != result:
                failed_tests += 1
                printf("Failed in {}. {} was {}, should be {}",
                        name, register, output, result)
        except BaseException as e:
            print(e)
            if not isinstance(result, BaseException) or not isinstance(e, result):
                error_tests += 1
                printf("Encountered error in {}, at operation {}: {}",
                        name, emu.getVal('%rip'), e)
                traceback.print_exc()
    printf("Tests done! {}/{}.",
        total_tests - failed_tests - error_tests, total_tests)
    printf("{} failed, and {} encountered a python error",
        failed_tests, error_tests)

################################################################################
# Arithmetic Operations

add_test("constant $255", 255, "%rsi", """
movq $255, %rsi
""")

add_test("static addition 10+$20", 30, "%rsi", """
movq $10, %rsi
addq $20, %rsi
""")

add_test("register addition 10+20", 30, "%rsi", """
movq $10, %rsi
movq $20, %rax
addq %rax, %rsi
""")

add_test("register subtraction 10-20", -10, "%rsi", """
movq $10, %rsi
movq $20, %rax
subq %rax, %rsi
""")

################################################################################
# Branching

branch_tests = [
    ("jg",10,">",5,0), ("jg",5,">",5,1), ("jg",5,">",10,1),
    ("jl",10,"<",5,1), ("jl",5,"<",5,1), ("jl",5,"<",10,0),
    ("je",10,"==",5,1),("je",5,"==",5,0),("je",5,"==",10,1),
    ("jge",10,">=",5,0),("jge",5,">=",5,0),("jge",5,">=",10,1),
    ("jle",10,"<=",5,1),("jle",5,"<=",5,0),("jle",5,"<=",10,0),
    ("jne",10,"!=",5,0),("jne",5,"!=",5,1),("jne",5,"!=",10,0),
]

for jump_instruct, a, comp, b, result in branch_tests:
    add_test("branch {a} {comp} {b}={result}".format(a=a,comp=comp,b=b,result=not result), result, "%rsi", """
    start:	cmpq ${b}, ${a}
            {jump_instruct} true
            movq $1, %rsi
            jmp return
    true:	movq $0, %rsi
    return:	ret
    """.format(a=a,b=b,jump_instruct=jump_instruct))

################################################################################
# Junk Comparisons

add_test("invalid comparison 1", infernal.JunkComparisonException, "None", """
start:	movq $100, %rsp   # Set stack pointer to a random position.
        popq %rsi		  # Move a Junk value into %rsi
        cmpq $10, %rsi    # Do a Junk comparison, which triggers the `i` comp
                          # virtual register.
        jg start		  # Attempt to do a jump to the start, if (Junk-10)>0,
                          # which makes no sense, and thus throws an error.
""")

add_test("invalid addition 1", infernal.JunkComparisonException, "None", """
start:	movq $100, %rsp   # Set stack pointer to a random position.
        popq %rsi		  # Move a Junk value into %rsi
        addq %rsi, %rsp   # Adds Junk to 101, which produces Junk.
        cmpq $10, %rsp    # Do a Junk comparison, which triggers the `i` comp
                          # virtual register.
        jg start		  # Attempt to do a jump to the start, if (Junk-10)>0,
                          # which makes no sense, and thus throws an error.
""")

add_test("invalid addition 2", infernal.JunkComparisonException, "None", """
start:	movq $100, %rsp   # Set stack pointer to a random position.
        popq %rsi		  # Move a Junk value into %rsi
        addq %rsp, %rsi   # Adds 101 to Junk, which produces Junk.
        cmpq $10, %rsi    # Do a Junk comparison, which triggers the `i` comp
                          # virtual register.
        jg start		  # Attempt to do a jump to the start, if (Junk-10)>0,
                          # which makes no sense, and thus throws an error.
""")

add_test("invalid subtraction 1", infernal.JunkComparisonException, "None", """
start:	movq $100, %rsp   # Set stack pointer to a random position.
        popq %rsi		  # Move a Junk value into %rsi
        subq %rsi, %rsp   # Adds Junk to 101, which produces Junk.
        cmpq $10, %rsp    # Do a Junk comparison, which triggers the `i` comp
                          # virtual register.
        jg start		  # Attempt to do a jump to the start, if (Junk-10)>0,
                          # which makes no sense, and thus throws an error.
""")

add_test("invalid subtraction 2", infernal.JunkComparisonException, "None", """
start:	movq $100, %rsp   # Set stack pointer to a random position.
        popq %rsi		  # Move a Junk value into %rsi
        subq %rsp, %rsi   # Adds 101 to Junk, which produces Junk.
        cmpq $10, %rsi    # Do a Junk comparison, which triggers the `i` comp
                          # virtual register.
        jg start		  # Attempt to do a jump to the start, if (Junk-10)>0,
                          # which makes no sense, and thus throws an error.
""")

################################################################################

if __name__ == "__main__":
    execute_tests()