| 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()
|
|---|
