Path 1: 776 calls (0.95)

1def setUp(self) -> None:
2        if self._should_be_skipped_due_to_version():
3            pytest.skip(
4                f"Test cannot run with Python {sys.version.split(' ', maxsplit=1)[0]}."
5            )
6        missing = []
7        for requirement in self._linter.config.requires:
8            try:
9                __import__(requirement)
10            except ImportError:
11                missing.append(requirement)
12        if missing:
13            pytest.skip(f"Requires {','.join(missing)} to be present.")
14        except_implementations = self._linter.config.except_implementations
15        if except_implementations:
16            if platform.python_implementation() in except_implementations:
17                msg = "Test cannot run with Python implementation %r"
18                pytest.skip(msg % platform.python_implementation())
19        excluded_platforms = self._linter.config.exclude_platforms
20        if excluded_platforms:
21            if sys.platform.lower() in excluded_platforms:
22                pytest.skip(f"Test cannot run on platform {sys.platform!r}")
23        if (
24            self._config
25            and self._config.getoption("minimal_messages_config")
26            and self._linter.config.exclude_from_minimal_messages_config
27        ):
28            pytest.skip("Test excluded from --minimal-messages-config")

Path 2: 24 calls (0.03)

Skipped (24) 

1def setUp(self) -> None:
2        if self._should_be_skipped_due_to_version():
3            pytest.skip(
4                f"Test cannot run with Python {sys.version.split(' ', maxsplit=1)[0]}."
5            )
6        missing = []
7        for requirement in self._linter.config.requires:
8            try:
9                __import__(requirement)
10            except ImportError:
11                missing.append(requirement)
12        if missing:
13            pytest.skip(f"Requires {','.join(missing)} to be present.")
14        except_implementations = self._linter.config.except_implementations
15        if except_implementations:
16            if platform.python_implementation() in except_implementations:
17                msg = "Test cannot run with Python implementation %r"
18                pytest.skip(msg % platform.python_implementation())
19        excluded_platforms = self._linter.config.exclude_platforms
20        if excluded_platforms:
21            if sys.platform.lower() in excluded_platforms:
22                pytest.skip(f"Test cannot run on platform {sys.platform!r}")
23        if (
24            self._config
25            and self._config.getoption("minimal_messages_config")
26            and self._linter.config.exclude_from_minimal_messages_config
27        ):
28            pytest.skip("Test excluded from --minimal-messages-config")

Path 3: 4 calls (0.0)

1def setUp(self) -> None:
2        if self._should_be_skipped_due_to_version():
3            pytest.skip(
4                f"Test cannot run with Python {sys.version.split(' ', maxsplit=1)[0]}."
5            )
6        missing = []
7        for requirement in self._linter.config.requires:
8            try:
9                __import__(requirement)
10            except ImportError:
11                missing.append(requirement)
12        if missing:
13            pytest.skip(f"Requires {','.join(missing)} to be present.")
14        except_implementations = self._linter.config.except_implementations
15        if except_implementations:
16            if platform.python_implementation() in except_implementations:
17                msg = "Test cannot run with Python implementation %r"
18                pytest.skip(msg % platform.python_implementation())
19        excluded_platforms = self._linter.config.exclude_platforms
20        if excluded_platforms:
21            if sys.platform.lower() in excluded_platforms:
22                pytest.skip(f"Test cannot run on platform {sys.platform!r}")
23        if (
24            self._config
25            and self._config.getoption("minimal_messages_config")
26            and self._linter.config.exclude_from_minimal_messages_config
27        ):
28            pytest.skip("Test excluded from --minimal-messages-config")

Path 4: 4 calls (0.0)

Skipped (4) 

