From 1f517e1d531123f25dee484bc630119eaae45f0a Mon Sep 17 00:00:00 2001 From: Ezio Melotti Date: Tue, 2 Feb 2010 17:34:37 +0000 Subject: #7092: Silence py3k warnings in test_exceptions and test_pep352. Patch by Florent Xicluna. --- Lib/test/test_exceptions.py | 69 +++++++++++++++++++-------------------- Lib/test/test_pep352.py | 78 +++++++++++++++++++++++++-------------------- 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 -- cgit v0.12