jaclang 0.7.34__py3-none-any.whl → 0.8.0__py3-none-any.whl

jaclang/vendor/mypy/test/meta/test_update_data.py

@@ -1,135 +0,0 @@
-"""
-A "meta test" which tests the `--update-data` feature for updating .test files.
-Updating the expected output, especially when it's in the form of inline (comment) assertions,
-can be brittle, which is why we're "meta-testing" here.
-"""
-
-from mypy.test.helpers import Suite
-from mypy.test.meta._pytest import PytestResult, dedent_docstring, run_pytest_data_suite
-
-
-def _run_pytest_update_data(data_suite: str) -> PytestResult:
-    """
-    Runs a suite of data test cases through 'pytest --update-data' until either tests pass
-    or until a maximum number of attempts (needed for incremental tests).
-    """
-    return run_pytest_data_suite(data_suite, extra_args=["--update-data"], max_attempts=3)
-
-
-class UpdateDataSuite(Suite):
-    def test_update_data(self) -> None:
-        # Note: We test multiple testcases rather than 'test case per test case'
-        #       so we could also exercise rewriting multiple testcases at once.
-        result = _run_pytest_update_data(
-            """
-            [case testCorrect]
-            s: str = 42  # E: Incompatible types in assignment (expression has type "int", variable has type "str")
-
-            [case testWrong]
-            s: str = 42  # E: wrong error
-
-            [case testXfail-xfail]
-            s: str = 42  # E: wrong error
-
-            [case testWrongMultiline]
-            s: str = 42  # E: foo \
-                         # N: bar
-
-            [case testMissingMultiline]
-            s: str = 42;  i: int = 'foo'
-
-            [case testExtraneous]
-            s: str = 'foo'  # E: wrong error
-
-            [case testExtraneousMultiline]
-            s: str = 'foo'  # E: foo \
-                            # E: bar
-
-            [case testExtraneousMultilineNonError]
-            s: str = 'foo'  # W: foo \
-                            # N: bar
-
-            [case testOutCorrect]
-            s: str = 42
-            [out]
-            main:1: error: Incompatible types in assignment (expression has type "int", variable has type "str")
-
-            [case testOutWrong]
-            s: str = 42
-            [out]
-            main:1: error: foobar
-
-            [case testOutWrongIncremental]
-            s: str = 42
-            [out]
-            main:1: error: foobar
-            [out2]
-            main:1: error: foobar
-
-            [case testWrongMultipleFiles]
-            import a, b
-            s: str = 42  # E: foo
-            [file a.py]
-            s1: str = 42  # E: bar
-            [file b.py]
-            s2: str = 43  # E: baz
-            [builtins fixtures/list.pyi]
-            """
-        )
-
-        # Assert
-        expected = dedent_docstring(
-            """
-        [case testCorrect]
-        s: str = 42  # E: Incompatible types in assignment (expression has type "int", variable has type "str")
-
-        [case testWrong]
-        s: str = 42  # E: Incompatible types in assignment (expression has type "int", variable has type "str")
-
-        [case testXfail-xfail]
-        s: str = 42  # E: wrong error
-
-        [case testWrongMultiline]
-        s: str = 42  # E: Incompatible types in assignment (expression has type "int", variable has type "str")
-
-        [case testMissingMultiline]
-        s: str = 42;  i: int = 'foo'  # E: Incompatible types in assignment (expression has type "int", variable has type "str") \\
-                                      # E: Incompatible types in assignment (expression has type "str", variable has type "int")
-
-        [case testExtraneous]
-        s: str = 'foo'
-
-        [case testExtraneousMultiline]
-        s: str = 'foo'
-
-        [case testExtraneousMultilineNonError]
-        s: str = 'foo'
-
-        [case testOutCorrect]
-        s: str = 42
-        [out]
-        main:1: error: Incompatible types in assignment (expression has type "int", variable has type "str")
-
-        [case testOutWrong]
-        s: str = 42
-        [out]
-        main:1: error: Incompatible types in assignment (expression has type "int", variable has type "str")
-
-        [case testOutWrongIncremental]
-        s: str = 42
-        [out]
-        main:1: error: Incompatible types in assignment (expression has type "int", variable has type "str")
-        [out2]
-        main:1: error: Incompatible types in assignment (expression has type "int", variable has type "str")
-
-        [case testWrongMultipleFiles]
-        import a, b
-        s: str = 42  # E: Incompatible types in assignment (expression has type "int", variable has type "str")
-        [file a.py]
-        s1: str = 42  # E: Incompatible types in assignment (expression has type "int", variable has type "str")
-        [file b.py]
-        s2: str = 43  # E: Incompatible types in assignment (expression has type "int", variable has type "str")
-        [builtins fixtures/list.pyi]
-        """
-        )
-        assert result.input_updated == expected

