diff --git a/opbtest/opbtestassertions.py b/opbtest/opbtestassertions.py new file mode 100644 index 0000000..c8644ff --- /dev/null +++ b/opbtest/opbtestassertions.py @@ -0,0 +1,54 @@ +import functools + + +class OpbTestAssertions(): + def __init__(self, json, case): + self.jsondata = json + self.case = case + self.registers = None + + def regs(self, registers): + if type(registers) is not list: + self.case.fail("Expected a list of registers") + self.registers = list(map(lambda reg: self.torawregistername(reg), registers)) + return self + + def torawregistername(self, register): + return int(register[1], 16) + + def assertregistername(self, register): + if not register.startswith("s"): + self.case.fail("Register name should start with 's', followed with 0-F") + + def reg(self, register): + self.assertregistername(register) + self.registers = [int(register[1], 16)] + return self + + def tocontain(self, expected): + for register in self.registers: + result = self.case.checkReg(self.jsondata, "a", register, expected) + if result != "": + self.case.fail(result) + + def contains(self, expected): + if self.registers is None: + self.case.fail("First call reg()/regs() to assert which register to check!") + + if type(expected) is int or type(expected) is str: + return self.tocontain(expected) + + if type(expected) is not list: + self.case.fail("Expected array as expected register values!") + if len(expected) != len(self.registers): + self.case.fail("Given registers and expected results arrays do not match!") + + results = [] + for i in range(0, len(expected)): + result = self.case.checkReg(self.jsondata, "a", self.registers[i], expected[i]) + if result != "": + results.append(result) + if len(results) > 0: + self.case.fail( + "Registers do not contain expected values: \n" + functools.reduce(lambda a, b: a + "\n" + b, results)) + diff --git a/opbtest/opbtestcase.py b/opbtest/opbtestcase.py index ca01117..dcf0f4b 100644 --- a/opbtest/opbtestcase.py +++ b/opbtest/opbtestcase.py @@ -1,110 +1,12 @@ +import glob +import json +import os +import subprocess +import time from unittest import TestCase -import subprocess, os, time, json, glob, functools - -class OpbTestAssertions(): - def __init__(self, json, case): - self.jsondata = json - self.case = case - self.registers = None - - def regs(self, registers): - if type(registers) is not list: - self.case.fail("Expected a list of registers") - self.registers = list(map(lambda reg: self.torawregistername(reg), registers)) - return self - - def torawregistername(self, register): - return int(register[1], 16) - - def assertregistername(self, register): - if not register.startswith("s"): - self.case.fail("Register name should start with 's', followed with 0-F") - - def reg(self, register): - self.assertregistername(register) - self.registers = [int(register[1], 16)] - return self - - def tocontain(self, expected): - for register in self.registers: - result = self.case.checkReg(self.jsondata, "a", register, expected) - if result != "": - self.case.fail(result) - - def contains(self, expected): - if self.registers is None: - self.case.fail("First call reg()/regs() to assert which register to check!") - - if type(expected) is int: - return self.tocontain(expected) - - if type(expected) is not list: - self.case.fail("Expected array as expected register values!") - if len(expected) != len(self.registers): - self.case.fail("Given registers and expected results arrays do not match!") - - results = [] - for i in range(0, len(expected)): - result = self.case.checkReg(self.jsondata, "a", self.registers[i], expected[i]) - if result != "": - results.append(result) - if len(results) > 0: - self.case.fail( - "Registers do not contain expected values: \n" + functools.reduce(lambda a, b: a + "\n" + b, results)) - - -class OpbTestMockable(): - def __init__(self, case, filename): - self.case = case - self.filename = filename - self.prepender = [] - self.proctotest = "" - self.appender = ["\nopbtestquitfn: output sD, FF\n"] - - def testproc(self, procname): - self.proctotest = procname - return self - - def setregs(self, regmap): - for key, val in regmap.items(): - self.prepender.append("load " + key + ", " + str(val) + "\n") - return self - - def execute(self): - with open(self.filename, 'r') as original: - data = original.readlines() - - def findlinebetween(data, statement1, statement2): - linenr = 0 - startcounting = False - for line in data: - if statement1 in line: - startcounting = True - if startcounting and statement2 in line: - break - linenr += 1 - - if linenr + 1 == len(data): - self.case.fail("No statements between " + statement1 + " and " + statement2 + " found") - return linenr - - def setupproc(data): - self.prepender.append("jump " + self.proctotest + "\n") - - linenr = findlinebetween(data, "proc " + self.proctotest, "}") - data = data[0:linenr] + ["jump opbtestquitfn\n"] + data[linenr:] - return data - - if len(self.proctotest) > 0: - data = setupproc(data) - - firstjump = findlinebetween(data, "jump", "jump") - - data = data[0:firstjump] + self.prepender + data[firstjump:] + self.appender - with open(self.filename, 'w') as modified: - modified.writelines(data) - return self.case.execute_file(self.filename) +from opbtest.opbtestassertions import OpbTestAssertions +from opbtest.opbtestmockable import OpbTestMockable class OpbTestCase(TestCase): @@ -185,7 +87,8 @@ class OpbTestCase(TestCase): def checkReg(self, jsondata, bank, nr, expected): actual = jsondata["regs_" + bank][nr] - if int(str(expected), 16) == actual: + if type(expected) is int: + expected = int(str(expected), 16) + if expected == actual: return "" - return "reg " + bank + "," + str(nr) + " should contain " + str(expected) + " but instead contains " + str( - actual) + return "reg " + bank + "," + str(nr) + " should contain " + str(expected) + " but instead contains " + str(actual) diff --git a/opbtest/opbtestmockable.py b/opbtest/opbtestmockable.py new file mode 100644 index 0000000..6168165 --- /dev/null +++ b/opbtest/opbtestmockable.py @@ -0,0 +1,53 @@ +class OpbTestMockable(): + def __init__(self, case, filename): + self.case = case + self.filename = filename + self.prepender = [] + self.proctotest = "" + self.appender = ["\nopbtestquitfn: output sD, FF\n"] + + def testproc(self, procname): + self.proctotest = procname + return self + def testfunc(self, funcname): + return self.testproc(funcname) + + def setregs(self, regmap): + for key, val in regmap.items(): + self.prepender.append("load " + key + ", " + str(val) + "\n") + return self + + def execute(self): + with open(self.filename, 'r') as original: + data = original.readlines() + + def findlinebetween(data, statement1, statement2): + linenr = 0 + startcounting = False + for line in data: + if statement1 in line: + startcounting = True + if startcounting and statement2 in line: + break + linenr += 1 + + if linenr + 1 == len(data): + self.case.fail("No statements between " + statement1 + " and " + statement2 + " found") + return linenr + + def setupproc(data): + self.prepender.append("jump " + self.proctotest + "\n") + + linenr = findlinebetween(data, self.proctotest + "(", "}") # add (, could also have been a call + data = data[0:linenr] + ["jump opbtestquitfn\n"] + data[linenr:] + return data + + if len(self.proctotest) > 0: + data = setupproc(data) + + firstjump = findlinebetween(data, "jump", "jump") + + data = data[0:firstjump] + self.prepender + data[firstjump:] + self.appender + with open(self.filename, 'w') as modified: + modified.writelines(data) + return self.case.execute_file(self.filename) diff --git a/test/functions.py b/test/functions.py index 8308f0e..f141a99 100644 --- a/test/functions.py +++ b/test/functions.py @@ -7,6 +7,20 @@ class TestFunctions(OpbTestCase): pass #self.do_not_cleanup_files() + def test_unknownproc_should_fail(self): + try: + self.load_file("functions.psm4").testproc("wazza").execute() + self.fail("Expected assertion error to occur") + except AssertionError: + pass + + def test_setregs_unknownregs_should_fail(self): + try: + self.load_file("functions.psm4").setregs({"wazza": 11}).execute() + self.fail("Expected assertion error to occur") + except AssertionError: + pass + def test_proc3_adds_to_existing_register(self): result = self.load_file("functions.psm4").testproc("proc3").setregs({"s5": 2}).execute() self.assertPsm(result).reg("s5").contains(3) @@ -18,3 +32,7 @@ class TestFunctions(OpbTestCase): def test_proc1_calls_proc2(self): result = self.load_file("functions.psm4").testproc("proc1").execute() self.assertPsm(result).regs(["s0", "s4"]).contains([42, 42]) + + def test_func1_calls_func1(self): + result = self.load_file("functions.psm4").testfunc("func1").execute() + self.assertPsm(result).reg("s1").contains(52)