Multi with statement

Lib/test/test_with.py

 #!/usr/bin/env python
 
 """Unit tests for the with statement specified in PEP 343."""
 
 
 __author__ = "Mike Bland"
 __email__ = "mbland at acm dot org"
 
 import sys
 import unittest
@@ skipping 636 matching lines @@
             def __exit__(self, t, v, tb): return False
         try:
             with EuropeanSwallow():
                 1/0
         except ZeroDivisionError:
             pass
         else:
             self.fail("ZeroDivisionError should have been raised")
 
 
 class NestedWith(unittest.TestCase):

[Benjamin, 2009/05/02 18:22:06]

You should test that the second's __exit__ is called even if the first one
raises.

[Georg, 2009/05/02 18:48:00]

Done.

 
     class Dummy(object):
-        def __init__(self, value=None): 
+        def __init__(self, value=None, gobble=False):
             if value is None:
                 value = self
             self.value = value
+            self.gobble = gobble
             self.enter_called = False
             self.exit_called = False
 
         def __enter__(self):
             self.enter_called = True
             return self.value
 
-        def __exit__(self, *exc_info): 
+        def __exit__(self, *exc_info):
             self.exit_called = True
-
-    class CtorThrows(object):
+            self.exc_info = exc_info
+            if self.gobble:
+                return True
+
+    class CtorRaises(object):
         def __init__(self): raise RuntimeError()
 
-    class EnterThrows(object):
+    class EnterRaises(object):
         def __enter__(self): raise RuntimeError()
         def __exit__(self, *exc_info): pass
+
+    class ExitRaises(object):
+        def __enter__(self): pass
+        def __exit__(self, *exc_info): raise RuntimeError()
 
     def testNoExceptions(self):
         with self.Dummy() as a, self.Dummy() as b:
             self.assertTrue(a.enter_called)
             self.assertTrue(b.enter_called)
         self.assertTrue(a.exit_called)
         self.assertTrue(b.exit_called)
 
     def testExceptionInExprList(self):
         try:
-            with self.Dummy() as a, self.CtorThrows():
+            with self.Dummy() as a, self.CtorRaises():
                 pass
         except:
             pass
         self.assertTrue(a.enter_called)
         self.assertTrue(a.exit_called)
 
     def testExceptionInEnter(self):
         try:
-            with self.Dummy() as a, self.EnterThrows():
-                pass
-        except:
+            with self.Dummy() as a, self.EnterRaises():
+                self.fail('body of bad with executed')
+        except RuntimeError:
             pass
+        else:
+            self.fail('RuntimeError not reraised')
         self.assertTrue(a.enter_called)
         self.assertTrue(a.exit_called)
-········
+
+    def testExceptionInExit(self):
+        body_executed = False
+        with self.Dummy(gobble=True) as a, self.ExitRaises():
+            body_executed = True
+        self.assertTrue(a.enter_called)
+        self.assertTrue(a.exit_called)
+        self.assertNotEqual(a.exc_info[0], None)
+
     def testEnterReturnsTuple(self):
         with self.Dummy(value=(1,2)) as (a1, a2), \
              self.Dummy(value=(10, 20)) as (b1, b2):
             self.assertEquals(1, a1)
             self.assertEquals(2, a2)
             self.assertEquals(10, b1)
             self.assertEquals(20, b2)
 
 def test_main():
     run_unittest(FailureTestCase, NonexceptionalTestCase,
                  NestedNonexceptionalTestCase, ExceptionalTestCase,
                  NonLocalFlowControlTestCase,
                  AssignmentTargetTestCase,
                  ExitSwallowsExceptionTestCase,
                  NestedWith)
 
 
 if __name__ == '__main__':
     test_main()