1
2import unittest
3
4class ExceptTestCases(unittest.TestCase):
5    def test_try_except_else_finally(self):
6        hit_except = False
7        hit_else = False
8        hit_finally = False
9
10        try:
11            raise Exception('nyaa!')
12        except:
13            hit_except = True
14        else:
15            hit_else = True
16        finally:
17            hit_finally = True
18
19        self.assertTrue(hit_except)
20        self.assertTrue(hit_finally)
21        self.assertFalse(hit_else)
22
23    def test_try_except_else_finally_no_exception(self):
24        hit_except = False
25        hit_else = False
26        hit_finally = False
27
28        try:
29            pass
30        except:
31            hit_except = True
32        else:
33            hit_else = True
34        finally:
35            hit_finally = True
36
37        self.assertFalse(hit_except)
38        self.assertTrue(hit_finally)
39        self.assertTrue(hit_else)
40
41    def test_try_except_finally(self):
42        hit_except = False
43        hit_finally = False
44
45        try:
46            raise Exception('yarr!')
47        except:
48            hit_except = True
49        finally:
50            hit_finally = True
51
52        self.assertTrue(hit_except)
53        self.assertTrue(hit_finally)
54
55    def test_try_except_finally_no_exception(self):
56        hit_except = False
57        hit_finally = False
58
59        try:
60            pass
61        except:
62            hit_except = True
63        finally:
64            hit_finally = True
65
66        self.assertFalse(hit_except)
67        self.assertTrue(hit_finally)
68
69    def test_try_except(self):
70        hit_except = False
71
72        try:
73            raise Exception('ahoy!')
74        except:
75            hit_except = True
76
77        self.assertTrue(hit_except)
78
79    def test_try_except_no_exception(self):
80        hit_except = False
81
82        try:
83            pass
84        except:
85            hit_except = True
86
87        self.assertFalse(hit_except)
88
89    def test_try_except_else(self):
90        hit_except = False
91        hit_else = False
92
93        try:
94            raise Exception('foo!')
95        except:
96            hit_except = True
97        else:
98            hit_else = True
99
100        self.assertFalse(hit_else)
101        self.assertTrue(hit_except)
102
103    def test_try_except_else_no_exception(self):
104        hit_except = False
105        hit_else = False
106
107        try:
108            pass
109        except:
110            hit_except = True
111        else:
112            hit_else = True
113
114        self.assertFalse(hit_except)
115        self.assertTrue(hit_else)
116
117    def test_try_finally_no_exception(self):
118        hit_finally = False
119
120        try:
121            pass
122        finally:
123            hit_finally = True
124
125        self.assertTrue(hit_finally)
126
127    def test_nested(self):
128        hit_finally = False
129        hit_inner_except = False
130        hit_inner_finally = False
131
132        try:
133            try:
134                raise Exception('inner exception')
135            except:
136                hit_inner_except = True
137            finally:
138                hit_inner_finally = True
139        finally:
140            hit_finally = True
141
142        self.assertTrue(hit_inner_except)
143        self.assertTrue(hit_inner_finally)
144        self.assertTrue(hit_finally)
145
146    def test_nested_else(self):
147        hit_else = False
148        hit_finally = False
149        hit_except = False
150        hit_inner_except = False
151        hit_inner_else = False
152
153        try:
154            try:
155                pass
156            except:
157                hit_inner_except = True
158            else:
159                hit_inner_else = True
160
161            raise Exception('outer exception')
162        except:
163            hit_except = True
164        else:
165            hit_else = True
166        finally:
167            hit_finally = True
168
169        self.assertFalse(hit_inner_except)
170        self.assertTrue(hit_inner_else)
171        self.assertFalse(hit_else)
172        self.assertTrue(hit_finally)
173        self.assertTrue(hit_except)
174
175    def test_nested_exception_in_except(self):
176        hit_else = False
177        hit_finally = False
178        hit_except = False
179        hit_inner_except = False
180        hit_inner_else = False
181
182        try:
183            try:
184                raise Exception('inner exception')
185            except:
186                hit_inner_except = True
187                raise Exception('outer exception')
188            else:
189                hit_inner_else = True
190        except:
191            hit_except = True
192        else:
193            hit_else = True
194        finally:
195            hit_finally = True
196
197        self.assertTrue(hit_inner_except)
198        self.assertFalse(hit_inner_else)
199        self.assertFalse(hit_else)
200        self.assertTrue(hit_finally)
201        self.assertTrue(hit_except)
202
203    def test_nested_exception_in_else(self):
204        hit_else = False
205        hit_finally = False
206        hit_except = False
207        hit_inner_except = False
208        hit_inner_else = False
209
210        try:
211            try:
212                pass
213            except:
214                hit_inner_except = True
215            else:
216                hit_inner_else = True
217                raise Exception('outer exception')
218        except:
219            hit_except = True
220        else:
221            hit_else = True
222        finally:
223            hit_finally = True
224
225        self.assertFalse(hit_inner_except)
226        self.assertTrue(hit_inner_else)
227        self.assertFalse(hit_else)
228        self.assertTrue(hit_finally)
229        self.assertTrue(hit_except)
230
231    def test_nested_exception_in_finally_no_exception(self):
232        hit_else = False
233        hit_finally = False
234        hit_except = False
235        hit_inner_except = False
236        hit_inner_else = False
237        hit_inner_finally = False
238
239        try:
240            try:
241                pass
242            except:
243                hit_inner_except = True
244            else:
245                hit_inner_else = True
246            finally:
247                hit_inner_finally = True
248                raise Exception('outer exception')
249        except:
250            hit_except = True
251        else:
252            hit_else = True
253        finally:
254            hit_finally = True
255
256        self.assertFalse(hit_inner_except)
257        self.assertTrue(hit_inner_else)
258        self.assertTrue(hit_inner_finally)
259        self.assertFalse(hit_else)
260        self.assertTrue(hit_finally)
261        self.assertTrue(hit_except)
262
263    def test_nested_exception_in_finally_with_exception(self):
264        hit_else = False
265        hit_finally = False
266        hit_except = False
267        hit_inner_except = False
268        hit_inner_else = False
269        hit_inner_finally = False
270
271        try:
272            try:
273                raise Exception('inner exception')
274            except:
275                hit_inner_except = True
276            else:
277                hit_inner_else = True
278            finally:
279                hit_inner_finally = True
280                raise Exception('outer exception')
281        except:
282            hit_except = True
283        else:
284            hit_else = True
285        finally:
286            hit_finally = True
287
288
289        self.assertTrue(hit_inner_except)
290        self.assertFalse(hit_inner_else)
291        self.assertTrue(hit_inner_finally)
292        self.assertFalse(hit_else)
293        self.assertTrue(hit_finally)
294        self.assertTrue(hit_except)
295
296
297class ExceptStarTestCases(unittest.TestCase):
298    def test_try_except_else_finally(self):
299        hit_except = False
300        hit_else = False
301        hit_finally = False
302
303        try:
304            raise Exception('nyaa!')
305        except* BaseException:
306            hit_except = True
307        else:
308            hit_else = True
309        finally:
310            hit_finally = True
311
312        self.assertTrue(hit_except)
313        self.assertTrue(hit_finally)
314        self.assertFalse(hit_else)
315
316    def test_try_except_else_finally_no_exception(self):
317        hit_except = False
318        hit_else = False
319        hit_finally = False
320
321        try:
322            pass
323        except* BaseException:
324            hit_except = True
325        else:
326            hit_else = True
327        finally:
328            hit_finally = True
329
330        self.assertFalse(hit_except)
331        self.assertTrue(hit_finally)
332        self.assertTrue(hit_else)
333
334    def test_try_except_finally(self):
335        hit_except = False
336        hit_finally = False
337
338        try:
339            raise Exception('yarr!')
340        except* BaseException:
341            hit_except = True
342        finally:
343            hit_finally = True
344
345        self.assertTrue(hit_except)
346        self.assertTrue(hit_finally)
347
348    def test_try_except_finally_no_exception(self):
349        hit_except = False
350        hit_finally = False
351
352        try:
353            pass
354        except* BaseException:
355            hit_except = True
356        finally:
357            hit_finally = True
358
359        self.assertFalse(hit_except)
360        self.assertTrue(hit_finally)
361
362    def test_try_except(self):
363        hit_except = False
364
365        try:
366            raise Exception('ahoy!')
367        except* BaseException:
368            hit_except = True
369
370        self.assertTrue(hit_except)
371
372    def test_try_except_no_exception(self):
373        hit_except = False
374
375        try:
376            pass
377        except* BaseException:
378            hit_except = True
379
380        self.assertFalse(hit_except)
381
382    def test_try_except_else(self):
383        hit_except = False
384        hit_else = False
385
386        try:
387            raise Exception('foo!')
388        except* BaseException:
389            hit_except = True
390        else:
391            hit_else = True
392
393        self.assertFalse(hit_else)
394        self.assertTrue(hit_except)
395
396    def test_try_except_else_no_exception(self):
397        hit_except = False
398        hit_else = False
399
400        try:
401            pass
402        except* BaseException:
403            hit_except = True
404        else:
405            hit_else = True
406
407        self.assertFalse(hit_except)
408        self.assertTrue(hit_else)
409
410    def test_try_finally_no_exception(self):
411        hit_finally = False
412
413        try:
414            pass
415        finally:
416            hit_finally = True
417
418        self.assertTrue(hit_finally)
419
420    def test_nested(self):
421        hit_finally = False
422        hit_inner_except = False
423        hit_inner_finally = False
424
425        try:
426            try:
427                raise Exception('inner exception')
428            except* BaseException:
429                hit_inner_except = True
430            finally:
431                hit_inner_finally = True
432        finally:
433            hit_finally = True
434
435        self.assertTrue(hit_inner_except)
436        self.assertTrue(hit_inner_finally)
437        self.assertTrue(hit_finally)
438
439    def test_nested_else(self):
440        hit_else = False
441        hit_finally = False
442        hit_except = False
443        hit_inner_except = False
444        hit_inner_else = False
445
446        try:
447            try:
448                pass
449            except* BaseException:
450                hit_inner_except = True
451            else:
452                hit_inner_else = True
453
454            raise Exception('outer exception')
455        except* BaseException:
456            hit_except = True
457        else:
458            hit_else = True
459        finally:
460            hit_finally = True
461
462        self.assertFalse(hit_inner_except)
463        self.assertTrue(hit_inner_else)
464        self.assertFalse(hit_else)
465        self.assertTrue(hit_finally)
466        self.assertTrue(hit_except)
467
468    def test_nested_mixed1(self):
469        hit_except = False
470        hit_finally = False
471        hit_inner_except = False
472        hit_inner_finally = False
473
474        try:
475            try:
476                raise Exception('inner exception')
477            except* BaseException:
478                hit_inner_except = True
479            finally:
480                hit_inner_finally = True
481        except:
482            hit_except = True
483        finally:
484            hit_finally = True
485
486        self.assertTrue(hit_inner_except)
487        self.assertTrue(hit_inner_finally)
488        self.assertFalse(hit_except)
489        self.assertTrue(hit_finally)
490
491    def test_nested_mixed2(self):
492        hit_except = False
493        hit_finally = False
494        hit_inner_except = False
495        hit_inner_finally = False
496
497        try:
498            try:
499                raise Exception('inner exception')
500            except:
501                hit_inner_except = True
502            finally:
503                hit_inner_finally = True
504        except* BaseException:
505            hit_except = True
506        finally:
507            hit_finally = True
508
509        self.assertTrue(hit_inner_except)
510        self.assertTrue(hit_inner_finally)
511        self.assertFalse(hit_except)
512        self.assertTrue(hit_finally)
513
514
515    def test_nested_else_mixed1(self):
516        hit_else = False
517        hit_finally = False
518        hit_except = False
519        hit_inner_except = False
520        hit_inner_else = False
521
522        try:
523            try:
524                pass
525            except* BaseException:
526                hit_inner_except = True
527            else:
528                hit_inner_else = True
529
530            raise Exception('outer exception')
531        except:
532            hit_except = True
533        else:
534            hit_else = True
535        finally:
536            hit_finally = True
537
538        self.assertFalse(hit_inner_except)
539        self.assertTrue(hit_inner_else)
540        self.assertFalse(hit_else)
541        self.assertTrue(hit_finally)
542        self.assertTrue(hit_except)
543
544    def test_nested_else_mixed2(self):
545        hit_else = False
546        hit_finally = False
547        hit_except = False
548        hit_inner_except = False
549        hit_inner_else = False
550
551        try:
552            try:
553                pass
554            except:
555                hit_inner_except = True
556            else:
557                hit_inner_else = True
558
559            raise Exception('outer exception')
560        except* BaseException:
561            hit_except = True
562        else:
563            hit_else = True
564        finally:
565            hit_finally = True
566
567        self.assertFalse(hit_inner_except)
568        self.assertTrue(hit_inner_else)
569        self.assertFalse(hit_else)
570        self.assertTrue(hit_finally)
571        self.assertTrue(hit_except)
572
573
574if __name__ == '__main__':
575    unittest.main()
576