|
1 # Python test set -- part 5, built-in exceptions |
|
2 |
|
3 import os |
|
4 import sys |
|
5 import unittest |
|
6 import pickle, cPickle |
|
7 import warnings |
|
8 |
|
9 from test.test_support import TESTFN, unlink, run_unittest, captured_output |
|
10 from test.test_pep352 import ignore_message_warning |
|
11 |
|
12 # XXX This is not really enough, each *operation* should be tested! |
|
13 |
|
14 class ExceptionTests(unittest.TestCase): |
|
15 |
|
16 def testReload(self): |
|
17 # Reloading the built-in exceptions module failed prior to Py2.2, while it |
|
18 # should act the same as reloading built-in sys. |
|
19 try: |
|
20 import exceptions |
|
21 reload(exceptions) |
|
22 except ImportError, e: |
|
23 self.fail("reloading exceptions: %s" % e) |
|
24 |
|
25 def raise_catch(self, exc, excname): |
|
26 try: |
|
27 raise exc, "spam" |
|
28 except exc, err: |
|
29 buf1 = str(err) |
|
30 try: |
|
31 raise exc("spam") |
|
32 except exc, err: |
|
33 buf2 = str(err) |
|
34 self.assertEquals(buf1, buf2) |
|
35 self.assertEquals(exc.__name__, excname) |
|
36 |
|
37 def testRaising(self): |
|
38 self.raise_catch(AttributeError, "AttributeError") |
|
39 self.assertRaises(AttributeError, getattr, sys, "undefined_attribute") |
|
40 |
|
41 self.raise_catch(EOFError, "EOFError") |
|
42 fp = open(TESTFN, 'w') |
|
43 fp.close() |
|
44 fp = open(TESTFN, 'r') |
|
45 savestdin = sys.stdin |
|
46 try: |
|
47 try: |
|
48 sys.stdin = fp |
|
49 x = raw_input() |
|
50 except EOFError: |
|
51 pass |
|
52 finally: |
|
53 sys.stdin = savestdin |
|
54 fp.close() |
|
55 unlink(TESTFN) |
|
56 |
|
57 self.raise_catch(IOError, "IOError") |
|
58 self.assertRaises(IOError, open, 'this file does not exist', 'r') |
|
59 |
|
60 self.raise_catch(ImportError, "ImportError") |
|
61 self.assertRaises(ImportError, __import__, "undefined_module") |
|
62 |
|
63 self.raise_catch(IndexError, "IndexError") |
|
64 x = [] |
|
65 self.assertRaises(IndexError, x.__getitem__, 10) |
|
66 |
|
67 self.raise_catch(KeyError, "KeyError") |
|
68 x = {} |
|
69 self.assertRaises(KeyError, x.__getitem__, 'key') |
|
70 |
|
71 self.raise_catch(KeyboardInterrupt, "KeyboardInterrupt") |
|
72 |
|
73 self.raise_catch(MemoryError, "MemoryError") |
|
74 |
|
75 self.raise_catch(NameError, "NameError") |
|
76 try: x = undefined_variable |
|
77 except NameError: pass |
|
78 |
|
79 self.raise_catch(OverflowError, "OverflowError") |
|
80 x = 1 |
|
81 for dummy in range(128): |
|
82 x += x # this simply shouldn't blow up |
|
83 |
|
84 self.raise_catch(RuntimeError, "RuntimeError") |
|
85 |
|
86 self.raise_catch(SyntaxError, "SyntaxError") |
|
87 try: exec '/\n' |
|
88 except SyntaxError: pass |
|
89 |
|
90 self.raise_catch(IndentationError, "IndentationError") |
|
91 |
|
92 self.raise_catch(TabError, "TabError") |
|
93 # can only be tested under -tt, and is the only test for -tt |
|
94 #try: compile("try:\n\t1/0\n \t1/0\nfinally:\n pass\n", '<string>', 'exec') |
|
95 #except TabError: pass |
|
96 #else: self.fail("TabError not raised") |
|
97 |
|
98 self.raise_catch(SystemError, "SystemError") |
|
99 |
|
100 self.raise_catch(SystemExit, "SystemExit") |
|
101 self.assertRaises(SystemExit, sys.exit, 0) |
|
102 |
|
103 self.raise_catch(TypeError, "TypeError") |
|
104 try: [] + () |
|
105 except TypeError: pass |
|
106 |
|
107 self.raise_catch(ValueError, "ValueError") |
|
108 self.assertRaises(ValueError, chr, 10000) |
|
109 |
|
110 self.raise_catch(ZeroDivisionError, "ZeroDivisionError") |
|
111 try: x = 1/0 |
|
112 except ZeroDivisionError: pass |
|
113 |
|
114 self.raise_catch(Exception, "Exception") |
|
115 try: x = 1/0 |
|
116 except Exception, e: pass |
|
117 |
|
118 def testSyntaxErrorMessage(self): |
|
119 # make sure the right exception message is raised for each of |
|
120 # these code fragments |
|
121 |
|
122 def ckmsg(src, msg): |
|
123 try: |
|
124 compile(src, '<fragment>', 'exec') |
|
125 except SyntaxError, e: |
|
126 if e.msg != msg: |
|
127 self.fail("expected %s, got %s" % (msg, e.msg)) |
|
128 else: |
|
129 self.fail("failed to get expected SyntaxError") |
|
130 |
|
131 s = '''while 1: |
|
132 try: |
|
133 pass |
|
134 finally: |
|
135 continue''' |
|
136 |
|
137 if not sys.platform.startswith('java'): |
|
138 ckmsg(s, "'continue' not supported inside 'finally' clause") |
|
139 |
|
140 s = '''if 1: |
|
141 try: |
|
142 continue |
|
143 except: |
|
144 pass''' |
|
145 |
|
146 ckmsg(s, "'continue' not properly in loop") |
|
147 ckmsg("continue\n", "'continue' not properly in loop") |
|
148 |
|
149 def testSettingException(self): |
|
150 # test that setting an exception at the C level works even if the |
|
151 # exception object can't be constructed. |
|
152 |
|
153 class BadException: |
|
154 def __init__(self_): |
|
155 raise RuntimeError, "can't instantiate BadException" |
|
156 |
|
157 def test_capi1(): |
|
158 import _testcapi |
|
159 try: |
|
160 _testcapi.raise_exception(BadException, 1) |
|
161 except TypeError, err: |
|
162 exc, err, tb = sys.exc_info() |
|
163 co = tb.tb_frame.f_code |
|
164 self.assertEquals(co.co_name, "test_capi1") |
|
165 self.assert_(co.co_filename.endswith('test_exceptions'+os.extsep+'py')) |
|
166 else: |
|
167 self.fail("Expected exception") |
|
168 |
|
169 def test_capi2(): |
|
170 import _testcapi |
|
171 try: |
|
172 _testcapi.raise_exception(BadException, 0) |
|
173 except RuntimeError, err: |
|
174 exc, err, tb = sys.exc_info() |
|
175 co = tb.tb_frame.f_code |
|
176 self.assertEquals(co.co_name, "__init__") |
|
177 self.assert_(co.co_filename.endswith('test_exceptions'+os.extsep+'py')) |
|
178 co2 = tb.tb_frame.f_back.f_code |
|
179 self.assertEquals(co2.co_name, "test_capi2") |
|
180 else: |
|
181 self.fail("Expected exception") |
|
182 |
|
183 if not sys.platform.startswith('java'): |
|
184 test_capi1() |
|
185 test_capi2() |
|
186 |
|
187 def test_WindowsError(self): |
|
188 try: |
|
189 WindowsError |
|
190 except NameError: |
|
191 pass |
|
192 else: |
|
193 self.failUnlessEqual(str(WindowsError(1001)), |
|
194 "1001") |
|
195 self.failUnlessEqual(str(WindowsError(1001, "message")), |
|
196 "[Error 1001] message") |
|
197 self.failUnlessEqual(WindowsError(1001, "message").errno, 22) |
|
198 self.failUnlessEqual(WindowsError(1001, "message").winerror, 1001) |
|
199 |
|
200 def testAttributes(self): |
|
201 # test that exception attributes are happy |
|
202 |
|
203 exceptionList = [ |
|
204 (BaseException, (), {'message' : '', 'args' : ()}), |
|
205 (BaseException, (1, ), {'message' : 1, 'args' : (1,)}), |
|
206 (BaseException, ('foo',), |
|
207 {'message' : 'foo', 'args' : ('foo',)}), |
|
208 (BaseException, ('foo', 1), |
|
209 {'message' : '', 'args' : ('foo', 1)}), |
|
210 (SystemExit, ('foo',), |
|
211 {'message' : 'foo', 'args' : ('foo',), 'code' : 'foo'}), |
|
212 (IOError, ('foo',), |
|
213 {'message' : 'foo', 'args' : ('foo',), 'filename' : None, |
|
214 'errno' : None, 'strerror' : None}), |
|
215 (IOError, ('foo', 'bar'), |
|
216 {'message' : '', 'args' : ('foo', 'bar'), 'filename' : None, |
|
217 'errno' : 'foo', 'strerror' : 'bar'}), |
|
218 (IOError, ('foo', 'bar', 'baz'), |
|
219 {'message' : '', 'args' : ('foo', 'bar'), 'filename' : 'baz', |
|
220 'errno' : 'foo', 'strerror' : 'bar'}), |
|
221 (IOError, ('foo', 'bar', 'baz', 'quux'), |
|
222 {'message' : '', 'args' : ('foo', 'bar', 'baz', 'quux')}), |
|
223 (EnvironmentError, ('errnoStr', 'strErrorStr', 'filenameStr'), |
|
224 {'message' : '', 'args' : ('errnoStr', 'strErrorStr'), |
|
225 'strerror' : 'strErrorStr', 'errno' : 'errnoStr', |
|
226 'filename' : 'filenameStr'}), |
|
227 (EnvironmentError, (1, 'strErrorStr', 'filenameStr'), |
|
228 {'message' : '', 'args' : (1, 'strErrorStr'), 'errno' : 1, |
|
229 'strerror' : 'strErrorStr', 'filename' : 'filenameStr'}), |
|
230 (SyntaxError, (), {'message' : '', 'msg' : None, 'text' : None, |
|
231 'filename' : None, 'lineno' : None, 'offset' : None, |
|
232 'print_file_and_line' : None}), |
|
233 (SyntaxError, ('msgStr',), |
|
234 {'message' : 'msgStr', 'args' : ('msgStr',), 'text' : None, |
|
235 'print_file_and_line' : None, 'msg' : 'msgStr', |
|
236 'filename' : None, 'lineno' : None, 'offset' : None}), |
|
237 (SyntaxError, ('msgStr', ('filenameStr', 'linenoStr', 'offsetStr', |
|
238 'textStr')), |
|
239 {'message' : '', 'offset' : 'offsetStr', 'text' : 'textStr', |
|
240 'args' : ('msgStr', ('filenameStr', 'linenoStr', |
|
241 'offsetStr', 'textStr')), |
|
242 'print_file_and_line' : None, 'msg' : 'msgStr', |
|
243 'filename' : 'filenameStr', 'lineno' : 'linenoStr'}), |
|
244 (SyntaxError, ('msgStr', 'filenameStr', 'linenoStr', 'offsetStr', |
|
245 'textStr', 'print_file_and_lineStr'), |
|
246 {'message' : '', 'text' : None, |
|
247 'args' : ('msgStr', 'filenameStr', 'linenoStr', 'offsetStr', |
|
248 'textStr', 'print_file_and_lineStr'), |
|
249 'print_file_and_line' : None, 'msg' : 'msgStr', |
|
250 'filename' : None, 'lineno' : None, 'offset' : None}), |
|
251 (UnicodeError, (), {'message' : '', 'args' : (),}), |
|
252 (UnicodeEncodeError, ('ascii', u'a', 0, 1, 'ordinal not in range'), |
|
253 {'message' : '', 'args' : ('ascii', u'a', 0, 1, |
|
254 'ordinal not in range'), |
|
255 'encoding' : 'ascii', 'object' : u'a', |
|
256 'start' : 0, 'reason' : 'ordinal not in range'}), |
|
257 (UnicodeDecodeError, ('ascii', '\xff', 0, 1, 'ordinal not in range'), |
|
258 {'message' : '', 'args' : ('ascii', '\xff', 0, 1, |
|
259 'ordinal not in range'), |
|
260 'encoding' : 'ascii', 'object' : '\xff', |
|
261 'start' : 0, 'reason' : 'ordinal not in range'}), |
|
262 (UnicodeTranslateError, (u"\u3042", 0, 1, "ouch"), |
|
263 {'message' : '', 'args' : (u'\u3042', 0, 1, 'ouch'), |
|
264 'object' : u'\u3042', 'reason' : 'ouch', |
|
265 'start' : 0, 'end' : 1}), |
|
266 ] |
|
267 try: |
|
268 exceptionList.append( |
|
269 (WindowsError, (1, 'strErrorStr', 'filenameStr'), |
|
270 {'message' : '', 'args' : (1, 'strErrorStr'), |
|
271 'strerror' : 'strErrorStr', 'winerror' : 1, |
|
272 'errno' : 22, 'filename' : 'filenameStr'}) |
|
273 ) |
|
274 except NameError: |
|
275 pass |
|
276 |
|
277 with warnings.catch_warnings(): |
|
278 ignore_message_warning() |
|
279 for exc, args, expected in exceptionList: |
|
280 try: |
|
281 raise exc(*args) |
|
282 except BaseException, e: |
|
283 if type(e) is not exc: |
|
284 raise |
|
285 # Verify module name |
|
286 self.assertEquals(type(e).__module__, 'exceptions') |
|
287 # Verify no ref leaks in Exc_str() |
|
288 s = str(e) |
|
289 for checkArgName in expected: |
|
290 self.assertEquals(repr(getattr(e, checkArgName)), |
|
291 repr(expected[checkArgName]), |
|
292 'exception "%s", attribute "%s"' % |
|
293 (repr(e), checkArgName)) |
|
294 |
|
295 # test for pickling support |
|
296 for p in pickle, cPickle: |
|
297 for protocol in range(p.HIGHEST_PROTOCOL + 1): |
|
298 new = p.loads(p.dumps(e, protocol)) |
|
299 for checkArgName in expected: |
|
300 got = repr(getattr(new, checkArgName)) |
|
301 want = repr(expected[checkArgName]) |
|
302 self.assertEquals(got, want, |
|
303 'pickled "%r", attribute "%s"' % |
|
304 (e, checkArgName)) |
|
305 |
|
306 def testSlicing(self): |
|
307 # Test that you can slice an exception directly instead of requiring |
|
308 # going through the 'args' attribute. |
|
309 args = (1, 2, 3) |
|
310 exc = BaseException(*args) |
|
311 self.failUnlessEqual(exc[:], args) |
|
312 |
|
313 def testKeywordArgs(self): |
|
314 # test that builtin exception don't take keyword args, |
|
315 # but user-defined subclasses can if they want |
|
316 self.assertRaises(TypeError, BaseException, a=1) |
|
317 |
|
318 class DerivedException(BaseException): |
|
319 def __init__(self, fancy_arg): |
|
320 BaseException.__init__(self) |
|
321 self.fancy_arg = fancy_arg |
|
322 |
|
323 x = DerivedException(fancy_arg=42) |
|
324 self.assertEquals(x.fancy_arg, 42) |
|
325 |
|
326 def testInfiniteRecursion(self): |
|
327 def f(): |
|
328 return f() |
|
329 self.assertRaises(RuntimeError, f) |
|
330 |
|
331 def g(): |
|
332 try: |
|
333 return g() |
|
334 except ValueError: |
|
335 return -1 |
|
336 |
|
337 # The test prints an unraisable recursion error when |
|
338 # doing "except ValueError", this is because subclass |
|
339 # checking has recursion checking too. |
|
340 with captured_output("stderr"): |
|
341 try: |
|
342 g() |
|
343 except RuntimeError: |
|
344 pass |
|
345 except: |
|
346 self.fail("Should have raised KeyError") |
|
347 else: |
|
348 self.fail("Should have raised KeyError") |
|
349 |
|
350 def testUnicodeStrUsage(self): |
|
351 # Make sure both instances and classes have a str and unicode |
|
352 # representation. |
|
353 self.failUnless(str(Exception)) |
|
354 self.failUnless(unicode(Exception)) |
|
355 self.failUnless(str(Exception('a'))) |
|
356 self.failUnless(unicode(Exception(u'a'))) |
|
357 self.failUnless(unicode(Exception(u'\xe1'))) |
|
358 |
|
359 def test_badisinstance(self): |
|
360 # Bug #2542: if issubclass(e, MyException) raises an exception, |
|
361 # it should be ignored |
|
362 class Meta(type): |
|
363 def __subclasscheck__(cls, subclass): |
|
364 raise ValueError() |
|
365 |
|
366 class MyException(Exception): |
|
367 __metaclass__ = Meta |
|
368 pass |
|
369 |
|
370 with captured_output("stderr") as stderr: |
|
371 try: |
|
372 raise KeyError() |
|
373 except MyException, e: |
|
374 self.fail("exception should not be a MyException") |
|
375 except KeyError: |
|
376 pass |
|
377 except: |
|
378 self.fail("Should have raised KeyError") |
|
379 else: |
|
380 self.fail("Should have raised KeyError") |
|
381 |
|
382 with captured_output("stderr") as stderr: |
|
383 def g(): |
|
384 try: |
|
385 return g() |
|
386 except RuntimeError: |
|
387 return sys.exc_info() |
|
388 e, v, tb = g() |
|
389 self.assert_(e is RuntimeError, e) |
|
390 self.assert_("maximum recursion depth exceeded" in str(v), v) |
|
391 |
|
392 |
|
393 def test_main(): |
|
394 run_unittest(ExceptionTests) |
|
395 |
|
396 if __name__ == '__main__': |
|
397 test_main() |