Issue #3602

Lib/test/test_warnings.py

 from contextlib import contextmanager
 import linecache
 import os
 import StringIO
 import sys
 import unittest
 from test import test_support
 
 import warning_tests
 
@@ skipping 61 matching lines @@
     """Testing the filtering functionality."""
 
     def test_error(self):
         with test_support.catch_warning(self.module) as w:
             self.module.resetwarnings()
             self.module.filterwarnings("error", category=UserWarning)
             self.assertRaises(UserWarning, self.module.warn,
                                 "FilterTests.test_error")
 
     def test_ignore(self):
-        with test_support.catch_warning(self.module) as w:
+        with test_support.catch_warning(module=self.module) as w:
             self.module.resetwarnings()
             self.module.filterwarnings("ignore", category=UserWarning)
             self.module.warn("FilterTests.test_ignore", UserWarning)
-            self.assert_(not w.message)
+            self.assertEquals(len(w), 0)
 
     def test_always(self):
-        with test_support.catch_warning(self.module) as w:
+        with test_support.catch_warning(module=self.module) as w:
             self.module.resetwarnings()
             self.module.filterwarnings("always", category=UserWarning)
             message = "FilterTests.test_always"
             self.module.warn(message, UserWarning)
             self.assert_(message, w.message)
-            w.message = None  # Reset.
             self.module.warn(message, UserWarning)
             self.assert_(w.message, message)
 
     def test_default(self):
         with test_support.catch_warning(self.module) as w:
             self.module.resetwarnings()
             self.module.filterwarnings("default", category=UserWarning)
             message = UserWarning("FilterTests.test_default")
             for x in xrange(2):
                 self.module.warn(message, UserWarning)
                 if x == 0:
                     self.assertEquals(w.message, message)
                     w.reset()
                 elif x == 1:
-                    self.assert_(not w.message, "unexpected warning: " + str(w))
+                    self.assert_(not len(w), "unexpected warning: " + str(w))
                 else:
                     raise ValueError("loop variant unhandled")
 
     def test_module(self):
         with test_support.catch_warning(self.module) as w:
             self.module.resetwarnings()
             self.module.filterwarnings("module", category=UserWarning)
             message = UserWarning("FilterTests.test_module")
             self.module.warn(message, UserWarning)
             self.assertEquals(w.message, message)
             w.reset()
             self.module.warn(message, UserWarning)
-            self.assert_(not w.message, "unexpected message: " + str(w))
+            self.assert_(not len(w), "unexpected message: " + str(w))
 
     def test_once(self):
         with test_support.catch_warning(self.module) as w:
             self.module.resetwarnings()
             self.module.filterwarnings("once", category=UserWarning)
             message = UserWarning("FilterTests.test_once")
             self.module.warn_explicit(message, UserWarning, "test_warnings.py",
                                     42)
             self.assertEquals(w.message, message)
             w.reset()
             self.module.warn_explicit(message, UserWarning, "test_warnings.py",
                                     13)
-            self.assert_(not w.message)
+            self.assertEquals(len(w), 0)
             self.module.warn_explicit(message, UserWarning, "test_warnings2.py",
                                     42)
-            self.assert_(not w.message)
+            self.assertEquals(len(w), 0)
 
     def test_inheritance(self):
         with test_support.catch_warning(self.module) as w:
             self.module.resetwarnings()
             self.module.filterwarnings("error", category=Warning)
             self.assertRaises(UserWarning, self.module.warn,
                                 "FilterTests.test_inheritance", UserWarning)
 
     def test_ordering(self):
         with test_support.catch_warning(self.module) as w:
             self.module.resetwarnings()
             self.module.filterwarnings("ignore", category=UserWarning)
             self.module.filterwarnings("error", category=UserWarning,
                                         append=True)
             w.reset()
             try:
                 self.module.warn("FilterTests.test_ordering", UserWarning)
             except UserWarning:
                 self.fail("order handling for actions failed")
-            self.assert_(not w.message)
+            self.assertEquals(len(w), 0)
 
     def test_filterwarnings(self):
         # Test filterwarnings().
         # Implicitly also tests resetwarnings().
         with test_support.catch_warning(self.module) as w:
             self.module.filterwarnings("error", "", Warning, "", 0)
             self.assertRaises(UserWarning, self.module.warn, 'convert to error')
 
             self.module.resetwarnings()
             text = 'handle normally'
@@ skipping 138 matching lines @@
         self.assertRaises(TypeError, self.module.warn_explicit,
                             None, UserWarning, None, None)
         # Either 'message' needs to be an instance of Warning or 'category'
         # needs to be a subclass.
         self.assertRaises(TypeError, self.module.warn_explicit,
                             None, None, None, 1)
         # 'registry' must be a dict or None.
         self.assertRaises((TypeError, AttributeError),
                             self.module.warn_explicit,
                             None, Warning, None, 1, registry=42)
-
 
 
 class CWarnTests(BaseTest, WarnTests):
     module = c_warnings
 
 class PyWarnTests(BaseTest, WarnTests):
     module = py_warnings
 
 
 class WCmdLineTests(unittest.TestCase):
@@ skipping 41 matching lines @@
         try:
             original_registry = self.module.onceregistry
             __warningregistry__ = {}
             with test_support.catch_warning(self.module) as w:
                 self.module.resetwarnings()
                 self.module.filterwarnings("once", category=UserWarning)
                 self.module.warn_explicit(message, UserWarning, "file", 42)
                 self.failUnlessEqual(w.message, message)
                 w.reset()
                 self.module.warn_explicit(message, UserWarning, "file", 42)
