Path 1: 518 calls (0.63)

→ test_file FunctionalTestFile (518)

→ config Config (518)

⚠ exception NoFileError (518)

37 run 12 not run

1def __init__(
2        self, test_file: FunctionalTestFile, config: Config | None = None
3    ) -> None:
4        _test_reporter = FunctionalTestReporter()
5        self._linter = PyLinter()
6        self._linter.config.persistent = 0
7        checkers.initialize(self._linter)
8
9        # See if test has its own .rc file, if so we use that one
10        rc_file: Path | str = PYLINTRC
11        try:
12            rc_file = test_file.option_file
13            self._linter.disable("suppressed-message")
14            self._linter.disable("locally-disabled")
15            self._linter.disable("useless-suppression")
16        except NoFileError:
17            pass
18
19        self._test_file = test_file
20        try:
21            args = [test_file.source]
22        except NoFileError:
23            # If we're still raising NoFileError the actual source file doesn't exist
24            args = [""]
25        if config and config.getoption("minimal_messages_config"):
26            with self._open_source_file() as f:
27                messages_to_enable = {msg[1] for msg in self.get_expected_messages(f)}
28                # Always enable fatal errors
29                messages_to_enable.add("astroid-error")
30                messages_to_enable.add("fatal")
31                messages_to_enable.add("syntax-error")
32            args.extend(["--disable=all", f"--enable={','.join(messages_to_enable)}"])
33
34        # Add testoptions
35        self._linter._arg_parser.add_argument(
36            "--min_pyver", type=parse_python_version, default=(2, 5)
37        )
38        self._linter._arg_parser.add_argument(
39            "--max_pyver", type=parse_python_version, default=(4, 0)
40        )
41        self._linter._arg_parser.add_argument(
42            "--min_pyver_end_position", type=parse_python_version, default=(3, 8)
43        )
44        self._linter._arg_parser.add_argument(
45            "--requires", type=lambda s: [i.strip() for i in s.split(",")], default=[]
46        )
47        self._linter._arg_parser.add_argument(
48            "--except_implementations",
49            type=lambda s: [i.strip() for i in s.split(",")],
50            default=[],
51        )
52        self._linter._arg_parser.add_argument(
53            "--exclude_platforms",
54            type=lambda s: [i.strip() for i in s.split(",")],
55            default=[],
56        )
57        self._linter._arg_parser.add_argument(
58            "--exclude_from_minimal_messages_config", default=False
59        )
60
61        _config_initialization(
62            self._linter, args_list=args, config_file=rc_file, reporter=_test_reporter
63        )
64
65        self._check_end_position = (
66            sys.version_info >= self._linter.config.min_pyver_end_position
67        )
68        # TODO: PY3.9: PyPy supports end_lineno from 3.9 and above
69        if self._check_end_position and IS_PYPY:
70            self._check_end_position = sys.version_info >= (3, 9)  # pragma: no cover
71
72        self._config = config
            

Path 2: 295 calls (0.36)

→ test_file FunctionalTestFile (295)

→ config Config (295)

38 run 11 not run

