Python code coverage for Lib/test/test_warnings.py

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