-                self.assert_(not w.message)
+                self.assertEquals(len(w), 0)
                 # Test the resetting of onceregistry.
                 self.module.onceregistry = {}
                 __warningregistry__ = {}
                 self.module.warn('onceregistry test')
                 self.failUnlessEqual(w.message.args, message.args)
                 # Removal of onceregistry is okay.
                 w.reset()
                 del self.module.onceregistry
                 __warningregistry__ = {}
                 self.module.warn_explicit(message, UserWarning, "file", 42)
-                self.failUnless(not w.message)
+                self.assertEquals(len(w), 0)
         finally:
             self.module.onceregistry = original_registry
 
     def test_showwarning_missing(self):
         # Test that showwarning() missing is okay.
         text = 'del showwarning test'
         with test_support.catch_warning(self.module):
             self.module.filterwarnings("always", category=UserWarning)
             del self.module.showwarning
             with test_support.captured_output('stderr') as stream:
@@ skipping 80 matching lines @@
         self.failUnlessEqual(expect, file_object.getvalue())
 
 class CWarningsDisplayTests(BaseTest, WarningsDisplayTests):
     module = c_warnings
 
 class PyWarningsDisplayTests(BaseTest, WarningsDisplayTests):
     module = py_warnings
 
 
 
-class WarningsSupportTests(object):
-    """Test the warning tools from test support module"""
+class CatchWarningTests(BaseTest):
 
-    def test_catch_warning_restore(self):
+    """Test catch_warnings()."""
+
+    def test_catch_warnings_restore(self):
         wmod = self.module
         orig_filters = wmod.filters
         orig_showwarning = wmod.showwarning
-        with test_support.catch_warning(wmod):
+        with wmod.catch_warnings(record=True, module=wmod):
             wmod.filters = wmod.showwarning = object()
         self.assert_(wmod.filters is orig_filters)
         self.assert_(wmod.showwarning is orig_showwarning)
-        with test_support.catch_warning(wmod, record=False):
+        with wmod.catch_warnings(module=wmod, record=False):
             wmod.filters = wmod.showwarning = object()
         self.assert_(wmod.filters is orig_filters)
         self.assert_(wmod.showwarning is orig_showwarning)
 
-    def test_catch_warning_recording(self):
+    def test_catch_warnings_recording(self):
         wmod = self.module
-        with test_support.catch_warning(wmod) as w:
-            self.assertEqual(w.warnings, [])
+        with wmod.catch_warnings(module=wmod, record=True) as w:
+            self.assertEqual(w, [])
             wmod.simplefilter("always")
             wmod.warn("foo")
             self.assertEqual(str(w.message), "foo")
             wmod.warn("bar")
             self.assertEqual(str(w.message), "bar")
-            self.assertEqual(str(w.warnings[0].message), "foo")
-            self.assertEqual(str(w.warnings[1].message), "bar")
+            self.assertEqual(str(w[0].message), "foo")
+            self.assertEqual(str(w[1].message), "bar")
             w.reset()
-            self.assertEqual(w.warnings, [])
+            self.assertEqual(w, [])
         orig_showwarning = wmod.showwarning
-        with test_support.catch_warning(wmod, record=False) as w:
+        with wmod.catch_warnings(module=wmod, record=False) as w:
             self.assert_(w is None)
             self.assert_(wmod.showwarning is orig_showwarning)
 
-
-class CWarningsSupportTests(BaseTest, WarningsSupportTests):
+class CCatchWarningTests(CatchWarningTests):
     module = c_warnings
 
-class PyWarningsSupportTests(BaseTest, WarningsSupportTests):
+class PyCatchWarningTests(CatchWarningTests):
     module = py_warnings
 
 
 class ShowwarningDeprecationTests(BaseTest):
 
     """Test the deprecation of the old warnings.showwarning() API works."""
 
     @staticmethod
     def bad_showwarning(message, category, filename, lineno, file=None):
+        pass
+
+    @staticmethod
+    def ok_showwarning(*args):
         pass
 
     def test_deprecation(self):
         # message, category, filename, lineno[, file[, line]]
         args = ("message", UserWarning, "file name", 42)
-        with test_support.catch_warning(self.module):
+        with test_support.catch_warning(module=self.module):
             self.module.filterwarnings("error", category=DeprecationWarning)
             self.module.showwarning = self.bad_showwarning
             self.assertRaises(DeprecationWarning, self.module.warn_explicit,
                                 *args)
+            self.module.showwarning = self.ok_showwarning
+            try:
+                self.module.warn_explicit(*args)
+            except DeprecationWarning as exc:
+                self.fail('showwarning(*args) should not trigger a '
+                            'DeprecationWarning')
 
 class CShowwarningDeprecationTests(ShowwarningDeprecationTests):
     module = c_warnings
 
 
 class PyShowwarningDeprecationTests(ShowwarningDeprecationTests):
     module = py_warnings
 
 
 def test_main():
     py_warnings.onceregistry.clear()
     c_warnings.onceregistry.clear()
-    test_support.run_unittest(CFilterTests,
-                                PyFilterTests,
-                                CWarnTests,
-                                PyWarnTests,
+    test_support.run_unittest(CFilterTests, PyFilterTests,
+                                CWarnTests, PyWarnTests,
                                 CWCmdLineTests, PyWCmdLineTests,
                                 _WarningsTests,
                                 CWarningsDisplayTests, PyWarningsDisplayTests,
-                                CWarningsSupportTests, PyWarningsSupportTests,
+                                CCatchWarningTests, PyCatchWarningTests,
                                 CShowwarningDeprecationTests,
-                                PyShowwarningDeprecationTests,
+                                    PyShowwarningDeprecationTests,
                              )
 
 
 if __name__ == "__main__":
     test_main()