1def __init__(
2        self, test_file: FunctionalTestFile, config: Config | None = None
3    ) -> None:
4        _test_reporter = FunctionalTestReporter()
5        self._linter = PyLinter()
6        self._linter.config.persistent = 0
7        checkers.initialize(self._linter)
8
9        # See if test has its own .rc file, if so we use that one
10        rc_file: Path | str = PYLINTRC
11        try:
12            rc_file = test_file.option_file
13            self._linter.disable("suppressed-message")
14            self._linter.disable("locally-disabled")
15            self._linter.disable("useless-suppression")
16        except NoFileError:
17            pass
18
19        self._test_file = test_file
20        try:
21            args = [test_file.source]
22        except NoFileError:
23            # If we're still raising NoFileError the actual source file doesn't exist
24            args = [""]
25        if config and config.getoption("minimal_messages_config"):
26            with self._open_source_file() as f:
27                messages_to_enable = {msg[1] for msg in self.get_expected_messages(f)}
28                # Always enable fatal errors
29                messages_to_enable.add("astroid-error")
30                messages_to_enable.add("fatal")
31                messages_to_enable.add("syntax-error")
32            args.extend(["--disable=all", f"--enable={','.join(messages_to_enable)}"])
33
34        # Add testoptions
35        self._linter._arg_parser.add_argument(
36            "--min_pyver", type=parse_python_version, default=(2, 5)
37        )
38        self._linter._arg_parser.add_argument(
39            "--max_pyver", type=parse_python_version, default=(4, 0)
40        )
41        self._linter._arg_parser.add_argument(
42            "--min_pyver_end_position", type=parse_python_version, default=(3, 8)
43        )
44        self._linter._arg_parser.add_argument(
45            "--requires", type=lambda s: [i.strip() for i in s.split(",")], default=[]
46        )
47        self._linter._arg_parser.add_argument(
48            "--except_implementations",
49            type=lambda s: [i.strip() for i in s.split(",")],
50            default=[],
51        )
52        self._linter._arg_parser.add_argument(
53            "--exclude_platforms",
54            type=lambda s: [i.strip() for i in s.split(",")],
55            default=[],
56        )
57        self._linter._arg_parser.add_argument(
58            "--exclude_from_minimal_messages_config", default=False
59        )
60
61        _config_initialization(
62            self._linter, args_list=args, config_file=rc_file, reporter=_test_reporter
63        )
64
65        self._check_end_position = (
66            sys.version_info >= self._linter.config.min_pyver_end_position
67        )
68        # TODO: PY3.9: PyPy supports end_lineno from 3.9 and above
69        if self._check_end_position and IS_PYPY:
70            self._check_end_position = sys.version_info >= (3, 9)  # pragma: no cover
71
72        self._config = config
            

Path 3: 3 calls (0.0)

→ test_file FunctionalTestFile (3)

→ config None (3)

⚠ exception NoFileError (3)

39 run 10 not run

1def __init__(
2        self, test_file: FunctionalTestFile, config: Config | None = None
3    ) -> None:
4        _test_reporter = FunctionalTestReporter()
5        self._linter = PyLinter()
6        self._linter.config.persistent = 0
7        checkers.initialize(self._linter)
8
9        # See if test has its own .rc file, if so we use that one
10        rc_file: Path | str = PYLINTRC
11        try:
12            rc_file = test_file.option_file
13            self._linter.disable("suppressed-message")
14            self._linter.disable("locally-disabled")
15            self._linter.disable("useless-suppression")
16        except NoFileError:
17            pass
18
19        self._test_file = test_file
20        try:
21            args = [test_file.source]
22        except NoFileError:
23            # If we're still raising NoFileError the actual source file doesn't exist
24            args = [""]
25        if config and config.getoption("minimal_messages_config"):
26            with self._open_source_file() as f:
27                messages_to_enable = {msg[1] for msg in self.get_expected_messages(f)}
28                # Always enable fatal errors
29                messages_to_enable.add("astroid-error")
30                messages_to_enable.add("fatal")
31                messages_to_enable.add("syntax-error")
32            args.extend(["--disable=all", f"--enable={','.join(messages_to_enable)}"])
33
34        # Add testoptions
35        self._linter._arg_parser.add_argument(
36            "--min_pyver", type=parse_python_version, default=(2, 5)
37        )
38        self._linter._arg_parser.add_argument(
39            "--max_pyver", type=parse_python_version, default=(4, 0)
40        )
41        self._linter._arg_parser.add_argument(
42            "--min_pyver_end_position", type=parse_python_version, default=(3, 8)
43        )
44        self._linter._arg_parser.add_argument(
45            "--requires", type=lambda s: [i.strip() for i in s.split(",")], default=[]
46        )
47        self._linter._arg_parser.add_argument(
48            "--except_implementations",
49            type=lambda s: [i.strip() for i in s.split(",")],
50            default=[],
51        )
52        self._linter._arg_parser.add_argument(
53            "--exclude_platforms",
54            type=lambda s: [i.strip() for i in s.split(",")],
55            default=[],
56        )
57        self._linter._arg_parser.add_argument(
58            "--exclude_from_minimal_messages_config", default=False
59        )
60
61        _config_initialization(
62            self._linter, args_list=args, config_file=rc_file, reporter=_test_reporter
63        )
64
65        self._check_end_position = (
66            sys.version_info >= self._linter.config.min_pyver_end_position
67        )
68        # TODO: PY3.9: PyPy supports end_lineno from 3.9 and above
69        if self._check_end_position and IS_PYPY:
70            self._check_end_position = sys.version_info >= (3, 9)  # pragma: no cover
71
72        self._config = config
            

