1from contextlib import contextmanager
2import linecache
3import os
4import StringIO
5import sys
6import unittest
7import subprocess
8from test import test_support
9from test.script_helper import assert_python_ok
10
11import warning_tests
12
13import warnings as original_warnings
14
15py_warnings = test_support.import_fresh_module('warnings', blocked=['_warnings'])
16c_warnings = test_support.import_fresh_module('warnings', fresh=['_warnings'])
17
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
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
43class 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
66class 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
189class CFilterTests(BaseTest, FilterTests):
190    module = c_warnings
191
192class PyFilterTests(BaseTest, FilterTests):
193    module = py_warnings
194
195
196class 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
351class 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
360class 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
370class 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
401class CWCmdLineTests(BaseTest, WCmdLineTests):
402    module = c_warnings
403
404class PyWCmdLineTests(BaseTest, WCmdLineTests):
405    module = py_warnings
406
407
408class _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
546class 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
590class CWarningsDisplayTests(BaseTest, WarningsDisplayTests):
591    module = c_warnings
592
593class PyWarningsDisplayTests(BaseTest, WarningsDisplayTests):
594    module = py_warnings
595
596
597class 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
700class CCatchWarningTests(CatchWarningTests):
701    module = c_warnings
702
703class PyCatchWarningTests(CatchWarningTests):
704    module = py_warnings
705
706
707class 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
739class CEnvironmentVariableTests(EnvironmentVariableTests):
740    module = c_warnings
741
742class PyEnvironmentVariableTests(EnvironmentVariableTests):
743    module = py_warnings
744
745
746def 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
760if __name__ == "__main__":
761    test_main()
762