1def setUp(self) -> None:
2        if self._should_be_skipped_due_to_version():
3            pytest.skip(
4                f"Test cannot run with Python {sys.version.split(' ', maxsplit=1)[0]}."
5            )
6        missing = []
7        for requirement in self._linter.config.requires:
8            try:
9                __import__(requirement)
10            except ImportError:
11                missing.append(requirement)
12        if missing:
13            pytest.skip(f"Requires {','.join(missing)} to be present.")
14        except_implementations = self._linter.config.except_implementations
15        if except_implementations:
16            if platform.python_implementation() in except_implementations:
17                msg = "Test cannot run with Python implementation %r"
18                pytest.skip(msg % platform.python_implementation())
19        excluded_platforms = self._linter.config.exclude_platforms
20        if excluded_platforms:
21            if sys.platform.lower() in excluded_platforms:
22                pytest.skip(f"Test cannot run on platform {sys.platform!r}")
23        if (
24            self._config
25            and self._config.getoption("minimal_messages_config")
26            and self._linter.config.exclude_from_minimal_messages_config
27        ):
28            pytest.skip("Test excluded from --minimal-messages-config")

Path 5: 3 calls (0.0)

Skipped (3) 

1def setUp(self) -> None:
2        if self._should_be_skipped_due_to_version():
3            pytest.skip(
4                f"Test cannot run with Python {sys.version.split(' ', maxsplit=1)[0]}."
5            )
6        missing = []
7        for requirement in self._linter.config.requires:
8            try:
9                __import__(requirement)
10            except ImportError:
11                missing.append(requirement)
12        if missing:
13            pytest.skip(f"Requires {','.join(missing)} to be present.")
14        except_implementations = self._linter.config.except_implementations
15        if except_implementations:
16            if platform.python_implementation() in except_implementations:
17                msg = "Test cannot run with Python implementation %r"
18                pytest.skip(msg % platform.python_implementation())
19        excluded_platforms = self._linter.config.exclude_platforms
20        if excluded_platforms:
21            if sys.platform.lower() in excluded_platforms:
22                pytest.skip(f"Test cannot run on platform {sys.platform!r}")
23        if (
24            self._config
25            and self._config.getoption("minimal_messages_config")
26            and self._linter.config.exclude_from_minimal_messages_config
27        ):
28            pytest.skip("Test excluded from --minimal-messages-config")

Path 6: 2 calls (0.0)

1def setUp(self) -> None:
2        if self._should_be_skipped_due_to_version():
3            pytest.skip(
4                f"Test cannot run with Python {sys.version.split(' ', maxsplit=1)[0]}."
5            )
6        missing = []
7        for requirement in self._linter.config.requires:
8            try:
9                __import__(requirement)
10            except ImportError:
11                missing.append(requirement)
12        if missing:
13            pytest.skip(f"Requires {','.join(missing)} to be present.")
14        except_implementations = self._linter.config.except_implementations
15        if except_implementations:
16            if platform.python_implementation() in except_implementations:
17                msg = "Test cannot run with Python implementation %r"
18                pytest.skip(msg % platform.python_implementation())
19        excluded_platforms = self._linter.config.exclude_platforms
20        if excluded_platforms:
21            if sys.platform.lower() in excluded_platforms:
22                pytest.skip(f"Test cannot run on platform {sys.platform!r}")
23        if (
24            self._config
25            and self._config.getoption("minimal_messages_config")
26            and self._linter.config.exclude_from_minimal_messages_config
27        ):
28            pytest.skip("Test excluded from --minimal-messages-config")

Path 7: 1 calls (0.0)

Skipped (1) 

1def setUp(self) -> None:
2        if self._should_be_skipped_due_to_version():
3            pytest.skip(
4                f"Test cannot run with Python {sys.version.split(' ', maxsplit=1)[0]}."
5            )
6        missing = []
7        for requirement in self._linter.config.requires:
8            try:
9                __import__(requirement)
10            except ImportError:
11                missing.append(requirement)
12        if missing:
13            pytest.skip(f"Requires {','.join(missing)} to be present.")
14        except_implementations = self._linter.config.except_implementations
15        if except_implementations:
16            if platform.python_implementation() in except_implementations:
17                msg = "Test cannot run with Python implementation %r"
18                pytest.skip(msg % platform.python_implementation())
19        excluded_platforms = self._linter.config.exclude_platforms
20        if excluded_platforms:
21            if sys.platform.lower() in excluded_platforms:
22                pytest.skip(f"Test cannot run on platform {sys.platform!r}")
23        if (
24            self._config
25            and self._config.getoption("minimal_messages_config")
26            and self._linter.config.exclude_from_minimal_messages_config
27        ):
28            pytest.skip("Test excluded from --minimal-messages-config")