Path 4: 1 calls (0.0)

→ test_file FunctionalTestFile (1)

→ config None (1)

⚠ exception RuntimeError (1)

34 run 15 not run

1def __init__(
2        self, test_file: FunctionalTestFile, config: Config | None = None
3    ) -> None:
4        _test_reporter = FunctionalTestReporter()
5        self._linter = PyLinter()
6        self._linter.config.persistent = 0
7        checkers.initialize(self._linter)
8
9        # See if test has its own .rc file, if so we use that one
10        rc_file: Path | str = PYLINTRC
11        try:
12            rc_file = test_file.option_file
13            self._linter.disable("suppressed-message")
14            self._linter.disable("locally-disabled")
15            self._linter.disable("useless-suppression")
16        except NoFileError:
17            pass
18
19        self._test_file = test_file
20        try:
21            args = [test_file.source]
22        except NoFileError:
23            # If we're still raising NoFileError the actual source file doesn't exist
24            args = [""]
25        if config and config.getoption("minimal_messages_config"):
26            with self._open_source_file() as f:
27                messages_to_enable = {msg[1] for msg in self.get_expected_messages(f)}
28                # Always enable fatal errors
29                messages_to_enable.add("astroid-error")
30                messages_to_enable.add("fatal")
31                messages_to_enable.add("syntax-error")
32            args.extend(["--disable=all", f"--enable={','.join(messages_to_enable)}"])
33
34        # Add testoptions
35        self._linter._arg_parser.add_argument(
36            "--min_pyver", type=parse_python_version, default=(2, 5)
37        )
38        self._linter._arg_parser.add_argument(
39            "--max_pyver", type=parse_python_version, default=(4, 0)
40        )
41        self._linter._arg_parser.add_argument(
42            "--min_pyver_end_position", type=parse_python_version, default=(3, 8)
43        )
44        self._linter._arg_parser.add_argument(
45            "--requires", type=lambda s: [i.strip() for i in s.split(",")], default=[]
46        )
47        self._linter._arg_parser.add_argument(
48            "--except_implementations",
49            type=lambda s: [i.strip() for i in s.split(",")],
50            default=[],
51        )
52        self._linter._arg_parser.add_argument(
53            "--exclude_platforms",
54            type=lambda s: [i.strip() for i in s.split(",")],
55            default=[],
56        )
57        self._linter._arg_parser.add_argument(
58            "--exclude_from_minimal_messages_config", default=False
59        )
60
61        _config_initialization(
62            self._linter, args_list=args, config_file=rc_file, reporter=_test_reporter
63        )
64
65        self._check_end_position = (
66            sys.version_info >= self._linter.config.min_pyver_end_position
67        )
68        # TODO: PY3.9: PyPy supports end_lineno from 3.9 and above
69        if self._check_end_position and IS_PYPY:
70            self._check_end_position = sys.version_info >= (3, 9)  # pragma: no cover
71
72        self._config = config
            

Path 5: 1 calls (0.0)

→ test_file FunctionalTestFile (1)

→ config MagicMock (1)

⚠ exception NoFileError (1)

43 run 6 not run

