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

2 files changed, 78 insertions, 69 deletions

diff --git a/Lib/test/test_exceptions.py b/Lib/test/test_exceptions.py
index b97affb..eff552f 100644
--- a/Lib/test/test_exceptions.py
+++ b/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,34 +276,32 @@ class ExceptionTests(unittest.TestCase):
         except NameError:
             pass
 
-        with warnings.catch_warnings():
-            ignore_message_warning()
-            for exc, args, expected in exceptionList:
-                try:
-                    raise exc(*args)
-                except BaseException, e:
-                    if type(e) is not exc:
-                        raise
-                    # Verify module name
-                    self.assertEquals(type(e).__module__, 'exceptions')
-                    # Verify no ref leaks in Exc_str()
-                    s = str(e)
-                    for checkArgName in expected:
-                        self.assertEquals(repr(getattr(e, checkArgName)),
-                                          repr(expected[checkArgName]),
-                                          'exception "%s", attribute "%s"' %
-                                           (repr(e), checkArgName))
-
-                    # test for pickling support
-                    for p in pickle, cPickle:
-                        for protocol in range(p.HIGHEST_PROTOCOL + 1):
-                            new = p.loads(p.dumps(e, protocol))
-                            for checkArgName in expected:
-                                got = repr(getattr(new, checkArgName))
-                                want = repr(expected[checkArgName])
-                                self.assertEquals(got, want,
-                                                  'pickled "%r", attribute "%s"' %
-                                                  (e, checkArgName))
+        for exc, args, expected in exceptionList:
+            try:
+                raise exc(*args)
+            except BaseException, e:
+                if type(e) is not exc:
+                    raise
+                # Verify module name
+                self.assertEquals(type(e).__module__, 'exceptions')
+                # Verify no ref leaks in Exc_str()
+                s = str(e)
+                for checkArgName in expected:
+                    self.assertEquals(repr(getattr(e, checkArgName)),
+                                      repr(expected[checkArgName]),
+                                      'exception "%s", attribute "%s"' %
+                                       (repr(e), checkArgName))
+
+                # test for pickling support
+                for p in pickle, cPickle:
+                    for protocol in range(p.HIGHEST_PROTOCOL + 1):
+                        new = p.loads(p.dumps(e, protocol))
+                        for checkArgName in expected:
+                            got = repr(getattr(new, checkArgName))
+                            want = repr(expected[checkArgName])
+                            self.assertEquals(got, want,
+                                              'pickled "%r", attribute "%s"' %
+                                              (e, checkArgName))
 
 
     def testDeprecatedMessageAttribute(self):
@@ -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")
+            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,
diff --git a/Lib/test/test_pep352.py b/Lib/test/test_pep352.py
index 7438d59..4654e26 100644
--- a/Lib/test/test_pep352.py
+++ b/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,13 +34,11 @@ 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__"):
-                self.assertTrue(hasattr(ins, attr),
-                        "%s missing %s attribute" %
+        for attr in ("args", "message", "__str__", "__repr__", "__getitem__"):
+            self.assertTrue(hasattr(ins, attr),
+                            "%s missing %s attribute" %
                             (ins.__class__.__name__, attr))
 
     def test_inheritance(self):
@@ -91,43 +102,39 @@ 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],
-                    [str(exc), str(arg)], [unicode(exc), unicode(arg)],
-                [repr(exc), exc.__class__.__name__ + repr(exc.args)], [exc[0],
-                arg])
-            self.interface_test_driver(results)
+        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])
+        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)],
-                    [repr(exc), exc.__class__.__name__ + repr(exc.args)],
-                    [exc[-1], args[-1]])
-            self.interface_test_driver(results)
+        results = ([len(exc.args), arg_count], [exc.args, args],
+                   [exc.message, ''], [str(exc), str(args)],
+                   [unicode(exc), unicode(args)],
+                   [repr(exc), exc.__class__.__name__ + repr(exc.args)],
+                   [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''],
-                    [repr(exc), exc.__class__.__name__ + '()'], [True, True])
-            self.interface_test_driver(results)
+        results = ([len(exc.args), 0], [exc.args, tuple()],
+                   [exc.message, ''],
+                   [str(exc), ''], [unicode(exc), u''],
+                   [repr(exc), exc.__class__.__name__ + '()'], [True, True])
+        self.interface_test_driver(results)
 
 
     def test_message_deprecation(self):
@@ -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