Extract more

Author: stevenfontanella

check.py

@@ -206,69 +206,71 @@ def check_expected(actual, expected, stdout=None):
             shared.fail(actual, expected)
 
 
+def run_one_spec_test(wast: Path, stdout=None, stderr=None):
+    test_name = wast.name
+    base_name = "-".join(wast.parts[-3:])
+
+    print('..', test_name, file=stdout)
+    # windows has some failures that need to be investigated
+    if test_name == 'names.wast' and shared.skip_if_on_windows('spec: ' + test_name):
+        return
+
+    expected = os.path.join(shared.get_test_dir('spec'), 'expected-output', test_name + '.log')
+
+    # some spec tests should fail (actual process failure, not just assert_invalid)
+    try:
+        actual = run_spec_test(str(wast), stdout=stdout, stderr=stderr)
+    except Exception as e:
+        if ('wasm-validator error' in str(e) or 'error: ' in str(e)) and '.fail.' in test_name:
+            print('<< test failed as expected >>', file=stdout)
+            return  # don't try all the binary format stuff TODO
+        else:
+            shared.fail_with_error(str(e))
+
+    check_expected(actual, expected, stdout=stdout)
+
+    # check binary format. here we can verify execution of the final
+    # result, no need for an output verification
+    actual = ''
+    with open(base_name + ".transformed", 'w') as transformed_spec_file:
+        for i, (module, asserts) in enumerate(support.split_wast(str(wast))):
+            if not module:
+                # Skip any initial assertions that don't have a module
+                return
+            print(f'        testing split module {i}', file=stdout)
+            split_name = base_name + f'_split{i}.wast'
+            support.write_wast(split_name, module)
+            run_opt_test(split_name, stdout=stdout, stderr=stderr)    # also that our optimizer doesn't break on it
+
+            result_wast_file = shared.binary_format_check(split_name, verify_final_result=False, base_name=base_name, stdout=stdout, stderr=stderr)
+            with open(result_wast_file) as f:
+                result_wast = f.read()
+                # add the asserts, and verify that the test still passes
+                transformed_spec_file.write(result_wast + '\n' + '\n'.join(asserts))
+
+    # compare all the outputs to the expected output
+    actual = run_spec_test(base_name + ".transformed", stdout=stdout, stderr=stderr)
+    check_expected(actual, os.path.join(shared.get_test_dir('spec'), 'expected-output', test_name + '.log'), stdout=stdout)
+
+
+def run_spec_test_with_wrapped_stdout(output_queue, wast: Path):
+    out = io.StringIO()
+    try:
+        ret = run_one_spec_test(wast, stdout=out, stderr=out)
+    except Exception as e:
+        print(e, file=out)
+        raise
+    finally:
+        # If a test fails, it's important to keep its output
+        output_queue.put(out.getvalue())
+    return ret
+
+
 def run_spec_tests():
     print('\n[ checking wasm-shell spec testcases... ]\n')
 
-    def run_one(wast: Path, stdout=None, stderr=None):
-        test_name = wast.name
-        base_name = "-".join(wast.parts[-3:])
-
-        print('..', test_name, file=stdout)
-        # windows has some failures that need to be investigated
-        if test_name == 'names.wast' and shared.skip_if_on_windows('spec: ' + test_name):
-            return
-
-        expected = os.path.join(shared.get_test_dir('spec'), 'expected-output', test_name + '.log')
-
-        # some spec tests should fail (actual process failure, not just assert_invalid)
-        try:
-            actual = run_spec_test(str(wast), stdout=stdout, stderr=stderr)
-        except Exception as e:
-            if ('wasm-validator error' in str(e) or 'error: ' in str(e)) and '.fail.' in test_name:
-                print('<< test failed as expected >>', file=stdout)
-                return  # don't try all the binary format stuff TODO
-            else:
-                shared.fail_with_error(str(e))
-
-        check_expected(actual, expected, stdout=stdout)
-
-        # check binary format. here we can verify execution of the final
-        # result, no need for an output verification
-        actual = ''
-        with open(base_name + ".transformed", 'w') as transformed_spec_file:
-            for i, (module, asserts) in enumerate(support.split_wast(str(wast))):
-                if not module:
-                    # Skip any initial assertions that don't have a module
-                    return
-                print(f'        testing split module {i}', file=stdout)
-                split_name = base_name + f'_split{i}.wast'
-                support.write_wast(split_name, module)
-                run_opt_test(split_name, stdout=stdout, stderr=stderr)    # also that our optimizer doesn't break on it
-
-                result_wast_file = shared.binary_format_check(split_name, verify_final_result=False, base_name=base_name, stdout=stdout, stderr=stderr)
-                with open(result_wast_file) as f:
-                    result_wast = f.read()
-                    # add the asserts, and verify that the test still passes
-                    transformed_spec_file.write(result_wast + '\n' + '\n'.join(asserts))
-
-        # compare all the outputs to the expected output
-        actual = run_spec_test(base_name + ".transformed", stdout=stdout, stderr=stderr)
-        check_expected(actual, os.path.join(shared.get_test_dir('spec'), 'expected-output', test_name + '.log'), stdout=stdout)
-
     output_queue = queue.Queue()
 
-    def run_with_wrapped_stdout(output_queue, wast: Path):
-        out = io.StringIO()
-        try:
-            ret = run_one(wast, stdout=out, stderr=out)
-        except Exception as e:
-            print(e, file=out)
-            raise
-        finally:
-            # If a test fails, it's important to keep its output
-            output_queue.put(out.getvalue())
-        return ret
-
     def printer():
         while True:
             try:
@@ -282,7 +284,7 @@ def printer():
 
     executor = ThreadPoolExecutor(max_workers=max(1, min(len(shared.options.spec_tests), os.cpu_count() * 4)))
     try:
-        results = executor.map(partial(run_with_wrapped_stdout, output_queue), map(Path, shared.options.spec_tests))
+        results = executor.map(partial(run_spec_test_with_wrapped_stdout, output_queue), map(Path, shared.options.spec_tests))
         for _ in results:
             # Iterating joins the threads. No return value here.
             pass