Resolved .nvimrc merge conflicts

Author: joebobmiles

.nvimrc

@@ -1,11 +1,13 @@
 " Allow us to build our application(s) with a keystroke.
 set makeprg=build
+
 " Create errorformat strings for detecting clang error messages.
 " (We consume ../ from the beginning of the filename due to how build.bat
 " works.)
 set errorformat+=%f(%l\\,%c):\ %trror:\ %m
 set errorformat+=%f(%l\\,%c):\ %tarning:\ %m
 
 noremap <F4> :make!<cr>:cwindow<cr>
+
 " Allow us to run the tests with a keystroke.
 noremap <F5> :!test<cr>

scripts/tester.py

@@ -8,7 +8,7 @@
 """
 
 
-import os, subprocess, struct, enum, sys
+import os, subprocess, struct, enum, sys, functools, inspect
 
 
 BUILD_DIR = "build"
@@ -21,6 +21,16 @@
 TESTS_ERRORED = 0
 
 
+def infile(name):
+    global DATA_DIR
+    return DATA_DIR + "/" + name + ".sq"
+
+
+def outfile(name):
+    global BUILD_DIR
+    return BUILD_DIR + "/" + name + ".x"
+
+
 def build(input_file, output_file):
     """ Takes in a SUBLEQ filename as input and invokes the assembler on it,
     producing an output binary of similar name in the build directory. The
