blob: 52bbaf9a55ef8361fb22d1c67da0419d8d409d5e [file] [log] [blame]
Christian Heimes33fe8092008-04-13 13:53:33 +00001from contextlib import contextmanager
Christian Heimes5fb7c2a2007-12-24 08:52:31 +00002import linecache
Raymond Hettingerdc9dcf12003-07-13 06:15:11 +00003import os
Christian Heimes5fb7c2a2007-12-24 08:52:31 +00004from io import StringIO
Guido van Rossum61e21b52007-08-20 19:06:03 +00005import sys
Raymond Hettingerd6f6e502003-07-13 08:37:40 +00006import unittest
Philip Jenvey0805ca32010-04-07 04:04:10 +00007import subprocess
Benjamin Petersonee8712c2008-05-20 21:35:26 +00008from test import support
Antoine Pitroucf9f9802010-11-10 13:55:25 +00009from test.script_helper import assert_python_ok
Jeremy Hylton85014662003-07-11 15:37:59 +000010
Guido van Rossum805365e2007-05-07 22:24:25 +000011from test import warning_tests
Jeremy Hylton85014662003-07-11 15:37:59 +000012
Christian Heimes33fe8092008-04-13 13:53:33 +000013import warnings as original_warnings
Jeremy Hylton85014662003-07-11 15:37:59 +000014
Nick Coghlan47384702009-04-22 16:13:36 +000015py_warnings = support.import_fresh_module('warnings', blocked=['_warnings'])
16c_warnings = support.import_fresh_module('warnings', fresh=['_warnings'])
Christian Heimes33fe8092008-04-13 13:53:33 +000017
18@contextmanager
19def 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
Florent Xiclunafd1b0932010-03-28 00:25:02 +000032 original_filters = module.filters
Christian Heimes33fe8092008-04-13 13:53:33 +000033 try:
Florent Xiclunafd1b0932010-03-28 00:25:02 +000034 module.filters = original_filters[:]
35 module.simplefilter("once")
Christian Heimes33fe8092008-04-13 13:53:33 +000036 warning_tests.warnings = module
37 yield
38 finally:
39 warning_tests.warnings = original_warnings
Florent Xiclunafd1b0932010-03-28 00:25:02 +000040 module.filters = original_filters
Christian Heimes33fe8092008-04-13 13:53:33 +000041
42
Ezio Melotti2688e812013-01-10 06:52:23 +020043class BaseTest:
Christian Heimes33fe8092008-04-13 13:53:33 +000044
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
Ezio Melotti2688e812013-01-10 06:52:23 +020066class FilterTests(BaseTest):
Christian Heimes33fe8092008-04-13 13:53:33 +000067
68 """Testing the filtering functionality."""
69
70 def test_error(self):
Brett Cannon1cd02472008-09-09 01:52:27 +000071 with original_warnings.catch_warnings(module=self.module) as w:
Christian Heimes33fe8092008-04-13 13:53:33 +000072 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):
Brett Cannon1cd02472008-09-09 01:52:27 +000078 with original_warnings.catch_warnings(record=True,
79 module=self.module) as w:
Christian Heimes33fe8092008-04-13 13:53:33 +000080 self.module.resetwarnings()
81 self.module.filterwarnings("ignore", category=UserWarning)
82 self.module.warn("FilterTests.test_ignore", UserWarning)
Ezio Melottib3aedd42010-11-20 19:04:17 +000083 self.assertEqual(len(w), 0)
Christian Heimes33fe8092008-04-13 13:53:33 +000084
85 def test_always(self):
Brett Cannon1cd02472008-09-09 01:52:27 +000086 with original_warnings.catch_warnings(record=True,
87 module=self.module) as w:
Christian Heimes33fe8092008-04-13 13:53:33 +000088 self.module.resetwarnings()
89 self.module.filterwarnings("always", category=UserWarning)
90 message = "FilterTests.test_always"
91 self.module.warn(message, UserWarning)
Benjamin Petersonc9c0f202009-06-30 23:06:06 +000092 self.assertTrue(message, w[-1].message)
Christian Heimes33fe8092008-04-13 13:53:33 +000093 self.module.warn(message, UserWarning)
Benjamin Petersonc9c0f202009-06-30 23:06:06 +000094 self.assertTrue(w[-1].message, message)
Christian Heimes33fe8092008-04-13 13:53:33 +000095
96 def test_default(self):
Brett Cannon1cd02472008-09-09 01:52:27 +000097 with original_warnings.catch_warnings(record=True,
98 module=self.module) as w:
Christian Heimes33fe8092008-04-13 13:53:33 +000099 self.module.resetwarnings()
100 self.module.filterwarnings("default", category=UserWarning)
101 message = UserWarning("FilterTests.test_default")
102 for x in range(2):
103 self.module.warn(message, UserWarning)
104 if x == 0:
Ezio Melottib3aedd42010-11-20 19:04:17 +0000105 self.assertEqual(w[-1].message, message)
Brett Cannon1cd02472008-09-09 01:52:27 +0000106 del w[:]
Christian Heimes33fe8092008-04-13 13:53:33 +0000107 elif x == 1:
Ezio Melottib3aedd42010-11-20 19:04:17 +0000108 self.assertEqual(len(w), 0)
Christian Heimes33fe8092008-04-13 13:53:33 +0000109 else:
110 raise ValueError("loop variant unhandled")
111
112 def test_module(self):
Brett Cannon1cd02472008-09-09 01:52:27 +0000113 with original_warnings.catch_warnings(record=True,
114 module=self.module) as w:
Christian Heimes33fe8092008-04-13 13:53:33 +0000115 self.module.resetwarnings()
116 self.module.filterwarnings("module", category=UserWarning)
117 message = UserWarning("FilterTests.test_module")
118 self.module.warn(message, UserWarning)
Ezio Melottib3aedd42010-11-20 19:04:17 +0000119 self.assertEqual(w[-1].message, message)
Brett Cannon1cd02472008-09-09 01:52:27 +0000120 del w[:]
Christian Heimes33fe8092008-04-13 13:53:33 +0000121 self.module.warn(message, UserWarning)
Ezio Melottib3aedd42010-11-20 19:04:17 +0000122 self.assertEqual(len(w), 0)
Christian Heimes33fe8092008-04-13 13:53:33 +0000123
124 def test_once(self):
Brett Cannon1cd02472008-09-09 01:52:27 +0000125 with original_warnings.catch_warnings(record=True,
126 module=self.module) as w:
Christian Heimes33fe8092008-04-13 13:53:33 +0000127 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)
Ezio Melottib3aedd42010-11-20 19:04:17 +0000132 self.assertEqual(w[-1].message, message)
Brett Cannon1cd02472008-09-09 01:52:27 +0000133 del w[:]
Christian Heimes33fe8092008-04-13 13:53:33 +0000134 self.module.warn_explicit(message, UserWarning, "test_warnings.py",
135 13)
Ezio Melottib3aedd42010-11-20 19:04:17 +0000136 self.assertEqual(len(w), 0)
Christian Heimes33fe8092008-04-13 13:53:33 +0000137 self.module.warn_explicit(message, UserWarning, "test_warnings2.py",
138 42)
Ezio Melottib3aedd42010-11-20 19:04:17 +0000139 self.assertEqual(len(w), 0)
Christian Heimes33fe8092008-04-13 13:53:33 +0000140
141 def test_inheritance(self):
Brett Cannon1cd02472008-09-09 01:52:27 +0000142 with original_warnings.catch_warnings(module=self.module) as w:
Christian Heimes33fe8092008-04-13 13:53:33 +0000143 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):
Brett Cannon1cd02472008-09-09 01:52:27 +0000149 with original_warnings.catch_warnings(record=True,
150 module=self.module) as w:
Christian Heimes33fe8092008-04-13 13:53:33 +0000151 self.module.resetwarnings()
152 self.module.filterwarnings("ignore", category=UserWarning)
153 self.module.filterwarnings("error", category=UserWarning,
154 append=True)
Brett Cannon1cd02472008-09-09 01:52:27 +0000155 del w[:]
Christian Heimes33fe8092008-04-13 13:53:33 +0000156 try:
157 self.module.warn("FilterTests.test_ordering", UserWarning)
158 except UserWarning:
159 self.fail("order handling for actions failed")
Ezio Melottib3aedd42010-11-20 19:04:17 +0000160 self.assertEqual(len(w), 0)
Christian Heimes33fe8092008-04-13 13:53:33 +0000161
162 def test_filterwarnings(self):
163 # Test filterwarnings().
164 # Implicitly also tests resetwarnings().
Brett Cannon1cd02472008-09-09 01:52:27 +0000165 with original_warnings.catch_warnings(record=True,
166 module=self.module) as w:
Christian Heimes33fe8092008-04-13 13:53:33 +0000167 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)
Brett Cannon1cd02472008-09-09 01:52:27 +0000173 self.assertEqual(str(w[-1].message), text)
Benjamin Petersonc9c0f202009-06-30 23:06:06 +0000174 self.assertTrue(w[-1].category is UserWarning)
Christian Heimes33fe8092008-04-13 13:53:33 +0000175
176 self.module.filterwarnings("ignore", "", Warning, "", 0)
177 text = 'filtered out'
178 self.module.warn(text)
Brett Cannon1cd02472008-09-09 01:52:27 +0000179 self.assertNotEqual(str(w[-1].message), text)
Christian Heimes33fe8092008-04-13 13:53:33 +0000180
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)
Brett Cannon1cd02472008-09-09 01:52:27 +0000186 self.assertEqual(str(w[-1].message), text)
Benjamin Petersonc9c0f202009-06-30 23:06:06 +0000187 self.assertTrue(w[-1].category is UserWarning)
Christian Heimes33fe8092008-04-13 13:53:33 +0000188
Ezio Melotti2688e812013-01-10 06:52:23 +0200189class CFilterTests(FilterTests, unittest.TestCase):
Christian Heimes33fe8092008-04-13 13:53:33 +0000190 module = c_warnings
191
Ezio Melotti2688e812013-01-10 06:52:23 +0200192class PyFilterTests(FilterTests, unittest.TestCase):
Christian Heimes33fe8092008-04-13 13:53:33 +0000193 module = py_warnings
194
195
Ezio Melotti2688e812013-01-10 06:52:23 +0200196class WarnTests(BaseTest):
Christian Heimes33fe8092008-04-13 13:53:33 +0000197
198 """Test warnings.warn() and warnings.warn_explicit()."""
199
200 def test_message(self):
Brett Cannon1cd02472008-09-09 01:52:27 +0000201 with original_warnings.catch_warnings(record=True,
202 module=self.module) as w:
Florent Xiclunafd1b0932010-03-28 00:25:02 +0000203 self.module.simplefilter("once")
Guido van Rossumd8faa362007-04-27 19:54:29 +0000204 for i in range(4):
Christian Heimes33fe8092008-04-13 13:53:33 +0000205 text = 'multi %d' %i # Different text on each call.
206 self.module.warn(text)
Brett Cannon1cd02472008-09-09 01:52:27 +0000207 self.assertEqual(str(w[-1].message), text)
Benjamin Petersonc9c0f202009-06-30 23:06:06 +0000208 self.assertTrue(w[-1].category is UserWarning)
Raymond Hettingerd6f6e502003-07-13 08:37:40 +0000209
Brett Cannon54bd41d2008-09-02 04:01:42 +0000210 # Issue 3639
211 def test_warn_nonstandard_types(self):
212 # warn() should handle non-standard types without issue.
213 for ob in (Warning, None, 42):
Benjamin Petersonfcf5d632008-10-16 23:24:44 +0000214 with original_warnings.catch_warnings(record=True,
215 module=self.module) as w:
Florent Xiclunafd1b0932010-03-28 00:25:02 +0000216 self.module.simplefilter("once")
Brett Cannon54bd41d2008-09-02 04:01:42 +0000217 self.module.warn(ob)
218 # Don't directly compare objects since
219 # ``Warning() != Warning()``.
Ezio Melottib3aedd42010-11-20 19:04:17 +0000220 self.assertEqual(str(w[-1].message), str(UserWarning(ob)))
Brett Cannon54bd41d2008-09-02 04:01:42 +0000221
Guido van Rossumd8faa362007-04-27 19:54:29 +0000222 def test_filename(self):
Christian Heimes33fe8092008-04-13 13:53:33 +0000223 with warnings_state(self.module):
Brett Cannon1cd02472008-09-09 01:52:27 +0000224 with original_warnings.catch_warnings(record=True,
225 module=self.module) as w:
Christian Heimes33fe8092008-04-13 13:53:33 +0000226 warning_tests.inner("spam1")
Brett Cannon1cd02472008-09-09 01:52:27 +0000227 self.assertEqual(os.path.basename(w[-1].filename),
228 "warning_tests.py")
Christian Heimes33fe8092008-04-13 13:53:33 +0000229 warning_tests.outer("spam2")
Brett Cannon1cd02472008-09-09 01:52:27 +0000230 self.assertEqual(os.path.basename(w[-1].filename),
231 "warning_tests.py")
Guido van Rossumd8faa362007-04-27 19:54:29 +0000232
233 def test_stacklevel(self):
234 # Test stacklevel argument
235 # make sure all messages are different, so the warning won't be skipped
Christian Heimes33fe8092008-04-13 13:53:33 +0000236 with warnings_state(self.module):
Brett Cannon1cd02472008-09-09 01:52:27 +0000237 with original_warnings.catch_warnings(record=True,
238 module=self.module) as w:
Christian Heimes33fe8092008-04-13 13:53:33 +0000239 warning_tests.inner("spam3", stacklevel=1)
Brett Cannon1cd02472008-09-09 01:52:27 +0000240 self.assertEqual(os.path.basename(w[-1].filename),
241 "warning_tests.py")
Christian Heimes33fe8092008-04-13 13:53:33 +0000242 warning_tests.outer("spam4", stacklevel=1)
Brett Cannon1cd02472008-09-09 01:52:27 +0000243 self.assertEqual(os.path.basename(w[-1].filename),
244 "warning_tests.py")
Guido van Rossumd8faa362007-04-27 19:54:29 +0000245
Christian Heimes33fe8092008-04-13 13:53:33 +0000246 warning_tests.inner("spam5", stacklevel=2)
Brett Cannon1cd02472008-09-09 01:52:27 +0000247 self.assertEqual(os.path.basename(w[-1].filename),
248 "test_warnings.py")
Christian Heimes33fe8092008-04-13 13:53:33 +0000249 warning_tests.outer("spam6", stacklevel=2)
Brett Cannon1cd02472008-09-09 01:52:27 +0000250 self.assertEqual(os.path.basename(w[-1].filename),
251 "warning_tests.py")
Christian Heimes5d8da202008-05-06 13:58:24 +0000252 warning_tests.outer("spam6.5", stacklevel=3)
Brett Cannon1cd02472008-09-09 01:52:27 +0000253 self.assertEqual(os.path.basename(w[-1].filename),
254 "test_warnings.py")
Guido van Rossumd8faa362007-04-27 19:54:29 +0000255
Christian Heimes33fe8092008-04-13 13:53:33 +0000256 warning_tests.inner("spam7", stacklevel=9999)
Brett Cannon1cd02472008-09-09 01:52:27 +0000257 self.assertEqual(os.path.basename(w[-1].filename),
258 "sys")
Christian Heimes33fe8092008-04-13 13:53:33 +0000259
Christian Heimes81ee3ef2008-05-04 22:42:01 +0000260 def test_missing_filename_not_main(self):
261 # If __file__ is not specified and __main__ is not the module name,
262 # then __file__ should be set to the module name.
263 filename = warning_tests.__file__
264 try:
265 del warning_tests.__file__
266 with warnings_state(self.module):
Brett Cannon1cd02472008-09-09 01:52:27 +0000267 with original_warnings.catch_warnings(record=True,
268 module=self.module) as w:
Christian Heimes81ee3ef2008-05-04 22:42:01 +0000269 warning_tests.inner("spam8", stacklevel=1)
Brett Cannon1cd02472008-09-09 01:52:27 +0000270 self.assertEqual(w[-1].filename, warning_tests.__name__)
Christian Heimes81ee3ef2008-05-04 22:42:01 +0000271 finally:
272 warning_tests.__file__ = filename
273
274 def test_missing_filename_main_with_argv(self):
275 # If __file__ is not specified and the caller is __main__ and sys.argv
276 # exists, then use sys.argv[0] as the file.
277 if not hasattr(sys, 'argv'):
278 return
279 filename = warning_tests.__file__
280 module_name = warning_tests.__name__
281 try:
282 del warning_tests.__file__
283 warning_tests.__name__ = '__main__'
284 with warnings_state(self.module):
Brett Cannon1cd02472008-09-09 01:52:27 +0000285 with original_warnings.catch_warnings(record=True,
286 module=self.module) as w:
Christian Heimes81ee3ef2008-05-04 22:42:01 +0000287 warning_tests.inner('spam9', stacklevel=1)
Brett Cannon1cd02472008-09-09 01:52:27 +0000288 self.assertEqual(w[-1].filename, sys.argv[0])
Christian Heimes81ee3ef2008-05-04 22:42:01 +0000289 finally:
290 warning_tests.__file__ = filename
291 warning_tests.__name__ = module_name
292
293 def test_missing_filename_main_without_argv(self):
294 # If __file__ is not specified, the caller is __main__, and sys.argv
295 # is not set, then '__main__' is the file name.
296 filename = warning_tests.__file__
297 module_name = warning_tests.__name__
298 argv = sys.argv
299 try:
300 del warning_tests.__file__
301 warning_tests.__name__ = '__main__'
302 del sys.argv
303 with warnings_state(self.module):
Brett Cannon1cd02472008-09-09 01:52:27 +0000304 with original_warnings.catch_warnings(record=True,
305 module=self.module) as w:
Christian Heimes81ee3ef2008-05-04 22:42:01 +0000306 warning_tests.inner('spam10', stacklevel=1)
Brett Cannon1cd02472008-09-09 01:52:27 +0000307 self.assertEqual(w[-1].filename, '__main__')
Christian Heimes81ee3ef2008-05-04 22:42:01 +0000308 finally:
309 warning_tests.__file__ = filename
310 warning_tests.__name__ = module_name
311 sys.argv = argv
312
Christian Heimesdaaf8ee2008-05-04 23:58:41 +0000313 def test_missing_filename_main_with_argv_empty_string(self):
Christian Heimes81ee3ef2008-05-04 22:42:01 +0000314 # If __file__ is not specified, the caller is __main__, and sys.argv[0]
315 # is the empty string, then '__main__ is the file name.
316 # Tests issue 2743.
317 file_name = warning_tests.__file__
318 module_name = warning_tests.__name__
319 argv = sys.argv
320 try:
321 del warning_tests.__file__
322 warning_tests.__name__ = '__main__'
323 sys.argv = ['']
324 with warnings_state(self.module):
Brett Cannon1cd02472008-09-09 01:52:27 +0000325 with original_warnings.catch_warnings(record=True,
326 module=self.module) as w:
Christian Heimes81ee3ef2008-05-04 22:42:01 +0000327 warning_tests.inner('spam11', stacklevel=1)
Brett Cannon1cd02472008-09-09 01:52:27 +0000328 self.assertEqual(w[-1].filename, '__main__')
Christian Heimes81ee3ef2008-05-04 22:42:01 +0000329 finally:
330 warning_tests.__file__ = file_name
331 warning_tests.__name__ = module_name
332 sys.argv = argv
333
Victor Stinnera4c704b2013-10-29 23:43:41 +0100334 def test_warn_explicit_non_ascii_filename(self):
335 with original_warnings.catch_warnings(record=True,
336 module=self.module) as w:
337 self.module.resetwarnings()
338 self.module.filterwarnings("always", category=UserWarning)
339
340 self.module.warn_explicit("text", UserWarning, "nonascii\xe9\u20ac", 1)
341 self.assertEqual(w[-1].filename, "nonascii\xe9\u20ac")
342
343 self.module.warn_explicit("text", UserWarning, "surrogate\udc80", 1)
344 self.assertEqual(w[-1].filename, "surrogate\udc80")
345
Brett Cannondb734912008-06-27 00:52:15 +0000346 def test_warn_explicit_type_errors(self):
Ezio Melotti13925002011-03-16 11:05:33 +0200347 # warn_explicit() should error out gracefully if it is given objects
Brett Cannondb734912008-06-27 00:52:15 +0000348 # of the wrong types.
349 # lineno is expected to be an integer.
350 self.assertRaises(TypeError, self.module.warn_explicit,
351 None, UserWarning, None, None)
352 # Either 'message' needs to be an instance of Warning or 'category'
353 # needs to be a subclass.
354 self.assertRaises(TypeError, self.module.warn_explicit,
355 None, None, None, 1)
356 # 'registry' must be a dict or None.
357 self.assertRaises((TypeError, AttributeError),
358 self.module.warn_explicit,
359 None, Warning, None, 1, registry=42)
360
Hirokazu Yamamoto1c0c0032009-07-17 06:55:42 +0000361 def test_bad_str(self):
362 # issue 6415
363 # Warnings instance with a bad format string for __str__ should not
364 # trigger a bus error.
365 class BadStrWarning(Warning):
366 """Warning with a bad format string for __str__."""
367 def __str__(self):
368 return ("A bad formatted string %(err)" %
369 {"err" : "there is no %(err)s"})
370
371 with self.assertRaises(ValueError):
372 self.module.warn(BadStrWarning())
373
374
Ezio Melotti2688e812013-01-10 06:52:23 +0200375class CWarnTests(WarnTests, unittest.TestCase):
Christian Heimes33fe8092008-04-13 13:53:33 +0000376 module = c_warnings
377
Nick Coghlanfce769e2009-04-11 14:30:59 +0000378 # As an early adopter, we sanity check the
379 # test.support.import_fresh_module utility function
380 def test_accelerated(self):
381 self.assertFalse(original_warnings is self.module)
382 self.assertFalse(hasattr(self.module.warn, '__code__'))
383
Ezio Melotti2688e812013-01-10 06:52:23 +0200384class PyWarnTests(WarnTests, unittest.TestCase):
Christian Heimes33fe8092008-04-13 13:53:33 +0000385 module = py_warnings
386
Nick Coghlanfce769e2009-04-11 14:30:59 +0000387 # As an early adopter, we sanity check the
388 # test.support.import_fresh_module utility function
389 def test_pure_python(self):
390 self.assertFalse(original_warnings is self.module)
391 self.assertTrue(hasattr(self.module.warn, '__code__'))
392
Christian Heimes33fe8092008-04-13 13:53:33 +0000393
Ezio Melotti2688e812013-01-10 06:52:23 +0200394class WCmdLineTests(BaseTest):
Christian Heimes33fe8092008-04-13 13:53:33 +0000395
396 def test_improper_input(self):
397 # Uses the private _setoption() function to test the parsing
398 # of command-line warning arguments
Brett Cannon1cd02472008-09-09 01:52:27 +0000399 with original_warnings.catch_warnings(module=self.module):
Christian Heimes33fe8092008-04-13 13:53:33 +0000400 self.assertRaises(self.module._OptionError,
401 self.module._setoption, '1:2:3:4:5:6')
402 self.assertRaises(self.module._OptionError,
403 self.module._setoption, 'bogus::Warning')
404 self.assertRaises(self.module._OptionError,
405 self.module._setoption, 'ignore:2::4:-5')
406 self.module._setoption('error::Warning::0')
407 self.assertRaises(UserWarning, self.module.warn, 'convert to error')
408
Antoine Pitroucf9f9802010-11-10 13:55:25 +0000409 def test_improper_option(self):
410 # Same as above, but check that the message is printed out when
411 # the interpreter is executed. This also checks that options are
412 # actually parsed at all.
413 rc, out, err = assert_python_ok("-Wxxx", "-c", "pass")
414 self.assertIn(b"Invalid -W option ignored: invalid action: 'xxx'", err)
415
416 def test_warnings_bootstrap(self):
417 # Check that the warnings module does get loaded when -W<some option>
418 # is used (see issue #10372 for an example of silent bootstrap failure).
419 rc, out, err = assert_python_ok("-Wi", "-c",
420 "import sys; sys.modules['warnings'].warn('foo', RuntimeWarning)")
421 # '-Wi' was observed
422 self.assertFalse(out.strip())
423 self.assertNotIn(b'RuntimeWarning', err)
424
Ezio Melotti2688e812013-01-10 06:52:23 +0200425class CWCmdLineTests(WCmdLineTests, unittest.TestCase):
Christian Heimes33fe8092008-04-13 13:53:33 +0000426 module = c_warnings
427
Ezio Melotti2688e812013-01-10 06:52:23 +0200428class PyWCmdLineTests(WCmdLineTests, unittest.TestCase):
Christian Heimes33fe8092008-04-13 13:53:33 +0000429 module = py_warnings
430
431
Ezio Melotti2688e812013-01-10 06:52:23 +0200432class _WarningsTests(BaseTest, unittest.TestCase):
Christian Heimes33fe8092008-04-13 13:53:33 +0000433
434 """Tests specific to the _warnings module."""
435
436 module = c_warnings
437
438 def test_filter(self):
439 # Everything should function even if 'filters' is not in warnings.
Brett Cannon1cd02472008-09-09 01:52:27 +0000440 with original_warnings.catch_warnings(module=self.module) as w:
Christian Heimes33fe8092008-04-13 13:53:33 +0000441 self.module.filterwarnings("error", "", Warning, "", 0)
442 self.assertRaises(UserWarning, self.module.warn,
443 'convert to error')
444 del self.module.filters
445 self.assertRaises(UserWarning, self.module.warn,
446 'convert to error')
447
448 def test_onceregistry(self):
449 # Replacing or removing the onceregistry should be okay.
450 global __warningregistry__
451 message = UserWarning('onceregistry test')
452 try:
453 original_registry = self.module.onceregistry
454 __warningregistry__ = {}
Brett Cannon1cd02472008-09-09 01:52:27 +0000455 with original_warnings.catch_warnings(record=True,
456 module=self.module) as w:
Christian Heimes33fe8092008-04-13 13:53:33 +0000457 self.module.resetwarnings()
458 self.module.filterwarnings("once", category=UserWarning)
459 self.module.warn_explicit(message, UserWarning, "file", 42)
Benjamin Petersonc9c0f202009-06-30 23:06:06 +0000460 self.assertEqual(w[-1].message, message)
Brett Cannon1cd02472008-09-09 01:52:27 +0000461 del w[:]
Christian Heimes33fe8092008-04-13 13:53:33 +0000462 self.module.warn_explicit(message, UserWarning, "file", 42)
Ezio Melottib3aedd42010-11-20 19:04:17 +0000463 self.assertEqual(len(w), 0)
Christian Heimes33fe8092008-04-13 13:53:33 +0000464 # Test the resetting of onceregistry.
465 self.module.onceregistry = {}
466 __warningregistry__ = {}
467 self.module.warn('onceregistry test')
Benjamin Petersonc9c0f202009-06-30 23:06:06 +0000468 self.assertEqual(w[-1].message.args, message.args)
Christian Heimes33fe8092008-04-13 13:53:33 +0000469 # Removal of onceregistry is okay.
Brett Cannon1cd02472008-09-09 01:52:27 +0000470 del w[:]
Christian Heimes33fe8092008-04-13 13:53:33 +0000471 del self.module.onceregistry
472 __warningregistry__ = {}
473 self.module.warn_explicit(message, UserWarning, "file", 42)
Ezio Melottib3aedd42010-11-20 19:04:17 +0000474 self.assertEqual(len(w), 0)
Christian Heimes33fe8092008-04-13 13:53:33 +0000475 finally:
476 self.module.onceregistry = original_registry
477
Brett Cannon0759dd62009-04-01 18:13:07 +0000478 def test_default_action(self):
479 # Replacing or removing defaultaction should be okay.
480 message = UserWarning("defaultaction test")
481 original = self.module.defaultaction
482 try:
483 with original_warnings.catch_warnings(record=True,
484 module=self.module) as w:
485 self.module.resetwarnings()
486 registry = {}
487 self.module.warn_explicit(message, UserWarning, "<test>", 42,
488 registry=registry)
489 self.assertEqual(w[-1].message, message)
490 self.assertEqual(len(w), 1)
491 self.assertEqual(len(registry), 1)
492 del w[:]
493 # Test removal.
494 del self.module.defaultaction
495 __warningregistry__ = {}
496 registry = {}
497 self.module.warn_explicit(message, UserWarning, "<test>", 43,
498 registry=registry)
499 self.assertEqual(w[-1].message, message)
500 self.assertEqual(len(w), 1)
501 self.assertEqual(len(registry), 1)
502 del w[:]
503 # Test setting.
504 self.module.defaultaction = "ignore"
505 __warningregistry__ = {}
506 registry = {}
507 self.module.warn_explicit(message, UserWarning, "<test>", 44,
508 registry=registry)
509 self.assertEqual(len(w), 0)
510 finally:
511 self.module.defaultaction = original
512
Christian Heimes33fe8092008-04-13 13:53:33 +0000513 def test_showwarning_missing(self):
514 # Test that showwarning() missing is okay.
515 text = 'del showwarning test'
Brett Cannon1cd02472008-09-09 01:52:27 +0000516 with original_warnings.catch_warnings(module=self.module):
Christian Heimes33fe8092008-04-13 13:53:33 +0000517 self.module.filterwarnings("always", category=UserWarning)
518 del self.module.showwarning
Benjamin Petersonee8712c2008-05-20 21:35:26 +0000519 with support.captured_output('stderr') as stream:
Christian Heimes33fe8092008-04-13 13:53:33 +0000520 self.module.warn(text)
521 result = stream.getvalue()
Benjamin Peterson577473f2010-01-19 00:09:57 +0000522 self.assertIn(text, result)
Christian Heimes33fe8092008-04-13 13:53:33 +0000523
Christian Heimes8dc226f2008-05-06 23:45:46 +0000524 def test_showwarning_not_callable(self):
Brett Cannonfcc05272009-04-01 20:27:29 +0000525 with original_warnings.catch_warnings(module=self.module):
526 self.module.filterwarnings("always", category=UserWarning)
Brett Cannon52a7d982011-07-17 19:17:55 -0700527 self.module.showwarning = print
528 with support.captured_output('stdout'):
529 self.module.warn('Warning!')
Brett Cannonfcc05272009-04-01 20:27:29 +0000530 self.module.showwarning = 23
Brett Cannon52a7d982011-07-17 19:17:55 -0700531 self.assertRaises(TypeError, self.module.warn, "Warning!")
Christian Heimes8dc226f2008-05-06 23:45:46 +0000532
Christian Heimes33fe8092008-04-13 13:53:33 +0000533 def test_show_warning_output(self):
534 # With showarning() missing, make sure that output is okay.
535 text = 'test show_warning'
Brett Cannon1cd02472008-09-09 01:52:27 +0000536 with original_warnings.catch_warnings(module=self.module):
Christian Heimes33fe8092008-04-13 13:53:33 +0000537 self.module.filterwarnings("always", category=UserWarning)
538 del self.module.showwarning
Benjamin Petersonee8712c2008-05-20 21:35:26 +0000539 with support.captured_output('stderr') as stream:
Christian Heimes33fe8092008-04-13 13:53:33 +0000540 warning_tests.inner(text)
541 result = stream.getvalue()
Benjamin Petersonc9c0f202009-06-30 23:06:06 +0000542 self.assertEqual(result.count('\n'), 2,
Christian Heimes33fe8092008-04-13 13:53:33 +0000543 "Too many newlines in %r" % result)
544 first_line, second_line = result.split('\n', 1)
545 expected_file = os.path.splitext(warning_tests.__file__)[0] + '.py'
Neal Norwitz32dde222008-04-15 06:43:13 +0000546 first_line_parts = first_line.rsplit(':', 3)
547 path, line, warning_class, message = first_line_parts
Christian Heimes33fe8092008-04-13 13:53:33 +0000548 line = int(line)
Benjamin Petersonc9c0f202009-06-30 23:06:06 +0000549 self.assertEqual(expected_file, path)
550 self.assertEqual(warning_class, ' ' + UserWarning.__name__)
551 self.assertEqual(message, ' ' + text)
Christian Heimes33fe8092008-04-13 13:53:33 +0000552 expected_line = ' ' + linecache.getline(path, line).strip() + '\n'
553 assert expected_line
Benjamin Petersonc9c0f202009-06-30 23:06:06 +0000554 self.assertEqual(second_line, expected_line)
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000555
Victor Stinner8b0508e2011-07-04 02:43:09 +0200556 def test_filename_none(self):
557 # issue #12467: race condition if a warning is emitted at shutdown
558 globals_dict = globals()
559 oldfile = globals_dict['__file__']
560 try:
Brett Cannon52a7d982011-07-17 19:17:55 -0700561 catch = original_warnings.catch_warnings(record=True,
562 module=self.module)
563 with catch as w:
Victor Stinner8b0508e2011-07-04 02:43:09 +0200564 self.module.filterwarnings("always", category=UserWarning)
565 globals_dict['__file__'] = None
566 original_warnings.warn('test', UserWarning)
Brett Cannon52a7d982011-07-17 19:17:55 -0700567 self.assertTrue(len(w))
Victor Stinner8b0508e2011-07-04 02:43:09 +0200568 finally:
569 globals_dict['__file__'] = oldfile
570
Thomas Wouters0e3f5912006-08-11 14:57:12 +0000571
Ezio Melotti2688e812013-01-10 06:52:23 +0200572class WarningsDisplayTests(BaseTest):
Christian Heimes5fb7c2a2007-12-24 08:52:31 +0000573
Christian Heimes33fe8092008-04-13 13:53:33 +0000574 """Test the displaying of warnings and the ability to overload functions
575 related to displaying warnings."""
576
Christian Heimes5fb7c2a2007-12-24 08:52:31 +0000577 def test_formatwarning(self):
578 message = "msg"
579 category = Warning
580 file_name = os.path.splitext(warning_tests.__file__)[0] + '.py'
581 line_num = 3
582 file_line = linecache.getline(file_name, line_num).strip()
Christian Heimes33fe8092008-04-13 13:53:33 +0000583 format = "%s:%s: %s: %s\n %s\n"
584 expect = format % (file_name, line_num, category.__name__, message,
585 file_line)
Benjamin Petersonc9c0f202009-06-30 23:06:06 +0000586 self.assertEqual(expect, self.module.formatwarning(message,
Christian Heimes33fe8092008-04-13 13:53:33 +0000587 category, file_name, line_num))
588 # Test the 'line' argument.
589 file_line += " for the win!"
590 expect = format % (file_name, line_num, category.__name__, message,
591 file_line)
Benjamin Petersonc9c0f202009-06-30 23:06:06 +0000592 self.assertEqual(expect, self.module.formatwarning(message,
Christian Heimes33fe8092008-04-13 13:53:33 +0000593 category, file_name, line_num, file_line))
Christian Heimes5fb7c2a2007-12-24 08:52:31 +0000594
595 def test_showwarning(self):
596 file_name = os.path.splitext(warning_tests.__file__)[0] + '.py'
597 line_num = 3
598 expected_file_line = linecache.getline(file_name, line_num).strip()
599 message = 'msg'
600 category = Warning
601 file_object = StringIO()
Christian Heimes33fe8092008-04-13 13:53:33 +0000602 expect = self.module.formatwarning(message, category, file_name,
603 line_num)
604 self.module.showwarning(message, category, file_name, line_num,
Christian Heimes5fb7c2a2007-12-24 08:52:31 +0000605 file_object)
Benjamin Petersonc9c0f202009-06-30 23:06:06 +0000606 self.assertEqual(file_object.getvalue(), expect)
Christian Heimes33fe8092008-04-13 13:53:33 +0000607 # Test 'line' argument.
608 expected_file_line += "for the win!"
609 expect = self.module.formatwarning(message, category, file_name,
610 line_num, expected_file_line)
611 file_object = StringIO()
612 self.module.showwarning(message, category, file_name, line_num,
613 file_object, expected_file_line)
Benjamin Petersonc9c0f202009-06-30 23:06:06 +0000614 self.assertEqual(expect, file_object.getvalue())
Christian Heimes33fe8092008-04-13 13:53:33 +0000615
Ezio Melotti2688e812013-01-10 06:52:23 +0200616class CWarningsDisplayTests(WarningsDisplayTests, unittest.TestCase):
Christian Heimes33fe8092008-04-13 13:53:33 +0000617 module = c_warnings
618
Ezio Melotti2688e812013-01-10 06:52:23 +0200619class PyWarningsDisplayTests(WarningsDisplayTests, unittest.TestCase):
Christian Heimes33fe8092008-04-13 13:53:33 +0000620 module = py_warnings
Christian Heimes5fb7c2a2007-12-24 08:52:31 +0000621
Brett Cannon1cd02472008-09-09 01:52:27 +0000622
Brett Cannonec92e182008-09-02 02:46:59 +0000623class CatchWarningTests(BaseTest):
Nick Coghlanb1304932008-07-13 12:25:08 +0000624
Brett Cannonec92e182008-09-02 02:46:59 +0000625 """Test catch_warnings()."""
626
627 def test_catch_warnings_restore(self):
Nick Coghlanb1304932008-07-13 12:25:08 +0000628 wmod = self.module
629 orig_filters = wmod.filters
630 orig_showwarning = wmod.showwarning
Benjamin Petersonfcf5d632008-10-16 23:24:44 +0000631 # Ensure both showwarning and filters are restored when recording
632 with wmod.catch_warnings(module=wmod, record=True):
Nick Coghlanb1304932008-07-13 12:25:08 +0000633 wmod.filters = wmod.showwarning = object()
Benjamin Petersonc9c0f202009-06-30 23:06:06 +0000634 self.assertTrue(wmod.filters is orig_filters)
635 self.assertTrue(wmod.showwarning is orig_showwarning)
Benjamin Petersonfcf5d632008-10-16 23:24:44 +0000636 # Same test, but with recording disabled
637 with wmod.catch_warnings(module=wmod, record=False):
Nick Coghlanb1304932008-07-13 12:25:08 +0000638 wmod.filters = wmod.showwarning = object()
Benjamin Petersonc9c0f202009-06-30 23:06:06 +0000639 self.assertTrue(wmod.filters is orig_filters)
640 self.assertTrue(wmod.showwarning is orig_showwarning)
Nick Coghlanb1304932008-07-13 12:25:08 +0000641
Brett Cannonec92e182008-09-02 02:46:59 +0000642 def test_catch_warnings_recording(self):
Nick Coghlanb1304932008-07-13 12:25:08 +0000643 wmod = self.module
Benjamin Petersonfcf5d632008-10-16 23:24:44 +0000644 # Ensure warnings are recorded when requested
645 with wmod.catch_warnings(module=wmod, record=True) as w:
Brett Cannonec92e182008-09-02 02:46:59 +0000646 self.assertEqual(w, [])
Benjamin Petersonc9c0f202009-06-30 23:06:06 +0000647 self.assertTrue(type(w) is list)
Nick Coghlanb1304932008-07-13 12:25:08 +0000648 wmod.simplefilter("always")
649 wmod.warn("foo")
Brett Cannon1cd02472008-09-09 01:52:27 +0000650 self.assertEqual(str(w[-1].message), "foo")
Nick Coghlanb1304932008-07-13 12:25:08 +0000651 wmod.warn("bar")
Brett Cannon1cd02472008-09-09 01:52:27 +0000652 self.assertEqual(str(w[-1].message), "bar")
Brett Cannonec92e182008-09-02 02:46:59 +0000653 self.assertEqual(str(w[0].message), "foo")
654 self.assertEqual(str(w[1].message), "bar")
Brett Cannon1cd02472008-09-09 01:52:27 +0000655 del w[:]
Brett Cannonec92e182008-09-02 02:46:59 +0000656 self.assertEqual(w, [])
Benjamin Petersonfcf5d632008-10-16 23:24:44 +0000657 # Ensure warnings are not recorded when not requested
Nick Coghlanb1304932008-07-13 12:25:08 +0000658 orig_showwarning = wmod.showwarning
Benjamin Petersonfcf5d632008-10-16 23:24:44 +0000659 with wmod.catch_warnings(module=wmod, record=False) as w:
Benjamin Petersonc9c0f202009-06-30 23:06:06 +0000660 self.assertTrue(w is None)
661 self.assertTrue(wmod.showwarning is orig_showwarning)
Nick Coghlanb1304932008-07-13 12:25:08 +0000662
Benjamin Petersonfcf5d632008-10-16 23:24:44 +0000663 def test_catch_warnings_reentry_guard(self):
664 wmod = self.module
665 # Ensure catch_warnings is protected against incorrect usage
666 x = wmod.catch_warnings(module=wmod, record=True)
667 self.assertRaises(RuntimeError, x.__exit__)
668 with x:
669 self.assertRaises(RuntimeError, x.__enter__)
670 # Same test, but with recording disabled
671 x = wmod.catch_warnings(module=wmod, record=False)
672 self.assertRaises(RuntimeError, x.__exit__)
673 with x:
674 self.assertRaises(RuntimeError, x.__enter__)
675
676 def test_catch_warnings_defaults(self):
677 wmod = self.module
678 orig_filters = wmod.filters
679 orig_showwarning = wmod.showwarning
680 # Ensure default behaviour is not to record warnings
681 with wmod.catch_warnings(module=wmod) as w:
Benjamin Petersonc9c0f202009-06-30 23:06:06 +0000682 self.assertTrue(w is None)
683 self.assertTrue(wmod.showwarning is orig_showwarning)
684 self.assertTrue(wmod.filters is not orig_filters)
685 self.assertTrue(wmod.filters is orig_filters)
Benjamin Petersonfcf5d632008-10-16 23:24:44 +0000686 if wmod is sys.modules['warnings']:
687 # Ensure the default module is this one
688 with wmod.catch_warnings() as w:
Benjamin Petersonc9c0f202009-06-30 23:06:06 +0000689 self.assertTrue(w is None)
690 self.assertTrue(wmod.showwarning is orig_showwarning)
691 self.assertTrue(wmod.filters is not orig_filters)
692 self.assertTrue(wmod.filters is orig_filters)
Benjamin Petersonfcf5d632008-10-16 23:24:44 +0000693
694 def test_check_warnings(self):
695 # Explicit tests for the test.support convenience wrapper
696 wmod = self.module
Florent Xicluna53b506be2010-03-18 20:00:57 +0000697 if wmod is not sys.modules['warnings']:
698 return
699 with support.check_warnings(quiet=False) as w:
700 self.assertEqual(w.warnings, [])
701 wmod.simplefilter("always")
702 wmod.warn("foo")
703 self.assertEqual(str(w.message), "foo")
704 wmod.warn("bar")
705 self.assertEqual(str(w.message), "bar")
706 self.assertEqual(str(w.warnings[0].message), "foo")
707 self.assertEqual(str(w.warnings[1].message), "bar")
708 w.reset()
709 self.assertEqual(w.warnings, [])
710
711 with support.check_warnings():
712 # defaults to quiet=True without argument
713 pass
714 with support.check_warnings(('foo', UserWarning)):
715 wmod.warn("foo")
716
717 with self.assertRaises(AssertionError):
718 with support.check_warnings(('', RuntimeWarning)):
719 # defaults to quiet=False with argument
720 pass
721 with self.assertRaises(AssertionError):
722 with support.check_warnings(('foo', RuntimeWarning)):
Benjamin Petersonfcf5d632008-10-16 23:24:44 +0000723 wmod.warn("foo")
Benjamin Petersonfcf5d632008-10-16 23:24:44 +0000724
Ezio Melotti2688e812013-01-10 06:52:23 +0200725class CCatchWarningTests(CatchWarningTests, unittest.TestCase):
Nick Coghlanb1304932008-07-13 12:25:08 +0000726 module = c_warnings
727
Ezio Melotti2688e812013-01-10 06:52:23 +0200728class PyCatchWarningTests(CatchWarningTests, unittest.TestCase):
Nick Coghlanb1304932008-07-13 12:25:08 +0000729 module = py_warnings
730
Christian Heimes5fb7c2a2007-12-24 08:52:31 +0000731
Philip Jenvey0805ca32010-04-07 04:04:10 +0000732class EnvironmentVariableTests(BaseTest):
733
734 def test_single_warning(self):
735 newenv = os.environ.copy()
736 newenv["PYTHONWARNINGS"] = "ignore::DeprecationWarning"
737 p = subprocess.Popen([sys.executable,
738 "-c", "import sys; sys.stdout.write(str(sys.warnoptions))"],
739 stdout=subprocess.PIPE, env=newenv)
Benjamin Petersonad6139a2010-04-11 21:16:33 +0000740 self.assertEqual(p.communicate()[0], b"['ignore::DeprecationWarning']")
741 self.assertEqual(p.wait(), 0)
Philip Jenvey0805ca32010-04-07 04:04:10 +0000742
743 def test_comma_separated_warnings(self):
744 newenv = os.environ.copy()
745 newenv["PYTHONWARNINGS"] = ("ignore::DeprecationWarning,"
746 "ignore::UnicodeWarning")
747 p = subprocess.Popen([sys.executable,
748 "-c", "import sys; sys.stdout.write(str(sys.warnoptions))"],
749 stdout=subprocess.PIPE, env=newenv)
Benjamin Petersonad6139a2010-04-11 21:16:33 +0000750 self.assertEqual(p.communicate()[0],
Philip Jenvey0805ca32010-04-07 04:04:10 +0000751 b"['ignore::DeprecationWarning', 'ignore::UnicodeWarning']")
Benjamin Petersonad6139a2010-04-11 21:16:33 +0000752 self.assertEqual(p.wait(), 0)
Philip Jenvey0805ca32010-04-07 04:04:10 +0000753
754 def test_envvar_and_command_line(self):
755 newenv = os.environ.copy()
756 newenv["PYTHONWARNINGS"] = "ignore::DeprecationWarning"
757 p = subprocess.Popen([sys.executable, "-W" "ignore::UnicodeWarning",
758 "-c", "import sys; sys.stdout.write(str(sys.warnoptions))"],
759 stdout=subprocess.PIPE, env=newenv)
Benjamin Petersonad6139a2010-04-11 21:16:33 +0000760 self.assertEqual(p.communicate()[0],
Philip Jenvey0805ca32010-04-07 04:04:10 +0000761 b"['ignore::UnicodeWarning', 'ignore::DeprecationWarning']")
Benjamin Petersonad6139a2010-04-11 21:16:33 +0000762 self.assertEqual(p.wait(), 0)
Philip Jenvey0805ca32010-04-07 04:04:10 +0000763
Philip Jenveye53de3d2010-04-14 03:01:39 +0000764 @unittest.skipUnless(sys.getfilesystemencoding() != 'ascii',
765 'requires non-ascii filesystemencoding')
766 def test_nonascii(self):
767 newenv = os.environ.copy()
768 newenv["PYTHONWARNINGS"] = "ignore:DeprecaciónWarning"
769 newenv["PYTHONIOENCODING"] = "utf-8"
770 p = subprocess.Popen([sys.executable,
771 "-c", "import sys; sys.stdout.write(str(sys.warnoptions))"],
772 stdout=subprocess.PIPE, env=newenv)
773 self.assertEqual(p.communicate()[0],
774 "['ignore:DeprecaciónWarning']".encode('utf-8'))
775 self.assertEqual(p.wait(), 0)
776
Ezio Melotti2688e812013-01-10 06:52:23 +0200777class CEnvironmentVariableTests(EnvironmentVariableTests, unittest.TestCase):
Philip Jenvey0805ca32010-04-07 04:04:10 +0000778 module = c_warnings
779
Ezio Melotti2688e812013-01-10 06:52:23 +0200780class PyEnvironmentVariableTests(EnvironmentVariableTests, unittest.TestCase):
Philip Jenvey0805ca32010-04-07 04:04:10 +0000781 module = py_warnings
782
783
Victor Stinner7d79b8b2010-05-19 20:40:50 +0000784class BootstrapTest(unittest.TestCase):
785 def test_issue_8766(self):
786 # "import encodings" emits a warning whereas the warnings is not loaded
Ezio Melotti42da6632011-03-15 05:18:48 +0200787 # or not completely loaded (warnings imports indirectly encodings by
Victor Stinner7d79b8b2010-05-19 20:40:50 +0000788 # importing linecache) yet
789 with support.temp_cwd() as cwd, support.temp_cwd('encodings'):
790 env = os.environ.copy()
791 env['PYTHONPATH'] = cwd
792
793 # encodings loaded by initfsencoding()
794 retcode = subprocess.call([sys.executable, '-c', 'pass'], env=env)
795 self.assertEqual(retcode, 0)
796
797 # Use -W to load warnings module at startup
798 retcode = subprocess.call(
799 [sys.executable, '-c', 'pass', '-W', 'always'],
800 env=env)
801 self.assertEqual(retcode, 0)
802
Victor Stinnerd1b48992013-10-28 19:16:21 +0100803class FinalizationTest(unittest.TestCase):
804 def test_finalization(self):
805 # Issue #19421: warnings.warn() should not crash
806 # during Python finalization
807 code = """
808import warnings
809warn = warnings.warn
810
811class A:
812 def __del__(self):
813 warn("test")
814
815a=A()
816 """
817 rc, out, err = assert_python_ok("-c", code)
818 # note: "__main__" filename is not correct, it should be the name
819 # of the script
820 self.assertEqual(err, b'__main__:7: UserWarning: test')
821
Ezio Melotti2688e812013-01-10 06:52:23 +0200822
823def setUpModule():
Christian Heimesdae2a892008-04-19 00:55:37 +0000824 py_warnings.onceregistry.clear()
825 c_warnings.onceregistry.clear()
Christian Heimes33fe8092008-04-13 13:53:33 +0000826
Ezio Melotti2688e812013-01-10 06:52:23 +0200827tearDownModule = setUpModule
Raymond Hettingerd6f6e502003-07-13 08:37:40 +0000828
829if __name__ == "__main__":
Ezio Melotti2688e812013-01-10 06:52:23 +0200830 unittest.main()