jaclang/vendor/mypy/test/test_find_sources.py

@@ -1,376 +0,0 @@
-from __future__ import annotations
-
-import os
-import shutil
-import tempfile
-import unittest
-
-import pytest
-
-from mypy.find_sources import InvalidSourceList, SourceFinder, create_source_list
-from mypy.fscache import FileSystemCache
-from mypy.modulefinder import BuildSource
-from mypy.options import Options
-
-
-class FakeFSCache(FileSystemCache):
-    def __init__(self, files: set[str]) -> None:
-        self.files = {os.path.abspath(f) for f in files}
-
-    def isfile(self, file: str) -> bool:
-        return file in self.files
-
-    def isdir(self, dir: str) -> bool:
-        if not dir.endswith(os.sep):
-            dir += os.sep
-        return any(f.startswith(dir) for f in self.files)
-
-    def listdir(self, dir: str) -> list[str]:
-        if not dir.endswith(os.sep):
-            dir += os.sep
-        return list({f[len(dir) :].split(os.sep)[0] for f in self.files if f.startswith(dir)})
-
-    def init_under_package_root(self, file: str) -> bool:
-        return False
-
-
-def normalise_path(path: str) -> str:
-    path = os.path.splitdrive(path)[1]
-    path = path.replace(os.sep, "/")
-    return path
-
-
-def normalise_build_source_list(sources: list[BuildSource]) -> list[tuple[str, str | None]]:
-    return sorted(
-        (s.module, (normalise_path(s.base_dir) if s.base_dir is not None else None))
-        for s in sources
-    )
-
-
-def crawl(finder: SourceFinder, f: str) -> tuple[str, str]:
-    module, base_dir = finder.crawl_up(f)
-    return module, normalise_path(base_dir)
-
-
-def find_sources_in_dir(finder: SourceFinder, f: str) -> list[tuple[str, str | None]]:
-    return normalise_build_source_list(finder.find_sources_in_dir(os.path.abspath(f)))
-
-
-def find_sources(
-    paths: list[str], options: Options, fscache: FileSystemCache
-) -> list[tuple[str, str | None]]:
-    paths = [os.path.abspath(p) for p in paths]
-    return normalise_build_source_list(create_source_list(paths, options, fscache))
-
-
-class SourceFinderSuite(unittest.TestCase):
-    def setUp(self) -> None:
-        self.tempdir = tempfile.mkdtemp()
-        self.oldcwd = os.getcwd()
-        os.chdir(self.tempdir)
-
-    def tearDown(self) -> None:
-        os.chdir(self.oldcwd)
-        shutil.rmtree(self.tempdir)
-
-    def test_crawl_no_namespace(self) -> None:
-        options = Options()
-        options.namespace_packages = False
-
-        finder = SourceFinder(FakeFSCache({"/setup.py"}), options)
-        assert crawl(finder, "/setup.py") == ("setup", "/")
-
-        finder = SourceFinder(FakeFSCache({"/a/setup.py"}), options)
-        assert crawl(finder, "/a/setup.py") == ("setup", "/a")
-
-        finder = SourceFinder(FakeFSCache({"/a/b/setup.py"}), options)
-        assert crawl(finder, "/a/b/setup.py") == ("setup", "/a/b")
-
-        finder = SourceFinder(FakeFSCache({"/a/setup.py", "/a/__init__.py"}), options)
-        assert crawl(finder, "/a/setup.py") == ("a.setup", "/")
-
-        finder = SourceFinder(FakeFSCache({"/a/invalid-name/setup.py", "/a/__init__.py"}), options)
-        assert crawl(finder, "/a/invalid-name/setup.py") == ("setup", "/a/invalid-name")
-
-        finder = SourceFinder(FakeFSCache({"/a/b/setup.py", "/a/__init__.py"}), options)
-        assert crawl(finder, "/a/b/setup.py") == ("setup", "/a/b")
-
-        finder = SourceFinder(
-            FakeFSCache({"/a/b/c/setup.py", "/a/__init__.py", "/a/b/c/__init__.py"}), options
-        )
-        assert crawl(finder, "/a/b/c/setup.py") == ("c.setup", "/a/b")
-
-    def test_crawl_namespace(self) -> None:
-        options = Options()
-        options.namespace_packages = True
-
-        finder = SourceFinder(FakeFSCache({"/setup.py"}), options)
-        assert crawl(finder, "/setup.py") == ("setup", "/")
-
-        finder = SourceFinder(FakeFSCache({"/a/setup.py"}), options)
-        assert crawl(finder, "/a/setup.py") == ("setup", "/a")
-
-        finder = SourceFinder(FakeFSCache({"/a/b/setup.py"}), options)
-        assert crawl(finder, "/a/b/setup.py") == ("setup", "/a/b")
-
-        finder = SourceFinder(FakeFSCache({"/a/setup.py", "/a/__init__.py"}), options)
-        assert crawl(finder, "/a/setup.py") == ("a.setup", "/")
-
-        finder = SourceFinder(FakeFSCache({"/a/invalid-name/setup.py", "/a/__init__.py"}), options)
-        assert crawl(finder, "/a/invalid-name/setup.py") == ("setup", "/a/invalid-name")
-
-        finder = SourceFinder(FakeFSCache({"/a/b/setup.py", "/a/__init__.py"}), options)
-        assert crawl(finder, "/a/b/setup.py") == ("a.b.setup", "/")
-
-        finder = SourceFinder(
-            FakeFSCache({"/a/b/c/setup.py", "/a/__init__.py", "/a/b/c/__init__.py"}), options
-        )
-        assert crawl(finder, "/a/b/c/setup.py") == ("a.b.c.setup", "/")
-
-    def test_crawl_namespace_explicit_base(self) -> None:
-        options = Options()
-        options.namespace_packages = True
-        options.explicit_package_bases = True
-
-        finder = SourceFinder(FakeFSCache({"/setup.py"}), options)
-        assert crawl(finder, "/setup.py") == ("setup", "/")
-
-        finder = SourceFinder(FakeFSCache({"/a/setup.py"}), options)
-        assert crawl(finder, "/a/setup.py") == ("setup", "/a")
-
-        finder = SourceFinder(FakeFSCache({"/a/b/setup.py"}), options)
-        assert crawl(finder, "/a/b/setup.py") == ("setup", "/a/b")
-
-        finder = SourceFinder(FakeFSCache({"/a/setup.py", "/a/__init__.py"}), options)
-        assert crawl(finder, "/a/setup.py") == ("a.setup", "/")
-
-        finder = SourceFinder(FakeFSCache({"/a/invalid-name/setup.py", "/a/__init__.py"}), options)
-        assert crawl(finder, "/a/invalid-name/setup.py") == ("setup", "/a/invalid-name")
-
-        finder = SourceFinder(FakeFSCache({"/a/b/setup.py", "/a/__init__.py"}), options)
-        assert crawl(finder, "/a/b/setup.py") == ("a.b.setup", "/")
-
-        finder = SourceFinder(
-            FakeFSCache({"/a/b/c/setup.py", "/a/__init__.py", "/a/b/c/__init__.py"}), options
-        )
-        assert crawl(finder, "/a/b/c/setup.py") == ("a.b.c.setup", "/")
-
-        # set mypy path, so we actually have some explicit base dirs
-        options.mypy_path = ["/a/b"]
-
-        finder = SourceFinder(FakeFSCache({"/a/b/c/setup.py"}), options)
-        assert crawl(finder, "/a/b/c/setup.py") == ("c.setup", "/a/b")
-
-        finder = SourceFinder(
-            FakeFSCache({"/a/b/c/setup.py", "/a/__init__.py", "/a/b/c/__init__.py"}), options
-        )
-        assert crawl(finder, "/a/b/c/setup.py") == ("c.setup", "/a/b")
-
-        options.mypy_path = ["/a/b", "/a/b/c"]
-        finder = SourceFinder(FakeFSCache({"/a/b/c/setup.py"}), options)
-        assert crawl(finder, "/a/b/c/setup.py") == ("setup", "/a/b/c")
-
-    def test_crawl_namespace_multi_dir(self) -> None:
-        options = Options()
-        options.namespace_packages = True
-        options.explicit_package_bases = True
-        options.mypy_path = ["/a", "/b"]
-
-        finder = SourceFinder(FakeFSCache({"/a/pkg/a.py", "/b/pkg/b.py"}), options)
-        assert crawl(finder, "/a/pkg/a.py") == ("pkg.a", "/a")
-        assert crawl(finder, "/b/pkg/b.py") == ("pkg.b", "/b")
-
-    def test_find_sources_in_dir_no_namespace(self) -> None:
-        options = Options()
-        options.namespace_packages = False
-
-        files = {
-            "/pkg/a1/b/c/d/e.py",
-            "/pkg/a1/b/f.py",
-            "/pkg/a2/__init__.py",
-            "/pkg/a2/b/c/d/e.py",
-            "/pkg/a2/b/f.py",
-        }
-        finder = SourceFinder(FakeFSCache(files), options)
-        assert find_sources_in_dir(finder, "/") == [
-            ("a2", "/pkg"),
-            ("e", "/pkg/a1/b/c/d"),
-            ("e", "/pkg/a2/b/c/d"),
-            ("f", "/pkg/a1/b"),
-            ("f", "/pkg/a2/b"),
-        ]
-
-    def test_find_sources_in_dir_namespace(self) -> None:
-        options = Options()
-        options.namespace_packages = True
-
-        files = {
-            "/pkg/a1/b/c/d/e.py",
-            "/pkg/a1/b/f.py",
-            "/pkg/a2/__init__.py",
-            "/pkg/a2/b/c/d/e.py",
-            "/pkg/a2/b/f.py",
-        }
-        finder = SourceFinder(FakeFSCache(files), options)
-        assert find_sources_in_dir(finder, "/") == [
-            ("a2", "/pkg"),
-            ("a2.b.c.d.e", "/pkg"),
-            ("a2.b.f", "/pkg"),
-            ("e", "/pkg/a1/b/c/d"),
-            ("f", "/pkg/a1/b"),
-        ]
-
-    def test_find_sources_in_dir_namespace_explicit_base(self) -> None:
-        options = Options()
-        options.namespace_packages = True
-        options.explicit_package_bases = True
-        options.mypy_path = ["/"]
-
-        files = {
-            "/pkg/a1/b/c/d/e.py",
-            "/pkg/a1/b/f.py",
-            "/pkg/a2/__init__.py",
-            "/pkg/a2/b/c/d/e.py",
-            "/pkg/a2/b/f.py",
-        }
-        finder = SourceFinder(FakeFSCache(files), options)
-        assert find_sources_in_dir(finder, "/") == [
-            ("pkg.a1.b.c.d.e", "/"),
-            ("pkg.a1.b.f", "/"),
-            ("pkg.a2", "/"),
-            ("pkg.a2.b.c.d.e", "/"),
-            ("pkg.a2.b.f", "/"),
-        ]
-
-        options.mypy_path = ["/pkg"]
-        finder = SourceFinder(FakeFSCache(files), options)
-        assert find_sources_in_dir(finder, "/") == [
-            ("a1.b.c.d.e", "/pkg"),
-            ("a1.b.f", "/pkg"),
-            ("a2", "/pkg"),
-            ("a2.b.c.d.e", "/pkg"),
-            ("a2.b.f", "/pkg"),
-        ]
-
-    def test_find_sources_in_dir_namespace_multi_dir(self) -> None:
-        options = Options()
-        options.namespace_packages = True
-        options.explicit_package_bases = True
-        options.mypy_path = ["/a", "/b"]
-
-        finder = SourceFinder(FakeFSCache({"/a/pkg/a.py", "/b/pkg/b.py"}), options)
-        assert find_sources_in_dir(finder, "/") == [("pkg.a", "/a"), ("pkg.b", "/b")]
-
-    def test_find_sources_exclude(self) -> None:
-        options = Options()
-        options.namespace_packages = True
-
-        # default
-        for excluded_dir in ["site-packages", ".whatever", "node_modules", ".x/.z"]:
-            fscache = FakeFSCache({"/dir/a.py", f"/dir/venv/{excluded_dir}/b.py"})
-            assert find_sources(["/"], options, fscache) == [("a", "/dir")]
-            with pytest.raises(InvalidSourceList):
-                find_sources(["/dir/venv/"], options, fscache)
-            assert find_sources([f"/dir/venv/{excluded_dir}"], options, fscache) == [
-                ("b", f"/dir/venv/{excluded_dir}")
-            ]
-            assert find_sources([f"/dir/venv/{excluded_dir}/b.py"], options, fscache) == [
-                ("b", f"/dir/venv/{excluded_dir}")
-            ]
-
-        files = {
-            "/pkg/a1/b/c/d/e.py",
-            "/pkg/a1/b/f.py",
-            "/pkg/a2/__init__.py",
-            "/pkg/a2/b/c/d/e.py",
-            "/pkg/a2/b/f.py",
-        }
-
-        # file name
-        options.exclude = [r"/f\.py$"]
-        fscache = FakeFSCache(files)
-        assert find_sources(["/"], options, fscache) == [
-            ("a2", "/pkg"),
-            ("a2.b.c.d.e", "/pkg"),
-            ("e", "/pkg/a1/b/c/d"),
-        ]
-        assert find_sources(["/pkg/a1/b/f.py"], options, fscache) == [("f", "/pkg/a1/b")]
-        assert find_sources(["/pkg/a2/b/f.py"], options, fscache) == [("a2.b.f", "/pkg")]
-
-        # directory name
-        options.exclude = ["/a1/"]
-        fscache = FakeFSCache(files)
-        assert find_sources(["/"], options, fscache) == [
-            ("a2", "/pkg"),
-            ("a2.b.c.d.e", "/pkg"),
-            ("a2.b.f", "/pkg"),
-        ]
-        with pytest.raises(InvalidSourceList):
-            find_sources(["/pkg/a1"], options, fscache)
-        with pytest.raises(InvalidSourceList):
-            find_sources(["/pkg/a1/"], options, fscache)
-        with pytest.raises(InvalidSourceList):
-            find_sources(["/pkg/a1/b"], options, fscache)
-
-        options.exclude = ["/a1/$"]
-        assert find_sources(["/pkg/a1"], options, fscache) == [
-            ("e", "/pkg/a1/b/c/d"),
-            ("f", "/pkg/a1/b"),
-        ]
-
-        # paths
-        options.exclude = ["/pkg/a1/"]
-        fscache = FakeFSCache(files)
-        assert find_sources(["/"], options, fscache) == [
-            ("a2", "/pkg"),
-            ("a2.b.c.d.e", "/pkg"),
-            ("a2.b.f", "/pkg"),
-        ]
-        with pytest.raises(InvalidSourceList):
-            find_sources(["/pkg/a1"], options, fscache)
-
-        # OR two patterns together
-        for orred in [["/(a1|a3)/"], ["a1", "a3"], ["a3", "a1"]]:
-            options.exclude = orred
-            fscache = FakeFSCache(files)
-            assert find_sources(["/"], options, fscache) == [
-                ("a2", "/pkg"),
-                ("a2.b.c.d.e", "/pkg"),
-                ("a2.b.f", "/pkg"),
-            ]
-
-        options.exclude = ["b/c/"]
-        fscache = FakeFSCache(files)
-        assert find_sources(["/"], options, fscache) == [
-            ("a2", "/pkg"),
-            ("a2.b.f", "/pkg"),
-            ("f", "/pkg/a1/b"),
-        ]
-
-        # nothing should be ignored as a result of this
-        big_exclude1 = [
-            "/pkg/a/",
-            "/2",
-            "/1",
-            "/pk/",
-            "/kg",
-            "/g.py",
-            "/bc",
-            "/xxx/pkg/a2/b/f.py",
-            "xxx/pkg/a2/b/f.py",
-        ]
-        big_exclude2 = ["|".join(big_exclude1)]
-        for big_exclude in [big_exclude1, big_exclude2]:
-            options.exclude = big_exclude
-            fscache = FakeFSCache(files)
-            assert len(find_sources(["/"], options, fscache)) == len(files)
-
-            files = {
-                "pkg/a1/b/c/d/e.py",
-                "pkg/a1/b/f.py",
-                "pkg/a2/__init__.py",
-                "pkg/a2/b/c/d/e.py",
-                "pkg/a2/b/f.py",
-            }
-            fscache = FakeFSCache(files)
-            assert len(find_sources(["."], options, fscache)) == len(files)

