cython

1
# mode: run
2

3
from __future__ import with_statement
4

5
def typename(t):
6
    name = type(t).__name__
7
    return u"<type '%s'>" % name
8

9
class MyException(Exception):
10
    pass
11

12
class ContextManager(object):
13
    def __init__(self, value, exit_ret = None):
14
        self.value = value
15
        self.exit_ret = exit_ret
16

17
    def __exit__(self, a, b, tb):
18
        print u"exit", typename(a), typename(b), typename(tb)
19
        return self.exit_ret
20

21
    def __enter__(self):
22
        print u"enter"
23
        return self.value
24

25
def no_as():
26
    """
27
    >>> no_as()
28
    enter
29
    hello
30
    exit <type 'NoneType'> <type 'NoneType'> <type 'NoneType'>
31
    """
32
    with ContextManager(u"value"):
33
        print u"hello"
34

35
def basic():
36
    """
37
    >>> basic()
38
    enter
39
    value
40
    exit <type 'NoneType'> <type 'NoneType'> <type 'NoneType'>
41
    """
42
    with ContextManager(u"value") as x:
43
        print x
44

45
def with_pass():
46
    """
47
    >>> with_pass()
48
    enter
49
    exit <type 'NoneType'> <type 'NoneType'> <type 'NoneType'>
50
    """
51
    with ContextManager(u"value") as x:
52
        pass
53

54
def with_exception(exit_ret):
55
    """
56
    >>> with_exception(None)
57
    enter
58
    value
59
    exit <type 'type'> <type 'MyException'> <type 'traceback'>
60
    outer except
61
    >>> with_exception(True)
62
    enter
63
    value
64
    exit <type 'type'> <type 'MyException'> <type 'traceback'>
65
    """
66
    try:
67
        with ContextManager(u"value", exit_ret=exit_ret) as value:
68
            print value
69
            raise MyException()
70
    except:
71
        print u"outer except"
72

73
def multitarget():
74
    """
75
    >>> multitarget()
76
    enter
77
    1 2 3 4 5
78
    exit <type 'NoneType'> <type 'NoneType'> <type 'NoneType'>
79
    """
80
    with ContextManager((1, 2, (3, (4, 5)))) as (a, b, (c, (d, e))):
81
        print a, b, c, d, e
82

83
def tupletarget():
84
    """
85
    >>> tupletarget()
86
    enter
87
    (1, 2, (3, (4, 5)))
88
    exit <type 'NoneType'> <type 'NoneType'> <type 'NoneType'>
89
    """
90
    with ContextManager((1, 2, (3, (4, 5)))) as t:
91
        print t
92

93
def typed():
94
    """
95
    >>> typed()
96
    enter
97
    10
98
    exit <type 'NoneType'> <type 'NoneType'> <type 'NoneType'>
99
    """
100
    cdef unsigned char i
101
    c = ContextManager(255)
102
    with c as i:
103
        i += 11
104
        print i
105

106
def multimanager():
107
    """
108
    >>> multimanager()
109
    enter
110
    enter
111
    enter
112
    enter
113
    enter
114
    enter
115
    2
116
    value
117
    1 2 3 4 5
118
    nested
119
    exit <type 'NoneType'> <type 'NoneType'> <type 'NoneType'>
120
    exit <type 'NoneType'> <type 'NoneType'> <type 'NoneType'>
121
    exit <type 'NoneType'> <type 'NoneType'> <type 'NoneType'>
122
    exit <type 'NoneType'> <type 'NoneType'> <type 'NoneType'>
123
    exit <type 'NoneType'> <type 'NoneType'> <type 'NoneType'>
124
    exit <type 'NoneType'> <type 'NoneType'> <type 'NoneType'>
125
    """
126
    with ContextManager(1), ContextManager(2) as x, ContextManager(u'value') as y,\
127
            ContextManager(3), ContextManager((1, 2, (3, (4, 5)))) as (a, b, (c, (d, e))):
128
        with ContextManager(u'nested') as nested:
129
            print x
130
            print y
131
            print a, b, c, d, e
132
            print nested
133

134
# Tests borrowed from pyregr test_with.py,
135
# modified to follow the constraints of Cython.
136
import unittest
137

138
class Dummy(object):
139
    def __init__(self, value=None, gobble=False):
140
        if value is None:
141
            value = self
142
        self.value = value
143
        self.gobble = gobble
144
        self.enter_called = False
145
        self.exit_called = False
146

147
    def __enter__(self):
148
        self.enter_called = True
149
        return self.value
150

151
    def __exit__(self, *exc_info):
152
        self.exit_called = True
153
        self.exc_info = exc_info
154
        if self.gobble:
155
            return True
156

157
class InitRaises(object):
158
    def __init__(self): raise RuntimeError()
159

160
class EnterRaises(object):
161
    def __enter__(self): raise RuntimeError()
162
    def __exit__(self, *exc_info): pass
163

164
class ExitRaises(object):
165
    def __enter__(self): pass
166
    def __exit__(self, *exc_info): raise RuntimeError()
167

168
class NestedWith(unittest.TestCase):
169
    """
170
    >>> NestedWith().runTest()
171
    """
172

173
    def runTest(self):
174
        self.testNoExceptions()
175
        self.testExceptionInExprList()
176
        self.testExceptionInEnter()
177
        self.testExceptionInExit()
178
        self.testEnterReturnsTuple()
179

180
    def testNoExceptions(self):
181
        with Dummy() as a, Dummy() as b:
182
            self.assertTrue(a.enter_called)
183
            self.assertTrue(b.enter_called)
184
        self.assertTrue(a.exit_called)
185
        self.assertTrue(b.exit_called)
186

187
    def testExceptionInExprList(self):
188
        try:
189
            with Dummy() as a, InitRaises():
190
                pass
191
        except:
192
            pass
193
        self.assertTrue(a.enter_called)
194
        self.assertTrue(a.exit_called)
195

196
    def testExceptionInEnter(self):
197
        try:
198
            with Dummy() as a, EnterRaises():
199
                self.fail('body of bad with executed')
200
        except RuntimeError:
201
            pass
202
        else:
203
            self.fail('RuntimeError not reraised')
204
        self.assertTrue(a.enter_called)
205
        self.assertTrue(a.exit_called)
206

207
    def testExceptionInExit(self):
208
        body_executed = False
209
        with Dummy(gobble=True) as a, ExitRaises():
210
            body_executed = True
211
        self.assertTrue(a.enter_called)
212
        self.assertTrue(a.exit_called)
213
        self.assertTrue(body_executed)
214
        self.assertNotEqual(a.exc_info[0], None)
215

216
    def testEnterReturnsTuple(self):
217
        with Dummy(value=(1,2)) as (a1, a2), \
218
             Dummy(value=(10, 20)) as (b1, b2):
219
            self.assertEqual(1, a1)
220
            self.assertEqual(2, a2)
221
            self.assertEqual(10, b1)
222
            self.assertEqual(20, b2)
223