Lines Matching refs:self
35 def get_exception_format(self, func, exc):
43 def syntax_error_with_caret(self):
46 def syntax_error_with_caret_2(self):
49 def syntax_error_with_caret_range(self):
52 def syntax_error_bad_indentation(self):
55 def syntax_error_with_caret_non_ascii(self):
58 def syntax_error_bad_indentation2(self):
61 def tokenizer_error_with_caret_range(self):
64 def test_caret(self):
65 err = self.get_exception_format(self.syntax_error_with_caret,
67 self.assertEqual(len(err), 4)
68 self.assertTrue(err[1].strip() == "return x!")
69 self.assertIn("^", err[2]) # third line has caret
70 self.assertEqual(err[1].find("!"), err[2].find("^")) # in the right place
71 self.assertEqual(err[2].count("^"), 1)
73 err = self.get_exception_format(self.syntax_error_with_caret_2,
75 self.assertIn("^", err[2]) # third line has caret
76 self.assertEqual(err[2].count('\n'), 1) # and no additional newline
77 self.assertEqual(err[1].find("+") + 1, err[2].find("^")) # in the right place
78 self.assertEqual(err[2].count("^"), 1)
80 err = self.get_exception_format(self.syntax_error_with_caret_non_ascii,
82 self.assertIn("^", err[2]) # third line has caret
83 self.assertEqual(err[2].count('\n'), 1) # and no additional newline
84 self.assertEqual(err[1].find("+") + 1, err[2].find("^")) # in the right place
85 self.assertEqual(err[2].count("^"), 1)
87 err = self.get_exception_format(self.syntax_error_with_caret_range,
89 self.assertIn("^", err[2]) # third line has caret
90 self.assertEqual(err[2].count('\n'), 1) # and no additional newline
91 self.assertEqual(err[1].find("y"), err[2].find("^")) # in the right place
92 self.assertEqual(err[2].count("^"), len("y for y in range(30)"))
94 err = self.get_exception_format(self.tokenizer_error_with_caret_range,
96 self.assertIn("^", err[2]) # third line has caret
97 self.assertEqual(err[2].count('\n'), 1) # and no additional newline
98 self.assertEqual(err[1].find("("), err[2].find("^")) # in the right place
99 self.assertEqual(err[2].count("^"), 1)
101 def test_nocaret(self):
104 self.assertEqual(len(err), 3)
105 self.assertEqual(err[1].strip(), "bad syntax")
107 def test_no_caret_with_no_debug_ranges_flag(self):
118 self.assertEqual(len(lines), 4)
119 self.assertEqual(lines[0], b'Traceback (most recent call last):')
120 self.assertIn(b'line 1, in <module>', lines[1])
121 self.assertEqual(lines[2], b' x = 1 / 0')
122 self.assertEqual(lines[3], b'ZeroDivisionError: division by zero')
126 def test_no_caret_with_no_debug_ranges_flag_python_traceback(self):
142 self.assertEqual(len(lines), 4)
143 self.assertEqual(lines[0], b'Traceback (most recent call last):')
144 self.assertIn(b'line 4, in <module>', lines[1])
145 self.assertEqual(lines[2], b' x = 1 / 0')
146 self.assertEqual(lines[3], b'ZeroDivisionError: division by zero')
150 def test_recursion_error_during_traceback(self):
171 self.assertEqual(rc, 0)
175 def test_bad_indentation(self):
176 err = self.get_exception_format(self.syntax_error_bad_indentation,
178 self.assertEqual(len(err), 4)
179 self.assertEqual(err[1].strip(), "print(2)")
180 self.assertIn("^", err[2])
181 self.assertEqual(err[1].find(")") + 1, err[2].find("^"))
184 err = self.get_exception_format(self.syntax_error_bad_indentation2,
186 self.assertEqual(len(err), 3)
187 self.assertEqual(err[1].strip(), "print(2)")
189 def test_base_exception(self):
193 self.assertEqual(lst, ['KeyboardInterrupt\n'])
195 def test_format_exception_only_bad__str__(self):
197 def __str__(self):
200 self.assertEqual(len(err), 1)
206 self.assertEqual(err[0], "%s: %s\n" % (str_name, str_value))
209 def test_encoded_file(self):
250 self.assertIn(("line %s" % lineno), stdout[1],
253 self.assertTrue(stdout[2].endswith(err_line),
257 self.assertTrue(actual_err_msg == err_msg,
278 def test_print_traceback_at_exit(self):
286 def __init__(self):
290 self.exc_info = sys.exc_info()
291 # self.exc_info[1] (traceback) contains frames:
292 # explicitly clear the reference to self in the current
294 self = None
296 def __del__(self):
297 traceback.print_exception(*self.exc_info)
307 self.assertEqual(stderr.splitlines(), expected)
309 def test_print_exception(self):
314 self.assertEqual(output.getvalue(), "Exception: projector\n")
316 def test_print_exception_exc(self):
319 self.assertEqual(output.getvalue(), "Exception: projector\n")
321 def test_format_exception_exc(self):
324 self.assertEqual(output, ["Exception: projector\n"])
325 with self.assertRaisesRegex(ValueError, 'Both or neither'):
327 with self.assertRaisesRegex(ValueError, 'Both or neither'):
329 with self.assertRaisesRegex(TypeError, 'positional-only'):
332 def test_format_exception_only_exc(self):
334 self.assertEqual(output, ["Exception: projector\n"])
336 def test_exception_is_None(self):
340 self.assertEqual(excfile.getvalue(), NONE_EXC_STRING)
344 self.assertEqual(excfile.getvalue(), NONE_EXC_STRING)
348 self.assertEqual(excfile.getvalue(), NONE_EXC_STRING)
350 self.assertEqual(traceback.format_exc(None), NONE_EXC_STRING)
351 self.assertEqual(traceback.format_exception(None), [NONE_EXC_STRING])
352 self.assertEqual(
354 self.assertEqual(
356 self.assertEqual(
359 def test_signatures(self):
360 self.assertEqual(
365 self.assertEqual(
370 self.assertEqual(
380 def get_exception(self, callable):
383 self.fail("No exception thrown.")
389 def test_basic_caret(self):
398 f' File "{__file__}", line {self.callable_line}, in get_exception\n'
404 result_lines = self.get_exception(f)
405 self.assertEqual(result_lines, expected_f.splitlines())
407 def test_line_with_unicode(self):
416 f' File "{__file__}", line {self.callable_line}, in get_exception\n'
422 result_lines = self.get_exception(f_with_unicode)
423 self.assertEqual(result_lines, expected_f.splitlines())
425 def test_caret_in_type_annotation(self):
433 f' File "{__file__}", line {self.callable_line}, in get_exception\n'
439 result_lines = self.get_exception(f_with_type)
440 self.assertEqual(result_lines, expected_f.splitlines())
442 def test_caret_multiline_expression(self):
453 f' File "{__file__}", line {self.callable_line}, in get_exception\n'
459 result_lines = self.get_exception(f_with_multiline)
460 self.assertEqual(result_lines, expected_f.splitlines())
462 def test_caret_multiline_expression_syntax_error(self):
477 # Need to defer the compilation until in self.get_exception(..)
484 f' File "{__file__}", line {self.callable_line}, in get_exception\n'
494 result_lines = self.get_exception(f_with_multiline)
495 self.assertEqual(result_lines, expected_f.splitlines())
497 def test_caret_multiline_expression_bin_op(self):
509 f' File "{__file__}", line {self.callable_line}, in get_exception\n'
515 result_lines = self.get_exception(f_with_multiline)
516 self.assertEqual(result_lines, expected_f.splitlines())
518 def test_caret_for_binary_operators(self):
526 f' File "{__file__}", line {self.callable_line}, in get_exception\n'
532 result_lines = self.get_exception(f_with_binary_operator)
533 self.assertEqual(result_lines, expected_error.splitlines())
535 def test_caret_for_binary_operators_with_unicode(self):
543 f' File "{__file__}", line {self.callable_line}, in get_exception\n'
549 result_lines = self.get_exception(f_with_binary_operator)
550 self.assertEqual(result_lines, expected_error.splitlines())
552 def test_caret_for_binary_operators_two_char(self):
560 f' File "{__file__}", line {self.callable_line}, in get_exception\n'
566 result_lines = self.get_exception(f_with_binary_operator)
567 self.assertEqual(result_lines, expected_error.splitlines())
569 def test_caret_for_subscript(self):
577 f' File "{__file__}", line {self.callable_line}, in get_exception\n'
583 result_lines = self.get_exception(f_with_subscript)
584 self.assertEqual(result_lines, expected_error.splitlines())
586 def test_caret_for_subscript_unicode(self):
594 f' File "{__file__}", line {self.callable_line}, in get_exception\n'
600 result_lines = self.get_exception(f_with_subscript)
601 self.assertEqual(result_lines, expected_error.splitlines())
603 def test_traceback_specialization_with_syntax_error(self):
609 self.addCleanup(unlink, TESTFN)
612 result_lines = self.get_exception(func)
617 f' File "{__file__}", line {self.callable_line}, in get_exception\n'
623 self.assertEqual(result_lines, expected_error.splitlines())
625 def test_traceback_very_long_line(self):
631 self.addCleanup(unlink, TESTFN)
634 result_lines = self.get_exception(func)
639 f' File "{__file__}", line {self.callable_line}, in get_exception\n'
645 self.assertEqual(result_lines, expected_error.splitlines())
647 def test_secondary_caret_not_elided(self):
656 f' File "{__file__}", line {self.callable_line}, in get_exception\n'
662 result_lines = self.get_exception(f_with_subscript)
663 self.assertEqual(result_lines, expected_error.splitlines())
665 def test_caret_exception_group(self):
675 f' | File "{__file__}", line {self.callable_line}, in get_exception\n'
686 result_lines = self.get_exception(exc)
687 self.assertEqual(result_lines, expected_error.splitlines())
689 def assertSpecialized(self, func, expected_specialization):
690 result_lines = self.get_exception(func)
692 self.assertEqual(specialization_line.lstrip(), expected_specialization)
694 def test_specialization_variations(self):
695 self.assertSpecialized(lambda: 1/0,
697 self.assertSpecialized(lambda: 1/0/3,
699 self.assertSpecialized(lambda: 1 / 0,
701 self.assertSpecialized(lambda: 1 / 0 / 3,
703 self.assertSpecialized(lambda: 1/ 0,
705 self.assertSpecialized(lambda: 1/ 0/3,
707 self.assertSpecialized(lambda: 1 / 0,
709 self.assertSpecialized(lambda: 1 / 0 / 5,
711 self.assertSpecialized(lambda: 1 /0,
713 self.assertSpecialized(lambda: 1//0,
715 self.assertSpecialized(lambda: 1//0//4,
717 self.assertSpecialized(lambda: 1 // 0,
719 self.assertSpecialized(lambda: 1 // 0 // 4,
721 self.assertSpecialized(lambda: 1 //0,
723 self.assertSpecialized(lambda: 1// 0,
726 def test_decorator_application_lineno_correct(self):
735 result_lines = self.get_exception(applydecs)
740 f' File "{__file__}", line {self.callable_line}, in get_exception\n'
748 self.assertEqual(result_lines, expected_error.splitlines())
754 result_lines = self.get_exception(applydecs_class)
758 f' File "{__file__}", line {self.callable_line}, in get_exception\n'
766 self.assertEqual(result_lines, expected_error.splitlines())
768 def test_multiline_method_call_a(self):
773 actual = self.get_exception(f)
776 f" File \"{__file__}\", line {self.callable_line}, in get_exception",
782 self.assertEqual(actual, expected)
784 def test_multiline_method_call_b(self):
789 actual = self.get_exception(f)
792 f" File \"{__file__}\", line {self.callable_line}, in get_exception",
797 self.assertEqual(actual, expected)
799 def test_multiline_method_call_c(self):
804 actual = self.get_exception(f)
807 f" File \"{__file__}\", line {self.callable_line}, in get_exception",
813 self.assertEqual(actual, expected)
815 def test_wide_characters_unicode_with_problematic_byte_offset(self):
819 actual = self.get_exception(f)
822 f" File \"{__file__}\", line {self.callable_line}, in get_exception",
827 self.assertEqual(actual, expected)
830 def test_byte_offset_with_wide_characters_middle(self):
835 actual = self.get_exception(f)
838 f" File \"{__file__}\", line {self.callable_line}, in get_exception",
843 self.assertEqual(actual, expected)
845 def test_byte_offset_multiline(self):
853 actual = self.get_exception(f)
856 f" File \"{__file__}\", line {self.callable_line}, in get_exception",
862 self.assertEqual(actual, expected)
871 def get_exception(self, callable):
875 self.fail("No exception thrown.")
886 def some_exception(self):
890 def check_traceback_format(self, cleanup_func=None):
893 self.some_exception()
918 self.assertEqual(traceback_fmt, python_fmt)
920 self.assertEqual(tbstderr.getvalue(), tbfile.getvalue())
922 self.assertEqual(excstderr.getvalue(), excfile.getvalue())
923 self.assertEqual(excfmt, excfile.getvalue())
928 self.assertEqual(len(tb_lines), 5)
930 self.assertTrue(banner.startswith('Traceback'))
931 self.assertTrue(location.startswith(' File'))
932 self.assertTrue(source_line.startswith(' raise'))
934 def test_traceback_format(self):
935 self.check_traceback_format()
937 def test_traceback_format_with_cleared_frames(self):
941 self.check_traceback_format(cleanup_tb)
943 def test_stack_format(self):
950 self.assertEqual(ststderr.getvalue(), stfile.getvalue())
954 self.assertEqual(ststderr.getvalue(), "".join(stfmt))
956 def test_print_stack(self):
962 self.assertEqual(stderr.getvalue().splitlines()[-4:], [
970 def _check_recursive_traceback_display(self, render_exc):
974 self.maxDiff = None
986 self.fail("no recursion occurred")
1012 self.assertEqual(actual[:-2], expected[:-2])
1013 self.assertRegex(actual[-2], expected[-2])
1015 self.assertIn(expected[-1], actual[-1])
1019 self.assertIn(int(re.search(r"\d+", actual[-2]).group()), range(rec_limit-60, rec_limit))
1033 self.fail("no value error was raised")
1058 self.assertEqual(actual, expected)
1072 self.fail("no value error was raised")
1094 self.assertEqual(actual, expected)
1103 self.fail("no error raised")
1125 self.assertEqual(actual, expected)
1134 self.fail("no error raised")
1157 self.assertEqual(actual, expected)
1160 def test_recursive_traceback_python(self):
1161 self._check_recursive_traceback_display(traceback.print_exc)
1165 def test_recursive_traceback_cpython_internal(self):
1170 self._check_recursive_traceback_display(render_exc)
1172 def test_format_stack(self):
1177 self.assertEqual(result[-2:], [
1185 def test_unhashable(self):
1189 def __eq__(self, other):
1206 self.assertEqual(11, len(tb))
1207 self.assertEqual(context_message.strip(), tb[5])
1208 self.assertIn('UnhashableException: ex2', tb[3])
1209 self.assertIn('UnhashableException: ex1', tb[10])
1211 def deep_eg(self):
1218 def test_exception_group_deep_recursion_capi(self):
1221 eg = self.deep_eg()
1226 self.assertIn('ExceptionGroup', output)
1227 self.assertLessEqual(output.count('ExceptionGroup'), LIMIT)
1229 def test_exception_group_deep_recursion_traceback(self):
1231 eg = self.deep_eg()
1236 self.assertIn('ExceptionGroup', output)
1237 self.assertLessEqual(output.count('ExceptionGroup'), LIMIT)
1240 def test_print_exception_bad_type_capi(self):
1244 self.assertEqual(
1250 def test_print_exception_bad_type_python(self):
1252 with self.assertRaisesRegex(TypeError, msg):
1269 def get_exception(self, exception_or_callable):
1279 def zero_div(self):
1282 def check_zero_div(self, msg):
1285 self.assertTrue(lines[-3].startswith(' File'))
1286 self.assertIn('1/0 # In zero_div', lines[-2])
1288 self.assertTrue(lines[-4].startswith(' File'))
1289 self.assertIn('1/0 # In zero_div', lines[-3])
1290 self.assertTrue(lines[-1].startswith('ZeroDivisionError'), lines[-1])
1292 def test_simple(self):
1297 lines = self.get_report(e).splitlines()
1299 self.assertEqual(len(lines), 4)
1300 self.assertTrue(lines[3].startswith('ZeroDivisionError'))
1302 self.assertEqual(len(lines), 5)
1303 self.assertTrue(lines[4].startswith('ZeroDivisionError'))
1304 self.assertTrue(lines[0].startswith('Traceback'))
1305 self.assertTrue(lines[1].startswith(' File'))
1306 self.assertIn('1/0 # Marker', lines[2])
1308 def test_cause(self):
1311 self.zero_div()
1316 blocks = boundaries.split(self.get_report(outer_raise))
1317 self.assertEqual(len(blocks), 3)
1318 self.assertEqual(blocks[1], cause_message)
1319 self.check_zero_div(blocks[0])
1320 self.assertIn('inner_raise() # Marker', blocks[2])
1322 def test_context(self):
1325 self.zero_div()
1330 blocks = boundaries.split(self.get_report(outer_raise))
1331 self.assertEqual(len(blocks), 3)
1332 self.assertEqual(blocks[1], context_message)
1333 self.check_zero_div(blocks[0])
1334 self.assertIn('inner_raise() # Marker', blocks[2])
1336 def test_context_suppression(self):
1344 lines = self.get_report(e).splitlines()
1345 self.assertEqual(len(lines), 4)
1346 self.assertTrue(lines[3].startswith('ZeroDivisionError'))
1347 self.assertTrue(lines[0].startswith('Traceback'))
1348 self.assertTrue(lines[1].startswith(' File'))
1349 self.assertIn('ZeroDivisionError from None', lines[2])
1351 def test_cause_and_context(self):
1356 self.zero_div()
1365 blocks = boundaries.split(self.get_report(outer_raise))
1366 self.assertEqual(len(blocks), 3)
1367 self.assertEqual(blocks[1], cause_message)
1368 self.check_zero_div(blocks[0])
1369 self.assertIn('inner_raise() # Marker', blocks[2])
1371 def test_cause_recursive(self):
1375 self.zero_div()
1383 blocks = boundaries.split(self.get_report(outer_raise))
1384 self.assertEqual(len(blocks), 3)
1385 self.assertEqual(blocks[1], cause_message)
1387 self.assertIn('raise KeyError from e', blocks[0])
1388 self.assertNotIn('1/0', blocks[0])
1391 self.assertIn('inner_raise() # Marker', blocks[2])
1392 self.check_zero_div(blocks[2])
1394 def test_syntax_error_offset_at_eol(self):
1398 msg = self.get_report(e).splitlines()
1399 self.assertEqual(msg[-2], " ^")
1402 msg = self.get_report(e).splitlines()
1403 self.assertEqual(msg[-2], ' ^')
1405 def test_syntax_error_no_lineno(self):
1410 msg = self.get_report(e).splitlines()
1411 self.assertEqual(msg,
1414 msg = self.get_report(e).splitlines()
1415 self.assertEqual(msg,
1422 msg = self.get_report(e).splitlines()
1423 self.assertEqual(msg,
1426 msg = self.get_report(e).splitlines()
1427 self.assertEqual(msg,
1430 def test_message_none(self):
1432 err = self.get_report(Exception(None))
1433 self.assertIn('Exception: None\n', err)
1434 err = self.get_report(Exception('None'))
1435 self.assertIn('Exception: None\n', err)
1436 err = self.get_report(Exception())
1437 self.assertIn('Exception\n', err)
1438 err = self.get_report(Exception(''))
1439 self.assertIn('Exception\n', err)
1441 def test_syntax_error_various_offsets(self):
1456 err = self.get_report(SyntaxError("msg", ("file.py", 1, offset+add, text)))
1458 self.assertEqual(exp, err)
1460 def test_exception_with_note(self):
1462 vanilla = self.get_report(e)
1465 self.assertEqual(self.get_report(e), vanilla + 'My Note\n')
1469 self.assertEqual(self.get_report(e), vanilla + '\n')
1473 self.assertEqual(self.get_report(e), vanilla + 'Your Note\n')
1476 self.assertEqual(self.get_report(e), vanilla)
1478 def test_exception_with_invalid_notes(self):
1480 vanilla = self.get_report(e)
1484 def __str__(self):
1487 def __repr__(self):
1492 def __repr__(self):
1497 self.assertEqual(self.get_report(e), vanilla + notes_repr)
1501 self.assertEqual(self.get_report(e), vanilla + err_msg)
1506 self.assertEqual(self.get_report(e), vanilla + bad_note + '\nFinal Note\n')
1511 self.assertEqual(self.get_report(e), vanilla + err_msg + '\nFinal Note\n')
1513 def test_exception_with_note_with_multiple_notes(self):
1515 vanilla = self.get_report(e)
1521 self.assertEqual(
1522 self.get_report(e),
1531 self.assertEqual(
1532 self.get_report(e),
1535 def test_exception_qualname(self):
1539 def __str__(self):
1542 err = self.get_report(A.B.X())
1546 self.assertEqual(exp, MODULE_PREFIX + err)
1548 def test_exception_modulename(self):
1550 def __str__(self):
1555 with self.subTest(modulename=modulename):
1556 err = self.get_report(X())
1563 self.assertEqual(exp, err)
1565 def test_exception_modulename_not_unicode(self):
1567 def __str__(self):
1572 err = self.get_report(X())
1574 self.assertEqual(exp, err)
1576 def test_exception_bad__str__(self):
1578 def __str__(self):
1580 err = self.get_report(X())
1583 self.assertEqual(MODULE_PREFIX + err, f"{str_name}: {str_value}\n")
1588 def test_exception_group_basic(self):
1594 f' | File "{__file__}", line {self.callable_line}, in get_exception\n'
1605 report = self.get_report(exc)
1606 self.assertEqual(report, expected)
1608 def test_exception_group_cause(self):
1629 f' | File "{__file__}", line {self.callable_line}, in get_exception\n'
1640 report = self.get_report(exc)
1641 self.assertEqual(report, expected)
1643 def test_exception_group_context_with_context(self):
1680 f' File "{__file__}", line {self.callable_line}, in get_exception\n'
1686 report = self.get_report(exc)
1687 self.assertEqual(report, expected)
1689 def test_exception_group_nested(self):
1726 f' | File "{__file__}", line {self.callable_line}, in get_exception\n'
1735 report = self.get_report(exc)
1736 self.assertEqual(report, expected)
1738 def test_exception_group_width_limit(self):
1779 report = self.get_report(eg)
1780 self.assertEqual(report, expected)
1782 def test_exception_group_depth_limit(self):
1861 report = self.get_report(exc)
1862 self.assertEqual(report, expected)
1864 def test_exception_group_with_notes(self):
1885 f' | File "{__file__}", line {self.callable_line}, in get_exception\n'
1910 report = self.get_report(exc)
1911 self.assertEqual(report, expected)
1913 def test_exception_group_with_multiple_notes(self):
1936 f' | File "{__file__}", line {self.callable_line}, in get_exception\n'
1964 report = self.get_report(exc)
1965 self.assertEqual(report, expected)
1967 def test_KeyboardInterrupt_at_first_line_of_frame(self):
1987 report = self.get_report(exc)
1990 self.assertEqual(report, expected)
1999 def get_report(self, e):
2000 e = self.get_exception(e)
2005 self.assertEqual(sio.getvalue(), s)
2015 def get_report(self, e):
2017 e = self.get_exception(e)
2028 def last_raises1(self):
2031 def last_raises2(self):
2032 self.last_raises1()
2034 def last_raises3(self):
2035 self.last_raises2()
2037 def last_raises4(self):
2038 self.last_raises3()
2040 def last_raises5(self):
2041 self.last_raises4()
2043 def last_returns_frame1(self):
2046 def last_returns_frame2(self):
2047 return self.last_returns_frame1()
2049 def last_returns_frame3(self):
2050 return self.last_returns_frame2()
2052 def last_returns_frame4(self):
2053 return self.last_returns_frame3()
2055 def last_returns_frame5(self):
2056 return self.last_returns_frame4()
2058 def test_extract_stack(self):
2059 frame = self.last_returns_frame5()
2063 self.assertEqual(actual[:ignore], expected[:ignore])
2064 self.assertEqual(actual[ignore+1:], expected[ignore+1:])
2065 self.assertEqual(len(actual), len(expected))
2069 self.assertGreater(len(nolim), 5)
2070 self.assertEqual(extract(limit=2), nolim[-2:])
2072 self.assertEqual(extract(limit=-2), nolim[:2])
2074 self.assertEqual(extract(limit=0), [])
2078 self.assertEqual(extract(), nolim[-2:])
2079 self.assertEqual(extract(limit=3), nolim[-3:])
2080 self.assertEqual(extract(limit=-3), nolim[:3])
2082 self.assertEqual(extract(), [])
2084 self.assertEqual(extract(), [])
2086 def test_extract_tb(self):
2088 self.last_raises5()
2096 self.assertEqual(len(nolim), 5+1)
2097 self.assertEqual(extract(limit=2), nolim[:2])
2098 self.assertEqual(extract(limit=10), nolim)
2099 self.assertEqual(extract(limit=-2), nolim[-2:])
2100 self.assertEqual(extract(limit=-10), nolim)
2101 self.assertEqual(extract(limit=0), [])
2103 self.assertEqual(extract(), nolim)
2105 self.assertEqual(extract(), nolim[:2])
2106 self.assertEqual(extract(limit=3), nolim[:3])
2107 self.assertEqual(extract(limit=-3), nolim[-3:])
2109 self.assertEqual(extract(), [])
2111 self.assertEqual(extract(), [])
2113 def test_format_exception(self):
2115 self.last_raises5()
2125 self.assertEqual(len(nolim), 5+1)
2126 self.assertEqual(extract(limit=2), nolim[:2])
2127 self.assertEqual(extract(limit=10), nolim)
2128 self.assertEqual(extract(limit=-2), nolim[-2:])
2129 self.assertEqual(extract(limit=-10), nolim)
2130 self.assertEqual(extract(limit=0), [])
2132 self.assertEqual(extract(), nolim)
2134 self.assertEqual(extract(), nolim[:2])
2135 self.assertEqual(extract(limit=3), nolim[:3])
2136 self.assertEqual(extract(limit=-3), nolim[-3:])
2138 self.assertEqual(extract(), [])
2140 self.assertEqual(extract(), [])
2148 def test_clear(self):
2164 self.assertEqual(len(inner_frame.f_locals), 1)
2170 self.assertEqual(len(inner_frame.f_locals), 0)
2172 def test_extract_stack(self):
2177 self.assertEqual(result[-2:], [
2181 self.assertEqual(len(result[0]), 4)
2186 def test_basics(self):
2190 self.assertEqual(f,
2192 self.assertEqual(tuple(f),
2194 self.assertEqual(f, traceback.FrameSummary("f", 1, "dummy"))
2195 self.assertEqual(f, tuple(f))
2198 self.assertEqual(tuple(f), f)
2199 self.assertIsNone(f.locals)
2200 self.assertNotEqual(f, object())
2201 self.assertEqual(f, ALWAYS_EQ)
2203 def test_lazy_lines(self):
2206 self.assertEqual(None, f._line)
2208 self.assertEqual(
2212 def test_no_line(self):
2214 self.assertEqual(f.line, None)
2216 def test_explicit_line(self):
2218 self.assertEqual("line", f.line)
2220 def test_len(self):
2222 self.assertEqual(len(f), 4)
2227 def test_walk_stack(self):
2232 self.assertEqual(len(s2) - len(s1), 1)
2233 self.assertEqual(s2[1:], s1)
2235 def test_walk_tb(self):
2241 self.assertEqual(len(s), 1)
2243 def test_extract_stack(self):
2245 self.assertIsInstance(s, traceback.StackSummary)
2247 def test_extract_stack_limit(self):
2249 self.assertEqual(len(s), 5)
2251 def test_extract_stack_lookup_lines(self):
2258 self.assertEqual(s[0].line, "import sys")
2260 def test_extract_stackup_deferred_lookup_lines(self):
2265 self.assertEqual({}, linecache.cache)
2267 self.assertEqual(s[0].line, "import sys")
2269 def test_from_list(self):
2271 self.assertEqual(
2275 def test_from_list_edited_stack(self):
2279 self.assertEqual(
2283 def test_format_smoke(self):
2287 self.assertEqual(
2291 def test_locals(self):
2296 self.assertEqual(s[0].locals, {'something': '1'})
2298 def test_no_locals(self):
2303 self.assertEqual(s[0].locals, None)
2305 def test_format_locals(self):
2312 self.assertEqual(
2321 def test_custom_format_frame(self):
2323 def format_frame_summary(self, frame_summary):
2331 self.assertEqual(
2335 def test_dropping_frames(self):
2348 def format_frame_summary(self, frame_summary):
2356 self.assertEqual(len(stack), 1)
2358 self.assertEqual(
2366 def test_smoke(self):
2374 self.assertEqual(None, exc.__cause__)
2375 self.assertEqual(None, exc.__context__)
2376 self.assertEqual(False, exc.__suppress_context__)
2377 self.assertEqual(expected_stack, exc.stack)
2378 self.assertEqual(exc_info[0], exc.exc_type)
2379 self.assertEqual(str(exc_info[1]), str(exc))
2381 def test_from_exception(self):
2389 self.expected_stack = traceback.StackSummary.extract(
2392 self.exc = traceback.TracebackException.from_exception(
2394 expected_stack = self.expected_stack
2395 exc = self.exc
2396 self.assertEqual(None, exc.__cause__)
2397 self.assertEqual(None, exc.__context__)
2398 self.assertEqual(False, exc.__suppress_context__)
2399 self.assertEqual(expected_stack, exc.stack)
2400 self.assertEqual(exc_info[0], exc.exc_type)
2401 self.assertEqual(str(exc_info[1]), str(exc))
2403 def test_cause(self):
2418 self.assertEqual(exc_cause, exc.__cause__)
2419 self.assertEqual(exc_context, exc.__context__)
2420 self.assertEqual(True, exc.__suppress_context__)
2421 self.assertEqual(expected_stack, exc.stack)
2422 self.assertEqual(exc_info[0], exc.exc_type)
2423 self.assertEqual(str(exc_info[1]), str(exc))
2425 def test_context(self):
2438 self.assertEqual(None, exc.__cause__)
2439 self.assertEqual(exc_context, exc.__context__)
2440 self.assertEqual(False, exc.__suppress_context__)
2441 self.assertEqual(expected_stack, exc.stack)
2442 self.assertEqual(exc_info[0], exc.exc_type)
2443 self.assertEqual(str(exc_info[1]), str(exc))
2445 def test_long_context_chain(self):
2457 self.fail("Exception not raised")
2463 self.assertGreater(len(res), sys.getrecursionlimit())
2464 self.assertGreater(
2467 self.assertIn(
2470 def test_compact_with_cause(self):
2483 self.assertEqual(exc_cause, exc.__cause__)
2484 self.assertEqual(None, exc.__context__)
2485 self.assertEqual(True, exc.__suppress_context__)
2486 self.assertEqual(expected_stack, exc.stack)
2487 self.assertEqual(exc_info[0], exc.exc_type)
2488 self.assertEqual(str(exc_info[1]), str(exc))
2490 def test_compact_no_cause(self):
2503 self.assertEqual(None, exc.__cause__)
2504 self.assertEqual(exc_context, exc.__context__)
2505 self.assertEqual(False, exc.__suppress_context__)
2506 self.assertEqual(expected_stack, exc.stack)
2507 self.assertEqual(exc_info[0], exc.exc_type)
2508 self.assertEqual(str(exc_info[1]), str(exc))
2510 def test_no_refs_to_exception_and_traceback_objects(self):
2519 self.assertEqual(sys.getrefcount(exc_info[1]), refcnt1)
2520 self.assertEqual(sys.getrefcount(exc_info[2]), refcnt2)
2522 def test_comparison_basic(self):
2529 self.assertIsNot(exc, exc2)
2530 self.assertEqual(exc, exc2)
2531 self.assertNotEqual(exc, object())
2532 self.assertEqual(exc, ALWAYS_EQ)
2534 def test_comparison_params_variations(self):
2554 self.assertEqual(exc, exc1) # limit=10 gets all frames
2555 self.assertNotEqual(exc, exc2) # limit=2 truncates the output
2559 self.assertNotEqual(exc, exc3)
2564 self.assertEqual(exc4, exc5)
2569 self.assertNotEqual(exc6, exc7)
2571 def test_comparison_equivalent_exceptions_are_equal(self):
2578 self.assertEqual(excs[0], excs[1])
2579 self.assertEqual(list(excs[0].format()), list(excs[1].format()))
2581 def test_unhashable(self):
2583 def __eq__(self, other):
2597 self.assertIn('UnhashableException: ex2\n', formatted[2])
2598 self.assertIn('UnhashableException: ex1\n', formatted[6])
2600 def test_limit(self):
2613 self.assertEqual(expected_stack, exc.stack)
2615 def test_lookup_lines(self):
2622 self.assertEqual(linecache.cache, {})
2624 self.assertEqual(exc.stack[0].line, "import sys")
2626 def test_locals(self):
2634 self.assertEqual(
2637 def test_no_locals(self):
2644 self.assertEqual(exc.stack[0].locals, None)
2646 def test_traceback_header(self):
2650 self.assertEqual(list(exc.format()), ["Exception: haven\n"])
2653 def test_print(self):
2663 self.assertEqual(
2673 def setUp(self):
2675 self.eg_info = self._get_exception_group()
2677 def _get_exception_group(self):
2684 self.lno_f = f.__code__.co_firstlineno
2685 self.lno_g = g.__code__.co_firstlineno
2707 self.fail('Exception Not Raised')
2709 def test_exception_group_construction(self):
2710 eg_info = self.eg_info
2713 self.assertIsNot(teg1, teg2)
2714 self.assertEqual(teg1, teg2)
2716 def test_exception_group_format_exception_only(self):
2717 teg = traceback.TracebackException(*self.eg_info)
2721 self.assertEqual(formatted, expected)
2723 def test_exception_group_format(self):
2724 teg = traceback.TracebackException(*self.eg_info)
2727 lno_f = self.lno_f
2728 lno_g = self.lno_g
2766 self.assertEqual(formatted, expected)
2768 def test_max_group_width(self):
2804 self.assertEqual(formatted, expected)
2806 def test_max_group_depth(self):
2832 self.assertEqual(formatted, expected)
2834 def test_comparison(self):
2836 raise self.eg_info[1]
2848 self.assertIsNot(exc, exc2)
2849 self.assertEqual(exc, exc2)
2850 self.assertEqual(exc, exc3)
2851 self.assertNotEqual(exc, ne)
2852 self.assertNotEqual(exc, object())
2853 self.assertEqual(exc, ALWAYS_EQ)
2858 def test_all(self):
2867 self.assertCountEqual(traceback.__all__, expected)