jaclang/vendor/mypy/test/test_ref_info.py

@@ -1,45 +0,0 @@
-"""Test exporting line-level reference information (undocumented feature)"""
-
-from __future__ import annotations
-
-import json
-import os
-import sys
-
-from mypy import build
-from mypy.modulefinder import BuildSource
-from mypy.options import Options
-from mypy.test.config import test_temp_dir
-from mypy.test.data import DataDrivenTestCase, DataSuite
-from mypy.test.helpers import assert_string_arrays_equal
-
-
-class RefInfoSuite(DataSuite):
-    required_out_section = True
-    files = ["ref-info.test"]
-
-    def run_case(self, testcase: DataDrivenTestCase) -> None:
-        options = Options()
-        options.use_builtins_fixtures = True
-        options.show_traceback = True
-        options.export_ref_info = True  # This is the flag we are testing
-
-        src = "\n".join(testcase.input)
-        result = build.build(
-            sources=[BuildSource("main", None, src)], options=options, alt_lib_path=test_temp_dir
-        )
-        assert not result.errors
-
-        major, minor = sys.version_info[:2]
-        ref_path = os.path.join(options.cache_dir, f"{major}.{minor}", "__main__.refs.json")
-
-        with open(ref_path) as refs_file:
-            data = json.load(refs_file)
-
-        a = []
-        for item in data:
-            a.append(f"{item['line']}:{item['column']}:{item['target']}")
-
-        assert_string_arrays_equal(
-            testcase.output, a, f"Invalid output ({testcase.file}, line {testcase.line})"
-        )

