def test_env_clang_format_style(self): lang = "cpp" env = { "CLANG_FORMAT_STYLE": "Google", } settings = _get_all_settings(Mock(indent=4), env=env)[lang] self.assertIn("-style=Google", settings.formatter)
def test_error_cases(self, case): env = os.environ.copy() lang = "rust" # Just so we avoid running tests N times if ENV.get(lang): env.update(ENV.get(lang)) settings = _get_all_settings(Mock(indent=4, extension=False), env=env)[lang] ext = settings.ext expected_error = TEST_ERROR_CASES[case] source_data = "from ctypes import c_int8 as i8, c_int16 as i16\n" + case tree = get_tree(source_data, ext) try: _transpile_one( [tree], tree, settings.transpiler, settings.rewriters, settings.transformers, settings.post_rewriters, ) except Exception as e: assert type(e) == expected_error
def test_env_cxx_gcc(self, case): lang = "cpp" ext = ".cpp" expected_filename = TESTS_DIR / "expected" / f"{case}{ext}" if not os.path.exists(expected_filename): raise unittest.SkipTest(f"{expected_filename} not found") env = os.environ.copy() env["CXX"] = "g++-11" if sys.platform == "darwin" else "g++" env["CXXFLAGS"] = "-std=c++14 -Wall -Werror" if not spawn.find_executable(env["CXX"]): raise unittest.SkipTest(f"{env['CXX']} not available") settings = _get_all_settings(Mock(indent=4), env=env)[lang] assert settings.linter[0].startswith("g++") if not spawn.find_executable("astyle"): raise unittest.SkipTest("astyle not available") settings.formatter = ["astyle"] exe = BUILD_DIR / a_dot_out exe.unlink(missing_ok=True) case_filename = TESTS_DIR / "cases" / f"{case}.py" case_output = GENERATED_DIR / f"{case}{ext}" args = [ f"--{lang}=1", "--comment-unsupported", str(case_filename), "--outdir", str(GENERATED_DIR), ] linter = _create_cmd(settings.linter, case_output) try: rv = main(args=args, env=env) assert rv == 0 linter.append("-Wno-unused-variable") if case == "coverage": linter.append("-Wno-pointer-arith") proc = run(linter, env=env) assert not proc.returncode except FileNotFoundError as e: raise unittest.SkipTest( f"Failed invoking {env['CXX']} or {linter}: {e}") finally: if not KEEP_GENERATED: case_output.unlink(missing_ok=True) exe.unlink(missing_ok=True)
def test_ext(self, case): lang = "rust" env = os.environ.copy() if ENV.get(lang): env.update(ENV.get(lang)) settings = _get_all_settings(Mock(indent=2))[lang] ext = settings.ext expected_filename = TESTS_DIR / "ext_expected" / f"{case}{ext}" case_filename = TESTS_DIR / "ext_cases" / f"{case}.py" case_output = GENERATED_DIR / f"{case}{ext}" args = [ "--rust=1", "--extension", str(case_filename), "--outdir", str(GENERATED_DIR), ] sys.argv += args try: main(args=args, env=env) with open(case_output) as actual: generated = actual.read() if os.path.exists( expected_filename) and not self.UPDATE_EXPECTED: with open(expected_filename) as f2: self.assertEqual(f2.read(), generated) print("expected = generated") if self.UPDATE_EXPECTED or not os.path.exists(expected_filename): with open(expected_filename, "w") as f: f.write(generated) finally: if not self.KEEP_GENERATED: case_output.unlink(missing_ok=True)
def test_comment_unimplemented_body(self, lang): env = os.environ.copy() settings = _get_all_settings(Mock(indent=4, extension=False, no_prologue=False), env=env)[lang] case = "unsupported_body" case_filename = TESTS_DIR / "cases" / f"{case}.py" source_data = dedent(""" def outer(): a = 1 def inner(): nonlocal a return a return inner() if __name__ == "__main__": x = outer() print(x) """) tree = get_tree(source_data, settings.ext) settings.transpiler._throw_on_unimplemented = False try: result = _transpile( [case_filename], [tree], settings, )[0][0] print(result) assert "nonlocal unimplemented on line 5:8" in result except Exception: settings.transpiler._throw_on_unimplemented = True raise
class CodeGeneratorTests(unittest.TestCase): LANGS = list(_get_all_settings(Mock(indent=4)).keys()) maxDiff = None def setUp(self): os.chdir(TESTS_DIR) @foreach(sorted(LANGS)) @foreach(sorted(TEST_CASES.keys())) def test_snippet(self, case, lang): env = os.environ.copy() if ENV.get(lang): env.update(ENV.get(lang)) settings = _get_all_settings(Mock(indent=4), env=env)[lang] ext = settings.ext source_data = TEST_CASES[case] is_script = has_main(source_data) if ext in [".dart", ".kt", ".rs"] and not is_script: source_data = f"def main():\n {source_data}" print(f">{source_data}<") tree = ast.parse(source_data) astpretty.pprint(tree) proc = run([sys.executable, "-c", source_data], capture_output=True) if proc.returncode: raise RuntimeError( f"Invalid case {case}:\n{proc.stdout}{proc.stderr}") try: result = transpile( "stdin", tree, settings.transpiler, settings.rewriters, settings.transformers, settings.post_rewriters, ) except NotImplementedError as e: raise unittest.SkipTest(str(e)) if settings.formatter: if not spawn.find_executable(settings.formatter[0]): raise unittest.SkipTest( f"{settings.formatter[0]} not available") if ext == ".kt": class_name = str(case.title()) + "Kt" exe = TESTS_DIR / (class_name + ".class") elif ext == ".cpp": exe = TESTS_DIR / "a.out" elif ext == ".dart" or (ext == ".nim" and sys.platform == "win32"): exe = TESTS_DIR / "cases" / f"{case}.exe" else: exe = TESTS_DIR / "cases" / f"{case}" exe.unlink(missing_ok=True) case_output = TESTS_DIR / "cases" / f"{case}{ext}" expect_success = f"{case}{ext}" in EXPECTED_SUCCESSES with open(case_output, "w") as f: f.write(result) if settings.formatter: if settings.ext == ".kt" and case_output.is_absolute(): # KtLint does not support absolute path in globs case_output = case_output.relative_to(Path.cwd()) proc = run([*settings.formatter, case_output], env=env, capture_output=True) if proc.returncode: raise unittest.SkipTest( f"Error: Could not reformat using {settings.formatter}:\n{proc.stdout}{proc.stderr}" ) try: compiler = COMPILERS[lang] if compiler: if not spawn.find_executable(compiler[0]): raise unittest.SkipTest(f"{compiler[0]} not available") proc = run([*compiler, case_output], env=env, capture_output=True) if proc.returncode and not expect_success: raise unittest.SkipTest( f"{case}{ext} doesnt compile:\n{proc.stdout}{proc.stderr}" ) if exe.exists() and os.access(exe, os.X_OK): if not expect_success: raise AssertionError(f"{case}{ext} compiled") elif INVOKER.get(lang): invoker = INVOKER.get(lang) if not spawn.find_executable(invoker[0]): raise unittest.SkipTest(f"{invoker[0]} not available") proc = run([*invoker, case_output], env=env, capture_output=True) if proc.returncode and not expect_success: raise unittest.SkipTest( f"Execution of {case}{ext} failed:\n{proc.stdout}{proc.stderr}" ) if not expect_success: raise AssertionError(f"{case}{ext} invoked") else: return finally: if not KEEP_GENERATED: case_output.unlink(missing_ok=True) exe.unlink(missing_ok=True) if not expect_success: assert False
class CodeGeneratorTests(unittest.TestCase): maxDiff = None SHOW_ERRORS = SHOW_ERRORS def setUp(self): os.makedirs(BUILD_DIR, exist_ok=True) os.chdir(BUILD_DIR) py2many.cli.CWD = BUILD_DIR @foreach(sorted(LANGS)) @foreach(sorted(TEST_CASES.keys())) def test_snippet(self, case, lang): env = os.environ.copy() if ENV.get(lang): env.update(ENV.get(lang)) settings = _get_all_settings(Mock(indent=4, extension=False, no_prologue=False), env=env)[lang] ext = settings.ext tree = get_tree(TEST_CASES[case], ext) case_filename = TESTS_DIR / "cases" / f"{case}.py" case_output = GENERATED_DIR / f"{case}{ext}" try: result = _transpile( [case_filename], [tree], settings, )[0][0] except NotImplementedError as e: raise unittest.SkipTest(str(e)) if settings.formatter: if not spawn.find_executable(settings.formatter[0]): raise unittest.SkipTest( f"{settings.formatter[0]} not available") exe = get_exe_filename(case, ext) exe.unlink(missing_ok=True) expect_success = f"{case}{ext}" in EXPECTED_SUCCESSES with open(case_output, "w") as f: f.write(result) if settings.formatter: if settings.ext == ".kt" and case_output.is_absolute(): # KtLint does not support absolute path in globs case_output = _relative_to_cwd(case_output) proc = run([*settings.formatter, case_output], env=env, capture_output=True) if proc.returncode and not self.SHOW_ERRORS: raise unittest.SkipTest( f"Error: Could not reformat using {settings.formatter}:\n{proc.stdout}{proc.stderr}" ) assert not proc.returncode try: compiler = COMPILERS.get(lang) if compiler: if not spawn.find_executable(compiler[0]): raise unittest.SkipTest(f"{compiler[0]} not available") proc = run([*compiler, case_output], env=env, capture_output=True) if proc.returncode and not expect_success and not self.SHOW_ERRORS: raise unittest.SkipTest( f"{case}{ext} doesnt compile:\n{proc.stdout}{proc.stderr}" ) assert not proc.returncode if INVOKER.get(lang): invoker = INVOKER.get(lang) if not spawn.find_executable(invoker[0]): raise unittest.SkipTest(f"{invoker[0]} not available") proc = run([*invoker, case_output], env=env, capture_output=True) if proc.returncode and not expect_success and not self.SHOW_ERRORS: raise unittest.SkipTest( f"Execution of {case}{ext} failed:\n{proc.stdout}{proc.stderr}" ) if not expect_success: assert proc.returncode, f"{case}{ext} invoked successfully" if expect_success: assert not proc.returncode, f"{case}{ext} failed" elif exe.exists() and os.access(exe, os.X_OK): proc = run([exe], env=env, capture_output=True) if proc.returncode and not expect_success and not self.SHOW_ERRORS: raise unittest.SkipTest( f"Invocation error {proc.returncode}:\n{proc.stdout}{proc.stderr}" ) if not expect_success: assert proc.returncode, f"{case}{ext} invoked successfully" if expect_success: assert not proc.returncode, f"{case}{ext} failed" else: return finally: if not KEEP_GENERATED: case_output.unlink(missing_ok=True) exe.unlink(missing_ok=True) if not expect_success: assert False
def test_arg_nim_indent(self): lang = "nim" settings = _get_all_settings(Mock(indent=2))[lang] self.assertIn("--indent:2", settings.formatter)
class CodeGeneratorTests(unittest.TestCase): maxDiff = None SHOW_ERRORS = SHOW_ERRORS KEEP_GENERATED = KEEP_GENERATED UPDATE_EXPECTED = UPDATE_EXPECTED LINT = os.environ.get("LINT", True) def setUp(self): os.makedirs(BUILD_DIR, exist_ok=True) os.chdir(BUILD_DIR) py2many.cli.CWD = BUILD_DIR @foreach(sorted(LANGS)) @foreach(sorted(TEST_CASES)) def test_generated(self, case, lang): env = os.environ.copy() if ENV.get(lang): env.update(ENV.get(lang)) settings = _get_all_settings(Mock(indent=4), env=env)[lang] ext = settings.ext expected_filename = TESTS_DIR / "expected" / f"{case}{ext}" if (not self.UPDATE_EXPECTED and not self.KEEP_GENERATED and not os.path.exists(expected_filename)): raise unittest.SkipTest(f"{expected_filename} not found") if settings.formatter: if not spawn.find_executable(settings.formatter[0]): raise unittest.SkipTest( f"{settings.formatter[0]} not available") case_filename = TESTS_DIR / "cases" / f"{case}.py" case_output = GENERATED_DIR / f"{case}{ext}" exe = get_exe_filename(case, ext) exe.unlink(missing_ok=True) is_script = has_main(case_filename) self.assertTrue(is_script) main_args = CASE_ARGS.get(case, tuple()) expected_exit_code = CASE_EXPECTED_EXITCODE.get(case, 0) expected_output = get_python_case_output(case_filename, main_args, expected_exit_code) self.assertTrue(expected_output, "Test cases must print something") expected_output = expected_output.splitlines() args = [ f"--{lang}=1", "--comment-unsupported", str(case_filename), "--outdir", str(GENERATED_DIR), ] try: rv = main(args=args, env=env) with open(case_output) as actual: generated = actual.read() if os.path.exists( expected_filename) and not self.UPDATE_EXPECTED: with open(expected_filename) as f2: expected_case_contents = f2.read() generated_cleaned = generated if ext == ".py": expected_case_contents = standardise_python( expected_case_contents) generated_cleaned = standardise_python(generated) self.assertEqual(expected_case_contents, generated_cleaned) print("expected = generated") expect_failure = (not self.SHOW_ERRORS and f"{case}{ext}" in EXPECTED_LINT_FAILURES) if not expect_failure: assert rv == 0, "formatting failed" elif rv: raise unittest.SkipTest("formatting failed") compiler = COMPILERS.get(lang) if compiler: if not spawn.find_executable(compiler[0]): raise unittest.SkipTest(f"{compiler[0]} not available") expect_compile_failure = (not self.SHOW_ERRORS and f"{case}{ext}" in EXPECTED_COMPILE_FAILURES) if expect_compile_failure: return cmd = _create_cmd(compiler, filename=case_output, exe=exe) print(f"Running {cmd} ...") proc = run(cmd, env=env, check=not expect_failure) if proc.returncode: raise unittest.SkipTest(f"{case}{ext} doesnt compile") if self.UPDATE_EXPECTED or not os.path.exists( expected_filename): with open(expected_filename, "w") as f: f.write(generated) stdout = None if ext == ".cpp" and (BUILD_DIR / a_dot_out).exists(): os.rename(BUILD_DIR / a_dot_out, exe) if INVOKER.get(lang): invoker = INVOKER.get(lang) if not spawn.find_executable(invoker[0]): raise unittest.SkipTest(f"{invoker[0]} not available") cmd = _create_cmd(invoker, filename=case_output, exe=exe) cmd += main_args proc = run( cmd, env=env, capture_output=True, ) stdout = proc.stdout if expect_failure and expected_exit_code != proc.returncode: raise unittest.SkipTest(f"Execution of {case}{ext} failed") assert ( expected_exit_code == proc.returncode ), f"Execution of {case}{ext} failed:\n{stdout}{proc.stderr}" if self.UPDATE_EXPECTED or not os.path.exists( expected_filename): with open(expected_filename, "w") as f: f.write(generated) elif exe.exists() and os.access(exe, os.X_OK): cmd = [exe, *main_args] print(f"Running {cmd} ...") proc = run(cmd, env=env, capture_output=True) assert expected_exit_code == proc.returncode stdout = proc.stdout else: raise RuntimeError(f"Compiled output {exe} not detected") self.assertTrue(stdout, "Invoked code produced no stdout") stdout = stdout.splitlines() self.assertEqual(expected_output, stdout) if settings.linter and self.LINT: if not spawn.find_executable(settings.linter[0]): raise unittest.SkipTest( f"{settings.linter[0]} not available") if settings.ext == ".kt" and case_output.is_absolute(): # KtLint does not support absolute path in globs case_output = _relative_to_cwd(case_output) linter = _create_cmd(settings.linter, case_output) if ext == ".cpp": linter.append("-Wno-unused-variable") if case == "coverage": linter.append("-Wno-null-arithmetic" if CXX == "clang++" else "-Wno-pointer-arith") proc = run(linter, env=env) # golint is failing regularly due to exports without docs if proc.returncode and linter[0] == "golint": expect_failure = True if proc.returncode and expect_failure: raise unittest.SkipTest(f"{case}{ext} failed linter") self.assertFalse(proc.returncode) if expect_failure: raise AssertionError(f"{case}{ext} passed unexpectedly") finally: if not self.KEEP_GENERATED: case_output.unlink(missing_ok=True) exe.unlink(missing_ok=True) if settings.ext == ".rs": assert in_cargo_toml(case)
main, ) import py2many.cli TESTS_DIR = Path(__file__).parent.absolute() ROOT_DIR = TESTS_DIR.parent BUILD_DIR = TESTS_DIR / "build" GENERATED_DIR = BUILD_DIR KEEP_GENERATED = os.environ.get("KEEP_GENERATED", False) SHOW_ERRORS = os.environ.get("SHOW_ERRORS", False) UPDATE_EXPECTED = os.environ.get("UPDATE_EXPECTED", False) CXX = os.environ.get("CXX", "clang++") LANGS = list(_get_all_settings(Mock(indent=4)).keys()) ENV = { "cpp": { "CLANG_FORMAT_STYLE": "Google" }, "rust": { "RUSTFLAGS": "--deny warnings" }, } COMPILERS = { "cpp": [CXX, "-std=c++14", "-I", str(ROOT_DIR)] + (["-stdlib=libc++"] if CXX == "clang++" else []) + (["-o", "{exe}", "{filename}"] if sys.platform == "win32" else []), "dart": ["dart", "compile", "exe"], "go": ["go", "build"], "kotlin": ["kotlinc"],
class CodeGeneratorTests(unittest.TestCase): LANGS = list(_get_all_settings(Mock(indent=4)).keys()) maxDiff = None SHOW_ERRORS = os.environ.get("SHOW_ERRORS", False) KEEP_GENERATED = os.environ.get("KEEP_GENERATED", False) UPDATE_EXPECTED = os.environ.get("UPDATE_EXPECTED", False) LINT = os.environ.get("LINT", True) def setUp(self): os.chdir(TESTS_DIR) @foreach(sorted(LANGS)) @foreach(sorted(TEST_CASES)) def test_generated(self, case, lang): env = os.environ.copy() if ENV.get(lang): env.update(ENV.get(lang)) settings = _get_all_settings(Mock(indent=4), env=env)[lang] ext = settings.ext if (not self.UPDATE_EXPECTED and not self.KEEP_GENERATED and not os.path.exists(f"expected/{case}{ext}")): raise unittest.SkipTest(f"expected/{case}{ext} not found") if settings.formatter: if not spawn.find_executable(settings.formatter[0]): raise unittest.SkipTest( f"{settings.formatter[0]} not available") if ext == ".kt": class_name = str(case.title()) + "Kt" exe = TESTS_DIR / (class_name + ".class") elif ext == ".cpp": exe = TESTS_DIR / "a.out" elif ext == ".dart" or (ext == ".nim" and sys.platform == "win32"): exe = TESTS_DIR / "cases" / f"{case}.exe" else: exe = TESTS_DIR / "cases" / f"{case}" exe.unlink(missing_ok=True) case_filename = TESTS_DIR / "cases" / f"{case}.py" case_output = TESTS_DIR / "cases" / f"{case}{ext}" is_script = has_main(case_filename) self.assertTrue(is_script) proc = run([sys.executable, str(case_filename)], capture_output=True) expected_output = proc.stdout if proc.returncode: raise RuntimeError( f"Invalid cases/{case}.py:\n{expected_output}{proc.stderr}") self.assertTrue(expected_output, "Test cases must print something") expected_output = expected_output.splitlines() args = [f"--{lang}=1", str(case_filename)] try: rv = main(args=args, env=env) with open(f"cases/{case}{ext}") as actual: generated = actual.read() if os.path.exists( f"expected/{case}{ext}") and not self.UPDATE_EXPECTED: with open(f"expected/{case}{ext}") as f2: self.assertEqual(f2.read(), generated) print("expected = generated") expect_failure = (not self.SHOW_ERRORS and f"{case}{ext}" in EXPECTED_LINT_FAILURES) if not expect_failure: assert rv, "formatting failed" elif not rv: raise unittest.SkipTest("formatting failed") compiler = COMPILERS[lang] if compiler: if not spawn.find_executable(compiler[0]): raise unittest.SkipTest(f"{compiler[0]} not available") expect_compile_failure = (not self.SHOW_ERRORS and f"{case}{ext}" in EXPECTED_COMPILE_FAILURES) if expect_compile_failure: return proc = run([*compiler, f"cases/{case}{ext}"], env=env, check=not expect_failure) if proc.returncode: raise unittest.SkipTest(f"{case}{ext} doesnt compile") if self.UPDATE_EXPECTED or not os.path.exists( f"expected/{case}{ext}"): with open(f"expected/{case}{ext}", "w") as f: f.write(generated) stdout = None if exe.exists() and os.access(exe, os.X_OK): stdout = run([exe], env=env, capture_output=True, check=True).stdout elif INVOKER.get(lang): invoker = INVOKER.get(lang) if not spawn.find_executable(invoker[0]): raise unittest.SkipTest(f"{invoker[0]} not available") proc = run( [*invoker, case_output], env=env, capture_output=True, check=not expect_failure, ) stdout = proc.stdout if proc.returncode: raise unittest.SkipTest(f"Execution of {case}{ext} failed") else: raise RuntimeError("Compiled output not detected") if expected_output and stdout: stdout = stdout.splitlines() self.assertEqual(expected_output, stdout) if settings.linter and self.LINT: if not spawn.find_executable(settings.linter[0]): raise unittest.SkipTest( f"{settings.linter[0]} not available") if settings.ext == ".kt" and case_output.is_absolute(): # KtLint does not support absolute path in globs case_output = case_output.relative_to(Path.cwd()) linter = _create_cmd(settings.linter, case_output) if ext == ".cpp": linter.append("-Wno-unused-variable") if case == "coverage": linter.append("-Wno-null-arithmetic" if CXX == "clang++" else "-Wno-pointer-arith") proc = run(linter, env=env) # golint is failing regularly due to exports without docs if proc.returncode and linter[0] == "golint": expect_failure = True if proc.returncode and expect_failure: raise unittest.SkipTest(f"{case}{ext} failed linter") self.assertFalse(proc.returncode) if expect_failure: raise AssertionError( f"{case}{ext} passed unexpectedly") finally: if not self.KEEP_GENERATED: case_output.unlink(missing_ok=True) exe.unlink(missing_ok=True)
class SelfTranspileTests(unittest.TestCase): SETTINGS = _get_all_settings(Mock(indent=4, extension=False)) def setUp(self): rmtree(OUT_DIR, ignore_errors=True) def test_rust_recursive(self): settings = self.SETTINGS["rust"] transpiler_module = ROOT_DIR / "pyrs" assert_only_reformat_failures( *_process_dir( settings, transpiler_module, OUT_DIR, False, _suppress_exceptions=False ) ) expected_file = OUT_DIR / "tests" / "test_clike.rs" assert expected_file.is_file(), f"{expected_file} missing" assert_only_reformat_failures( *_process_dir( settings, PY2MANY_MODULE, OUT_DIR, False, _suppress_exceptions=False ), ) def test_dart_recursive(self): settings = self.SETTINGS["dart"] transpiler_module = ROOT_DIR / "pydart" assert_only_reformat_failures( *_process_dir( settings, transpiler_module, OUT_DIR, False, _suppress_exceptions=False ), ) assert_only_reformat_failures( *_process_dir( settings, PY2MANY_MODULE, OUT_DIR, False, _suppress_exceptions=False ), ) def test_kotlin_recursive(self): settings = self.SETTINGS["kotlin"] suppress_exceptions = False if not SHOW_ERRORS and settings.formatter: if not spawn.find_executable(settings.formatter[0]): suppress_exceptions = FileNotFoundError transpiler_module = ROOT_DIR / "pykt" assert_only_reformat_failures( *_process_dir( settings, transpiler_module, OUT_DIR, False, _suppress_exceptions=suppress_exceptions, ) ) successful, format_errors, failures = _process_dir( settings, PY2MANY_MODULE, OUT_DIR, False, _suppress_exceptions=suppress_exceptions, ) if suppress_exceptions: raise unittest.SkipTest(f"{settings.formatter[0]} not available") assert_only_reformat_failures( successful, format_errors, failures, ) def test_go_recursive(self): settings = self.SETTINGS["go"] suppress_exceptions = False if SHOW_ERRORS else AstTypeNotSupported transpiler_module = ROOT_DIR / "pygo" assert_some_failures( *_process_dir( settings, transpiler_module, OUT_DIR, False, _suppress_exceptions=suppress_exceptions, ), expected_success=set(["transpiler.py"]), ) assert_some_failures( *_process_dir( settings, PY2MANY_MODULE, OUT_DIR, False, _suppress_exceptions=suppress_exceptions, ), expected_success={ "__main__.py", "analysis.py", "annotation_transformer.py", "ast_helpers.py", "astx.py", "context.py", "cli.py", "declaration_extractor.py", "exceptions.py", "language.py", "mutability_transformer.py", "nesting_transformer.py", "python_transformer.py", "result.py", "rewriters.py", "smt.py", "scope.py", "toposort_modules.py", "tracer.py", }, ) def test_nim_recursive(self): settings = self.SETTINGS["nim"] transpiler_module = ROOT_DIR / "pynim" assert_only_reformat_failures( *_process_dir( settings, transpiler_module, OUT_DIR, False, _suppress_exceptions=False, ) ) assert_only_reformat_failures( *_process_dir( settings, PY2MANY_MODULE, OUT_DIR, False, _suppress_exceptions=False, ), ) def test_cpp_recursive(self): settings = self.SETTINGS["cpp"] transpiler_module = ROOT_DIR / "pycpp" successful, format_errors, failures = _process_dir( settings, transpiler_module, OUT_DIR, False, _suppress_exceptions=False, ) assert len(successful) >= 11 successful, format_errors, failures = _process_dir( settings, PY2MANY_MODULE, OUT_DIR, False, _suppress_exceptions=False ) assert len(successful) >= 15 def test_julia_recursive(self): settings = self.SETTINGS["julia"] suppress_exceptions = (False,) if not SHOW_ERRORS: if settings.formatter: if not spawn.find_executable(settings.formatter[0]): suppress_exceptions = (FileNotFoundError,) transpiler_module = ROOT_DIR / "pyjl" successful, format_errors, failures = _process_dir( settings, transpiler_module, OUT_DIR, False, _suppress_exceptions=suppress_exceptions, ) if FileNotFoundError not in suppress_exceptions: assert_only_reformat_failures(successful, format_errors, failures) successful, format_errors, failures = _process_dir( settings, PY2MANY_MODULE, OUT_DIR, False, _suppress_exceptions=suppress_exceptions, ) if FileNotFoundError in suppress_exceptions: raise unittest.SkipTest(f"{settings.formatter[0]} not available") assert_only_reformat_failures( successful, format_errors, failures, )