text: import os
  import warnings
  from typing import List
  from typing import Optional
  from typing import Tuple
  
  import pytest
  from _pytest.fixtures import FixtureRequest
  from _pytest.pytester import Pytester
  
  WARNINGS_SUMMARY_HEADER = "warnings summary"
  
  
  @pytest.fixture
  def pyfile_with_warnings(pytester: Pytester, request: FixtureRequest) -> str:
      """Create a test file which calls a function in a module which generates warnings."""
      pytester.syspathinsert()
      test_name = request.function.__name__
      module_name = test_name.lstrip("test_") + "_module"
      test_file = pytester.makepyfile(
          """
          import {module_name}
          def test_func():
              assert {module_name}.foo() == 1
          """.format(
              module_name=module_name
          ),
          **{
              module_name: """
              import warnings
              def foo():
                  warnings.warn(UserWarning("user warning"))
                  warnings.warn(RuntimeWarning("runtime warning"))
                  return 1
              """,
          },
      )
      return str(test_file)
  
  
  @pytest.mark.filterwarnings("default::UserWarning", "default::RuntimeWarning")
  def test_normal_flow(pytester: Pytester, pyfile_with_warnings) -> None:
      """Check that the warnings section is displayed."""
      result = pytester.runpytest(pyfile_with_warnings)
      result.stdout.fnmatch_lines(
          [
              "*== %s ==*" % WARNINGS_SUMMARY_HEADER,
              "test_normal_flow.py::test_func",
              "*normal_flow_module.py:3: UserWarning: user warning",
              '*  warnings.warn(UserWarning("user warning"))',
              "*normal_flow_module.py:4: RuntimeWarning: runtime warning",
              '*  warnings.warn(RuntimeWarning("runtime warning"))',
              "* 1 passed, 2 warnings*",
          ]
      )
  
  
  @pytest.mark.filterwarnings("always::UserWarning")
  def test_setup_teardown_warnings(pytester: Pytester) -> None:
      pytester.makepyfile(
          """
          import warnings
          import pytest
  
          @pytest.fixture
          def fix():
              warnings.warn(UserWarning("warning during setup"))
              yield
              warnings.warn(UserWarning("warning during teardown"))
  
          def test_func(fix):
              pass
      """
      )
      result = pytester.runpytest()
      result.stdout.fnmatch_lines(
          [
              "*== %s ==*" % WARNINGS_SUMMARY_HEADER,
              "*test_setup_teardown_warnings.py:6: UserWarning: warning during setup",
              '*warnings.warn(UserWarning("warning during setup"))',
              "*test_setup_teardown_warnings.py:8: UserWarning: warning during teardown",
              '*warnings.warn(UserWarning("warning during teardown"))',
              "* 1 passed, 2 warnings*",
          ]
      )
  
  
  @pytest.mark.parametrize("method", ["cmdline", "ini"])
  def test_as_errors(pytester: Pytester, pyfile_with_warnings, method) -> None:
      args = ("-W", "error") if method == "cmdline" else ()
      if method == "ini":
          pytester.makeini(
              """
              [pytest]
              filterwarnings=error
              """
          )
      # Use a subprocess, since changing logging level affects other threads
      # (xdist).
      result = pytester.runpytest_subprocess(*args, pyfile_with_warnings)
      result.stdout.fnmatch_lines(
          [
              "E       UserWarning: user warning",
              "as_errors_module.py:3: UserWarning",
              "* 1 failed in *",
          ]
      )
  
  
  @pytest.mark.parametrize("method", ["cmdline", "ini"])
  def test_ignore(pytester: Pytester, pyfile_with_warnings, method) -> None:
      args = ("-W", "ignore") if method == "cmdline" else ()
      if method == "ini":
          pytester.makeini(
              """
          [pytest]
          filterwarnings= ignore
          """
          )
  
      result = pytester.runpytest(*args, pyfile_with_warnings)
      result.stdout.fnmatch_lines(["* 1 passed in *"])
      assert WARNINGS_SUMMARY_HEADER not in result.stdout.str()
  
  
  @pytest.mark.filterwarnings("always::UserWarning")
  def test_unicode(pytester: Pytester) -> None:
      pytester.makepyfile(
          """
          import warnings
          import pytest
  
  
          @pytest.fixture
          def fix():
              warnings.warn("测试")
              yield
  
          def test_func(fix):
              pass
          """
      )
      result = pytester.runpytest()
      result.stdout.fnmatch_lines(
          [
              "*== %s ==*" % WARNINGS_SUMMARY_HEADER,
              "*test_unicode.py:7: UserWarning: \u6d4b\u8bd5*",
              "* 1 passed, 1 warning*",
          ]
      )
  
  
  def test_works_with_filterwarnings(pytester: Pytester) -> None:
      """Ensure our warnings capture does not mess with pre-installed filters (#2430)."""
      pytester.makepyfile(
          """
          import warnings
  
          class MyWarning(Warning):
              pass
  
          warnings.filterwarnings("error", category=MyWarning)
  
          class TestWarnings(object):
              def test_my_warning(self):
                  try:
                      warnings.warn(MyWarning("warn!"))
                      assert False
                  except MyWarning:
                      assert True
      """
      )
      result = pytester.runpytest()
      result.stdout.fnmatch_lines(["*== 1 passed in *"])
  
  
  @pytest.mark.parametrize("default_config", ["ini", "cmdline"])
  def test_filterwarnings_mark(pytester: Pytester, default_config) -> None:
      """Test ``filterwarnings`` mark works and takes precedence over command
      line and ini options."""
      if default_config == "ini":
          pytester.makeini(
              """
              [pytest]
              filterwarnings = always::RuntimeWarning
          """
          )
      pytester.makepyfile(
          """
          import warnings
          import pytest
  
          @pytest.mark.filterwarnings('ignore::RuntimeWarning')
          def test_ignore_runtime_warning():
              warnings.warn(RuntimeWarning())
  
          @pytest.mark.filterwarnings('error')
          def test_warning_error():
              warnings.warn(RuntimeWarning())
  
          def test_show_warning():
              warnings.warn(RuntimeWarning())
      """
      )
      result = pytester.runpytest(
          "-W always::RuntimeWarning" if default_config == "cmdline" else ""
      )
      result.stdout.fnmatch_lines(["*= 1 failed, 2 passed, 1 warning in *"])
  
  
  def test_non_string_warning_argument(pytester: Pytester) -> None:
      """Non-str argument passed to warning breaks pytest (#2956)"""
      pytester.makepyfile(
          """\
          import warnings
          import pytest
  
          def test():
              warnings.warn(UserWarning(1, 'foo'))
          """
      )
      result = pytester.runpytest("-W", "always::UserWarning")
      result.stdout.fnmatch_lines(["*= 1 passed, 1 warning in *"])
  
  
  def test_filterwarnings_mark_registration(pytester: Pytester) -> None:
      """Ensure filterwarnings mark is registered"""
      pytester.makepyfile(
          """
          import pytest
  
          @pytest.mark.filterwarnings('error')
          def test_func():
              pass
      """
      )
      result = pytester.runpytest("--strict-markers")
      assert result.ret == 0
  
  
  @pytest.mark.filterwarnings("always::UserWarning")
  def test_warning_captured_hook(pytester: Pytester) -> None:
      pytester.makeconftest(
          """
          def pytest_configure(config):
              config.issue_config_time_warning(UserWarning("config warning"), stacklevel=2)
      """
      )
      pytester.makepyfile(
          """
          import pytest, warnings
  
          warnings.warn(UserWarning("collect warning"))
  
          @pytest.fixture
          def fix():
              warnings.warn(UserWarning("setup warning"))
              yield 1
              warnings.warn(UserWarning("teardown warning"))
  
          def test_func(fix):
              warnings.warn(UserWarning("call warning"))
              assert fix == 1
          """
      )
  
      collected = []
  
      class WarningCollector:
          def pytest_warning_recorded(self, warning_message, when, nodeid, location):
              collected.append((str(warning_message.message), when, nodeid, location))
  
      result = pytester.runpytest(plugins=[WarningCollector()])
      result.stdout.fnmatch_lines(["*1 passed*"])
  
      expected = [
          ("config warning", "config", ""),
          ("collect warning", "collect", ""),
          ("setup warning", "runtest", "test_warning_captured_hook.py::test_func"),
          ("call warning", "runtest", "test_warning_captured_hook.py::test_func"),
          ("teardown warning", "runtest", "test_warning_captured_hook.py::test_func"),
      ]
      for index in range(len(expected)):
          collected_result = collected[index]
          expected_result = expected[index]
  
          assert collected_result[0] == expected_result[0], str(collected)
          assert collected_result[1] == expected_result[1], str(collected)
          assert collected_result[2] == expected_result[2], str(collected)
  
          # NOTE: collected_result[3] is location, which differs based on the platform you are on
          #       thus, the best we can do here is assert the types of the parameters match what we expect
          #       and not try and preload it in the expected array
          if collected_result[3] is not None:
              assert type(collected_result[3][0]) is str, str(collected)
              assert type(collected_result[3][1]) is int, str(collected)
              assert type(collected_result[3][2]) is str, str(collected)
          else:
              assert collected_result[3] is None, str(collected)
  
  
  @pytest.mark.filterwarnings("always::UserWarning")
  def test_collection_warnings(pytester: Pytester) -> None:
      """Check that we also capture warnings issued during test collection (#3251)."""
      pytester.makepyfile(
          """
          import warnings
  
          warnings.warn(UserWarning("collection warning"))
  
          def test_foo():
              pass
      """
      )
      result = pytester.runpytest()
      result.stdout.fnmatch_lines(
          [
              "*== %s ==*" % WARNINGS_SUMMARY_HEADER,
              "  *collection_warnings.py:3: UserWarning: collection warning",
              '    warnings.warn(UserWarning("collection warning"))',
              "* 1 passed, 1 warning*",
          ]
      )
  
  
  @pytest.mark.filterwarnings("always::UserWarning")
  def test_mark_regex_escape(pytester: Pytester) -> None:
      """@pytest.mark.filterwarnings should not try to escape regex characters (#3936)"""
      pytester.makepyfile(
          r"""
          import pytest, warnings
  
          @pytest.mark.filterwarnings(r"ignore:some \(warning\)")
          def test_foo():
              warnings.warn(UserWarning("some (warning)"))
      """
      )
      result = pytester.runpytest()
      assert WARNINGS_SUMMARY_HEADER not in result.stdout.str()
  
  
  @pytest.mark.filterwarnings("default::pytest.PytestWarning")
  @pytest.mark.parametrize("ignore_pytest_warnings", ["no", "ini", "cmdline"])
  def test_hide_pytest_internal_warnings(
      pytester: Pytester, ignore_pytest_warnings
  ) -> None:
      """Make sure we can ignore internal pytest warnings using a warnings filter."""
      pytester.makepyfile(
          """
          import pytest
          import warnings
  
          warnings.warn(pytest.PytestWarning("some internal warning"))
  
          def test_bar():
              pass
      """
      )
      if ignore_pytest_warnings == "ini":
          pytester.makeini(
              """
              [pytest]
              filterwarnings = ignore::pytest.PytestWarning
          """
          )
      args = (
          ["-W", "ignore::pytest.PytestWarning"]
          if ignore_pytest_warnings == "cmdline"
          else []
      )
      result = pytester.runpytest(*args)
      if ignore_pytest_warnings != "no":
          assert WARNINGS_SUMMARY_HEADER not in result.stdout.str()
      else:
          result.stdout.fnmatch_lines(
              [
                  "*== %s ==*" % WARNINGS_SUMMARY_HEADER,
                  "*test_hide_pytest_internal_warnings.py:4: PytestWarning: some internal warning",
                  "* 1 passed, 1 warning *",
              ]
          )
  
  
  @pytest.mark.parametrize("ignore_on_cmdline", [True, False])
  def test_option_precedence_cmdline_over_ini(
      pytester: Pytester, ignore_on_cmdline
  ) -> None:
      """Filters defined in the command-line should take precedence over filters in ini files (#3946)."""
      pytester.makeini(
          """
          [pytest]
          filterwarnings = error::UserWarning
      """
      )
      pytester.makepyfile(
          """
          import warnings
          def test():
              warnings.warn(UserWarning('hello'))
      """
      )
      args = ["-W", "ignore"] if ignore_on_cmdline else []
      result = pytester.runpytest(*args)
      if ignore_on_cmdline:
          result.stdout.fnmatch_lines(["* 1 passed in*"])
      else:
          result.stdout.fnmatch_lines(["* 1 failed in*"])
  
  
  def test_option_precedence_mark(pytester: Pytester) -> None:
      """Filters defined by marks should always take precedence (#3946)."""
      pytester.makeini(
          """
          [pytest]
          filterwarnings = ignore
      """
      )
      pytester.makepyfile(
          """
          import pytest, warnings
          @pytest.mark.filterwarnings('error')
          def test():
              warnings.warn(UserWarning('hello'))
      """
      )
      result = pytester.runpytest("-W", "ignore")
      result.stdout.fnmatch_lines(["* 1 failed in*"])
  
  
  class TestDeprecationWarningsByDefault:
      """
      Note: all pytest runs are executed in a subprocess so we don't inherit warning filters
      from pytest's own test suite
      """
  
      def create_file(self, pytester: Pytester, mark="") -> None:
          pytester.makepyfile(
              """
              import pytest, warnings
  
              warnings.warn(DeprecationWarning("collection"))
  
              {mark}
              def test_foo():
                  warnings.warn(PendingDeprecationWarning("test run"))
          """.format(
                  mark=mark
              )
          )
  
      @pytest.mark.parametrize("customize_filters", [True, False])
      def test_shown_by_default(self, pytester: Pytester, customize_filters) -> None:
          """Show deprecation warnings by default, even if user has customized the warnings filters (#4013)."""
          self.create_file(pytester)
          if customize_filters:
              pytester.makeini(
                  """
                  [pytest]
                  filterwarnings =
                      once::UserWarning
              """
              )
          result = pytester.runpytest_subprocess()
          result.stdout.fnmatch_lines(
              [
                  "*== %s ==*" % WARNINGS_SUMMARY_HEADER,
                  "*test_shown_by_default.py:3: DeprecationWarning: collection",
                  "*test_shown_by_default.py:7: PendingDeprecationWarning: test run",
                  "* 1 passed, 2 warnings*",
              ]
          )
  
      def test_hidden_by_ini(self, pytester: Pytester) -> None:
          self.create_file(pytester)
          pytester.makeini(
              """
              [pytest]
              filterwarnings =
                  ignore::DeprecationWarning
                  ignore::PendingDeprecationWarning
          """
          )
          result = pytester.runpytest_subprocess()
          assert WARNINGS_SUMMARY_HEADER not in result.stdout.str()
  
      def test_hidden_by_mark(self, pytester: Pytester) -> None:
          """Should hide the deprecation warning from the function, but the warning during collection should
          be displayed normally.
          """
          self.create_file(
              pytester,
              mark='@pytest.mark.filterwarnings("ignore::PendingDeprecationWarning")',
          )
          result = pytester.runpytest_subprocess()
          result.stdout.fnmatch_lines(
              [
                  "*== %s ==*" % WARNINGS_SUMMARY_HEADER,
                  "*test_hidden_by_mark.py:3: DeprecationWarning: collection",
                  "* 1 passed, 1 warning*",
              ]
          )
  
      def test_hidden_by_cmdline(self, pytester: Pytester) -> None:
          self.create_file(pytester)
          result = pytester.runpytest_subprocess(
              "-W",
              "ignore::DeprecationWarning",
              "-W",
              "ignore::PendingDeprecationWarning",
          )
          assert WARNINGS_SUMMARY_HEADER not in result.stdout.str()
  
      def test_hidden_by_system(self, pytester: Pytester, monkeypatch) -> None:
          self.create_file(pytester)
          monkeypatch.setenv("PYTHONWARNINGS", "once::UserWarning")
          result = pytester.runpytest_subprocess()
          assert WARNINGS_SUMMARY_HEADER not in result.stdout.str()
  
  
  @pytest.mark.parametrize("change_default", [None, "ini", "cmdline"])
  def test_removed_in_x_warning_as_error(pytester: Pytester, change_default) -> None:
      """This ensures that PytestRemovedInXWarnings raised by pytest are turned into errors.
  
      This test should be enabled as part of each major release, and skipped again afterwards
      to ensure our deprecations are turning into warnings as expected.
      """
      pytester.makepyfile(
          """
          import warnings, pytest
          def test():
              warnings.warn(pytest.PytestRemovedIn7Warning("some warning"))
      """
      )
      if change_default == "ini":
          pytester.makeini(
              """
              [pytest]
              filterwarnings =
                  ignore::pytest.PytestRemovedIn7Warning
          """
          )
  
      args = (
          ("-Wignore::pytest.PytestRemovedIn7Warning",)
          if change_default == "cmdline"
          else ()
      )
      result = pytester.runpytest(*args)
      if change_default is None:
          result.stdout.fnmatch_lines(["* 1 failed in *"])
      else:
          assert change_default in ("ini", "cmdline")
          result.stdout.fnmatch_lines(["* 1 passed in *"])
  
  
  class TestAssertionWarnings:
      @staticmethod
      def assert_result_warns(result, msg) -> None:
          result.stdout.fnmatch_lines(["*PytestAssertRewriteWarning: %s*" % msg])
  
      def test_tuple_warning(self, pytester: Pytester) -> None:
          pytester.makepyfile(
              """\
              def test_foo():
                  assert (1,2)
              """
          )
          result = pytester.runpytest()
          self.assert_result_warns(
              result, "assertion is always true, perhaps remove parentheses?"
          )
  
  
  def test_warnings_checker_twice() -> None:
      """Issue #4617"""
      expectation = pytest.warns(UserWarning)
      with expectation:
          warnings.warn("Message A", UserWarning)
      with expectation:
          warnings.warn("Message B", UserWarning)
  
  
  @pytest.mark.filterwarnings("always::UserWarning")
  def test_group_warnings_by_message(pytester: Pytester) -> None:
      pytester.copy_example("warnings/test_group_warnings_by_message.py")
      result = pytester.runpytest()
      result.stdout.fnmatch_lines(
          [
              "*== %s ==*" % WARNINGS_SUMMARY_HEADER,
              "test_group_warnings_by_message.py::test_foo[[]0[]]",
              "test_group_warnings_by_message.py::test_foo[[]1[]]",
              "test_group_warnings_by_message.py::test_foo[[]2[]]",
              "test_group_warnings_by_message.py::test_foo[[]3[]]",
              "test_group_warnings_by_message.py::test_foo[[]4[]]",
              "test_group_warnings_by_message.py::test_foo_1",
              "  */test_group_warnings_by_message.py:*: UserWarning: foo",
              "    warnings.warn(UserWarning(msg))",
              "",
              "test_group_warnings_by_message.py::test_bar[[]0[]]",
              "test_group_warnings_by_message.py::test_bar[[]1[]]",
              "test_group_warnings_by_message.py::test_bar[[]2[]]",
              "test_group_warnings_by_message.py::test_bar[[]3[]]",
              "test_group_warnings_by_message.py::test_bar[[]4[]]",
              "  */test_group_warnings_by_message.py:*: UserWarning: bar",
              "    warnings.warn(UserWarning(msg))",
              "",
              "-- Docs: *",
              "*= 11 passed, 11 warnings *",
          ],
          consecutive=True,
      )
  
  
  @pytest.mark.filterwarnings("always::UserWarning")
  def test_group_warnings_by_message_summary(pytester: Pytester) -> None:
      pytester.copy_example("warnings/test_group_warnings_by_message_summary")
      pytester.syspathinsert()
      result = pytester.runpytest()
      result.stdout.fnmatch_lines(
          [
              "*== %s ==*" % WARNINGS_SUMMARY_HEADER,
              "test_1.py: 21 warnings",
              "test_2.py: 1 warning",
              "  */test_1.py:7: UserWarning: foo",
              "    warnings.warn(UserWarning(msg))",
              "",
              "test_1.py: 20 warnings",
              "  */test_1.py:7: UserWarning: bar",
              "    warnings.warn(UserWarning(msg))",
              "",
              "-- Docs: *",
              "*= 42 passed, 42 warnings *",
          ],
          consecutive=True,
      )
  
  
  def test_pytest_configure_warning(pytester: Pytester, recwarn) -> None:
      """Issue 5115."""
      pytester.makeconftest(
          """
          def pytest_configure():
              import warnings
  
              warnings.warn("from pytest_configure")
          """
      )
  
      result = pytester.runpytest()
      assert result.ret == 5
      assert "INTERNALERROR" not in result.stderr.str()
      warning = recwarn.pop()
      assert str(warning.message) == "from pytest_configure"
  
  
  class TestStackLevel:
      @pytest.fixture
      def capwarn(self, pytester: Pytester):
          class CapturedWarnings:
              captured: List[
                  Tuple[warnings.WarningMessage, Optional[Tuple[str, int, str]]]
              ] = []
  
              @classmethod
              def pytest_warning_recorded(cls, warning_message, when, nodeid, location):
                  cls.captured.append((warning_message, location))
  
          pytester.plugins = [CapturedWarnings()]
  
          return CapturedWarnings
  
      def test_issue4445_rewrite(self, pytester: Pytester, capwarn) -> None:
          """#4445: Make sure the warning points to a reasonable location
          See origin of _issue_warning_captured at: _pytest.assertion.rewrite.py:241
          """
          pytester.makepyfile(some_mod="")
          conftest = pytester.makeconftest(
              """
                  import some_mod
                  import pytest
  
                  pytest.register_assert_rewrite("some_mod")
              """
          )
          pytester.parseconfig()
  
          # with stacklevel=5 the warning originates from register_assert_rewrite
          # function in the created conftest.py
          assert len(capwarn.captured) == 1
          warning, location = capwarn.captured.pop()
          file, lineno, func = location
  
          assert "Module already imported" in str(warning.message)
          assert file == str(conftest)
          assert func == "<module>"  # the above conftest.py
          assert lineno == 4
  
      def test_issue4445_preparse(self, pytester: Pytester, capwarn) -> None:
          """#4445: Make sure the warning points to a reasonable location
          See origin of _issue_warning_captured at: _pytest.config.__init__.py:910
          """
          pytester.makeconftest(
              """
              import nothing
              """
          )
          pytester.parseconfig("--help")
  
          # with stacklevel=2 the warning should originate from config._preparse and is
          # thrown by an erroneous conftest.py
          assert len(capwarn.captured) == 1
          warning, location = capwarn.captured.pop()
          file, _, func = location
  
          assert "could not load initial conftests" in str(warning.message)
          assert f"config{os.sep}__init__.py" in file
          assert func == "_preparse"
  
      @pytest.mark.filterwarnings("default")
      def test_conftest_warning_captured(self, pytester: Pytester) -> None:
          """Warnings raised during importing of conftest.py files is captured (#2891)."""
          pytester.makeconftest(
              """
              import warnings
              warnings.warn(UserWarning("my custom warning"))
              """
          )
          result = pytester.runpytest()
          result.stdout.fnmatch_lines(
              ["conftest.py:2", "*UserWarning: my custom warning*"]
          )
  
      def test_issue4445_import_plugin(self, pytester: Pytester, capwarn) -> None:
          """#4445: Make sure the warning points to a reasonable location"""
          pytester.makepyfile(
              some_plugin="""
              import pytest
              pytest.skip("thing", allow_module_level=True)
              """
          )
          pytester.syspathinsert()
          pytester.parseconfig("-p", "some_plugin")
  
          # with stacklevel=2 the warning should originate from
          # config.PytestPluginManager.import_plugin is thrown by a skipped plugin
  
          assert len(capwarn.captured) == 1
          warning, location = capwarn.captured.pop()
          file, _, func = location
  
          assert "skipped plugin 'some_plugin': thing" in str(warning.message)
          assert f"config{os.sep}__init__.py" in file
          assert func == "_warn_about_skipped_plugins"
  
      def test_issue4445_issue5928_mark_generator(self, pytester: Pytester) -> None:
          """#4445 and #5928: Make sure the warning from an unknown mark points to
          the test file where this mark is used.
          """
          testfile = pytester.makepyfile(
              """
              import pytest
  
              @pytest.mark.unknown
              def test_it():
                  pass
              """
          )
          result = pytester.runpytest_subprocess()
          # with stacklevel=2 the warning should originate from the above created test file
          result.stdout.fnmatch_lines_random(
              [
                  f"*{testfile}:3*",
                  "*Unknown pytest.mark.unknown*",
              ]
          )
  