jaclang/vendor/mypy/test/testapi.py

@@ -1,45 +0,0 @@
-from __future__ import annotations
-
-import sys
-from io import StringIO
-
-import mypy.api
-from mypy.test.helpers import Suite
-
-
-class APISuite(Suite):
-    def setUp(self) -> None:
-        self.sys_stdout = sys.stdout
-        self.sys_stderr = sys.stderr
-        sys.stdout = self.stdout = StringIO()
-        sys.stderr = self.stderr = StringIO()
-
-    def tearDown(self) -> None:
-        sys.stdout = self.sys_stdout
-        sys.stderr = self.sys_stderr
-        assert self.stdout.getvalue() == ""
-        assert self.stderr.getvalue() == ""
-
-    def test_capture_bad_opt(self) -> None:
-        """stderr should be captured when a bad option is passed."""
-        _, stderr, _ = mypy.api.run(["--some-bad-option"])
-        assert isinstance(stderr, str)
-        assert stderr != ""
-
-    def test_capture_empty(self) -> None:
-        """stderr should be captured when a bad option is passed."""
-        _, stderr, _ = mypy.api.run([])
-        assert isinstance(stderr, str)
-        assert stderr != ""
-
-    def test_capture_help(self) -> None:
-        """stdout should be captured when --help is passed."""
-        stdout, _, _ = mypy.api.run(["--help"])
-        assert isinstance(stdout, str)
-        assert stdout != ""
-
-    def test_capture_version(self) -> None:
-        """stdout should be captured when --version is passed."""
-        stdout, _, _ = mypy.api.run(["--version"])
-        assert isinstance(stdout, str)
-        assert stdout != ""

