Changeset 391 for python/trunk/Lib/test/test_exceptions.py

Timestamp:

Mar 19, 2014, 11:31:01 PM (11 years ago)

Author:

dmik

Message:

python: Merge vendor 2.7.6 to trunk.

Location:

python/trunk

Files:

• . (modified) (1 prop)
• Lib/test/test_exceptions.py (modified) (17 diffs)

python/trunk/Lib/test/test_exceptions.py

@@ -5 +5 @@
 import unittest
 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_support import (TESTFN, unlink, run_unittest, captured_output,
+                               check_warnings, cpython_only)
+from test.test_pep352 import ignore_deprecation_warnings
 
 # XXX This is not really enough, each *operation* should be tested!
@@ -18 +18 @@
         # should act the same as reloading built-in sys.
         try:
+            from imp import reload
             import exceptions
             reload(exceptions)
@@ -32 +33 @@
         except exc, err:
             buf2 = str(err)
-        self.assertEquals(buf1, buf2)
-        self.assertEquals(exc.__name__, excname)
+        self.assertEqual(buf1, buf2)
+        self.assertEqual(exc.__name__, excname)
 
     def testRaising(self):
@@ -109 +110 @@
 
         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
 
@@ -147 +148 @@
         ckmsg("continue\n", "'continue' not properly in loop")
 
+    @cpython_only
     def testSettingException(self):
         # test that setting an exception at the C level works even if the
@@ -162 +164 @@
                 exc, err, tb = sys.exc_info()
                 co = tb.tb_frame.f_code
-                self.assertEquals(co.co_name, "test_capi1")
-                self.assert_(co.co_filename.endswith('test_exceptions'+os.extsep+'py'))
+                self.assertEqual(co.co_name, "test_capi1")
+                self.assertTrue(co.co_filename.endswith('test_exceptions'+os.extsep+'py'))
             else:
                 self.fail("Expected exception")
@@ -174 +176 @@
                 exc, err, tb = sys.exc_info()
                 co = tb.tb_frame.f_code
-                self.assertEquals(co.co_name, "__init__")
-                self.assert_(co.co_filename.endswith('test_exceptions'+os.extsep+'py'))
+                self.assertEqual(co.co_name, "__init__")
+                self.assertTrue(co.co_filename.endswith('test_exceptions'+os.extsep+'py'))
                 co2 = tb.tb_frame.f_back.f_code
-                self.assertEquals(co2.co_name, "test_capi2")
+                self.assertEqual(co2.co_name, "test_capi2")
             else:
                 self.fail("Expected exception")
@@ -191 +193 @@
             pass
         else:
