Lib/test/test_warnings.py

   1 from contextlib import contextmanager
   2 import linecache
   3 import os
   4 import StringIO
   5 import sys
   6 import unittest
   7 import subprocess
   8 from test import test_support
   9 from test.script_helper import assert_python_ok
  10
  11 import warning_tests
  12
  13 import warnings as original_warnings
  14
  15 py_warnings = test_support.import_fresh_module('warnings', blocked=['_warnings'])
  16 c_warnings = test_support.import_fresh_module('warnings', fresh=['_warnings'])
  17
  18 @contextmanager
  19 def warnings_state(module):
  20     """Use a specific warnings implementation in warning_tests."""
  21     global __warningregistry__
  22     for to_clear in (sys, warning_tests):
  23         try:
  24             to_clear.__warningregistry__.clear()
  25         except AttributeError:
  26             pass
  27     try:
  28         __warningregistry__.clear()
  29     except NameError:
  30         pass
  31     original_warnings = warning_tests.warnings
  32     original_filters = module.filters
  33     try:
  34         module.filters = original_filters[:]
  35         module.simplefilter("once")
  36         warning_tests.warnings = module
  37         yield
  38     finally:
  39         warning_tests.warnings = original_warnings
  40         module.filters = original_filters
  41
  42
  43 class BaseTest(unittest.TestCase):
  44
  45     """Basic bookkeeping required for testing."""
  46
  47     def setUp(self):
  48         # The __warningregistry__ needs to be in a pristine state for tests
  49         # to work properly.
  50         if '__warningregistry__' in globals():
  51             del globals()['__warningregistry__']
  52         if hasattr(warning_tests, '__warningregistry__'):
  53             del warning_tests.__warningregistry__
  54         if hasattr(sys, '__warningregistry__'):
  55             del sys.__warningregistry__
  56         # The 'warnings' module must be explicitly set so that the proper
  57         # interaction between _warnings and 'warnings' can be controlled.
  58         sys.modules['warnings'] = self.module
  59         super(BaseTest, self).setUp()
  60
  61     def tearDown(self):
  62         sys.modules['warnings'] = original_warnings
  63         super(BaseTest, self).tearDown()
  64
  65
  66 class FilterTests(object):
  67
  68     """Testing the filtering functionality."""
  69
  70     def test_error(self):
  71         with original_warnings.catch_warnings(module=self.module) as w:
  72             self.module.resetwarnings()
  73             self.module.filterwarnings("error", category=UserWarning)
  74             self.assertRaises(UserWarning, self.module.warn,
  75                                 "FilterTests.test_error")
  76
  77     def test_ignore(self):
  78         with original_warnings.catch_warnings(record=True,
  79                 module=self.module) as w:
  80             self.module.resetwarnings()
  81             self.module.filterwarnings("ignore", category=UserWarning)
  82             self.module.warn("FilterTests.test_ignore", UserWarning)
  83             self.assertEqual(len(w), 0)
  84
  85     def test_always(self):
  86         with original_warnings.catch_warnings(record=True,
  87                 module=self.module) as w:
  88             self.module.resetwarnings()
  89             self.module.filterwarnings("always", category=UserWarning)
  90             message = "FilterTests.test_always"
  91             self.module.warn(message, UserWarning)
  92             self.assertTrue(message, w[-1].message)
  93             self.module.warn(message, UserWarning)
  94             self.assertTrue(w[-1].message, message)
  95
  96     def test_default(self):
  97         with original_warnings.catch_warnings(record=True,
  98                 module=self.module) as w:
  99             self.module.resetwarnings()
 100             self.module.filterwarnings("default", category=UserWarning)
 101             message = UserWarning("FilterTests.test_default")
 102             for x in xrange(2):
 103                 self.module.warn(message, UserWarning)
 104                 if x == 0:
 105                     self.assertEqual(w[-1].message, message)
 106                     del w[:]
 107                 elif x == 1:
 108                     self.assertEqual(len(w), 0)
 109                 else:
 110                     raise ValueError("loop variant unhandled")
 111
 112     def test_module(self):
 113         with original_warnings.catch_warnings(record=True,
 114                 module=self.module) as w:
 115             self.module.resetwarnings()
 116             self.module.filterwarnings("module", category=UserWarning)
 117             message = UserWarning("FilterTests.test_module")
 118             self.module.warn(message, UserWarning)
 119             self.assertEqual(w[-1].message, message)
 120             del w[:]
 121             self.module.warn(message, UserWarning)
 122             self.assertEqual(len(w), 0)
 123
 124     def test_once(self):
 125         with original_warnings.catch_warnings(record=True,
 126                 module=self.module) as w:
 127             self.module.resetwarnings()
 128             self.module.filterwarnings("once", category=UserWarning)
 129             message = UserWarning("FilterTests.test_once")
 130             self.module.warn_explicit(message, UserWarning, "test_warnings.py",
 131                                     42)
 132             self.assertEqual(w[-1].message, message)
 133             del w[:]
 134             self.module.warn_explicit(message, UserWarning, "test_warnings.py",
 135                                     13)
 136             self.assertEqual(len(w), 0)
 137             self.module.warn_explicit(message, UserWarning, "test_warnings2.py",
 138                                     42)
 139             self.assertEqual(len(w), 0)
 140
 141     def test_inheritance(self):
 142         with original_warnings.catch_warnings(module=self.module) as w:
 143             self.module.resetwarnings()
 144             self.module.filterwarnings("error", category=Warning)
 145             self.assertRaises(UserWarning, self.module.warn,
 146                                 "FilterTests.test_inheritance", UserWarning)
 147
 148     def test_ordering(self):
 149         with original_warnings.catch_warnings(record=True,
 150                 module=self.module) as w:
 151             self.module.resetwarnings()
 152             self.module.filterwarnings("ignore", category=UserWarning)
 153             self.module.filterwarnings("error", category=UserWarning,
 154                                         append=True)
 155             del w[:]
 156             try:
 157                 self.module.warn("FilterTests.test_ordering", UserWarning)
 158             except UserWarning:
 159                 self.fail("order handling for actions failed")
 160             self.assertEqual(len(w), 0)
 161
 162     def test_filterwarnings(self):
 163         # Test filterwarnings().
 164         # Implicitly also tests resetwarnings().
 165         with original_warnings.catch_warnings(record=True,
 166                 module=self.module) as w:
 167             self.module.filterwarnings("error", "", Warning, "", 0)
 168             self.assertRaises(UserWarning, self.module.warn, 'convert to error')
 169
 170             self.module.resetwarnings()
 171             text = 'handle normally'
 172             self.module.warn(text)
 173             self.assertEqual(str(w[-1].message), text)
 174             self.assertTrue(w[-1].category is UserWarning)
 175
 176             self.module.filterwarnings("ignore", "", Warning, "", 0)
 177             text = 'filtered out'
 178             self.module.warn(text)
 179             self.assertNotEqual(str(w[-1].message), text)
 180
 181             self.module.resetwarnings()
 182             self.module.filterwarnings("error", "hex*", Warning, "", 0)
 183             self.assertRaises(UserWarning, self.module.warn, 'hex/oct')
 184             text = 'nonmatching text'
 185             self.module.warn(text)
 186             self.assertEqual(str(w[-1].message), text)
 187             self.assertTrue(w[-1].category is UserWarning)
 188
 189 class CFilterTests(BaseTest, FilterTests):
 190     module = c_warnings
 191
 192 class PyFilterTests(BaseTest, FilterTests):
 193     module = py_warnings
 194
 195
 196 class WarnTests(unittest.TestCase):
 197
 198     """Test warnings.warn() and warnings.warn_explicit()."""
 199
 200     def test_message(self):
 201         with original_warnings.catch_warnings(record=True,
 202                 module=self.module) as w:
 203             self.module.simplefilter("once")
 204             for i in range(4):
 205                 text = 'multi %d' %i  # Different text on each call.
 206                 self.module.warn(text)
 207                 self.assertEqual(str(w[-1].message), text)
 208                 self.assertTrue(w[-1].category is UserWarning)
 209
 210     def test_filename(self):
 211         with warnings_state(self.module):
 212             with original_warnings.catch_warnings(record=True,
 213                     module=self.module) as w:
 214                 warning_tests.inner("spam1")
 215                 self.assertEqual(os.path.basename(w[-1].filename),
 216                                     "warning_tests.py")
 217                 warning_tests.outer("spam2")
 218                 self.assertEqual(os.path.basename(w[-1].filename),
 219                                     "warning_tests.py")
 220
 221     def test_stacklevel(self):
 222         # Test stacklevel argument
 223         # make sure all messages are different, so the warning won't be skipped
 224         with warnings_state(self.module):
 225             with original_warnings.catch_warnings(record=True,
 226                     module=self.module) as w:
 227                 warning_tests.inner("spam3", stacklevel=1)
 228                 self.assertEqual(os.path.basename(w[-1].filename),
 229                                     "warning_tests.py")
 230                 warning_tests.outer("spam4", stacklevel=1)
 231                 self.assertEqual(os.path.basename(w[-1].filename),
 232                                     "warning_tests.py")
 233
 234                 warning_tests.inner("spam5", stacklevel=2)
 235                 self.assertEqual(os.path.basename(w[-1].filename),
 236                                     "test_warnings.py")
 237                 warning_tests.outer("spam6", stacklevel=2)
 238                 self.assertEqual(os.path.basename(w[-1].filename),
 239                                     "warning_tests.py")
 240                 warning_tests.outer("spam6.5", stacklevel=3)
 241                 self.assertEqual(os.path.basename(w[-1].filename),
 242                                     "test_warnings.py")
 243
 244                 warning_tests.inner("spam7", stacklevel=9999)
 245                 self.assertEqual(os.path.basename(w[-1].filename),
 246                                     "sys")
 247
 248     def test_missing_filename_not_main(self):
 249         # If __file__ is not specified and __main__ is not the module name,
 250         # then __file__ should be set to the module name.
 251         filename = warning_tests.__file__
 252         try:
 253             del warning_tests.__file__
 254             with warnings_state(self.module):
 255                 with original_warnings.catch_warnings(record=True,
 256                         module=self.module) as w:
 257                     warning_tests.inner("spam8", stacklevel=1)
 258                     self.assertEqual(w[-1].filename, warning_tests.__name__)
 259         finally:
 260             warning_tests.__file__ = filename
 261
 262     def test_missing_filename_main_with_argv(self):
 263         # If __file__ is not specified and the caller is __main__ and sys.argv
 264         # exists, then use sys.argv[0] as the file.
 265         if not hasattr(sys, 'argv'):
 266             return
 267         filename = warning_tests.__file__
 268         module_name = warning_tests.__name__
 269         try:
 270             del warning_tests.__file__
 271             warning_tests.__name__ = '__main__'
 272             with warnings_state(self.module):
 273                 with original_warnings.catch_warnings(record=True,
 274                         module=self.module) as w:
 275                     warning_tests.inner('spam9', stacklevel=1)
 276                     self.assertEqual(w[-1].filename, sys.argv[0])
 277         finally:
 278             warning_tests.__file__ = filename
 279             warning_tests.__name__ = module_name
 280
 281     def test_missing_filename_main_without_argv(self):
 282         # If __file__ is not specified, the caller is __main__, and sys.argv
 283         # is not set, then '__main__' is the file name.
 284         filename = warning_tests.__file__
 285         module_name = warning_tests.__name__
 286         argv = sys.argv
 287         try:
 288             del warning_tests.__file__
 289             warning_tests.__name__ = '__main__'
 290             del sys.argv
 291             with warnings_state(self.module):
 292                 with original_warnings.catch_warnings(record=True,
 293                         module=self.module) as w:
 294                     warning_tests.inner('spam10', stacklevel=1)
 295                     self.assertEqual(w[-1].filename, '__main__')
 296         finally:
 297             warning_tests.__file__ = filename
 298             warning_tests.__name__ = module_name
 299             sys.argv = argv
 300
 301     def test_missing_filename_main_with_argv_empty_string(self):
 302         # If __file__ is not specified, the caller is __main__, and sys.argv[0]
 303         # is the empty string, then '__main__ is the file name.
 304         # Tests issue 2743.
 305         file_name = warning_tests.__file__
 306         module_name = warning_tests.__name__
 307         argv = sys.argv
 308         try:
 309             del warning_tests.__file__
 310             warning_tests.__name__ = '__main__'
 311             sys.argv = ['']
 312             with warnings_state(self.module):
 313                 with original_warnings.catch_warnings(record=True,
 314                         module=self.module) as w:
 315                     warning_tests.inner('spam11', stacklevel=1)
 316                     self.assertEqual(w[-1].filename, '__main__')
 317         finally:
 318             warning_tests.__file__ = file_name
 319             warning_tests.__name__ = module_name
 320             sys.argv = argv
 321
 322     def test_warn_explicit_type_errors(self):
 323         # warn_explicit() should error out gracefully if it is given objects
 324         # of the wrong types.
 325         # lineno is expected to be an integer.
 326         self.assertRaises(TypeError, self.module.warn_explicit,
 327                             None, UserWarning, None, None)
 328         # Either 'message' needs to be an instance of Warning or 'category'
 329         # needs to be a subclass.
 330         self.assertRaises(TypeError, self.module.warn_explicit,
 331                             None, None, None, 1)
 332         # 'registry' must be a dict or None.
 333         self.assertRaises((TypeError, AttributeError),
 334                             self.module.warn_explicit,
 335                             None, Warning, None, 1, registry=42)
 336
 337     def test_bad_str(self):
 338         # issue 6415
 339         # Warnings instance with a bad format string for __str__ should not
 340         # trigger a bus error.
 341         class BadStrWarning(Warning):
 342             """Warning with a bad format string for __str__."""
 343             def __str__(self):
 344                 return ("A bad formatted string %(err)" %
 345                         {"err" : "there is no %(err)s"})
 346
 347         with self.assertRaises(ValueError):
 348             self.module.warn(BadStrWarning())
 349
 350
 351 class CWarnTests(BaseTest, WarnTests):
 352     module = c_warnings
 353
 354     # As an early adopter, we sanity check the
 355     # test_support.import_fresh_module utility function
 356     def test_accelerated(self):
 357         self.assertFalse(original_warnings is self.module)
 358         self.assertFalse(hasattr(self.module.warn, 'func_code'))
 359
 360 class PyWarnTests(BaseTest, WarnTests):
 361     module = py_warnings
 362
 363     # As an early adopter, we sanity check the
 364     # test_support.import_fresh_module utility function
 365     def test_pure_python(self):
 366         self.assertFalse(original_warnings is self.module)
 367         self.assertTrue(hasattr(self.module.warn, 'func_code'))
 368
 369
 370 class WCmdLineTests(unittest.TestCase):
 371
 372     def test_improper_input(self):
 373         # Uses the private _setoption() function to test the parsing
 374         # of command-line warning arguments
 375         with original_warnings.catch_warnings(module=self.module):
 376             self.assertRaises(self.module._OptionError,
 377                               self.module._setoption, '1:2:3:4:5:6')
 378             self.assertRaises(self.module._OptionError,
 379                               self.module._setoption, 'bogus::Warning')
 380             self.assertRaises(self.module._OptionError,
 381                               self.module._setoption, 'ignore:2::4:-5')
 382             self.module._setoption('error::Warning::0')
 383             self.assertRaises(UserWarning, self.module.warn, 'convert to error')
 384
 385     def test_improper_option(self):
 386         # Same as above, but check that the message is printed out when
 387         # the interpreter is executed. This also checks that options are
 388         # actually parsed at all.
 389         rc, out, err = assert_python_ok("-Wxxx", "-c", "pass")
 390         self.assertIn(b"Invalid -W option ignored: invalid action: 'xxx'", err)
 391
 392     def test_warnings_bootstrap(self):
 393         # Check that the warnings module does get loaded when -W<some option>
 394         # is used (see issue #10372 for an example of silent bootstrap failure).
 395         rc, out, err = assert_python_ok("-Wi", "-c",
 396             "import sys; sys.modules['warnings'].warn('foo', RuntimeWarning)")
 397         # '-Wi' was observed
 398         self.assertFalse(out.strip())
 399         self.assertNotIn(b'RuntimeWarning', err)
 400
 401 class CWCmdLineTests(BaseTest, WCmdLineTests):
 402     module = c_warnings
 403
 404 class PyWCmdLineTests(BaseTest, WCmdLineTests):
 405     module = py_warnings
 406
 407
 408 class _WarningsTests(BaseTest):
 409
 410     """Tests specific to the _warnings module."""
 411
 412     module = c_warnings
 413
 414     def test_filter(self):
 415         # Everything should function even if 'filters' is not in warnings.
 416         with original_warnings.catch_warnings(module=self.module) as w:
 417             self.module.filterwarnings("error", "", Warning, "", 0)
 418             self.assertRaises(UserWarning, self.module.warn,
 419                                 'convert to error')
 420             del self.module.filters
 421             self.assertRaises(UserWarning, self.module.warn,
 422                                 'convert to error')
 423
 424     def test_onceregistry(self):
 425         # Replacing or removing the onceregistry should be okay.
 426         global __warningregistry__
 427         message = UserWarning('onceregistry test')
 428         try:
 429             original_registry = self.module.onceregistry
 430             __warningregistry__ = {}
 431             with original_warnings.catch_warnings(record=True,
 432                     module=self.module) as w:
 433                 self.module.resetwarnings()
 434                 self.module.filterwarnings("once", category=UserWarning)
 435                 self.module.warn_explicit(message, UserWarning, "file", 42)
 436                 self.assertEqual(w[-1].message, message)
 437                 del w[:]
 438                 self.module.warn_explicit(message, UserWarning, "file", 42)
 439                 self.assertEqual(len(w), 0)
 440                 # Test the resetting of onceregistry.
 441                 self.module.onceregistry = {}
 442                 __warningregistry__ = {}
 443                 self.module.warn('onceregistry test')
 444                 self.assertEqual(w[-1].message.args, message.args)
 445                 # Removal of onceregistry is okay.
 446                 del w[:]
 447                 del self.module.onceregistry
 448                 __warningregistry__ = {}
 449                 self.module.warn_explicit(message, UserWarning, "file", 42)
 450                 self.assertEqual(len(w), 0)
 451         finally:
 452             self.module.onceregistry = original_registry
 453
 454     def test_default_action(self):
 455         # Replacing or removing defaultaction should be okay.
 456         message = UserWarning("defaultaction test")
 457         original = self.module.defaultaction
 458         try:
 459             with original_warnings.catch_warnings(record=True,
 460                     module=self.module) as w:
 461                 self.module.resetwarnings()
 462                 registry = {}
 463                 self.module.warn_explicit(message, UserWarning, "<test>", 42,
 464                                             registry=registry)
 465                 self.assertEqual(w[-1].message, message)
 466                 self.assertEqual(len(w), 1)
 467                 self.assertEqual(len(registry), 1)
 468                 del w[:]
 469                 # Test removal.
 470                 del self.module.defaultaction
 471                 __warningregistry__ = {}
 472                 registry = {}
 473                 self.module.warn_explicit(message, UserWarning, "<test>", 43,
 474                                             registry=registry)
 475                 self.assertEqual(w[-1].message, message)
 476                 self.assertEqual(len(w), 1)
 477                 self.assertEqual(len(registry), 1)
 478                 del w[:]
 479                 # Test setting.
 480                 self.module.defaultaction = "ignore"
 481                 __warningregistry__ = {}
 482                 registry = {}
 483                 self.module.warn_explicit(message, UserWarning, "<test>", 44,
 484                                             registry=registry)
 485                 self.assertEqual(len(w), 0)
 486         finally:
 487             self.module.defaultaction = original
 488
 489     def test_showwarning_missing(self):
 490         # Test that showwarning() missing is okay.
 491         text = 'del showwarning test'
 492         with original_warnings.catch_warnings(module=self.module):
 493             self.module.filterwarnings("always", category=UserWarning)
 494             del self.module.showwarning
 495             with test_support.captured_output('stderr') as stream:
 496                 self.module.warn(text)
 497                 result = stream.getvalue()
 498         self.assertIn(text, result)
 499
 500     def test_showwarning_not_callable(self):
 501         with original_warnings.catch_warnings(module=self.module):
 502             self.module.filterwarnings("always", category=UserWarning)
 503             old_showwarning = self.module.showwarning
 504             self.module.showwarning = 23
 505             try:
 506                 self.assertRaises(TypeError, self.module.warn, "Warning!")
 507             finally:
 508                 self.module.showwarning = old_showwarning
 509
 510     def test_show_warning_output(self):
 511         # With showarning() missing, make sure that output is okay.
 512         text = 'test show_warning'
 513         with original_warnings.catch_warnings(module=self.module):
 514             self.module.filterwarnings("always", category=UserWarning)
 515             del self.module.showwarning
 516             with test_support.captured_output('stderr') as stream:
 517                 warning_tests.inner(text)
 518                 result = stream.getvalue()
 519         self.assertEqual(result.count('\n'), 2,
 520                              "Too many newlines in %r" % result)
 521         first_line, second_line = result.split('\n', 1)
 522         expected_file = os.path.splitext(warning_tests.__file__)[0] + '.py'
 523         first_line_parts = first_line.rsplit(':', 3)
 524         path, line, warning_class, message = first_line_parts
 525         line = int(line)
 526         self.assertEqual(expected_file, path)
 527         self.assertEqual(warning_class, ' ' + UserWarning.__name__)
 528         self.assertEqual(message, ' ' + text)
 529         expected_line = '  ' + linecache.getline(path, line).strip() + '\n'
 530         assert expected_line
 531         self.assertEqual(second_line, expected_line)
 532
 533     def test_filename_none(self):
 534         # issue #12467: race condition if a warning is emitted at shutdown
 535         globals_dict = globals()
 536         oldfile = globals_dict['__file__']
 537         try:
 538             with original_warnings.catch_warnings(module=self.module) as w:
 539                 self.module.filterwarnings("always", category=UserWarning)
 540                 globals_dict['__file__'] = None
 541                 self.module.warn('test', UserWarning)
 542         finally:
 543             globals_dict['__file__'] = oldfile
 544
 545
 546 class WarningsDisplayTests(unittest.TestCase):
 547
 548     """Test the displaying of warnings and the ability to overload functions
 549     related to displaying warnings."""
 550
 551     def test_formatwarning(self):
 552         message = "msg"
 553         category = Warning
 554         file_name = os.path.splitext(warning_tests.__file__)[0] + '.py'
 555         line_num = 3
 556         file_line = linecache.getline(file_name, line_num).strip()
 557         format = "%s:%s: %s: %s\n  %s\n"
 558         expect = format % (file_name, line_num, category.__name__, message,
 559                             file_line)
 560         self.assertEqual(expect, self.module.formatwarning(message,
 561                                                 category, file_name, line_num))
 562         # Test the 'line' argument.
 563         file_line += " for the win!"
 564         expect = format % (file_name, line_num, category.__name__, message,
 565                             file_line)
 566         self.assertEqual(expect, self.module.formatwarning(message,
 567                                     category, file_name, line_num, file_line))
 568
 569     def test_showwarning(self):
 570         file_name = os.path.splitext(warning_tests.__file__)[0] + '.py'
 571         line_num = 3
 572         expected_file_line = linecache.getline(file_name, line_num).strip()
 573         message = 'msg'
 574         category = Warning
 575         file_object = StringIO.StringIO()
 576         expect = self.module.formatwarning(message, category, file_name,
 577                                             line_num)
 578         self.module.showwarning(message, category, file_name, line_num,
 579                                 file_object)
 580         self.assertEqual(file_object.getvalue(), expect)
 581         # Test 'line' argument.
 582         expected_file_line += "for the win!"
 583         expect = self.module.formatwarning(message, category, file_name,
 584                                             line_num, expected_file_line)
 585         file_object = StringIO.StringIO()
 586         self.module.showwarning(message, category, file_name, line_num,
 587                                 file_object, expected_file_line)
 588         self.assertEqual(expect, file_object.getvalue())
 589
 590 class CWarningsDisplayTests(BaseTest, WarningsDisplayTests):
 591     module = c_warnings
 592
 593 class PyWarningsDisplayTests(BaseTest, WarningsDisplayTests):
 594     module = py_warnings
 595
 596
 597 class CatchWarningTests(BaseTest):
 598
 599     """Test catch_warnings()."""
 600
 601     def test_catch_warnings_restore(self):
 602         wmod = self.module
 603         orig_filters = wmod.filters
 604         orig_showwarning = wmod.showwarning
 605         # Ensure both showwarning and filters are restored when recording
 606         with wmod.catch_warnings(module=wmod, record=True):
 607             wmod.filters = wmod.showwarning = object()
 608         self.assertTrue(wmod.filters is orig_filters)
 609         self.assertTrue(wmod.showwarning is orig_showwarning)
 610         # Same test, but with recording disabled
 611         with wmod.catch_warnings(module=wmod, record=False):
 612             wmod.filters = wmod.showwarning = object()
 613         self.assertTrue(wmod.filters is orig_filters)
 614         self.assertTrue(wmod.showwarning is orig_showwarning)
 615
 616     def test_catch_warnings_recording(self):
 617         wmod = self.module
 618         # Ensure warnings are recorded when requested
 619         with wmod.catch_warnings(module=wmod, record=True) as w:
 620             self.assertEqual(w, [])
 621             self.assertTrue(type(w) is list)
 622             wmod.simplefilter("always")
 623             wmod.warn("foo")
 624             self.assertEqual(str(w[-1].message), "foo")
 625             wmod.warn("bar")
 626             self.assertEqual(str(w[-1].message), "bar")
 627             self.assertEqual(str(w[0].message), "foo")
 628             self.assertEqual(str(w[1].message), "bar")
 629             del w[:]
 630             self.assertEqual(w, [])
 631         # Ensure warnings are not recorded when not requested
 632         orig_showwarning = wmod.showwarning
 633         with wmod.catch_warnings(module=wmod, record=False) as w:
 634             self.assertTrue(w is None)
 635             self.assertTrue(wmod.showwarning is orig_showwarning)
 636
 637     def test_catch_warnings_reentry_guard(self):
 638         wmod = self.module
 639         # Ensure catch_warnings is protected against incorrect usage
 640         x = wmod.catch_warnings(module=wmod, record=True)
 641         self.assertRaises(RuntimeError, x.__exit__)
 642         with x:
 643             self.assertRaises(RuntimeError, x.__enter__)
 644         # Same test, but with recording disabled
 645         x = wmod.catch_warnings(module=wmod, record=False)
 646         self.assertRaises(RuntimeError, x.__exit__)
 647         with x:
 648             self.assertRaises(RuntimeError, x.__enter__)
 649
 650     def test_catch_warnings_defaults(self):
 651         wmod = self.module
 652         orig_filters = wmod.filters
 653         orig_showwarning = wmod.showwarning
 654         # Ensure default behaviour is not to record warnings
 655         with wmod.catch_warnings(module=wmod) as w:
 656             self.assertTrue(w is None)
 657             self.assertTrue(wmod.showwarning is orig_showwarning)
 658             self.assertTrue(wmod.filters is not orig_filters)
 659         self.assertTrue(wmod.filters is orig_filters)
 660         if wmod is sys.modules['warnings']:
 661             # Ensure the default module is this one
 662             with wmod.catch_warnings() as w:
 663                 self.assertTrue(w is None)
 664                 self.assertTrue(wmod.showwarning is orig_showwarning)
 665                 self.assertTrue(wmod.filters is not orig_filters)
 666             self.assertTrue(wmod.filters is orig_filters)
 667
 668     def test_check_warnings(self):
 669         # Explicit tests for the test_support convenience wrapper
 670         wmod = self.module
 671         if wmod is not sys.modules['warnings']:
 672             return
 673         with test_support.check_warnings(quiet=False) as w:
 674             self.assertEqual(w.warnings, [])
 675             wmod.simplefilter("always")
 676             wmod.warn("foo")
 677             self.assertEqual(str(w.message), "foo")
 678             wmod.warn("bar")
 679             self.assertEqual(str(w.message), "bar")
 680             self.assertEqual(str(w.warnings[0].message), "foo")
 681             self.assertEqual(str(w.warnings[1].message), "bar")
 682             w.reset()
 683             self.assertEqual(w.warnings, [])
 684
 685         with test_support.check_warnings():
 686             # defaults to quiet=True without argument
 687             pass
 688         with test_support.check_warnings(('foo', UserWarning)):
 689             wmod.warn("foo")
 690
 691         with self.assertRaises(AssertionError):
 692             with test_support.check_warnings(('', RuntimeWarning)):
 693                 # defaults to quiet=False with argument
 694                 pass
 695         with self.assertRaises(AssertionError):
 696             with test_support.check_warnings(('foo', RuntimeWarning)):
 697                 wmod.warn("foo")
 698
 699
 700 class CCatchWarningTests(CatchWarningTests):
 701     module = c_warnings
 702
 703 class PyCatchWarningTests(CatchWarningTests):
 704     module = py_warnings
 705
 706
 707 class EnvironmentVariableTests(BaseTest):
 708
 709     def test_single_warning(self):
 710         newenv = os.environ.copy()
 711         newenv["PYTHONWARNINGS"] = "ignore::DeprecationWarning"
 712         p = subprocess.Popen([sys.executable,
 713                 "-c", "import sys; sys.stdout.write(str(sys.warnoptions))"],
 714                 stdout=subprocess.PIPE, env=newenv)
 715         self.assertEqual(p.communicate()[0], "['ignore::DeprecationWarning']")
 716         self.assertEqual(p.wait(), 0)
 717
 718     def test_comma_separated_warnings(self):
 719         newenv = os.environ.copy()
 720         newenv["PYTHONWARNINGS"] = ("ignore::DeprecationWarning,"
 721                                     "ignore::UnicodeWarning")
 722         p = subprocess.Popen([sys.executable,
 723                 "-c", "import sys; sys.stdout.write(str(sys.warnoptions))"],
 724                 stdout=subprocess.PIPE, env=newenv)
 725         self.assertEqual(p.communicate()[0],
 726                 "['ignore::DeprecationWarning', 'ignore::UnicodeWarning']")
 727         self.assertEqual(p.wait(), 0)
 728
 729     def test_envvar_and_command_line(self):
 730         newenv = os.environ.copy()
 731         newenv["PYTHONWARNINGS"] = "ignore::DeprecationWarning"
 732         p = subprocess.Popen([sys.executable, "-W" "ignore::UnicodeWarning",
 733                 "-c", "import sys; sys.stdout.write(str(sys.warnoptions))"],
 734                 stdout=subprocess.PIPE, env=newenv)
 735         self.assertEqual(p.communicate()[0],
 736                 "['ignore::UnicodeWarning', 'ignore::DeprecationWarning']")
 737         self.assertEqual(p.wait(), 0)
 738
 739 class CEnvironmentVariableTests(EnvironmentVariableTests):
 740     module = c_warnings
 741
 742 class PyEnvironmentVariableTests(EnvironmentVariableTests):
 743     module = py_warnings
 744
 745
 746 def test_main():
 747     py_warnings.onceregistry.clear()
 748     c_warnings.onceregistry.clear()
 749     test_support.run_unittest(CFilterTests, PyFilterTests,
 750                                 CWarnTests, PyWarnTests,
 751                                 CWCmdLineTests, PyWCmdLineTests,
 752                                 _WarningsTests,
 753                                 CWarningsDisplayTests, PyWarningsDisplayTests,
 754                                 CCatchWarningTests, PyCatchWarningTests,
 755                                 CEnvironmentVariableTests,
 756                                 PyEnvironmentVariableTests
 757                              )
 758
 759
 760 if __name__ == "__main__":
 761     test_main()