jaclang/vendor/mypy/test/testargs.py

@@ -1,77 +0,0 @@
-"""Ensure the argparse parser and Options class are in sync.
-
-In particular, verify that the argparse defaults are the same as the Options
-defaults, and that argparse doesn't assign any new members to the Options
-object it creates.
-"""
-
-from __future__ import annotations
-
-import argparse
-import sys
-
-from mypy.main import infer_python_executable, process_options
-from mypy.options import Options
-from mypy.test.helpers import Suite, assert_equal
-
-
-class ArgSuite(Suite):
-    def test_coherence(self) -> None:
-        options = Options()
-        _, parsed_options = process_options([], require_targets=False)
-        # FIX: test this too. Requires changing working dir to avoid finding 'setup.cfg'
-        options.config_file = parsed_options.config_file
-        assert_equal(options.snapshot(), parsed_options.snapshot())
-
-    def test_executable_inference(self) -> None:
-        """Test the --python-executable flag with --python-version"""
-        sys_ver_str = "{ver.major}.{ver.minor}".format(ver=sys.version_info)
-
-        base = ["file.py"]  # dummy file
-
-        # test inference given one (infer the other)
-        matching_version = base + [f"--python-version={sys_ver_str}"]
-        _, options = process_options(matching_version)
-        assert options.python_version == sys.version_info[:2]
-        assert options.python_executable == sys.executable
-
-        matching_version = base + [f"--python-executable={sys.executable}"]
-        _, options = process_options(matching_version)
-        assert options.python_version == sys.version_info[:2]
-        assert options.python_executable == sys.executable
-
-        # test inference given both
-        matching_version = base + [
-            f"--python-version={sys_ver_str}",
-            f"--python-executable={sys.executable}",
-        ]
-        _, options = process_options(matching_version)
-        assert options.python_version == sys.version_info[:2]
-        assert options.python_executable == sys.executable
-
-        # test that --no-site-packages will disable executable inference
-        matching_version = base + [f"--python-version={sys_ver_str}", "--no-site-packages"]
-        _, options = process_options(matching_version)
-        assert options.python_version == sys.version_info[:2]
-        assert options.python_executable is None
-
-        # Test setting python_version/executable from config file
-        special_opts = argparse.Namespace()
-        special_opts.python_executable = None
-        special_opts.python_version = None
-        special_opts.no_executable = None
-
-        # first test inferring executable from version
-        options = Options()
-        options.python_executable = None
-        options.python_version = sys.version_info[:2]
-        infer_python_executable(options, special_opts)
-        assert options.python_version == sys.version_info[:2]
-        assert options.python_executable == sys.executable
-
-        # then test inferring version from executable
-        options = Options()
-        options.python_executable = sys.executable
-        infer_python_executable(options, special_opts)
-        assert options.python_version == sys.version_info[:2]
-        assert options.python_executable == sys.executable