text: from contextlib import contextmanager
  import linecache
  import os
  from io import StringIO
  import re
  import sys
  import textwrap
  import unittest
  from test import support
  from test.support.script_helper import assert_python_ok, assert_python_failure
  
  from test.test_warnings.data import stacklevel as warning_tests
  
  import warnings as original_warnings
  
  py_warnings = support.import_fresh_module('warnings', blocked=['_warnings'])
  c_warnings = support.import_fresh_module('warnings', fresh=['_warnings'])
  
  Py_DEBUG = hasattr(sys, 'gettotalrefcount')
  
  @contextmanager
  def warnings_state(module):
      """Use a specific warnings implementation in warning_tests."""
      global __warningregistry__
      for to_clear in (sys, warning_tests):
          try:
              to_clear.__warningregistry__.clear()
          except AttributeError:
              pass
      try:
          __warningregistry__.clear()
      except NameError:
          pass
      original_warnings = warning_tests.warnings
      original_filters = module.filters
      try:
          module.filters = original_filters[:]
          module.simplefilter("once")
          warning_tests.warnings = module
          yield
      finally:
          warning_tests.warnings = original_warnings
          module.filters = original_filters
  
  
  class BaseTest:
  
      """Basic bookkeeping required for testing."""
  
      def setUp(self):
          self.old_unittest_module = unittest.case.warnings
          # The __warningregistry__ needs to be in a pristine state for tests
          # to work properly.
          if '__warningregistry__' in globals():
              del globals()['__warningregistry__']
          if hasattr(warning_tests, '__warningregistry__'):
              del warning_tests.__warningregistry__
          if hasattr(sys, '__warningregistry__'):
              del sys.__warningregistry__
          # The 'warnings' module must be explicitly set so that the proper
          # interaction between _warnings and 'warnings' can be controlled.
          sys.modules['warnings'] = self.module
          # Ensure that unittest.TestCase.assertWarns() uses the same warnings
          # module than warnings.catch_warnings(). Otherwise,
          # warnings.catch_warnings() will be unable to remove the added filter.
          unittest.case.warnings = self.module
          super(BaseTest, self).setUp()
  
      def tearDown(self):
          sys.modules['warnings'] = original_warnings
          unittest.case.warnings = self.old_unittest_module
          super(BaseTest, self).tearDown()
  
  class PublicAPITests(BaseTest):
  
      """Ensures that the correct values are exposed in the
      public API.
      """
  
      def test_module_all_attribute(self):
          self.assertTrue(hasattr(self.module, '__all__'))
          target_api = ["warn", "warn_explicit", "showwarning",
                        "formatwarning", "filterwarnings", "simplefilter",
                        "resetwarnings", "catch_warnings"]
          self.assertSetEqual(set(self.module.__all__),
                              set(target_api))
  
  class CPublicAPITests(PublicAPITests, unittest.TestCase):
      module = c_warnings
  
  class PyPublicAPITests(PublicAPITests, unittest.TestCase):
      module = py_warnings
  
  class FilterTests(BaseTest):
  
      """Testing the filtering functionality."""
  
      def test_error(self):
          with original_warnings.catch_warnings(module=self.module) as w:
              self.module.resetwarnings()
              self.module.filterwarnings("error", category=UserWarning)
              self.assertRaises(UserWarning, self.module.warn,
                                  "FilterTests.test_error")
  
      def test_error_after_default(self):
          with original_warnings.catch_warnings(module=self.module) as w:
              self.module.resetwarnings()
              message = "FilterTests.test_ignore_after_default"
              def f():
                  self.module.warn(message, UserWarning)
  
              with support.captured_stderr() as stderr:
                  f()
              stderr = stderr.getvalue()
              self.assertIn("UserWarning: FilterTests.test_ignore_after_default",
                            stderr)
              self.assertIn("self.module.warn(message, UserWarning)",
                            stderr)
  
              self.module.filterwarnings("error", category=UserWarning)
              self.assertRaises(UserWarning, f)
  
      def test_ignore(self):
          with original_warnings.catch_warnings(record=True,
                  module=self.module) as w:
              self.module.resetwarnings()
              self.module.filterwarnings("ignore", category=UserWarning)
              self.module.warn("FilterTests.test_ignore", UserWarning)
              self.assertEqual(len(w), 0)
              self.assertEqual(list(__warningregistry__), ['version'])
  
      def test_ignore_after_default(self):
          with original_warnings.catch_warnings(record=True,
                  module=self.module) as w:
              self.module.resetwarnings()
              message = "FilterTests.test_ignore_after_default"
              def f():
                  self.module.warn(message, UserWarning)
              f()
              self.module.filterwarnings("ignore", category=UserWarning)
              f()
              f()
              self.assertEqual(len(w), 1)
  
      def test_always(self):
          with original_warnings.catch_warnings(record=True,
                  module=self.module) as w:
              self.module.resetwarnings()
              self.module.filterwarnings("always", category=UserWarning)
              message = "FilterTests.test_always"
              def f():
                  self.module.warn(message, UserWarning)
              f()
              self.assertEqual(len(w), 1)
              self.assertEqual(w[-1].message.args[0], message)
              f()
              self.assertEqual(len(w), 2)
              self.assertEqual(w[-1].message.args[0], message)
  
      def test_always_after_default(self):
          with original_warnings.catch_warnings(record=True,
                  module=self.module) as w:
              self.module.resetwarnings()
              message = "FilterTests.test_always_after_ignore"
              def f():
                  self.module.warn(message, UserWarning)
              f()
              self.assertEqual(len(w), 1)
              self.assertEqual(w[-1].message.args[0], message)
              f()
              self.assertEqual(len(w), 1)
              self.module.filterwarnings("always", category=UserWarning)
              f()
              self.assertEqual(len(w), 2)
              self.assertEqual(w[-1].message.args[0], message)
              f()
              self.assertEqual(len(w), 3)
              self.assertEqual(w[-1].message.args[0], message)
  
      def test_default(self):
          with original_warnings.catch_warnings(record=True,
                  module=self.module) as w:
              self.module.resetwarnings()
              self.module.filterwarnings("default", category=UserWarning)
              message = UserWarning("FilterTests.test_default")
              for x in range(2):
                  self.module.warn(message, UserWarning)
                  if x == 0:
                      self.assertEqual(w[-1].message, message)
                      del w[:]
                  elif x == 1:
                      self.assertEqual(len(w), 0)
                  else:
                      raise ValueError("loop variant unhandled")
  
      def test_module(self):
          with original_warnings.catch_warnings(record=True,
                  module=self.module) as w:
              self.module.resetwarnings()
              self.module.filterwarnings("module", category=UserWarning)
              message = UserWarning("FilterTests.test_module")
              self.module.warn(message, UserWarning)
              self.assertEqual(w[-1].message, message)
              del w[:]
              self.module.warn(message, UserWarning)
              self.assertEqual(len(w), 0)
  
      def test_once(self):
          with original_warnings.catch_warnings(record=True,
                  module=self.module) as w:
              self.module.resetwarnings()
              self.module.filterwarnings("once", category=UserWarning)
              message = UserWarning("FilterTests.test_once")
              self.module.warn_explicit(message, UserWarning, "__init__.py",
                                      42)
              self.assertEqual(w[-1].message, message)
              del w[:]
              self.module.warn_explicit(message, UserWarning, "__init__.py",
                                      13)
              self.assertEqual(len(w), 0)
              self.module.warn_explicit(message, UserWarning, "test_warnings2.py",
                                      42)
              self.assertEqual(len(w), 0)
  
      def test_module_globals(self):
          with original_warnings.catch_warnings(record=True,
                  module=self.module) as w:
              self.module.simplefilter("always", UserWarning)
  
              # bpo-33509: module_globals=None must not crash
              self.module.warn_explicit('msg', UserWarning, "filename", 42,
                                        module_globals=None)
              self.assertEqual(len(w), 1)
  
              # Invalid module_globals type
              with self.assertRaises(TypeError):
                  self.module.warn_explicit('msg', UserWarning, "filename", 42,
                                            module_globals=True)
              self.assertEqual(len(w), 1)
  
              # Empty module_globals
              self.module.warn_explicit('msg', UserWarning, "filename", 42,
                                        module_globals={})
              self.assertEqual(len(w), 2)
  
      def test_inheritance(self):
          with original_warnings.catch_warnings(module=self.module) as w:
              self.module.resetwarnings()
              self.module.filterwarnings("error", category=Warning)
              self.assertRaises(UserWarning, self.module.warn,
                                  "FilterTests.test_inheritance", UserWarning)
  
      def test_ordering(self):
          with original_warnings.catch_warnings(record=True,
                  module=self.module) as w:
              self.module.resetwarnings()
              self.module.filterwarnings("ignore", category=UserWarning)
              self.module.filterwarnings("error", category=UserWarning,
                                          append=True)
              del w[:]
              try:
                  self.module.warn("FilterTests.test_ordering", UserWarning)
              except UserWarning:
                  self.fail("order handling for actions failed")
              self.assertEqual(len(w), 0)
  
      def test_filterwarnings(self):
          # Test filterwarnings().
          # Implicitly also tests resetwarnings().
          with original_warnings.catch_warnings(record=True,
                  module=self.module) as w:
              self.module.filterwarnings("error", "", Warning, "", 0)
              self.assertRaises(UserWarning, self.module.warn, 'convert to error')
  
              self.module.resetwarnings()
              text = 'handle normally'
              self.module.warn(text)
              self.assertEqual(str(w[-1].message), text)
              self.assertIs(w[-1].category, UserWarning)
  
              self.module.filterwarnings("ignore", "", Warning, "", 0)
              text = 'filtered out'
              self.module.warn(text)
              self.assertNotEqual(str(w[-1].message), text)
  
              self.module.resetwarnings()
              self.module.filterwarnings("error", "hex*", Warning, "", 0)
              self.assertRaises(UserWarning, self.module.warn, 'hex/oct')
              text = 'nonmatching text'
              self.module.warn(text)
              self.assertEqual(str(w[-1].message), text)
              self.assertIs(w[-1].category, UserWarning)
  
      def test_message_matching(self):
          with original_warnings.catch_warnings(record=True,
                  module=self.module) as w:
              self.module.simplefilter("ignore", UserWarning)
              self.module.filterwarnings("error", "match", UserWarning)
              self.assertRaises(UserWarning, self.module.warn, "match")
              self.assertRaises(UserWarning, self.module.warn, "match prefix")
              self.module.warn("suffix match")
              self.assertEqual(w, [])
              self.module.warn("something completely different")
              self.assertEqual(w, [])
  
      def test_mutate_filter_list(self):
          class X:
              def match(self, a):
                  L[:] = []
  
          L = [("default",X(),UserWarning,X(),0) for i in range(2)]
          with original_warnings.catch_warnings(record=True,
                  module=self.module) as w:
              self.module.filters = L
              self.module.warn_explicit(UserWarning("b"), None, "f.py", 42)
              self.assertEqual(str(w[-1].message), "b")
  
      def test_filterwarnings_duplicate_filters(self):
          with original_warnings.catch_warnings(module=self.module):
              self.module.resetwarnings()
              self.module.filterwarnings("error", category=UserWarning)
              self.assertEqual(len(self.module.filters), 1)
              self.module.filterwarnings("ignore", category=UserWarning)
              self.module.filterwarnings("error", category=UserWarning)
              self.assertEqual(
                  len(self.module.filters), 2,
                  "filterwarnings inserted duplicate filter"
              )
              self.assertEqual(
                  self.module.filters[0][0], "error",
                  "filterwarnings did not promote filter to "
                  "the beginning of list"
              )
  
      def test_simplefilter_duplicate_filters(self):
          with original_warnings.catch_warnings(module=self.module):
              self.module.resetwarnings()
              self.module.simplefilter("error", category=UserWarning)
              self.assertEqual(len(self.module.filters), 1)
              self.module.simplefilter("ignore", category=UserWarning)
              self.module.simplefilter("error", category=UserWarning)
              self.assertEqual(
                  len(self.module.filters), 2,
                  "simplefilter inserted duplicate filter"
              )
              self.assertEqual(
                  self.module.filters[0][0], "error",
                  "simplefilter did not promote filter to the beginning of list"
              )
  
      def test_append_duplicate(self):
          with original_warnings.catch_warnings(module=self.module,
                  record=True) as w:
              self.module.resetwarnings()
              self.module.simplefilter("ignore")
              self.module.simplefilter("error", append=True)
              self.module.simplefilter("ignore", append=True)
              self.module.warn("test_append_duplicate", category=UserWarning)
              self.assertEqual(len(self.module.filters), 2,
                  "simplefilter inserted duplicate filter"
              )
              self.assertEqual(len(w), 0,
                  "appended duplicate changed order of filters"
              )
  
  class CFilterTests(FilterTests, unittest.TestCase):
      module = c_warnings
  
  class PyFilterTests(FilterTests, unittest.TestCase):
      module = py_warnings
  
  
  class WarnTests(BaseTest):
  
      """Test warnings.warn() and warnings.warn_explicit()."""
  
      def test_message(self):
          with original_warnings.catch_warnings(record=True,
                  module=self.module) as w:
              self.module.simplefilter("once")
              for i in range(4):
                  text = 'multi %d' %i  # Different text on each call.
                  self.module.warn(text)
                  self.assertEqual(str(w[-1].message), text)
                  self.assertIs(w[-1].category, UserWarning)
  
      # Issue 3639
      def test_warn_nonstandard_types(self):
          # warn() should handle non-standard types without issue.
          for ob in (Warning, None, 42):
              with original_warnings.catch_warnings(record=True,
                      module=self.module) as w:
                  self.module.simplefilter("once")
                  self.module.warn(ob)
                  # Don't directly compare objects since
                  # ``Warning() != Warning()``.
                  self.assertEqual(str(w[-1].message), str(UserWarning(ob)))
  
      def test_filename(self):
          with warnings_state(self.module):
              with original_warnings.catch_warnings(record=True,
                      module=self.module) as w:
                  warning_tests.inner("spam1")
                  self.assertEqual(os.path.basename(w[-1].filename),
                                      "stacklevel.py")
                  warning_tests.outer("spam2")
                  self.assertEqual(os.path.basename(w[-1].filename),
                                      "stacklevel.py")
  
      def test_stacklevel(self):
          # Test stacklevel argument
          # make sure all messages are different, so the warning won't be skipped
          with warnings_state(self.module):
              with original_warnings.catch_warnings(record=True,
                      module=self.module) as w:
                  warning_tests.inner("spam3", stacklevel=1)
                  self.assertEqual(os.path.basename(w[-1].filename),
                                      "stacklevel.py")
                  warning_tests.outer("spam4", stacklevel=1)
                  self.assertEqual(os.path.basename(w[-1].filename),
                                      "stacklevel.py")
  
                  warning_tests.inner("spam5", stacklevel=2)
                  self.assertEqual(os.path.basename(w[-1].filename),
                                      "__init__.py")
                  warning_tests.outer("spam6", stacklevel=2)
                  self.assertEqual(os.path.basename(w[-1].filename),
                                      "stacklevel.py")
                  warning_tests.outer("spam6.5", stacklevel=3)
                  self.assertEqual(os.path.basename(w[-1].filename),
                                      "__init__.py")
  
                  warning_tests.inner("spam7", stacklevel=9999)
                  self.assertEqual(os.path.basename(w[-1].filename),
                                      "sys")
  
      def test_stacklevel_import(self):
          # Issue #24305: With stacklevel=2, module-level warnings should work.
          support.unload('test.test_warnings.data.import_warning')
          with warnings_state(self.module):
              with original_warnings.catch_warnings(record=True,
                      module=self.module) as w:
                  self.module.simplefilter('always')
                  import test.test_warnings.data.import_warning
                  self.assertEqual(len(w), 1)
                  self.assertEqual(w[0].filename, __file__)
  
      def test_exec_filename(self):
          filename = "<warnings-test>"
          codeobj = compile(("import warnings\n"
                             "warnings.warn('hello', UserWarning)"),
                            filename, "exec")
          with original_warnings.catch_warnings(record=True) as w:
              self.module.simplefilter("always", category=UserWarning)
              exec(codeobj)
          self.assertEqual(w[0].filename, filename)
  
      def test_warn_explicit_non_ascii_filename(self):
          with original_warnings.catch_warnings(record=True,
                  module=self.module) as w:
              self.module.resetwarnings()
              self.module.filterwarnings("always", category=UserWarning)
              for filename in ("nonascii\xe9\u20ac", "surrogate\udc80"):
                  try:
                      os.fsencode(filename)
                  except UnicodeEncodeError:
                      continue
                  self.module.warn_explicit("text", UserWarning, filename, 1)
                  self.assertEqual(w[-1].filename, filename)
  
      def test_warn_explicit_type_errors(self):
          # warn_explicit() should error out gracefully if it is given objects
          # of the wrong types.
          # lineno is expected to be an integer.
          self.assertRaises(TypeError, self.module.warn_explicit,
                              None, UserWarning, None, None)
          # Either 'message' needs to be an instance of Warning or 'category'
          # needs to be a subclass.
          self.assertRaises(TypeError, self.module.warn_explicit,
                              None, None, None, 1)
          # 'registry' must be a dict or None.
          self.assertRaises((TypeError, AttributeError),
                              self.module.warn_explicit,
                              None, Warning, None, 1, registry=42)
  
      def test_bad_str(self):
          # issue 6415
          # Warnings instance with a bad format string for __str__ should not
          # trigger a bus error.
          class BadStrWarning(Warning):
              """Warning with a bad format string for __str__."""
              def __str__(self):
                  return ("A bad formatted string %(err)" %
                          {"err" : "there is no %(err)s"})
  
          with self.assertRaises(ValueError):
              self.module.warn(BadStrWarning())
  
      def test_warning_classes(self):
          class MyWarningClass(Warning):
              pass
  
          class NonWarningSubclass:
              pass
  
          # passing a non-subclass of Warning should raise a TypeError
          with self.assertRaises(TypeError) as cm:
              self.module.warn('bad warning category', '')
          self.assertIn('category must be a Warning subclass, not ',
                        str(cm.exception))
  
          with self.assertRaises(TypeError) as cm:
              self.module.warn('bad warning category', NonWarningSubclass)
          self.assertIn('category must be a Warning subclass, not ',
                        str(cm.exception))
  
          # check that warning instances also raise a TypeError
          with self.assertRaises(TypeError) as cm:
              self.module.warn('bad warning category', MyWarningClass())
          self.assertIn('category must be a Warning subclass, not ',
                        str(cm.exception))
  
          with original_warnings.catch_warnings(module=self.module):
              self.module.resetwarnings()
              self.module.filterwarnings('default')
              with self.assertWarns(MyWarningClass) as cm:
                  self.module.warn('good warning category', MyWarningClass)
              self.assertEqual('good warning category', str(cm.warning))
  
              with self.assertWarns(UserWarning) as cm:
                  self.module.warn('good warning category', None)
              self.assertEqual('good warning category', str(cm.warning))
  
              with self.assertWarns(MyWarningClass) as cm:
                  self.module.warn('good warning category', MyWarningClass)
              self.assertIsInstance(cm.warning, Warning)
  
  class CWarnTests(WarnTests, unittest.TestCase):
      module = c_warnings
  
      # As an early adopter, we sanity check the
      # test.support.import_fresh_module utility function
      def test_accelerated(self):
          self.assertIsNot(original_warnings, self.module)
          self.assertFalse(hasattr(self.module.warn, '__code__'))
  
  class PyWarnTests(WarnTests, unittest.TestCase):
      module = py_warnings
  
      # As an early adopter, we sanity check the
      # test.support.import_fresh_module utility function
      def test_pure_python(self):
          self.assertIsNot(original_warnings, self.module)
          self.assertTrue(hasattr(self.module.warn, '__code__'))
  
  
  class WCmdLineTests(BaseTest):
  
      def test_improper_input(self):
          # Uses the private _setoption() function to test the parsing
          # of command-line warning arguments
          with original_warnings.catch_warnings(module=self.module):
              self.assertRaises(self.module._OptionError,
                                self.module._setoption, '1:2:3:4:5:6')
              self.assertRaises(self.module._OptionError,
                                self.module._setoption, 'bogus::Warning')
              self.assertRaises(self.module._OptionError,
                                self.module._setoption, 'ignore:2::4:-5')
              self.module._setoption('error::Warning::0')
              self.assertRaises(UserWarning, self.module.warn, 'convert to error')
  
  
  class CWCmdLineTests(WCmdLineTests, unittest.TestCase):
      module = c_warnings
  
  
  class PyWCmdLineTests(WCmdLineTests, unittest.TestCase):
      module = py_warnings
  
      def test_improper_option(self):
          # Same as above, but check that the message is printed out when
          # the interpreter is executed. This also checks that options are
          # actually parsed at all.
          rc, out, err = assert_python_ok("-Wxxx", "-c", "pass")
          self.assertIn(b"Invalid -W option ignored: invalid action: 'xxx'", err)
  
      def test_warnings_bootstrap(self):
          # Check that the warnings module does get loaded when -W<some option>
          # is used (see issue #10372 for an example of silent bootstrap failure).
          rc, out, err = assert_python_ok("-Wi", "-c",
              "import sys; sys.modules['warnings'].warn('foo', RuntimeWarning)")
          # '-Wi' was observed
          self.assertFalse(out.strip())
          self.assertNotIn(b'RuntimeWarning', err)
  
  
  class _WarningsTests(BaseTest, unittest.TestCase):
  
      """Tests specific to the _warnings module."""
  
      module = c_warnings
  
      def test_filter(self):
          # Everything should function even if 'filters' is not in warnings.
          with original_warnings.catch_warnings(module=self.module) as w:
              self.module.filterwarnings("error", "", Warning, "", 0)
              self.assertRaises(UserWarning, self.module.warn,
                                  'convert to error')
              del self.module.filters
              self.assertRaises(UserWarning, self.module.warn,
                                  'convert to error')
  
      def test_onceregistry(self):
          # Replacing or removing the onceregistry should be okay.
          global __warningregistry__
          message = UserWarning('onceregistry test')
          try:
              original_registry = self.module.onceregistry
              __warningregistry__ = {}
              with original_warnings.catch_warnings(record=True,
                      module=self.module) as w:
                  self.module.resetwarnings()
                  self.module.filterwarnings("once", category=UserWarning)
                  self.module.warn_explicit(message, UserWarning, "file", 42)
                  self.assertEqual(w[-1].message, message)
                  del w[:]
                  self.module.warn_explicit(message, UserWarning, "file", 42)
                  self.assertEqual(len(w), 0)
                  # Test the resetting of onceregistry.
                  self.module.onceregistry = {}
                  __warningregistry__ = {}
                  self.module.warn('onceregistry test')
                  self.assertEqual(w[-1].message.args, message.args)
                  # Removal of onceregistry is okay.
                  del w[:]
                  del self.module.onceregistry
                  __warningregistry__ = {}
                  self.module.warn_explicit(message, UserWarning, "file", 42)
                  self.assertEqual(len(w), 0)
          finally:
              self.module.onceregistry = original_registry
  
      def test_default_action(self):
          # Replacing or removing defaultaction should be okay.
          message = UserWarning("defaultaction test")
          original = self.module.defaultaction
          try:
              with original_warnings.catch_warnings(record=True,
                      module=self.module) as w:
                  self.module.resetwarnings()
                  registry = {}
                  self.module.warn_explicit(message, UserWarning, "<test>", 42,
                                              registry=registry)
                  self.assertEqual(w[-1].message, message)
                  self.assertEqual(len(w), 1)
                  # One actual registry key plus the "version" key
                  self.assertEqual(len(registry), 2)
                  self.assertIn("version", registry)
                  del w[:]
                  # Test removal.
                  del self.module.defaultaction
                  __warningregistry__ = {}
                  registry = {}
                  self.module.warn_explicit(message, UserWarning, "<test>", 43,
                                              registry=registry)
                  self.assertEqual(w[-1].message, message)
                  self.assertEqual(len(w), 1)
                  self.assertEqual(len(registry), 2)
                  del w[:]
                  # Test setting.
                  self.module.defaultaction = "ignore"
                  __warningregistry__ = {}
                  registry = {}
                  self.module.warn_explicit(message, UserWarning, "<test>", 44,
                                              registry=registry)
                  self.assertEqual(len(w), 0)
          finally:
              self.module.defaultaction = original
  
      def test_showwarning_missing(self):
          # Test that showwarning() missing is okay.
          text = 'del showwarning test'
          with original_warnings.catch_warnings(module=self.module):
              self.module.filterwarnings("always", category=UserWarning)
              del self.module.showwarning
              with support.captured_output('stderr') as stream:
                  self.module.warn(text)
                  result = stream.getvalue()
          self.assertIn(text, result)
  
      def test_showwarnmsg_missing(self):
          # Test that _showwarnmsg() missing is okay.
          text = 'del _showwarnmsg test'
          with original_warnings.catch_warnings(module=self.module):
              self.module.filterwarnings("always", category=UserWarning)
  
              show = self.module._showwarnmsg
              try:
                  del self.module._showwarnmsg
                  with support.captured_output('stderr') as stream:
                      self.module.warn(text)
                      result = stream.getvalue()
              finally:
                  self.module._showwarnmsg = show
          self.assertIn(text, result)
  
      def test_showwarning_not_callable(self):
          with original_warnings.catch_warnings(module=self.module):
              self.module.filterwarnings("always", category=UserWarning)
              self.module.showwarning = print
              with support.captured_output('stdout'):
                  self.module.warn('Warning!')
              self.module.showwarning = 23
              self.assertRaises(TypeError, self.module.warn, "Warning!")
  
      def test_show_warning_output(self):
          # With showwarning() missing, make sure that output is okay.
          text = 'test show_warning'
          with original_warnings.catch_warnings(module=self.module):
              self.module.filterwarnings("always", category=UserWarning)
              del self.module.showwarning
              with support.captured_output('stderr') as stream:
                  warning_tests.inner(text)
                  result = stream.getvalue()
          self.assertEqual(result.count('\n'), 2,
                               "Too many newlines in %r" % result)
          first_line, second_line = result.split('\n', 1)
          expected_file = os.path.splitext(warning_tests.__file__)[0] + '.py'
          first_line_parts = first_line.rsplit(':', 3)
          path, line, warning_class, message = first_line_parts
          line = int(line)
          self.assertEqual(expected_file, path)
          self.assertEqual(warning_class, ' ' + UserWarning.__name__)
          self.assertEqual(message, ' ' + text)
          expected_line = '  ' + linecache.getline(path, line).strip() + '\n'
          assert expected_line
          self.assertEqual(second_line, expected_line)
  
      def test_filename_none(self):
          # issue #12467: race condition if a warning is emitted at shutdown
          globals_dict = globals()
          oldfile = globals_dict['__file__']
          try:
              catch = original_warnings.catch_warnings(record=True,
                                                       module=self.module)
              with catch as w:
                  self.module.filterwarnings("always", category=UserWarning)
                  globals_dict['__file__'] = None
                  original_warnings.warn('test', UserWarning)
                  self.assertTrue(len(w))
          finally:
              globals_dict['__file__'] = oldfile
  
      def test_stderr_none(self):
          rc, stdout, stderr = assert_python_ok("-c",
              "import sys; sys.stderr = None; "
              "import warnings; warnings.simplefilter('always'); "
              "warnings.warn('Warning!')")
          self.assertEqual(stdout, b'')
          self.assertNotIn(b'Warning!', stderr)
          self.assertNotIn(b'Error', stderr)
  
      def test_issue31285(self):
          # warn_explicit() should neither raise a SystemError nor cause an
          # assertion failure, in case the return value of get_source() has a
          # bad splitlines() method.
          def get_bad_loader(splitlines_ret_val):
              class BadLoader:
                  def get_source(self, fullname):
                      class BadSource(str):
                          def splitlines(self):
                              return splitlines_ret_val
                      return BadSource('spam')
              return BadLoader()
  
          wmod = self.module
          with original_warnings.catch_warnings(module=wmod):
              wmod.filterwarnings('default', category=UserWarning)
  
              with support.captured_stderr() as stderr:
                  wmod.warn_explicit(
                      'foo', UserWarning, 'bar', 1,
                      module_globals={'__loader__': get_bad_loader(42),
                                      '__name__': 'foobar'})
              self.assertIn('UserWarning: foo', stderr.getvalue())
  
              show = wmod._showwarnmsg
              try:
                  del wmod._showwarnmsg
                  with support.captured_stderr() as stderr:
                      wmod.warn_explicit(
                          'eggs', UserWarning, 'bar', 1,
                          module_globals={'__loader__': get_bad_loader([42]),
                                          '__name__': 'foobar'})
                  self.assertIn('UserWarning: eggs', stderr.getvalue())
              finally:
                  wmod._showwarnmsg = show
  
      @support.cpython_only
      def test_issue31411(self):
          # warn_explicit() shouldn't raise a SystemError in case
          # warnings.onceregistry isn't a dictionary.
          wmod = self.module
          with original_warnings.catch_warnings(module=wmod):
              wmod.filterwarnings('once')
              with support.swap_attr(wmod, 'onceregistry', None):
                  with self.assertRaises(TypeError):
                      wmod.warn_explicit('foo', Warning, 'bar', 1, registry=None)
  
      @support.cpython_only
      def test_issue31416(self):
          # warn_explicit() shouldn't cause an assertion failure in case of a
          # bad warnings.filters or warnings.defaultaction.
          wmod = self.module
          with original_warnings.catch_warnings(module=wmod):
              wmod.filters = [(None, None, Warning, None, 0)]
              with self.assertRaises(TypeError):
                  wmod.warn_explicit('foo', Warning, 'bar', 1)
  
              wmod.filters = []
              with support.swap_attr(wmod, 'defaultaction', None), \
                   self.assertRaises(TypeError):
                  wmod.warn_explicit('foo', Warning, 'bar', 1)
  
      @support.cpython_only
      def test_issue31566(self):
          # warn() shouldn't cause an assertion failure in case of a bad
          # __name__ global.
          with original_warnings.catch_warnings(module=self.module):
              self.module.filterwarnings('error', category=UserWarning)
              with support.swap_item(globals(), '__name__', b'foo'), \
                   support.swap_item(globals(), '__file__', None):
                  self.assertRaises(UserWarning, self.module.warn, 'bar')
  
  
  class WarningsDisplayTests(BaseTest):
  
      """Test the displaying of warnings and the ability to overload functions
      related to displaying warnings."""
  
      def test_formatwarning(self):
          message = "msg"
          category = Warning
          file_name = os.path.splitext(warning_tests.__file__)[0] + '.py'
          line_num = 3
          file_line = linecache.getline(file_name, line_num).strip()
          format = "%s:%s: %s: %s\n  %s\n"
          expect = format % (file_name, line_num, category.__name__, message,
                              file_line)
          self.assertEqual(expect, self.module.formatwarning(message,
                                                  category, file_name, line_num))
          # Test the 'line' argument.
          file_line += " for the win!"
          expect = format % (file_name, line_num, category.__name__, message,
                              file_line)
          self.assertEqual(expect, self.module.formatwarning(message,
                                      category, file_name, line_num, file_line))
  
      def test_showwarning(self):
          file_name = os.path.splitext(warning_tests.__file__)[0] + '.py'
          line_num = 3
          expected_file_line = linecache.getline(file_name, line_num).strip()
          message = 'msg'
          category = Warning
          file_object = StringIO()
          expect = self.module.formatwarning(message, category, file_name,
                                              line_num)
          self.module.showwarning(message, category, file_name, line_num,
                                  file_object)
          self.assertEqual(file_object.getvalue(), expect)
          # Test 'line' argument.
          expected_file_line += "for the win!"
          expect = self.module.formatwarning(message, category, file_name,
                                              line_num, expected_file_line)
          file_object = StringIO()
          self.module.showwarning(message, category, file_name, line_num,
                                  file_object, expected_file_line)
          self.assertEqual(expect, file_object.getvalue())
  
      def test_formatwarning_override(self):
          # bpo-35178: Test that a custom formatwarning function gets the 'line'
          # argument as a positional argument, and not only as a keyword argument
          def myformatwarning(message, category, filename, lineno, text):
              return f'm={message}:c={category}:f={filename}:l={lineno}:t={text}'
  
          file_name = os.path.splitext(warning_tests.__file__)[0] + '.py'
          line_num = 3
          file_line = linecache.getline(file_name, line_num).strip()
          message = 'msg'
          category = Warning
          file_object = StringIO()
          expected = f'm={message}:c={category}:f={file_name}:l={line_num}' + \
                     f':t={file_line}'
          with support.swap_attr(self.module, 'formatwarning', myformatwarning):
              self.module.showwarning(message, category, file_name, line_num,
                                      file_object, file_line)
              self.assertEqual(file_object.getvalue(), expected)
  
  
  class CWarningsDisplayTests(WarningsDisplayTests, unittest.TestCase):
      module = c_warnings
  
  class PyWarningsDisplayTests(WarningsDisplayTests, unittest.TestCase):
      module = py_warnings
  
      def test_tracemalloc(self):
          self.addCleanup(support.unlink, support.TESTFN)
  
          with open(support.TESTFN, 'w') as fp:
              fp.write(textwrap.dedent("""
                  def func():
                      f = open(__file__)
                      # Emit ResourceWarning
                      f = None
  
                  func()
              """))
  
          def run(*args):
              res = assert_python_ok(*args)
              stderr = res.err.decode('ascii', 'replace')
              stderr = '\n'.join(stderr.splitlines())
  
              # normalize newlines
              stderr = re.sub('<.*>', '<...>', stderr)
              return stderr
  
          # tracemalloc disabled
          stderr = run('-Wd', support.TESTFN)
          expected = textwrap.dedent('''
              {fname}:5: ResourceWarning: unclosed file <...>
                f = None
              ResourceWarning: Enable tracemalloc to get the object allocation traceback
          ''')
          expected = expected.format(fname=support.TESTFN).strip()
          self.assertEqual(stderr, expected)
  
          # tracemalloc enabled
          stderr = run('-Wd', '-X', 'tracemalloc=2', support.TESTFN)
          expected = textwrap.dedent('''
              {fname}:5: ResourceWarning: unclosed file <...>
                f = None
              Object allocated at (most recent call last):
                File "{fname}", lineno 7
                  func()
                File "{fname}", lineno 3
                  f = open(__file__)
          ''')
          expected = expected.format(fname=support.TESTFN).strip()
          self.assertEqual(stderr, expected)
  
  
  class CatchWarningTests(BaseTest):
  
      """Test catch_warnings()."""
  
      def test_catch_warnings_restore(self):
          wmod = self.module
          orig_filters = wmod.filters
          orig_showwarning = wmod.showwarning
          # Ensure both showwarning and filters are restored when recording
          with wmod.catch_warnings(module=wmod, record=True):
              wmod.filters = wmod.showwarning = object()
          self.assertIs(wmod.filters, orig_filters)
          self.assertIs(wmod.showwarning, orig_showwarning)
          # Same test, but with recording disabled
          with wmod.catch_warnings(module=wmod, record=False):
              wmod.filters = wmod.showwarning = object()
          self.assertIs(wmod.filters, orig_filters)
          self.assertIs(wmod.showwarning, orig_showwarning)
  
      def test_catch_warnings_recording(self):
          wmod = self.module
          # Ensure warnings are recorded when requested
          with wmod.catch_warnings(module=wmod, record=True) as w:
              self.assertEqual(w, [])
              self.assertIs(type(w), list)
              wmod.simplefilter("always")
              wmod.warn("foo")
              self.assertEqual(str(w[-1].message), "foo")
              wmod.warn("bar")
              self.assertEqual(str(w[-1].message), "bar")
              self.assertEqual(str(w[0].message), "foo")
              self.assertEqual(str(w[1].message), "bar")
              del w[:]
              self.assertEqual(w, [])
          # Ensure warnings are not recorded when not requested
          orig_showwarning = wmod.showwarning
          with wmod.catch_warnings(module=wmod, record=False) as w:
              self.assertIsNone(w)
              self.assertIs(wmod.showwarning, orig_showwarning)
  
      def test_catch_warnings_reentry_guard(self):
          wmod = self.module
          # Ensure catch_warnings is protected against incorrect usage
          x = wmod.catch_warnings(module=wmod, record=True)
          self.assertRaises(RuntimeError, x.__exit__)
          with x:
              self.assertRaises(RuntimeError, x.__enter__)
          # Same test, but with recording disabled
          x = wmod.catch_warnings(module=wmod, record=False)
          self.assertRaises(RuntimeError, x.__exit__)
          with x:
              self.assertRaises(RuntimeError, x.__enter__)
  
      def test_catch_warnings_defaults(self):
          wmod = self.module
          orig_filters = wmod.filters
          orig_showwarning = wmod.showwarning
          # Ensure default behaviour is not to record warnings
          with wmod.catch_warnings(module=wmod) as w:
              self.assertIsNone(w)
              self.assertIs(wmod.showwarning, orig_showwarning)
              self.assertIsNot(wmod.filters, orig_filters)
          self.assertIs(wmod.filters, orig_filters)
          if wmod is sys.modules['warnings']:
              # Ensure the default module is this one
              with wmod.catch_warnings() as w:
                  self.assertIsNone(w)
                  self.assertIs(wmod.showwarning, orig_showwarning)
                  self.assertIsNot(wmod.filters, orig_filters)
              self.assertIs(wmod.filters, orig_filters)
  
      def test_record_override_showwarning_before(self):
          # Issue #28835: If warnings.showwarning() was overridden, make sure
          # that catch_warnings(record=True) overrides it again.
          text = "This is a warning"
          wmod = self.module
          my_log = []
  
          def my_logger(message, category, filename, lineno, file=None, line=None):
              nonlocal my_log
              my_log.append(message)
  
          # Override warnings.showwarning() before calling catch_warnings()
          with support.swap_attr(wmod, 'showwarning', my_logger):
              with wmod.catch_warnings(module=wmod, record=True) as log:
                  self.assertIsNot(wmod.showwarning, my_logger)
  
                  wmod.simplefilter("always")
                  wmod.warn(text)
  
              self.assertIs(wmod.showwarning, my_logger)
  
          self.assertEqual(len(log), 1, log)
          self.assertEqual(log[0].message.args[0], text)
          self.assertEqual(my_log, [])
  
      def test_record_override_showwarning_inside(self):
          # Issue #28835: It is possible to override warnings.showwarning()
          # in the catch_warnings(record=True) context manager.
          text = "This is a warning"
          wmod = self.module
          my_log = []
  
          def my_logger(message, category, filename, lineno, file=None, line=None):
              nonlocal my_log
              my_log.append(message)
  
          with wmod.catch_warnings(module=wmod, record=True) as log:
              wmod.simplefilter("always")
              wmod.showwarning = my_logger
              wmod.warn(text)
  
          self.assertEqual(len(my_log), 1, my_log)
          self.assertEqual(my_log[0].args[0], text)
          self.assertEqual(log, [])
  
      def test_check_warnings(self):
          # Explicit tests for the test.support convenience wrapper
          wmod = self.module
          if wmod is not sys.modules['warnings']:
              self.skipTest('module to test is not loaded warnings module')
          with support.check_warnings(quiet=False) as w:
              self.assertEqual(w.warnings, [])
              wmod.simplefilter("always")
              wmod.warn("foo")
              self.assertEqual(str(w.message), "foo")
              wmod.warn("bar")
              self.assertEqual(str(w.message), "bar")
              self.assertEqual(str(w.warnings[0].message), "foo")
              self.assertEqual(str(w.warnings[1].message), "bar")
              w.reset()
              self.assertEqual(w.warnings, [])
  
          with support.check_warnings():
              # defaults to quiet=True without argument
              pass
          with support.check_warnings(('foo', UserWarning)):
              wmod.warn("foo")
  
          with self.assertRaises(AssertionError):
              with support.check_warnings(('', RuntimeWarning)):
                  # defaults to quiet=False with argument
                  pass
          with self.assertRaises(AssertionError):
              with support.check_warnings(('foo', RuntimeWarning)):
                  wmod.warn("foo")
  
  class CCatchWarningTests(CatchWarningTests, unittest.TestCase):
      module = c_warnings
  
  class PyCatchWarningTests(CatchWarningTests, unittest.TestCase):
      module = py_warnings
  
  
  class EnvironmentVariableTests(BaseTest):
  
      def test_single_warning(self):
          rc, stdout, stderr = assert_python_ok("-E", "-c",
              "import sys; sys.stdout.write(str(sys.warnoptions))",
              PYTHONWARNINGS="ignore::DeprecationWarning",
              PYTHONDEVMODE="")
          self.assertEqual(stdout, b"['ignore::DeprecationWarning']")
  
      def test_comma_separated_warnings(self):
          rc, stdout, stderr = assert_python_ok("-E", "-c",
              "import sys; sys.stdout.write(str(sys.warnoptions))",
              PYTHONWARNINGS="ignore::DeprecationWarning,ignore::UnicodeWarning",
              PYTHONDEVMODE="")
          self.assertEqual(stdout,
              b"['ignore::DeprecationWarning', 'ignore::UnicodeWarning']")
  
      def test_envvar_and_command_line(self):
          rc, stdout, stderr = assert_python_ok("-Wignore::UnicodeWarning", "-E", "-c",
              "import sys; sys.stdout.write(str(sys.warnoptions))",
              PYTHONWARNINGS="ignore::DeprecationWarning",
              PYTHONDEVMODE="")
          self.assertEqual(stdout,
              b"['ignore::DeprecationWarning', 'ignore::UnicodeWarning']")
  
      def test_conflicting_envvar_and_command_line(self):
          rc, stdout, stderr = assert_python_failure("-Werror::DeprecationWarning", "-E", "-c",
              "import sys, warnings; sys.stdout.write(str(sys.warnoptions)); "
              "warnings.warn('Message', DeprecationWarning)",
              PYTHONWARNINGS="default::DeprecationWarning",
              PYTHONDEVMODE="")
          self.assertEqual(stdout,
              b"['default::DeprecationWarning', 'error::DeprecationWarning']")
          self.assertEqual(stderr.splitlines(),
              [b"Traceback (most recent call last):",
               b"  File \"<string>\", line 1, in <module>",
               b"DeprecationWarning: Message"])
  
      def test_default_filter_configuration(self):
          pure_python_api = self.module is py_warnings
          if Py_DEBUG:
              expected_default_filters = []
          else:
              if pure_python_api:
                  main_module_filter = re.compile("__main__")
              else:
                  main_module_filter = "__main__"
              expected_default_filters = [
                  ('default', None, DeprecationWarning, main_module_filter, 0),
                  ('ignore', None, DeprecationWarning, None, 0),
                  ('ignore', None, PendingDeprecationWarning, None, 0),
                  ('ignore', None, ImportWarning, None, 0),
                  ('ignore', None, ResourceWarning, None, 0),
              ]
          expected_output = [str(f).encode() for f in expected_default_filters]
  
          if pure_python_api:
              # Disable the warnings acceleration module in the subprocess
              code = "import sys; sys.modules.pop('warnings', None); sys.modules['_warnings'] = None; "
          else:
              code = ""
          code += "import warnings; [print(f) for f in warnings.filters]"
  
          rc, stdout, stderr = assert_python_ok("-c", code, __isolated=True)
          stdout_lines = [line.strip() for line in stdout.splitlines()]
          self.maxDiff = None
          self.assertEqual(stdout_lines, expected_output)
  
  
      @unittest.skipUnless(sys.getfilesystemencoding() != 'ascii',
                           'requires non-ascii filesystemencoding')
      def test_nonascii(self):
          rc, stdout, stderr = assert_python_ok("-E", "-c",
              "import sys; sys.stdout.write(str(sys.warnoptions))",
              PYTHONIOENCODING="utf-8",
              PYTHONWARNINGS="ignore:DeprecaciónWarning",
              PYTHONDEVMODE="")
          self.assertEqual(stdout,
              "['ignore:DeprecaciónWarning']".encode('utf-8'))
  
  class CEnvironmentVariableTests(EnvironmentVariableTests, unittest.TestCase):
      module = c_warnings
  
  class PyEnvironmentVariableTests(EnvironmentVariableTests, unittest.TestCase):
      module = py_warnings
  
  
  class BootstrapTest(unittest.TestCase):
      def test_issue_8766(self):
          # "import encodings" emits a warning whereas the warnings is not loaded
          # or not completely loaded (warnings imports indirectly encodings by
          # importing linecache) yet
          with support.temp_cwd() as cwd, support.temp_cwd('encodings'):
              # encodings loaded by initfsencoding()
              assert_python_ok("-E", '-c', 'pass', PYTHONPATH=cwd)
  
              # Use -W to load warnings module at startup
              assert_python_ok('-E', '-c', 'pass', '-W', 'always', PYTHONPATH=cwd)
  
  
  class FinalizationTest(unittest.TestCase):
      @support.requires_type_collecting
      def test_finalization(self):
          # Issue #19421: warnings.warn() should not crash
          # during Python finalization
          code = """
  import warnings
  warn = warnings.warn
  
  class A:
      def __del__(self):
          warn("test")
  
  a=A()
          """
          rc, out, err = assert_python_ok("-c", code)
          self.assertEqual(err.decode(), '<string>:7: UserWarning: test')
  
      def test_late_resource_warning(self):
          # Issue #21925: Emitting a ResourceWarning late during the Python
          # shutdown must be logged.
  
          expected = b"sys:1: ResourceWarning: unclosed file "
  
          # don't import the warnings module
          # (_warnings will try to import it)
          code = "f = open(%a)" % __file__
          rc, out, err = assert_python_ok("-Wd", "-c", code)
          self.assertTrue(err.startswith(expected), ascii(err))
  
          # import the warnings module
          code = "import warnings; f = open(%a)" % __file__
          rc, out, err = assert_python_ok("-Wd", "-c", code)
          self.assertTrue(err.startswith(expected), ascii(err))
  
  
  def setUpModule():
      py_warnings.onceregistry.clear()
      c_warnings.onceregistry.clear()
  
  tearDownModule = setUpModule
  
  if __name__ == "__main__":
      unittest.main()
  