#7092: Silence py3k warnings in test_exceptions and test_pep352. Patch by Florent Xicluna.

Lib/test/test_exceptions.py

@@ -7,7 +7,7 @@ import pickle, cPickle
 import warnings
 
 from test.test_support import TESTFN, unlink, run_unittest, captured_output
-from test.test_pep352 import ignore_message_warning
+from test.test_pep352 import ignore_deprecation_warnings
 
 # XXX This is not really enough, each *operation* should be tested!
 
@@ -17,6 +17,7 @@ class ExceptionTests(unittest.TestCase):
         # Reloading the built-in exceptions module failed prior to Py2.2, while it
         # should act the same as reloading built-in sys.
         try:
+            from imp import reload
             import exceptions
             reload(exceptions)
         except ImportError, e:
@@ -108,11 +109,11 @@ class ExceptionTests(unittest.TestCase):
         self.assertRaises(ValueError, chr, 10000)
 
         self.raise_catch(ZeroDivisionError, "ZeroDivisionError")
-        try: x = 1/0
+        try: x = 1 // 0
         except ZeroDivisionError: pass
 
         self.raise_catch(Exception, "Exception")
-        try: x = 1/0
+        try: x = 1 // 0
         except Exception, e: pass
 
     def testSyntaxErrorMessage(self):
@@ -197,6 +198,7 @@ class ExceptionTests(unittest.TestCase):
             self.assertEqual(WindowsError(1001, "message").errno, 22)
             self.assertEqual(WindowsError(1001, "message").winerror, 1001)
 
+    @ignore_deprecation_warnings
     def testAttributes(self):
         # test that exception attributes are happy
 
@@ -274,8 +276,6 @@ class ExceptionTests(unittest.TestCase):
         except NameError:
             pass
 
-        with warnings.catch_warnings():
-            ignore_message_warning()
         for exc, args, expected in exceptionList:
             try:
                 raise exc(*args)
@@ -331,6 +331,7 @@ class ExceptionTests(unittest.TestCase):
         with self.assertRaises(AttributeError):
             exc.message
 
+    @ignore_deprecation_warnings
     def testPickleMessageAttribute(self):
         # Pickling with message attribute must work, as well.
         e = Exception("foo")
@@ -338,18 +339,18 @@ class ExceptionTests(unittest.TestCase):
         f.message = "bar"
         for p in pickle, cPickle:
             ep = p.loads(p.dumps(e))
-            with warnings.catch_warnings():
-                ignore_message_warning()
             self.assertEqual(ep.message, "foo")
             fp = p.loads(p.dumps(f))
             self.assertEqual(fp.message, "bar")
 
+    @ignore_deprecation_warnings
     def testSlicing(self):
         # Test that you can slice an exception directly instead of requiring
         # going through the 'args' attribute.
         args = (1, 2, 3)
         exc = BaseException(*args)
         self.assertEqual(exc[:], args)
+        self.assertEqual(exc.args[:], args)
 
     def testKeywordArgs(self):
         # test that builtin exception don't take keyword args,

Lib/test/test_pep352.py

@@ -4,14 +4,27 @@ import exceptions
 import warnings
 from test.test_support import run_unittest
 import os
+import sys
 from platform import system as platform_system
 
-def ignore_message_warning():
-    """Ignore the DeprecationWarning for BaseException.message."""
-    warnings.resetwarnings()
-    warnings.filterwarnings("ignore", "BaseException.message",
-                            DeprecationWarning)
+DEPRECATION_WARNINGS = ["BaseException.message has been deprecated"]
 
+if sys.py3kwarning:
+    DEPRECATION_WARNINGS.extend(
+        ["exceptions must derive from BaseException",
+         "catching classes that don't inherit from BaseException is not allowed",
+         "__get(item|slice)__ not supported for exception classes"])
+
+# Silence Py3k and other deprecation warnings
+def ignore_deprecation_warnings(func):
+    """Ignore the known DeprecationWarnings."""
+    def wrapper(*args, **kw):
+        with warnings.catch_warnings():
+            warnings.resetwarnings()
+            for text in DEPRECATION_WARNINGS:
+                warnings.filterwarnings("ignore", text, DeprecationWarning)
+            return func(*args, **kw)
+    return wrapper
 
 class ExceptionClassTests(unittest.TestCase):
 
@@ -21,11 +34,9 @@ class ExceptionClassTests(unittest.TestCase):
     def test_builtins_new_style(self):
         self.assertTrue(issubclass(Exception, object))
 
+    @ignore_deprecation_warnings
     def verify_instance_interface(self, ins):
-        with warnings.catch_warnings():
-            ignore_message_warning()
-            for attr in ("args", "message", "__str__", "__repr__",
-                            "__getitem__"):
+        for attr in ("args", "message", "__str__", "__repr__", "__getitem__"):
             self.assertTrue(hasattr(ins, attr),
                             "%s missing %s attribute" %
                             (ins.__class__.__name__, attr))
@@ -91,26 +102,23 @@ class ExceptionClassTests(unittest.TestCase):
             self.assertEqual(given, expected, "%s: %s != %s" % (test_name,
                 given, expected))
 
+    @ignore_deprecation_warnings
     def test_interface_single_arg(self):
         # Make sure interface works properly when given a single argument
         arg = "spam"
         exc = Exception(arg)
-        with warnings.catch_warnings():
-            ignore_message_warning()
-            results = ([len(exc.args), 1], [exc.args[0], arg],
-                    [exc.message, arg],
+        results = ([len(exc.args), 1], [exc.args[0], arg], [exc.message, arg],
                    [str(exc), str(arg)], [unicode(exc), unicode(arg)],
-                [repr(exc), exc.__class__.__name__ + repr(exc.args)], [exc[0],
-                arg])
+                   [repr(exc), exc.__class__.__name__ + repr(exc.args)],
+                   [exc[0], arg])
         self.interface_test_driver(results)
 
+    @ignore_deprecation_warnings
     def test_interface_multi_arg(self):
         # Make sure interface correct when multiple arguments given
         arg_count = 3
         args = tuple(range(arg_count))
         exc = Exception(*args)
-        with warnings.catch_warnings():
-            ignore_message_warning()
         results = ([len(exc.args), arg_count], [exc.args, args],
                    [exc.message, ''], [str(exc), str(args)],
                    [unicode(exc), unicode(args)],
@@ -118,11 +126,10 @@ class ExceptionClassTests(unittest.TestCase):
                    [exc[-1], args[-1]])
         self.interface_test_driver(results)
 
+    @ignore_deprecation_warnings
     def test_interface_no_arg(self):
         # Make sure that with no args that interface is correct
         exc = Exception()
-        with warnings.catch_warnings():
-            ignore_message_warning()
         results = ([len(exc.args), 0], [exc.args, tuple()],
                    [exc.message, ''],
                    [str(exc), ''], [unicode(exc), u''],
@@ -179,6 +186,7 @@ class UsageTests(unittest.TestCase):
             self.fail("TypeError expected when catching %s as specified in a "
                         "tuple" % type(object_))
 
+    @ignore_deprecation_warnings
     def test_raise_classic(self):
         # Raising a classic class is okay (for now).
         class ClassicClass:
@@ -194,7 +202,7 @@ class UsageTests(unittest.TestCase):
         except ClassicClass:
             pass
         except:
-            self.fail("unable to raise class class instance")
+            self.fail("unable to raise classic class instance")
 
     def test_raise_new_style_non_exception(self):
         # You cannot raise a new-style class that does not inherit from