1def __init__(
2        self, test_file: FunctionalTestFile, config: Config | None = None
3    ) -> None:
4        _test_reporter = FunctionalTestReporter()
5        self._linter = PyLinter()
6        self._linter.config.persistent = 0
7        checkers.initialize(self._linter)
8
9        # See if test has its own .rc file, if so we use that one
10        rc_file: Path | str = PYLINTRC
11        try:
12            rc_file = test_file.option_file
13            self._linter.disable("suppressed-message")
14            self._linter.disable("locally-disabled")
15            self._linter.disable("useless-suppression")
16        except NoFileError:
17            pass
18
19        self._test_file = test_file
20        try:
21            args = [test_file.source]
22        except NoFileError:
23            # If we're still raising NoFileError the actual source file doesn't exist
24            args = [""]
25        if config and config.getoption("minimal_messages_config"):
26            with self._open_source_file() as f:
27                messages_to_enable = {msg[1] for msg in self.get_expected_messages(f)}
28                # Always enable fatal errors
29                messages_to_enable.add("astroid-error")
30                messages_to_enable.add("fatal")
31                messages_to_enable.add("syntax-error")
32            args.extend(["--disable=all", f"--enable={','.join(messages_to_enable)}"])
33
34        # Add testoptions
35        self._linter._arg_parser.add_argument(
36            "--min_pyver", type=parse_python_version, default=(2, 5)
37        )
38        self._linter._arg_parser.add_argument(
39            "--max_pyver", type=parse_python_version, default=(4, 0)
40        )
41        self._linter._arg_parser.add_argument(
42            "--min_pyver_end_position", type=parse_python_version, default=(3, 8)
43        )
44        self._linter._arg_parser.add_argument(
45            "--requires", type=lambda s: [i.strip() for i in s.split(",")], default=[]
46        )
47        self._linter._arg_parser.add_argument(
48            "--except_implementations",
49            type=lambda s: [i.strip() for i in s.split(",")],
50            default=[],
51        )
52        self._linter._arg_parser.add_argument(
53            "--exclude_platforms",
54            type=lambda s: [i.strip() for i in s.split(",")],
55            default=[],
56        )
57        self._linter._arg_parser.add_argument(
58            "--exclude_from_minimal_messages_config", default=False
59        )
60
61        _config_initialization(
62            self._linter, args_list=args, config_file=rc_file, reporter=_test_reporter
63        )
64
65        self._check_end_position = (
66            sys.version_info >= self._linter.config.min_pyver_end_position
67        )
68        # TODO: PY3.9: PyPy supports end_lineno from 3.9 and above
69        if self._check_end_position and IS_PYPY:
70            self._check_end_position = sys.version_info >= (3, 9)  # pragma: no cover
71
72        self._config = config
            

Path 6: 1 calls (0.0)

→ test_file FunctionalTestFile (1)

→ config MagicMock (1)

44 run 5 not run

1def __init__(
2        self, test_file: FunctionalTestFile, config: Config | None = None
3    ) -> None:
4        _test_reporter = FunctionalTestReporter()
5        self._linter = PyLinter()
6        self._linter.config.persistent = 0
7        checkers.initialize(self._linter)
8
9        # See if test has its own .rc file, if so we use that one
10        rc_file: Path | str = PYLINTRC
11        try:
12            rc_file = test_file.option_file
13            self._linter.disable("suppressed-message")
14            self._linter.disable("locally-disabled")
15            self._linter.disable("useless-suppression")
16        except NoFileError:
17            pass
18
19        self._test_file = test_file
20        try:
21            args = [test_file.source]
22        except NoFileError:
23            # If we're still raising NoFileError the actual source file doesn't exist
24            args = [""]
25        if config and config.getoption("minimal_messages_config"):
26            with self._open_source_file() as f:
27                messages_to_enable = {msg[1] for msg in self.get_expected_messages(f)}
28                # Always enable fatal errors
29                messages_to_enable.add("astroid-error")
30                messages_to_enable.add("fatal")
31                messages_to_enable.add("syntax-error")
32            args.extend(["--disable=all", f"--enable={','.join(messages_to_enable)}"])
33
34        # Add testoptions
35        self._linter._arg_parser.add_argument(
36            "--min_pyver", type=parse_python_version, default=(2, 5)
37        )
38        self._linter._arg_parser.add_argument(
39            "--max_pyver", type=parse_python_version, default=(4, 0)
40        )
41        self._linter._arg_parser.add_argument(
42            "--min_pyver_end_position", type=parse_python_version, default=(3, 8)
43        )
44        self._linter._arg_parser.add_argument(
45            "--requires", type=lambda s: [i.strip() for i in s.split(",")], default=[]
46        )
47        self._linter._arg_parser.add_argument(
48            "--except_implementations",
49            type=lambda s: [i.strip() for i in s.split(",")],
50            default=[],
51        )
52        self._linter._arg_parser.add_argument(
53            "--exclude_platforms",
54            type=lambda s: [i.strip() for i in s.split(",")],
55            default=[],
56        )
57        self._linter._arg_parser.add_argument(
58            "--exclude_from_minimal_messages_config", default=False
59        )
60
61        _config_initialization(
62            self._linter, args_list=args, config_file=rc_file, reporter=_test_reporter
63        )
64
65        self._check_end_position = (
66            sys.version_info >= self._linter.config.min_pyver_end_position
67        )
68        # TODO: PY3.9: PyPy supports end_lineno from 3.9 and above
69        if self._check_end_position and IS_PYPY:
70            self._check_end_position = sys.version_info >= (3, 9)  # pragma: no cover
71
72        self._config = config