/Lib/test/test_warnings.py
http://unladen-swallow.googlecode.com/ · Python · 670 lines · 519 code · 95 blank · 56 comment · 74 complexity · 4e5cf5d9c6c69eeeaf6f531be3be1151 MD5 · raw file
- from contextlib import contextmanager
- import linecache
- import os
- import StringIO
- import sys
- import unittest
- from test import test_support
- import warning_tests
- import warnings as original_warnings
- sys.modules['_warnings'] = 0
- del sys.modules['warnings']
- import warnings as py_warnings
- del sys.modules['_warnings']
- del sys.modules['warnings']
- import warnings as c_warnings
- sys.modules['warnings'] = original_warnings
- @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
- try:
- warning_tests.warnings = module
- yield
- finally:
- warning_tests.warnings = original_warnings
- class BaseTest(unittest.TestCase):
- """Basic bookkeeping required for testing."""
- def setUp(self):
- # 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
- super(BaseTest, self).setUp()
- def tearDown(self):
- sys.modules['warnings'] = original_warnings
- super(BaseTest, self).tearDown()
- class FilterTests(object):
- """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_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.assertEquals(len(w), 0)
- 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"
- self.module.warn(message, UserWarning)
- self.assert_(message, w[-1].message)
- self.module.warn(message, UserWarning)
- self.assert_(w[-1].message, 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 xrange(2):
- self.module.warn(message, UserWarning)
- if x == 0:
- self.assertEquals(w[-1].message, message)
- del w[:]
- elif x == 1:
- self.assertEquals(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.assertEquals(w[-1].message, message)
- del w[:]
- self.module.warn(message, UserWarning)
- self.assertEquals(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, "test_warnings.py",
- 42)
- self.assertEquals(w[-1].message, message)
- del w[:]
- self.module.warn_explicit(message, UserWarning, "test_warnings.py",
- 13)
- self.assertEquals(len(w), 0)
- self.module.warn_explicit(message, UserWarning, "test_warnings2.py",
- 42)
- self.assertEquals(len(w), 0)
- 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.assertEquals(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.assert_(w[-1].category is 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.assert_(w[-1].category is UserWarning)
- class CFilterTests(BaseTest, FilterTests):
- module = c_warnings
- class PyFilterTests(BaseTest, FilterTests):
- module = py_warnings
- class WarnTests(unittest.TestCase):
- """Test warnings.warn() and warnings.warn_explicit()."""
- def test_message(self):
- with original_warnings.catch_warnings(record=True,
- module=self.module) as w:
- 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.assert_(w[-1].category is UserWarning)
- 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),
- "warning_tests.py")
- warning_tests.outer("spam2")
- self.assertEqual(os.path.basename(w[-1].filename),
- "warning_tests.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),
- "warning_tests.py")
- warning_tests.outer("spam4", stacklevel=1)
- self.assertEqual(os.path.basename(w[-1].filename),
- "warning_tests.py")
- warning_tests.inner("spam5", stacklevel=2)
- self.assertEqual(os.path.basename(w[-1].filename),
- "test_warnings.py")
- warning_tests.outer("spam6", stacklevel=2)
- self.assertEqual(os.path.basename(w[-1].filename),
- "warning_tests.py")
- warning_tests.outer("spam6.5", stacklevel=3)
- self.assertEqual(os.path.basename(w[-1].filename),
- "test_warnings.py")
- warning_tests.inner("spam7", stacklevel=9999)
- self.assertEqual(os.path.basename(w[-1].filename),
- "sys")
- def test_missing_filename_not_main(self):
- # If __file__ is not specified and __main__ is not the module name,
- # then __file__ should be set to the module name.
- filename = warning_tests.__file__
- try:
- del warning_tests.__file__
- with warnings_state(self.module):
- with original_warnings.catch_warnings(record=True,
- module=self.module) as w:
- warning_tests.inner("spam8", stacklevel=1)
- self.assertEqual(w[-1].filename, warning_tests.__name__)
- finally:
- warning_tests.__file__ = filename
- def test_missing_filename_main_with_argv(self):
- # If __file__ is not specified and the caller is __main__ and sys.argv
- # exists, then use sys.argv[0] as the file.
- if not hasattr(sys, 'argv'):
- return
- filename = warning_tests.__file__
- module_name = warning_tests.__name__
- try:
- del warning_tests.__file__
- warning_tests.__name__ = '__main__'
- with warnings_state(self.module):
- with original_warnings.catch_warnings(record=True,
- module=self.module) as w:
- warning_tests.inner('spam9', stacklevel=1)
- self.assertEqual(w[-1].filename, sys.argv[0])
- finally:
- warning_tests.__file__ = filename
- warning_tests.__name__ = module_name
- def test_missing_filename_main_without_argv(self):
- # If __file__ is not specified, the caller is __main__, and sys.argv
- # is not set, then '__main__' is the file name.
- filename = warning_tests.__file__
- module_name = warning_tests.__name__
- argv = sys.argv
- try:
- del warning_tests.__file__
- warning_tests.__name__ = '__main__'
- del sys.argv
- with warnings_state(self.module):
- with original_warnings.catch_warnings(record=True,
- module=self.module) as w:
- warning_tests.inner('spam10', stacklevel=1)
- self.assertEqual(w[-1].filename, '__main__')
- finally:
- warning_tests.__file__ = filename
- warning_tests.__name__ = module_name
- sys.argv = argv
- def test_missing_filename_main_with_argv_empty_string(self):
- # If __file__ is not specified, the caller is __main__, and sys.argv[0]
- # is the empty string, then '__main__ is the file name.
- # Tests issue 2743.
- file_name = warning_tests.__file__
- module_name = warning_tests.__name__
- argv = sys.argv
- try:
- del warning_tests.__file__
- warning_tests.__name__ = '__main__'
- sys.argv = ['']
- with warnings_state(self.module):
- with original_warnings.catch_warnings(record=True,
- module=self.module) as w:
- warning_tests.inner('spam11', stacklevel=1)
- self.assertEqual(w[-1].filename, '__main__')
- finally:
- warning_tests.__file__ = file_name
- warning_tests.__name__ = module_name
- sys.argv = argv
- def test_warn_explicit_type_errors(self):
- # warn_explicit() shoud 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"})
- self.assertRaises(ValueError, self.module.warn, BadStrWarning())
- class CWarnTests(BaseTest, WarnTests):
- module = c_warnings
- class PyWarnTests(BaseTest, WarnTests):
- module = py_warnings
- class WCmdLineTests(unittest.TestCase):
- 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(BaseTest, WCmdLineTests):
- module = c_warnings
- class PyWCmdLineTests(BaseTest, WCmdLineTests):
- module = py_warnings
- class _WarningsTests(BaseTest):
- """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.failUnlessEqual(w[-1].message, message)
- del w[:]
- self.module.warn_explicit(message, UserWarning, "file", 42)
- self.assertEquals(len(w), 0)
- # Test the resetting of onceregistry.
- self.module.onceregistry = {}
- __warningregistry__ = {}
- self.module.warn('onceregistry test')
- self.failUnlessEqual(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.assertEquals(len(w), 0)
- finally:
- self.module.onceregistry = original_registry
- 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 test_support.captured_output('stderr') as stream:
- self.module.warn(text)
- result = stream.getvalue()
- self.failUnless(text in result)
- def test_showwarning_not_callable(self):
- self.module.filterwarnings("always", category=UserWarning)
- old_showwarning = self.module.showwarning
- self.module.showwarning = 23
- try:
- self.assertRaises(TypeError, self.module.warn, "Warning!")
- finally:
- self.module.showwarning = old_showwarning
- self.module.resetwarnings()
- def test_show_warning_output(self):
- # With showarning() 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 test_support.captured_output('stderr') as stream:
- warning_tests.inner(text)
- result = stream.getvalue()
- self.failUnlessEqual(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.failUnlessEqual(expected_file, path)
- self.failUnlessEqual(warning_class, ' ' + UserWarning.__name__)
- self.failUnlessEqual(message, ' ' + text)
- expected_line = ' ' + linecache.getline(path, line).strip() + '\n'
- assert expected_line
- self.failUnlessEqual(second_line, expected_line)
- class WarningsDisplayTests(unittest.TestCase):
- """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.failUnlessEqual(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.failUnlessEqual(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.StringIO()
- expect = self.module.formatwarning(message, category, file_name,
- line_num)
- self.module.showwarning(message, category, file_name, line_num,
- file_object)
- self.failUnlessEqual(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.StringIO()
- self.module.showwarning(message, category, file_name, line_num,
- file_object, expected_file_line)
- self.failUnlessEqual(expect, file_object.getvalue())
- class CWarningsDisplayTests(BaseTest, WarningsDisplayTests):
- module = c_warnings
- class PyWarningsDisplayTests(BaseTest, WarningsDisplayTests):
- module = py_warnings
- 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.assert_(wmod.filters is orig_filters)
- self.assert_(wmod.showwarning is orig_showwarning)
- # Same test, but with recording disabled
- with wmod.catch_warnings(module=wmod, record=False):
- wmod.filters = wmod.showwarning = object()
- self.assert_(wmod.filters is orig_filters)
- self.assert_(wmod.showwarning is 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.assert_(type(w) is 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.assert_(w is None)
- self.assert_(wmod.showwarning is 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.assert_(w is None)
- self.assert_(wmod.showwarning is orig_showwarning)
- self.assert_(wmod.filters is not orig_filters)
- self.assert_(wmod.filters is orig_filters)
- if wmod is sys.modules['warnings']:
- # Ensure the default module is this one
- with wmod.catch_warnings() as w:
- self.assert_(w is None)
- self.assert_(wmod.showwarning is orig_showwarning)
- self.assert_(wmod.filters is not orig_filters)
- self.assert_(wmod.filters is orig_filters)
- def test_check_warnings(self):
- # Explicit tests for the test_support convenience wrapper
- wmod = self.module
- if wmod is sys.modules['warnings']:
- with test_support.check_warnings() 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, [])
- class CCatchWarningTests(CatchWarningTests):
- module = c_warnings
- class PyCatchWarningTests(CatchWarningTests):
- module = py_warnings
- class ShowwarningDeprecationTests(BaseTest):
- """Test the deprecation of the old warnings.showwarning() API works."""
- @staticmethod
- def bad_showwarning(message, category, filename, lineno, file=None):
- pass
- @staticmethod
- def ok_showwarning(*args):
- pass
- def test_deprecation(self):
- # message, category, filename, lineno[, file[, line]]
- args = ("message", UserWarning, "file name", 42)
- with original_warnings.catch_warnings(module=self.module):
- self.module.filterwarnings("error", category=DeprecationWarning)
- self.module.showwarning = self.bad_showwarning
- self.assertRaises(DeprecationWarning, self.module.warn_explicit,
- *args)
- self.module.showwarning = self.ok_showwarning
- try:
- self.module.warn_explicit(*args)
- except DeprecationWarning as exc:
- self.fail('showwarning(*args) should not trigger a '
- 'DeprecationWarning')
- class CShowwarningDeprecationTests(ShowwarningDeprecationTests):
- module = c_warnings
- class PyShowwarningDeprecationTests(ShowwarningDeprecationTests):
- module = py_warnings
- def test_main():
- py_warnings.onceregistry.clear()
- c_warnings.onceregistry.clear()
- test_support.run_unittest(CFilterTests, PyFilterTests,
- CWarnTests, PyWarnTests,
- CWCmdLineTests, PyWCmdLineTests,
- _WarningsTests,
- CWarningsDisplayTests, PyWarningsDisplayTests,
- CCatchWarningTests, PyCatchWarningTests,
- CShowwarningDeprecationTests,
- PyShowwarningDeprecationTests,
- )
- if __name__ == "__main__":
- test_main()