@@ -29,6 +39,8 @@ def build(input_file, output_file):
     binary. If an error occurred, then the output value is the message output
     by the assembler.
     """
+    global ASSEMBLER
+
     result = subprocess.run([ ASSEMBLER,
                               input_file,
                               output_file
@@ -39,73 +51,182 @@ def build(input_file, output_file):
     return result.stdout, result.returncode
 
 
-##
+def unpack(file):
+    data = None
+
+    with open(file, "rb") as f:
+        data = [ i[0] for i in struct.iter_unpack("i", f.read()) ]
+
+    return data
+
+
+class TestResult():
+
+    def __init__(self, name, success, messages = []):
+        self.test = name
+        self.success = success
+        self.messages = messages
+
+    def report(self):
+        status = "PASSED" if self.success else "FAILED"
+
+        message = f"==> Test \"{self.test}\" {status}"
+
+        if self.success is not True:
+            def prepend_tab(string):
+                return "\t"+string
+
+            message = message+"\n" + "\n".join(map(prepend_tab, self.messages))
+
+        print(message)
+
+
+class TestAssertion():
+
+    def __init__(self, expected, actual, success, message):
+        self.expected = expected
+        self.actual = actual
+        self.success = success
+        self.message = message
+
+    def report(self):
+        status = "Failed to assert" if not self.success else "Asserted"
+        return f"{status} that {self.message}"
+
+
+class Test():
+
+    def __init__(self, name, test):
+        self.name = name
+        self._test = test
+        self._asserts = []
+        self._errored = False
+
+    def run(self):
+        self._test(self)
+
+        # Get all the messages from the assertions that failed.
+        messages = [ a.report() for a in self._asserts if not a.success ]
+
+        passing = len(messages) == 0
+
+        return TestResult(self.name, passing and not self._errored, messages)
+
+    def error(self, message):
+        print(f"==> TEST ERROR: \t{message}")
+
+    def is_equal(self, expected, actual):
+        self._asserts.append(TestAssertion(
+            expected,
+            actual,
+            expected == actual,
+            f"{expected} == {actual}"
+        ))
+
+
+class Tester():
+
+    def __init__(self):
+        self._tests = []
+
+    def add_test(self, test):
+        self._tests.append(Test(test.__name__, test))
+
+    def run(self):
+        results = []
+
+        for test in self._tests:
+            result = test.run()
+            result.report()
+
+            results.append(result)
+
+        failing_tests = len([ r for r in results if r.success is False ])
+
+        if failing_tests > 0:
+            passing_tests = len(self._tests) - failing_tests
+            print(f"\n\t{passing_tests} / {len(self._tests)} tests passing.")
+
+        else:
+            print("\n\tAll tests passing.")
+
+
+
+tester = Tester()
+
+
 ## ASSEMBLER TESTS
-##
 
-# TODO[joe] Create tests that confirm assembler error messages?
-# These would include usage errors and syntax errors. This functionality would
-# be desirable at some point, when we get around to implementing syntax error
-# checking. However, this is sufficient for now.
-assembler_tests = {
-    'basic': [ 0, 0, -1 ],
-    'next_address': [ 1, 2, 3 ],
-    'complex': [ 0, 1, 3, 0, 1, 6, 0, 0, -1 ],
-    'two_address': [ 0, 1, 3 ],
-    'one_address': [ 1, 1, 3 ],
-}
+@tester.add_test
+def basic(test):
+    _, returncode = build(infile(test.name), outfile(test.name))
 
+    if returncode:
+        test.error(f"Build for {outfile(self)} exited with code {returncode}")
 
-for test, expected_result in assembler_tests.items():
-    test_file = DATA_DIR+"\\"+test+".sq"
-    output_file = test_file.replace(".sq", ".x").replace(DATA_DIR, BUILD_DIR)
+    test.is_equal([ 0, 0, -1 ], unpack(outfile(test.name)))
 
-    output, returncode = build(test_file, output_file)
+@tester.add_test
+def next_address(test):
+    _, returncode = build(infile(test.name), outfile(test.name))
 
     if returncode:
-        if output:
-            print(output.decode("utf-8"))
+        test.error(f"Build for {outfile(self)} exited with code {returncode}")
 
-        print("==> ERROR: Build for \"{}\" exited with code {}".format(test_file,
-                                                                       returncode))
+    test.is_equal([ 1, 2, 3 ], unpack(outfile(test.name)))
 
-        TESTS_ERRORED = TESTS_ERRORED + 1
-        
-        continue
+@tester.add_test
+def two_address(test):
+    _, returncode = build(infile(test.name), outfile(test.name))
 
-    program = []
+    if returncode:
+        test.error(f"Build for {outfile(self)} exited with code {returncode}")
 
-    with open(output_file, "rb") as program_file:
-        program = [ i[0] for i in struct.iter_unpack("i", program_file.read()) ]
+    test.is_equal([ 0, 1, 3 ], unpack(outfile(test.name)))
 
-    if not program == expected_result:
-        print("\nExpected {}, got {}\n".format(expected_result, program))
-        print("==> FAILED: \"{}\" ".format(test_file))
+@tester.add_test
+def one_address(test):
+    _, returncode = build(infile(test.name), outfile(test.name))
 
-    else:
-        print("==> PASSED: \"{}\" ".format(test_file))
+    if returncode:
+        test.error(f"Build for {outfile(self)} exited with code {returncode}")
 
-        TESTS_PASSED = TESTS_PASSED + 1
+    test.is_equal([ 1, 1, 3 ], unpack(outfile(test.name)))
 
+@tester.add_test
+def label(test):
+    _, returncode = build(infile(test.name), outfile(test.name))
 
-##
-## EMULATOR TESTS
-##
+    if returncode:
+        test.error(f"Build for {outfile(self)} exited with code {returncode}")
+
+    test.is_equal([ 0, 0, -1], unpack(outfile(test.name)))
 
-emulator_tests = {}
+@tester.add_test
+def identifier(test):
+    _, returncode = build(infile(test.name), outfile(test.name))
 
+    if returncode:
+        test.error(f"Build for {outfile(self)} exited with code {returncode}")
+
+    test.is_equal([ 0, 0, -1 ],  unpack(outfile(test.name)))
 
-##
-## Test Statistics
-##
+@tester.add_test
+def complex(test):
+    _, returncode = build(infile(test.name), outfile(test.name))
+
+    if returncode:
+        test.error(f"Build for {outfile(self)} exited with code {returncode}")
 
-TOTAL_TESTS = len(assembler_tests) + len(emulator_tests)
+    test.is_equal([ 0, 1, 3, 0, 1, 6, 0, 0, -1 ], unpack(outfile(test.name)))
+
+
+## EMULATOR TESTS
+# todo(jrm): Write the emulator tests
 
-# Total tests passed vs total tests run.
-print("\n  {} / {} tests passed".format(TESTS_PASSED, 
-                                        len(assembler_tests)+len(emulator_tests)))
 
-# Total tests that errored.
-print("  {} tests errored".format(TESTS_ERRORED))
+# Run the tests
+tester.run()
 
-sys.exit(TOTAL_TESTS - TESTS_PASSED)
+# todo(jrm) have tester.run() return the number of tests failed.
+# sys.exit(TOTAL_TESTS - TESTS_PASSED)