-            self.failUnlessEqual(str(WindowsError(1001)),
+            self.assertEqual(str(WindowsError(1001)),
                                  "1001")
-            self.failUnlessEqual(str(WindowsError(1001, "message")),
+            self.assertEqual(str(WindowsError(1001, "message")),
                                  "[Error 1001] message")
-            self.failUnlessEqual(WindowsError(1001, "message").errno, 22)
-            self.failUnlessEqual(WindowsError(1001, "message").winerror, 1001)
-
+            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
@@ -275 +278 @@
             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.assertEqual(type(e).__module__, 'exceptions')
+                # Verify no ref leaks in Exc_str()
+                s = str(e)
+                for checkArgName in expected:
+                    self.assertEqual(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.assertEqual(got, want,
+                                             'pickled "%r", attribute "%s"' %
+                                             (e, checkArgName))
 
 
@@ -309 +310 @@
         # BaseException.__init__ triggers a deprecation warning.
         exc = BaseException("foo")
-        with warnings.catch_warnings(record=True) as w:
-            self.assertEquals(exc.message, "foo")
-        self.assertEquals(len(w), 1)
-        self.assertEquals(w[0].category, DeprecationWarning)
-        self.assertEquals(
-            str(w[0].message),
-            "BaseException.message has been deprecated as of Python 2.6")
-
+        with check_warnings(("BaseException.message has been deprecated "
+                             "as of Python 2.6", DeprecationWarning)) as w:
+            self.assertEqual(exc.message, "foo")
+        self.assertEqual(len(w.warnings), 1)
 
     def testRegularMessageAttribute(self):
@@ -323 +320 @@
         exc = BaseException("foo")
         exc.message = "bar"
-        with warnings.catch_warnings(record=True) as w:
-            self.assertEquals(exc.message, "bar")
-        self.assertEquals(len(w), 0)
+        with check_warnings(quiet=True) as w:
+            self.assertEqual(exc.message, "bar")
+        self.assertEqual(len(w.warnings), 0)
         # Deleting the message is supported, too.
         del exc.message
-        self.assertRaises(AttributeError, getattr, exc, "message")
-
+        with self.assertRaises(AttributeError):
+            exc.message
+
+    @ignore_deprecation_warnings
     def testPickleMessageAttribute(self):
         # Pickling with message attribute must work, as well.
@@ -337 +336 @@
         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
@@ -348 +346 @@
         args = (1, 2, 3)
         exc = BaseException(*args)
-        self.failUnlessEqual(exc[:], args)
+        self.assertEqual(exc[:], args)
+        self.assertEqual(exc.args[:], args)
 
     def testKeywordArgs(self):
@@ -361 +360 @@
 
         x = DerivedException(fancy_arg=42)
-        self.assertEquals(x.fancy_arg, 42)
+        self.assertEqual(x.fancy_arg, 42)
 
     def testInfiniteRecursion(self):
@@ -390 +389 @@
         # Make sure both instances and classes have a str and unicode
         # representation.
-        self.failUnless(str(Exception))
-        self.failUnless(unicode(Exception))
-        self.failUnless(str(Exception('a')))
-        self.failUnless(unicode(Exception(u'a')))
-        self.failUnless(unicode(Exception(u'\xe1')))
+        self.assertTrue(str(Exception))
+        self.assertTrue(unicode(Exception))
+        self.assertTrue(str(Exception('a')))
+        self.assertTrue(unicode(Exception(u'a')))
+        self.assertTrue(unicode(Exception(u'\xe1')))
 
     def testUnicodeChangeAttributes(self):
@@ -463 +462 @@
                     return sys.exc_info()
             e, v, tb = g()
-            self.assert_(e is RuntimeError, e)
-            self.assert_("maximum recursion depth exceeded" in str(v), v)
-
+            self.assertTrue(e is RuntimeError, e)
+            self.assertIn("maximum recursion depth exceeded", str(v))
+
+    def test_new_returns_invalid_instance(self):
+        # See issue #11627.
+        class MyException(Exception):
+            def __new__(cls, *args):
+                return object()
+
+        with self.assertRaises(TypeError):
+            raise MyException
+
+    def test_assert_with_tuple_arg(self):
+        try:
+            assert False, (3,)
+        except AssertionError as e:
+            self.assertEqual(str(e), "(3,)")
+
+    def test_bad_exception_clearing(self):
+        # See issue 16445: use of Py_XDECREF instead of Py_CLEAR in
+        # BaseException_set_message gave a possible way to segfault the
+        # interpreter.
+        class Nasty(str):
+            def __del__(message):
+                del e.message
+
+        e = ValueError(Nasty("msg"))
+        e.args = ()
+        del e.message
 
 
@@ -574 +599 @@
         self.assertEqual(unicode(e), u'f\xf6\xf6')
 
+    @cpython_only
+    def test_exception_with_doc(self):
+        import _testcapi
+        doc2 = "This is a test docstring."
+        doc4 = "This is another test docstring."
+
+        self.assertRaises(SystemError, _testcapi.make_exception_with_doc,
+                          "error1")
+
+        # test basic usage of PyErr_NewException
+        error1 = _testcapi.make_exception_with_doc("_testcapi.error1")
+        self.assertIs(type(error1), type)
+        self.assertTrue(issubclass(error1, Exception))
+        self.assertIsNone(error1.__doc__)
+
+        # test with given docstring
+        error2 = _testcapi.make_exception_with_doc("_testcapi.error2", doc2)
+        self.assertEqual(error2.__doc__, doc2)
+
+        # test with explicit base (without docstring)
+        error3 = _testcapi.make_exception_with_doc("_testcapi.error3",
+                                                   base=error2)
+        self.assertTrue(issubclass(error3, error2))
+
+        # test with explicit base tuple
+        class C(object):
+            pass
+        error4 = _testcapi.make_exception_with_doc("_testcapi.error4", doc4,
+                                                   (error3, C))
+        self.assertTrue(issubclass(error4, error3))
+        self.assertTrue(issubclass(error4, C))
+        self.assertEqual(error4.__doc__, doc4)
+
+        # test with explicit dictionary
+        error5 = _testcapi.make_exception_with_doc("_testcapi.error5", "",
+                                                   error4, {'a': 1})
+        self.assertTrue(issubclass(error5, error4))
+        self.assertEqual(error5.a, 1)
+        self.assertEqual(error5.__doc__, "")
+
 
 def test_main():