| """Test cases for traceback module""" |
| |
| from collections import namedtuple |
| from io import StringIO |
| import linecache |
| import sys |
| import types |
| import inspect |
| import unittest |
| import re |
| from test import support |
| from test.support import (Error, captured_output, cpython_only, ALWAYS_EQ, |
| requires_debug_ranges, has_no_debug_ranges, |
| requires_subprocess) |
| from test.support.os_helper import TESTFN, unlink |
| from test.support.script_helper import assert_python_ok, assert_python_failure |
| |
| import os |
| import textwrap |
| import traceback |
| from functools import partial |
| |
| MODULE_PREFIX = f'{__name__}.' if __name__ == '__main__' else '' |
| |
| test_code = namedtuple('code', ['co_filename', 'co_name']) |
| test_code.co_positions = lambda _: iter([(6, 6, 0, 0)]) |
| test_frame = namedtuple('frame', ['f_code', 'f_globals', 'f_locals']) |
| test_tb = namedtuple('tb', ['tb_frame', 'tb_lineno', 'tb_next', 'tb_lasti']) |
| |
| |
| class TracebackCases(unittest.TestCase): |
| # For now, a very minimal set of tests. I want to be sure that |
| # formatting of SyntaxErrors works based on changes for 2.1. |
| |
| def get_exception_format(self, func, exc): |
| try: |
| func() |
| except exc as value: |
| return traceback.format_exception_only(exc, value) |
| else: |
| raise ValueError("call did not raise exception") |
| |
| def syntax_error_with_caret(self): |
| compile("def fact(x):\n\treturn x!\n", "?", "exec") |
| |
| def syntax_error_with_caret_2(self): |
| compile("1 +\n", "?", "exec") |
| |
| def syntax_error_with_caret_range(self): |
| compile("f(x, y for y in range(30), z)", "?", "exec") |
| |
| def syntax_error_bad_indentation(self): |
| compile("def spam():\n print(1)\n print(2)", "?", "exec") |
| |
| def syntax_error_with_caret_non_ascii(self): |
| compile('Python = "\u1e54\xfd\u0163\u0125\xf2\xf1" +', "?", "exec") |
| |
| def syntax_error_bad_indentation2(self): |
| compile(" print(2)", "?", "exec") |
| |
| def tokenizer_error_with_caret_range(self): |
| compile("blech ( ", "?", "exec") |
| |
| def test_caret(self): |
| err = self.get_exception_format(self.syntax_error_with_caret, |
| SyntaxError) |
| self.assertEqual(len(err), 4) |
| self.assertTrue(err[1].strip() == "return x!") |
| self.assertIn("^", err[2]) # third line has caret |
| self.assertEqual(err[1].find("!"), err[2].find("^")) # in the right place |
| self.assertEqual(err[2].count("^"), 1) |
| |
| err = self.get_exception_format(self.syntax_error_with_caret_2, |
| SyntaxError) |
| self.assertIn("^", err[2]) # third line has caret |
| self.assertEqual(err[2].count('\n'), 1) # and no additional newline |
| self.assertEqual(err[1].find("+") + 1, err[2].find("^")) # in the right place |
| self.assertEqual(err[2].count("^"), 1) |
| |
| err = self.get_exception_format(self.syntax_error_with_caret_non_ascii, |
| SyntaxError) |
| self.assertIn("^", err[2]) # third line has caret |
| self.assertEqual(err[2].count('\n'), 1) # and no additional newline |
| self.assertEqual(err[1].find("+") + 1, err[2].find("^")) # in the right place |
| self.assertEqual(err[2].count("^"), 1) |
| |
| err = self.get_exception_format(self.syntax_error_with_caret_range, |
| SyntaxError) |
| self.assertIn("^", err[2]) # third line has caret |
| self.assertEqual(err[2].count('\n'), 1) # and no additional newline |
| self.assertEqual(err[1].find("y"), err[2].find("^")) # in the right place |
| self.assertEqual(err[2].count("^"), len("y for y in range(30)")) |
| |
| err = self.get_exception_format(self.tokenizer_error_with_caret_range, |
| SyntaxError) |
| self.assertIn("^", err[2]) # third line has caret |
| self.assertEqual(err[2].count('\n'), 1) # and no additional newline |
| self.assertEqual(err[1].find("("), err[2].find("^")) # in the right place |
| self.assertEqual(err[2].count("^"), 1) |
| |
| def test_nocaret(self): |
| exc = SyntaxError("error", ("x.py", 23, None, "bad syntax")) |
| err = traceback.format_exception_only(SyntaxError, exc) |
| self.assertEqual(len(err), 3) |
| self.assertEqual(err[1].strip(), "bad syntax") |
| |
| def test_no_caret_with_no_debug_ranges_flag(self): |
| # Make sure that if `-X no_debug_ranges` is used, there are no carets |
| # in the traceback. |
| try: |
| with open(TESTFN, 'w') as f: |
| f.write("x = 1 / 0\n") |
| |
| _, _, stderr = assert_python_failure( |
| '-X', 'no_debug_ranges', TESTFN) |
| |
| lines = stderr.splitlines() |
| self.assertEqual(len(lines), 4) |
| self.assertEqual(lines[0], b'Traceback (most recent call last):') |
| self.assertIn(b'line 1, in <module>', lines[1]) |
| self.assertEqual(lines[2], b' x = 1 / 0') |
| self.assertEqual(lines[3], b'ZeroDivisionError: division by zero') |
| finally: |
| unlink(TESTFN) |
| |
| def test_no_caret_with_no_debug_ranges_flag_python_traceback(self): |
| code = textwrap.dedent(""" |
| import traceback |
| try: |
| x = 1 / 0 |
| except: |
| traceback.print_exc() |
| """) |
| try: |
| with open(TESTFN, 'w') as f: |
| f.write(code) |
| |
| _, _, stderr = assert_python_ok( |
| '-X', 'no_debug_ranges', TESTFN) |
| |
| lines = stderr.splitlines() |
| self.assertEqual(len(lines), 4) |
| self.assertEqual(lines[0], b'Traceback (most recent call last):') |
| self.assertIn(b'line 4, in <module>', lines[1]) |
| self.assertEqual(lines[2], b' x = 1 / 0') |
| self.assertEqual(lines[3], b'ZeroDivisionError: division by zero') |
| finally: |
| unlink(TESTFN) |
| |
| def test_recursion_error_during_traceback(self): |
| code = textwrap.dedent(""" |
| import sys |
| from weakref import ref |
| |
| sys.setrecursionlimit(15) |
| |
| def f(): |
| ref(lambda: 0, []) |
| f() |
| |
| try: |
| f() |
| except RecursionError: |
| pass |
| """) |
| try: |
| with open(TESTFN, 'w') as f: |
| f.write(code) |
| |
| rc, _, _ = assert_python_ok(TESTFN) |
| self.assertEqual(rc, 0) |
| finally: |
| unlink(TESTFN) |
| |
| def test_bad_indentation(self): |
| err = self.get_exception_format(self.syntax_error_bad_indentation, |
| IndentationError) |
| self.assertEqual(len(err), 4) |
| self.assertEqual(err[1].strip(), "print(2)") |
| self.assertIn("^", err[2]) |
| self.assertEqual(err[1].find(")") + 1, err[2].find("^")) |
| |
| # No caret for "unexpected indent" |
| err = self.get_exception_format(self.syntax_error_bad_indentation2, |
| IndentationError) |
| self.assertEqual(len(err), 3) |
| self.assertEqual(err[1].strip(), "print(2)") |
| |
| def test_base_exception(self): |
| # Test that exceptions derived from BaseException are formatted right |
| e = KeyboardInterrupt() |
| lst = traceback.format_exception_only(e.__class__, e) |
| self.assertEqual(lst, ['KeyboardInterrupt\n']) |
| |
| def test_format_exception_only_bad__str__(self): |
| class X(Exception): |
| def __str__(self): |
| 1/0 |
| err = traceback.format_exception_only(X, X()) |
| self.assertEqual(len(err), 1) |
| str_value = '<exception str() failed>' |
| if X.__module__ in ('__main__', 'builtins'): |
| str_name = X.__qualname__ |
| else: |
| str_name = '.'.join([X.__module__, X.__qualname__]) |
| self.assertEqual(err[0], "%s: %s\n" % (str_name, str_value)) |
| |
| @requires_subprocess() |
| def test_encoded_file(self): |
| # Test that tracebacks are correctly printed for encoded source files: |
| # - correct line number (Issue2384) |
| # - respect file encoding (Issue3975) |
| import sys, subprocess |
| |
| # The spawned subprocess has its stdout redirected to a PIPE, and its |
| # encoding may be different from the current interpreter, on Windows |
| # at least. |
| process = subprocess.Popen([sys.executable, "-c", |
| "import sys; print(sys.stdout.encoding)"], |
| stdout=subprocess.PIPE, |
| stderr=subprocess.STDOUT) |
| stdout, stderr = process.communicate() |
| output_encoding = str(stdout, 'ascii').splitlines()[0] |
| |
| def do_test(firstlines, message, charset, lineno): |
| # Raise the message in a subprocess, and catch the output |
| try: |
| with open(TESTFN, "w", encoding=charset) as output: |
| output.write("""{0}if 1: |
| import traceback; |
| raise RuntimeError('{1}') |
| """.format(firstlines, message)) |
| |
| process = subprocess.Popen([sys.executable, TESTFN], |
| stdout=subprocess.PIPE, stderr=subprocess.STDOUT) |
| stdout, stderr = process.communicate() |
| stdout = stdout.decode(output_encoding).splitlines() |
| finally: |
| unlink(TESTFN) |
| |
| # The source lines are encoded with the 'backslashreplace' handler |
| encoded_message = message.encode(output_encoding, |
| 'backslashreplace') |
| # and we just decoded them with the output_encoding. |
| message_ascii = encoded_message.decode(output_encoding) |
| |
| err_line = "raise RuntimeError('{0}')".format(message_ascii) |
| err_msg = "RuntimeError: {0}".format(message_ascii) |
| |
| self.assertIn(("line %s" % lineno), stdout[1], |
| "Invalid line number: {0!r} instead of {1}".format( |
| stdout[1], lineno)) |
| self.assertTrue(stdout[2].endswith(err_line), |
| "Invalid traceback line: {0!r} instead of {1!r}".format( |
| stdout[2], err_line)) |
| actual_err_msg = stdout[3] |
| self.assertTrue(actual_err_msg == err_msg, |
| "Invalid error message: {0!r} instead of {1!r}".format( |
| actual_err_msg, err_msg)) |
| |
| do_test("", "foo", "ascii", 3) |
| for charset in ("ascii", "iso-8859-1", "utf-8", "GBK"): |
| if charset == "ascii": |
| text = "foo" |
| elif charset == "GBK": |
| text = "\u4E02\u5100" |
| else: |
| text = "h\xe9 ho" |
| do_test("# coding: {0}\n".format(charset), |
| text, charset, 4) |
| do_test("#!shebang\n# coding: {0}\n".format(charset), |
| text, charset, 5) |
| do_test(" \t\f\n# coding: {0}\n".format(charset), |
| text, charset, 5) |
| # Issue #18960: coding spec should have no effect |
| do_test("x=0\n# coding: GBK\n", "h\xe9 ho", 'utf-8', 5) |
| |
| def test_print_traceback_at_exit(self): |
| # Issue #22599: Ensure that it is possible to use the traceback module |
| # to display an exception at Python exit |
| code = textwrap.dedent(""" |
| import sys |
| import traceback |
| |
| class PrintExceptionAtExit(object): |
| def __init__(self): |
| try: |
| x = 1 / 0 |
| except Exception: |
| self.exc_info = sys.exc_info() |
| # self.exc_info[1] (traceback) contains frames: |
| # explicitly clear the reference to self in the current |
| # frame to break a reference cycle |
| self = None |
| |
| def __del__(self): |
| traceback.print_exception(*self.exc_info) |
| |
| # Keep a reference in the module namespace to call the destructor |
| # when the module is unloaded |
| obj = PrintExceptionAtExit() |
| """) |
| rc, stdout, stderr = assert_python_ok('-c', code) |
| expected = [b'Traceback (most recent call last):', |
| b' File "<string>", line 8, in __init__', |
| b'ZeroDivisionError: division by zero'] |
| self.assertEqual(stderr.splitlines(), expected) |
| |
| def test_print_exception(self): |
| output = StringIO() |
| traceback.print_exception( |
| Exception, Exception("projector"), None, file=output |
| ) |
| self.assertEqual(output.getvalue(), "Exception: projector\n") |
| |
| def test_print_exception_exc(self): |
| output = StringIO() |
| traceback.print_exception(Exception("projector"), file=output) |
| self.assertEqual(output.getvalue(), "Exception: projector\n") |
| |
| def test_format_exception_exc(self): |
| e = Exception("projector") |
| output = traceback.format_exception(e) |
| self.assertEqual(output, ["Exception: projector\n"]) |
| with self.assertRaisesRegex(ValueError, 'Both or neither'): |
| traceback.format_exception(e.__class__, e) |
| with self.assertRaisesRegex(ValueError, 'Both or neither'): |
| traceback.format_exception(e.__class__, tb=e.__traceback__) |
| with self.assertRaisesRegex(TypeError, 'positional-only'): |
| traceback.format_exception(exc=e) |
| |
| def test_format_exception_only_exc(self): |
| output = traceback.format_exception_only(Exception("projector")) |
| self.assertEqual(output, ["Exception: projector\n"]) |
| |
| def test_exception_is_None(self): |
| NONE_EXC_STRING = 'NoneType: None\n' |
| excfile = StringIO() |
| traceback.print_exception(None, file=excfile) |
| self.assertEqual(excfile.getvalue(), NONE_EXC_STRING) |
| |
| excfile = StringIO() |
| traceback.print_exception(None, None, None, file=excfile) |
| self.assertEqual(excfile.getvalue(), NONE_EXC_STRING) |
| |
| excfile = StringIO() |
| traceback.print_exc(None, file=excfile) |
| self.assertEqual(excfile.getvalue(), NONE_EXC_STRING) |
| |
| self.assertEqual(traceback.format_exc(None), NONE_EXC_STRING) |
| self.assertEqual(traceback.format_exception(None), [NONE_EXC_STRING]) |
| self.assertEqual( |
| traceback.format_exception(None, None, None), [NONE_EXC_STRING]) |
| self.assertEqual( |
| traceback.format_exception_only(None), [NONE_EXC_STRING]) |
| self.assertEqual( |
| traceback.format_exception_only(None, None), [NONE_EXC_STRING]) |
| |
| def test_signatures(self): |
| self.assertEqual( |
| str(inspect.signature(traceback.print_exception)), |
| ('(exc, /, value=<implicit>, tb=<implicit>, ' |
| 'limit=None, file=None, chain=True)')) |
| |
| self.assertEqual( |
| str(inspect.signature(traceback.format_exception)), |
| ('(exc, /, value=<implicit>, tb=<implicit>, limit=None, ' |
| 'chain=True)')) |
| |
| self.assertEqual( |
| str(inspect.signature(traceback.format_exception_only)), |
| '(exc, /, value=<implicit>)') |
| |
| |
| @requires_debug_ranges() |
| class TracebackErrorLocationCaretTests(unittest.TestCase): |
| """ |
| Tests for printing code error expressions as part of PEP 657 |
| """ |
| def get_exception(self, callable): |
| try: |
| callable() |
| self.fail("No exception thrown.") |
| except: |
| return traceback.format_exc().splitlines()[:-1] |
| |
| callable_line = get_exception.__code__.co_firstlineno + 2 |
| |
| def test_basic_caret(self): |
| # NOTE: In caret tests, "if True:" is used as a way to force indicator |
| # display, since the raising expression spans only part of the line. |
| def f(): |
| if True: raise ValueError("basic caret tests") |
| |
| lineno_f = f.__code__.co_firstlineno |
| expected_f = ( |
| 'Traceback (most recent call last):\n' |
| f' File "{__file__}", line {self.callable_line}, in get_exception\n' |
| ' callable()\n' |
| f' File "{__file__}", line {lineno_f+1}, in f\n' |
| ' if True: raise ValueError("basic caret tests")\n' |
| ' ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n' |
| ) |
| result_lines = self.get_exception(f) |
| self.assertEqual(result_lines, expected_f.splitlines()) |
| |
| def test_line_with_unicode(self): |
| # Make sure that even if a line contains multi-byte unicode characters |
| # the correct carets are printed. |
| def f_with_unicode(): |
| if True: raise ValueError("Ĥellö Wörld") |
| |
| lineno_f = f_with_unicode.__code__.co_firstlineno |
| expected_f = ( |
| 'Traceback (most recent call last):\n' |
| f' File "{__file__}", line {self.callable_line}, in get_exception\n' |
| ' callable()\n' |
| f' File "{__file__}", line {lineno_f+1}, in f_with_unicode\n' |
| ' if True: raise ValueError("Ĥellö Wörld")\n' |
| ' ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n' |
| ) |
| result_lines = self.get_exception(f_with_unicode) |
| self.assertEqual(result_lines, expected_f.splitlines()) |
| |
| def test_caret_in_type_annotation(self): |
| def f_with_type(): |
| def foo(a: THIS_DOES_NOT_EXIST ) -> int: |
| return 0 |
| |
| lineno_f = f_with_type.__code__.co_firstlineno |
| expected_f = ( |
| 'Traceback (most recent call last):\n' |
| f' File "{__file__}", line {self.callable_line}, in get_exception\n' |
| ' callable()\n' |
| f' File "{__file__}", line {lineno_f+1}, in f_with_type\n' |
| ' def foo(a: THIS_DOES_NOT_EXIST ) -> int:\n' |
| ' ^^^^^^^^^^^^^^^^^^^\n' |
| ) |
| result_lines = self.get_exception(f_with_type) |
| self.assertEqual(result_lines, expected_f.splitlines()) |
| |
| def test_caret_multiline_expression(self): |
| # Make sure no carets are printed for expressions spanning multiple |
| # lines. |
| def f_with_multiline(): |
| if True: raise ValueError( |
| "error over multiple lines" |
| ) |
| |
| lineno_f = f_with_multiline.__code__.co_firstlineno |
| expected_f = ( |
| 'Traceback (most recent call last):\n' |
| f' File "{__file__}", line {self.callable_line}, in get_exception\n' |
| ' callable()\n' |
| f' File "{__file__}", line {lineno_f+1}, in f_with_multiline\n' |
| ' if True: raise ValueError(\n' |
| ' ^^^^^^^^^^^^^^^^^' |
| ) |
| result_lines = self.get_exception(f_with_multiline) |
| self.assertEqual(result_lines, expected_f.splitlines()) |
| |
| def test_caret_multiline_expression_syntax_error(self): |
| # Make sure an expression spanning multiple lines that has |
| # a syntax error is correctly marked with carets. |
| code = textwrap.dedent(""" |
| def foo(*args, **kwargs): |
| pass |
| |
| a, b, c = 1, 2, 3 |
| |
| foo(a, z |
| for z in |
| range(10), b, c) |
| """) |
| |
| def f_with_multiline(): |
| # Need to defer the compilation until in self.get_exception(..) |
| return compile(code, "?", "exec") |
| |
| lineno_f = f_with_multiline.__code__.co_firstlineno |
| |
| expected_f = ( |
| 'Traceback (most recent call last):\n' |
| f' File "{__file__}", line {self.callable_line}, in get_exception\n' |
| ' callable()\n' |
| f' File "{__file__}", line {lineno_f+2}, in f_with_multiline\n' |
| ' return compile(code, "?", "exec")\n' |
| ' ^^^^^^^^^^^^^^^^^^^^^^^^^^\n' |
| ' File "?", line 7\n' |
| ' foo(a, z\n' |
| ' ^' |
| ) |
| |
| result_lines = self.get_exception(f_with_multiline) |
| self.assertEqual(result_lines, expected_f.splitlines()) |
| |
| def test_caret_multiline_expression_bin_op(self): |
| # Make sure no carets are printed for expressions spanning multiple |
| # lines. |
| def f_with_multiline(): |
| return ( |
| 2 + 1 / |
| 0 |
| ) |
| |
| lineno_f = f_with_multiline.__code__.co_firstlineno |
| expected_f = ( |
| 'Traceback (most recent call last):\n' |
| f' File "{__file__}", line {self.callable_line}, in get_exception\n' |
| ' callable()\n' |
| f' File "{__file__}", line {lineno_f+2}, in f_with_multiline\n' |
| ' 2 + 1 /\n' |
| ' ^^^' |
| ) |
| result_lines = self.get_exception(f_with_multiline) |
| self.assertEqual(result_lines, expected_f.splitlines()) |
| |
| def test_caret_for_binary_operators(self): |
| def f_with_binary_operator(): |
| divisor = 20 |
| return 10 + divisor / 0 + 30 |
| |
| lineno_f = f_with_binary_operator.__code__.co_firstlineno |
| expected_error = ( |
| 'Traceback (most recent call last):\n' |
| f' File "{__file__}", line {self.callable_line}, in get_exception\n' |
| ' callable()\n' |
| f' File "{__file__}", line {lineno_f+2}, in f_with_binary_operator\n' |
| ' return 10 + divisor / 0 + 30\n' |
| ' ~~~~~~~~^~~\n' |
| ) |
| result_lines = self.get_exception(f_with_binary_operator) |
| self.assertEqual(result_lines, expected_error.splitlines()) |
| |
| def test_caret_for_binary_operators_with_unicode(self): |
| def f_with_binary_operator(): |
| áóà = 20 |
| return 10 + áóà / 0 + 30 |
| |
| lineno_f = f_with_binary_operator.__code__.co_firstlineno |
| expected_error = ( |
| 'Traceback (most recent call last):\n' |
| f' File "{__file__}", line {self.callable_line}, in get_exception\n' |
| ' callable()\n' |
| f' File "{__file__}", line {lineno_f+2}, in f_with_binary_operator\n' |
| ' return 10 + áóà / 0 + 30\n' |
| ' ~~~~^~~\n' |
| ) |
| result_lines = self.get_exception(f_with_binary_operator) |
| self.assertEqual(result_lines, expected_error.splitlines()) |
| |
| def test_caret_for_binary_operators_two_char(self): |
| def f_with_binary_operator(): |
| divisor = 20 |
| return 10 + divisor // 0 + 30 |
| |
| lineno_f = f_with_binary_operator.__code__.co_firstlineno |
| expected_error = ( |
| 'Traceback (most recent call last):\n' |
| f' File "{__file__}", line {self.callable_line}, in get_exception\n' |
| ' callable()\n' |
| f' File "{__file__}", line {lineno_f+2}, in f_with_binary_operator\n' |
| ' return 10 + divisor // 0 + 30\n' |
| ' ~~~~~~~~^^~~\n' |
| ) |
| result_lines = self.get_exception(f_with_binary_operator) |
| self.assertEqual(result_lines, expected_error.splitlines()) |
| |
| def test_caret_for_subscript(self): |
| def f_with_subscript(): |
| some_dict = {'x': {'y': None}} |
| return some_dict['x']['y']['z'] |
| |
| lineno_f = f_with_subscript.__code__.co_firstlineno |
| expected_error = ( |
| 'Traceback (most recent call last):\n' |
| f' File "{__file__}", line {self.callable_line}, in get_exception\n' |
| ' callable()\n' |
| f' File "{__file__}", line {lineno_f+2}, in f_with_subscript\n' |
| " return some_dict['x']['y']['z']\n" |
| ' ~~~~~~~~~~~~~~~~~~~^^^^^\n' |
| ) |
| result_lines = self.get_exception(f_with_subscript) |
| self.assertEqual(result_lines, expected_error.splitlines()) |
| |
| def test_caret_for_subscript_unicode(self): |
| def f_with_subscript(): |
| some_dict = {'ó': {'á': {'Ã': {'theta': 1}}}} |
| return some_dict['ó']['á']['Ã']['beta'] |
| |
| lineno_f = f_with_subscript.__code__.co_firstlineno |
| expected_error = ( |
| 'Traceback (most recent call last):\n' |
| f' File "{__file__}", line {self.callable_line}, in get_exception\n' |
| ' callable()\n' |
| f' File "{__file__}", line {lineno_f+2}, in f_with_subscript\n' |
| " return some_dict['ó']['á']['Ã']['beta']\n" |
| ' ~~~~~~~~~~~~~~~~~~~~~~~~^^^^^^^^\n' |
| ) |
| result_lines = self.get_exception(f_with_subscript) |
| self.assertEqual(result_lines, expected_error.splitlines()) |
| |
| def test_traceback_specialization_with_syntax_error(self): |
| bytecode = compile("1 / 0 / 1 / 2\n", TESTFN, "exec") |
| |
| with open(TESTFN, "w") as file: |
| # make the file's contents invalid |
| file.write("1 $ 0 / 1 / 2\n") |
| self.addCleanup(unlink, TESTFN) |
| |
| func = partial(exec, bytecode) |
| result_lines = self.get_exception(func) |
| |
| lineno_f = bytecode.co_firstlineno |
| expected_error = ( |
| 'Traceback (most recent call last):\n' |
| f' File "{__file__}", line {self.callable_line}, in get_exception\n' |
| ' callable()\n' |
| f' File "{TESTFN}", line {lineno_f}, in <module>\n' |
| " 1 $ 0 / 1 / 2\n" |
| ' ^^^^^\n' |
| ) |
| self.assertEqual(result_lines, expected_error.splitlines()) |
| |
| def test_traceback_very_long_line(self): |
| source = "if True: " + "a" * 256 |
| bytecode = compile(source, TESTFN, "exec") |
| |
| with open(TESTFN, "w") as file: |
| file.write(source) |
| self.addCleanup(unlink, TESTFN) |
| |
| func = partial(exec, bytecode) |
| result_lines = self.get_exception(func) |
| |
| lineno_f = bytecode.co_firstlineno |
| expected_error = ( |
| 'Traceback (most recent call last):\n' |
| f' File "{__file__}", line {self.callable_line}, in get_exception\n' |
| ' callable()\n' |
| f' File "{TESTFN}", line {lineno_f}, in <module>\n' |
| f' {source}\n' |
| f' {" "*len("if True: ") + "^"*256}\n' |
| ) |
| self.assertEqual(result_lines, expected_error.splitlines()) |
| |
| def test_secondary_caret_not_elided(self): |
| # Always show a line's indicators if they include the secondary character. |
| def f_with_subscript(): |
| some_dict = {'x': {'y': None}} |
| some_dict['x']['y']['z'] |
| |
| lineno_f = f_with_subscript.__code__.co_firstlineno |
| expected_error = ( |
| 'Traceback (most recent call last):\n' |
| f' File "{__file__}", line {self.callable_line}, in get_exception\n' |
| ' callable()\n' |
| f' File "{__file__}", line {lineno_f+2}, in f_with_subscript\n' |
| " some_dict['x']['y']['z']\n" |
| ' ~~~~~~~~~~~~~~~~~~~^^^^^\n' |
| ) |
| result_lines = self.get_exception(f_with_subscript) |
| self.assertEqual(result_lines, expected_error.splitlines()) |
| |
| def test_caret_exception_group(self): |
| # Notably, this covers whether indicators handle margin strings correctly. |
| # (Exception groups use margin strings to display vertical indicators.) |
| # The implementation must account for both "indent" and "margin" offsets. |
| |
| def exc(): |
| if True: raise ExceptionGroup("eg", [ValueError(1), TypeError(2)]) |
| |
| expected_error = ( |
| f' + Exception Group Traceback (most recent call last):\n' |
| f' | File "{__file__}", line {self.callable_line}, in get_exception\n' |
| f' | callable()\n' |
| f' | File "{__file__}", line {exc.__code__.co_firstlineno + 1}, in exc\n' |
| f' | if True: raise ExceptionGroup("eg", [ValueError(1), TypeError(2)])\n' |
| f' | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n' |
| f' | ExceptionGroup: eg (2 sub-exceptions)\n' |
| f' +-+---------------- 1 ----------------\n' |
| f' | ValueError: 1\n' |
| f' +---------------- 2 ----------------\n' |
| f' | TypeError: 2\n') |
| |
| result_lines = self.get_exception(exc) |
| self.assertEqual(result_lines, expected_error.splitlines()) |
| |
| def assertSpecialized(self, func, expected_specialization): |
| result_lines = self.get_exception(func) |
| specialization_line = result_lines[-1] |
| self.assertEqual(specialization_line.lstrip(), expected_specialization) |
| |
| def test_specialization_variations(self): |
| self.assertSpecialized(lambda: 1/0, |
| "~^~") |
| self.assertSpecialized(lambda: 1/0/3, |
| "~^~") |
| self.assertSpecialized(lambda: 1 / 0, |
| "~~^~~") |
| self.assertSpecialized(lambda: 1 / 0 / 3, |
| "~~^~~") |
| self.assertSpecialized(lambda: 1/ 0, |
| "~^~~") |
| self.assertSpecialized(lambda: 1/ 0/3, |
| "~^~~") |
| self.assertSpecialized(lambda: 1 / 0, |
| "~~~~~^~~~") |
| self.assertSpecialized(lambda: 1 / 0 / 5, |
| "~~~~~^~~~") |
| self.assertSpecialized(lambda: 1 /0, |
| "~~^~") |
| self.assertSpecialized(lambda: 1//0, |
| "~^^~") |
| self.assertSpecialized(lambda: 1//0//4, |
| "~^^~") |
| self.assertSpecialized(lambda: 1 // 0, |
| "~~^^~~") |
| self.assertSpecialized(lambda: 1 // 0 // 4, |
| "~~^^~~") |
| self.assertSpecialized(lambda: 1 //0, |
| "~~^^~") |
| self.assertSpecialized(lambda: 1// 0, |
| "~^^~~") |
| |
| def test_decorator_application_lineno_correct(self): |
| def dec_error(func): |
| raise TypeError |
| def dec_fine(func): |
| return func |
| def applydecs(): |
| @dec_error |
| @dec_fine |
| def g(): pass |
| result_lines = self.get_exception(applydecs) |
| lineno_applydescs = applydecs.__code__.co_firstlineno |
| lineno_dec_error = dec_error.__code__.co_firstlineno |
| expected_error = ( |
| 'Traceback (most recent call last):\n' |
| f' File "{__file__}", line {self.callable_line}, in get_exception\n' |
| ' callable()\n' |
| f' File "{__file__}", line {lineno_applydescs + 1}, in applydecs\n' |
| ' @dec_error\n' |
| ' ^^^^^^^^^\n' |
| f' File "{__file__}", line {lineno_dec_error + 1}, in dec_error\n' |
| ' raise TypeError\n' |
| ) |
| self.assertEqual(result_lines, expected_error.splitlines()) |
| |
| def applydecs_class(): |
| @dec_error |
| @dec_fine |
| class A: pass |
| result_lines = self.get_exception(applydecs_class) |
| lineno_applydescs_class = applydecs_class.__code__.co_firstlineno |
| expected_error = ( |
| 'Traceback (most recent call last):\n' |
| f' File "{__file__}", line {self.callable_line}, in get_exception\n' |
| ' callable()\n' |
| f' File "{__file__}", line {lineno_applydescs_class + 1}, in applydecs_class\n' |
| ' @dec_error\n' |
| ' ^^^^^^^^^\n' |
| f' File "{__file__}", line {lineno_dec_error + 1}, in dec_error\n' |
| ' raise TypeError\n' |
| ) |
| self.assertEqual(result_lines, expected_error.splitlines()) |
| |
| def test_multiline_method_call_a(self): |
| def f(): |
| (None |
| .method |
| )() |
| actual = self.get_exception(f) |
| expected = [ |
| f"Traceback (most recent call last):", |
| f" File \"{__file__}\", line {self.callable_line}, in get_exception", |
| f" callable()", |
| f" File \"{__file__}\", line {f.__code__.co_firstlineno + 2}, in f", |
| f" .method", |
| f" ^^^^^^", |
| ] |
| self.assertEqual(actual, expected) |
| |
| def test_multiline_method_call_b(self): |
| def f(): |
| (None. |
| method |
| )() |
| actual = self.get_exception(f) |
| expected = [ |
| f"Traceback (most recent call last):", |
| f" File \"{__file__}\", line {self.callable_line}, in get_exception", |
| f" callable()", |
| f" File \"{__file__}\", line {f.__code__.co_firstlineno + 2}, in f", |
| f" method", |
| ] |
| self.assertEqual(actual, expected) |
| |
| def test_multiline_method_call_c(self): |
| def f(): |
| (None |
| . method |
| )() |
| actual = self.get_exception(f) |
| expected = [ |
| f"Traceback (most recent call last):", |
| f" File \"{__file__}\", line {self.callable_line}, in get_exception", |
| f" callable()", |
| f" File \"{__file__}\", line {f.__code__.co_firstlineno + 2}, in f", |
| f" . method", |
| f" ^^^^^^", |
| ] |
| self.assertEqual(actual, expected) |
| |
| def test_wide_characters_unicode_with_problematic_byte_offset(self): |
| def f(): |
| ｗｉｄｔｈ |
| |
| actual = self.get_exception(f) |
| expected = [ |
| f"Traceback (most recent call last):", |
| f" File \"{__file__}\", line {self.callable_line}, in get_exception", |
| f" callable()", |
| f" File \"{__file__}\", line {f.__code__.co_firstlineno + 1}, in f", |
| f" ｗｉｄｔｈ", |
| ] |
| self.assertEqual(actual, expected) |
| |
| |
| def test_byte_offset_with_wide_characters_middle(self): |
| def f(): |
| ｗｉｄｔｈ = 1 |
| raise ValueError(ｗｉｄｔｈ) |
| |
| actual = self.get_exception(f) |
| expected = [ |
| f"Traceback (most recent call last):", |
| f" File \"{__file__}\", line {self.callable_line}, in get_exception", |
| f" callable()", |
| f" File \"{__file__}\", line {f.__code__.co_firstlineno + 2}, in f", |
| f" raise ValueError(ｗｉｄｔｈ)", |
| ] |
| self.assertEqual(actual, expected) |
| |
| def test_byte_offset_multiline(self): |
| def f(): |
| ï½—ï½—ï½— = 1 |
| ｔｈ = 0 |
| |
| print(1, ï½—ï½—ï½—( |
| ｔｈ)) |
| |
| actual = self.get_exception(f) |
| expected = [ |
| f"Traceback (most recent call last):", |
| f" File \"{__file__}\", line {self.callable_line}, in get_exception", |
| f" callable()", |
| f" File \"{__file__}\", line {f.__code__.co_firstlineno + 4}, in f", |
| f" print(1, ï½—ï½—ï½—(", |
| f" ^^^^", |
| ] |
| self.assertEqual(actual, expected) |
| |
| |
| @cpython_only |
| @requires_debug_ranges() |
| class CPythonTracebackErrorCaretTests(TracebackErrorLocationCaretTests): |
| """ |
| Same set of tests as above but with Python's internal traceback printing. |
| """ |
| def get_exception(self, callable): |
| from _testcapi import exception_print |
| try: |
| callable() |
| self.fail("No exception thrown.") |
| except Exception as e: |
| with captured_output("stderr") as tbstderr: |
| exception_print(e) |
| return tbstderr.getvalue().splitlines()[:-1] |
| |
| callable_line = get_exception.__code__.co_firstlineno + 3 |
| |
| |
| class TracebackFormatTests(unittest.TestCase): |
| |
| def some_exception(self): |
| raise KeyError('blah') |
| |
| @cpython_only |
| def check_traceback_format(self, cleanup_func=None): |
| from _testcapi import traceback_print |
| try: |
| self.some_exception() |
| except KeyError: |
| type_, value, tb = sys.exc_info() |
| if cleanup_func is not None: |
| # Clear the inner frames, not this one |
| cleanup_func(tb.tb_next) |
| traceback_fmt = 'Traceback (most recent call last):\n' + \ |
| ''.join(traceback.format_tb(tb)) |
| file_ = StringIO() |
| traceback_print(tb, file_) |
| python_fmt = file_.getvalue() |
| # Call all _tb and _exc functions |
| with captured_output("stderr") as tbstderr: |
| traceback.print_tb(tb) |
| tbfile = StringIO() |
| traceback.print_tb(tb, file=tbfile) |
| with captured_output("stderr") as excstderr: |
| traceback.print_exc() |
| excfmt = traceback.format_exc() |
| excfile = StringIO() |
| traceback.print_exc(file=excfile) |
| else: |
| raise Error("unable to create test traceback string") |
| |
| # Make sure that Python and the traceback module format the same thing |
| self.assertEqual(traceback_fmt, python_fmt) |
| # Now verify the _tb func output |
| self.assertEqual(tbstderr.getvalue(), tbfile.getvalue()) |
| # Now verify the _exc func output |
| self.assertEqual(excstderr.getvalue(), excfile.getvalue()) |
| self.assertEqual(excfmt, excfile.getvalue()) |
| |
| # Make sure that the traceback is properly indented. |
| tb_lines = python_fmt.splitlines() |
| banner = tb_lines[0] |
| self.assertEqual(len(tb_lines), 5) |
| location, source_line = tb_lines[-2], tb_lines[-1] |
| self.assertTrue(banner.startswith('Traceback')) |
| self.assertTrue(location.startswith(' File')) |
| self.assertTrue(source_line.startswith(' raise')) |
| |
| def test_traceback_format(self): |
| self.check_traceback_format() |
| |
| def test_traceback_format_with_cleared_frames(self): |
| # Check that traceback formatting also works with a clear()ed frame |
| def cleanup_tb(tb): |
| tb.tb_frame.clear() |
| self.check_traceback_format(cleanup_tb) |
| |
| def test_stack_format(self): |
| # Verify _stack functions. Note we have to use _getframe(1) to |
| # compare them without this frame appearing in the output |
| with captured_output("stderr") as ststderr: |
| traceback.print_stack(sys._getframe(1)) |
| stfile = StringIO() |
| traceback.print_stack(sys._getframe(1), file=stfile) |
| self.assertEqual(ststderr.getvalue(), stfile.getvalue()) |
| |
| stfmt = traceback.format_stack(sys._getframe(1)) |
| |
| self.assertEqual(ststderr.getvalue(), "".join(stfmt)) |
| |
| def test_print_stack(self): |
| def prn(): |
| traceback.print_stack() |
| with captured_output("stderr") as stderr: |
| prn() |
| lineno = prn.__code__.co_firstlineno |
| self.assertEqual(stderr.getvalue().splitlines()[-4:], [ |
| ' File "%s", line %d, in test_print_stack' % (__file__, lineno+3), |
| ' prn()', |
| ' File "%s", line %d, in prn' % (__file__, lineno+1), |
| ' traceback.print_stack()', |
| ]) |
| |
| # issue 26823 - Shrink recursive tracebacks |
| def _check_recursive_traceback_display(self, render_exc): |
| # Always show full diffs when this test fails |
| # Note that rearranging things may require adjusting |
| # the relative line numbers in the expected tracebacks |
| self.maxDiff = None |
| |
| # Check hitting the recursion limit |
| def f(): |
| f() |
| |
| with captured_output("stderr") as stderr_f: |
| try: |
| f() |
| except RecursionError: |
| render_exc() |
| else: |
| self.fail("no recursion occurred") |
| |
| lineno_f = f.__code__.co_firstlineno |
| result_f = ( |
| 'Traceback (most recent call last):\n' |
| f' File "{__file__}", line {lineno_f+5}, in _check_recursive_traceback_display\n' |
| ' f()\n' |
| f' File "{__file__}", line {lineno_f+1}, in f\n' |
| ' f()\n' |
| f' File "{__file__}", line {lineno_f+1}, in f\n' |
| ' f()\n' |
| f' File "{__file__}", line {lineno_f+1}, in f\n' |
| ' f()\n' |
| # XXX: The following line changes depending on whether the tests |
| # are run through the interactive interpreter or with -m |
| # It also varies depending on the platform (stack size) |
| # Fortunately, we don't care about exactness here, so we use regex |
| r' \[Previous line repeated (\d+) more times\]' '\n' |
| 'RecursionError: maximum recursion depth exceeded\n' |
| ) |
| |
| expected = result_f.splitlines() |
| actual = stderr_f.getvalue().splitlines() |
| |
| # Check the output text matches expectations |
| # 2nd last line contains the repetition count |
| self.assertEqual(actual[:-2], expected[:-2]) |
| self.assertRegex(actual[-2], expected[-2]) |
| # last line can have additional text appended |
| self.assertIn(expected[-1], actual[-1]) |
| |
| # Check the recursion count is roughly as expected |
| rec_limit = sys.getrecursionlimit() |
| self.assertIn(int(re.search(r"\d+", actual[-2]).group()), range(rec_limit-60, rec_limit)) |
| |
| # Check a known (limited) number of recursive invocations |
| def g(count=10): |
| if count: |
| return g(count-1) |
| raise ValueError |
| |
| with captured_output("stderr") as stderr_g: |
| try: |
| g() |
| except ValueError: |
| render_exc() |
| else: |
| self.fail("no value error was raised") |
| |
| lineno_g = g.__code__.co_firstlineno |
| result_g = ( |
| f' File "{__file__}", line {lineno_g+2}, in g\n' |
| ' return g(count-1)\n' |
| ' ^^^^^^^^^^\n' |
| f' File "{__file__}", line {lineno_g+2}, in g\n' |
| ' return g(count-1)\n' |
| ' ^^^^^^^^^^\n' |
| f' File "{__file__}", line {lineno_g+2}, in g\n' |
| ' return g(count-1)\n' |
| ' ^^^^^^^^^^\n' |
| ' [Previous line repeated 7 more times]\n' |
| f' File "{__file__}", line {lineno_g+3}, in g\n' |
| ' raise ValueError\n' |
| 'ValueError\n' |
| ) |
| tb_line = ( |
| 'Traceback (most recent call last):\n' |
| f' File "{__file__}", line {lineno_g+7}, in _check_recursive_traceback_display\n' |
| ' g()\n' |
| ) |
| expected = (tb_line + result_g).splitlines() |
| actual = stderr_g.getvalue().splitlines() |
| self.assertEqual(actual, expected) |
| |
| # Check 2 different repetitive sections |
| def h(count=10): |
| if count: |
| return h(count-1) |
| g() |
| |
| with captured_output("stderr") as stderr_h: |
| try: |
| h() |
| except ValueError: |
| render_exc() |
| else: |
| self.fail("no value error was raised") |
| |
| lineno_h = h.__code__.co_firstlineno |
| result_h = ( |
| 'Traceback (most recent call last):\n' |
| f' File "{__file__}", line {lineno_h+7}, in _check_recursive_traceback_display\n' |
| ' h()\n' |
| f' File "{__file__}", line {lineno_h+2}, in h\n' |
| ' return h(count-1)\n' |
| ' ^^^^^^^^^^\n' |
| f' File "{__file__}", line {lineno_h+2}, in h\n' |
| ' return h(count-1)\n' |
| ' ^^^^^^^^^^\n' |
| f' File "{__file__}", line {lineno_h+2}, in h\n' |
| ' return h(count-1)\n' |
| ' ^^^^^^^^^^\n' |
| ' [Previous line repeated 7 more times]\n' |
| f' File "{__file__}", line {lineno_h+3}, in h\n' |
| ' g()\n' |
| ) |
| expected = (result_h + result_g).splitlines() |
| actual = stderr_h.getvalue().splitlines() |
| self.assertEqual(actual, expected) |
| |
| # Check the boundary conditions. First, test just below the cutoff. |
| with captured_output("stderr") as stderr_g: |
| try: |
| g(traceback._RECURSIVE_CUTOFF) |
| except ValueError: |
| render_exc() |
| else: |
| self.fail("no error raised") |
| result_g = ( |
| f' File "{__file__}", line {lineno_g+2}, in g\n' |
| ' return g(count-1)\n' |
| ' ^^^^^^^^^^\n' |
| f' File "{__file__}", line {lineno_g+2}, in g\n' |
| ' return g(count-1)\n' |
| ' ^^^^^^^^^^\n' |
| f' File "{__file__}", line {lineno_g+2}, in g\n' |
| ' return g(count-1)\n' |
| ' ^^^^^^^^^^\n' |
| f' File "{__file__}", line {lineno_g+3}, in g\n' |
| ' raise ValueError\n' |
| 'ValueError\n' |
| ) |
| tb_line = ( |
| 'Traceback (most recent call last):\n' |
| f' File "{__file__}", line {lineno_g+77}, in _check_recursive_traceback_display\n' |
| ' g(traceback._RECURSIVE_CUTOFF)\n' |
| ) |
| expected = (tb_line + result_g).splitlines() |
| actual = stderr_g.getvalue().splitlines() |
| self.assertEqual(actual, expected) |
| |
| # Second, test just above the cutoff. |
| with captured_output("stderr") as stderr_g: |
| try: |
| g(traceback._RECURSIVE_CUTOFF + 1) |
| except ValueError: |
| render_exc() |
| else: |
| self.fail("no error raised") |
| result_g = ( |
| f' File "{__file__}", line {lineno_g+2}, in g\n' |
| ' return g(count-1)\n' |
| ' ^^^^^^^^^^\n' |
| f' File "{__file__}", line {lineno_g+2}, in g\n' |
| ' return g(count-1)\n' |
| ' ^^^^^^^^^^\n' |
| f' File "{__file__}", line {lineno_g+2}, in g\n' |
| ' return g(count-1)\n' |
| ' ^^^^^^^^^^\n' |
| ' [Previous line repeated 1 more time]\n' |
| f' File "{__file__}", line {lineno_g+3}, in g\n' |
| ' raise ValueError\n' |
| 'ValueError\n' |
| ) |
| tb_line = ( |
| 'Traceback (most recent call last):\n' |
| f' File "{__file__}", line {lineno_g+108}, in _check_recursive_traceback_display\n' |
| ' g(traceback._RECURSIVE_CUTOFF + 1)\n' |
| ) |
| expected = (tb_line + result_g).splitlines() |
| actual = stderr_g.getvalue().splitlines() |
| self.assertEqual(actual, expected) |
| |
| @requires_debug_ranges() |
| def test_recursive_traceback_python(self): |
| self._check_recursive_traceback_display(traceback.print_exc) |
| |
| @cpython_only |
| @requires_debug_ranges() |
| def test_recursive_traceback_cpython_internal(self): |
| from _testcapi import exception_print |
| def render_exc(): |
| exc_type, exc_value, exc_tb = sys.exc_info() |
| exception_print(exc_value) |
| self._check_recursive_traceback_display(render_exc) |
| |
| def test_format_stack(self): |
| def fmt(): |
| return traceback.format_stack() |
| result = fmt() |
| lineno = fmt.__code__.co_firstlineno |
| self.assertEqual(result[-2:], [ |
| ' File "%s", line %d, in test_format_stack\n' |
| ' result = fmt()\n' % (__file__, lineno+2), |
| ' File "%s", line %d, in fmt\n' |
| ' return traceback.format_stack()\n' % (__file__, lineno+1), |
| ]) |
| |
| @cpython_only |
| def test_unhashable(self): |
| from _testcapi import exception_print |
| |
| class UnhashableException(Exception): |
| def __eq__(self, other): |
| return True |
| |
| ex1 = UnhashableException('ex1') |
| ex2 = UnhashableException('ex2') |
| try: |
| raise ex2 from ex1 |
| except UnhashableException: |
| try: |
| raise ex1 |
| except UnhashableException: |
| exc_type, exc_val, exc_tb = sys.exc_info() |
| |
| with captured_output("stderr") as stderr_f: |
| exception_print(exc_val) |
| |
| tb = stderr_f.getvalue().strip().splitlines() |
| self.assertEqual(11, len(tb)) |
| self.assertEqual(context_message.strip(), tb[5]) |
| self.assertIn('UnhashableException: ex2', tb[3]) |
| self.assertIn('UnhashableException: ex1', tb[10]) |
| |
| def deep_eg(self): |
| e = TypeError(1) |
| for i in range(2000): |
| e = ExceptionGroup('eg', [e]) |
| return e |
| |
| @cpython_only |
| def test_exception_group_deep_recursion_capi(self): |
| from _testcapi import exception_print |
| LIMIT = 75 |
| eg = self.deep_eg() |
| with captured_output("stderr") as stderr_f: |
| with support.infinite_recursion(max_depth=LIMIT): |
| exception_print(eg) |
| output = stderr_f.getvalue() |
| self.assertIn('ExceptionGroup', output) |
| self.assertLessEqual(output.count('ExceptionGroup'), LIMIT) |
| |
| def test_exception_group_deep_recursion_traceback(self): |
| LIMIT = 75 |
| eg = self.deep_eg() |
| with captured_output("stderr") as stderr_f: |
| with support.infinite_recursion(max_depth=LIMIT): |
| traceback.print_exception(type(eg), eg, eg.__traceback__) |
| output = stderr_f.getvalue() |
| self.assertIn('ExceptionGroup', output) |
| self.assertLessEqual(output.count('ExceptionGroup'), LIMIT) |
| |
| @cpython_only |
| def test_print_exception_bad_type_capi(self): |
| from _testcapi import exception_print |
| with captured_output("stderr") as stderr: |
| exception_print(42) |
| self.assertEqual( |
| stderr.getvalue(), |
| ('TypeError: print_exception(): ' |
| 'Exception expected for value, int found\n') |
| ) |
| |
| def test_print_exception_bad_type_python(self): |
| msg = "Exception expected for value, int found" |
| with self.assertRaisesRegex(TypeError, msg): |
| traceback.print_exception(42) |
| |
| |
| cause_message = ( |
| "\nThe above exception was the direct cause " |
| "of the following exception:\n\n") |
| |
| context_message = ( |
| "\nDuring handling of the above exception, " |
| "another exception occurred:\n\n") |
| |
| boundaries = re.compile( |
| '(%s|%s)' % (re.escape(cause_message), re.escape(context_message))) |
| |
| class BaseExceptionReportingTests: |
| |
| def get_exception(self, exception_or_callable): |
| if isinstance(exception_or_callable, BaseException): |
| return exception_or_callable |
| try: |
| exception_or_callable() |
| except Exception as e: |
| return e |
| |
| callable_line = get_exception.__code__.co_firstlineno + 4 |
| |
| def zero_div(self): |
| 1/0 # In zero_div |
| |
| def check_zero_div(self, msg): |
| lines = msg.splitlines() |
| if has_no_debug_ranges(): |
| self.assertTrue(lines[-3].startswith(' File')) |
| self.assertIn('1/0 # In zero_div', lines[-2]) |
| else: |
| self.assertTrue(lines[-4].startswith(' File')) |
| self.assertIn('1/0 # In zero_div', lines[-3]) |
| self.assertTrue(lines[-1].startswith('ZeroDivisionError'), lines[-1]) |
| |
| def test_simple(self): |
| try: |
| 1/0 # Marker |
| except ZeroDivisionError as _: |
| e = _ |
| lines = self.get_report(e).splitlines() |
| if has_no_debug_ranges(): |
| self.assertEqual(len(lines), 4) |
| self.assertTrue(lines[3].startswith('ZeroDivisionError')) |
| else: |
| self.assertEqual(len(lines), 5) |
| self.assertTrue(lines[4].startswith('ZeroDivisionError')) |
| self.assertTrue(lines[0].startswith('Traceback')) |
| self.assertTrue(lines[1].startswith(' File')) |
| self.assertIn('1/0 # Marker', lines[2]) |
| |
| def test_cause(self): |
| def inner_raise(): |
| try: |
| self.zero_div() |
| except ZeroDivisionError as e: |
| raise KeyError from e |
| def outer_raise(): |
| inner_raise() # Marker |
| blocks = boundaries.split(self.get_report(outer_raise)) |
| self.assertEqual(len(blocks), 3) |
| self.assertEqual(blocks[1], cause_message) |
| self.check_zero_div(blocks[0]) |
| self.assertIn('inner_raise() # Marker', blocks[2]) |
| |
| def test_context(self): |
| def inner_raise(): |
| try: |
| self.zero_div() |
| except ZeroDivisionError: |
| raise KeyError |
| def outer_raise(): |
| inner_raise() # Marker |
| blocks = boundaries.split(self.get_report(outer_raise)) |
| self.assertEqual(len(blocks), 3) |
| self.assertEqual(blocks[1], context_message) |
| self.check_zero_div(blocks[0]) |
| self.assertIn('inner_raise() # Marker', blocks[2]) |
| |
| def test_context_suppression(self): |
| try: |
| try: |
| raise Exception |
| except: |
| raise ZeroDivisionError from None |
| except ZeroDivisionError as _: |
| e = _ |
| lines = self.get_report(e).splitlines() |
| self.assertEqual(len(lines), 4) |
| self.assertTrue(lines[3].startswith('ZeroDivisionError')) |
| self.assertTrue(lines[0].startswith('Traceback')) |
| self.assertTrue(lines[1].startswith(' File')) |
| self.assertIn('ZeroDivisionError from None', lines[2]) |
| |
| def test_cause_and_context(self): |
| # When both a cause and a context are set, only the cause should be |
| # displayed and the context should be muted. |
| def inner_raise(): |
| try: |
| self.zero_div() |
| except ZeroDivisionError as _e: |
| e = _e |
| try: |
| xyzzy |
| except NameError: |
| raise KeyError from e |
| def outer_raise(): |
| inner_raise() # Marker |
| blocks = boundaries.split(self.get_report(outer_raise)) |
| self.assertEqual(len(blocks), 3) |
| self.assertEqual(blocks[1], cause_message) |
| self.check_zero_div(blocks[0]) |
| self.assertIn('inner_raise() # Marker', blocks[2]) |
| |
| def test_cause_recursive(self): |
| def inner_raise(): |
| try: |
| try: |
| self.zero_div() |
| except ZeroDivisionError as e: |
| z = e |
| raise KeyError from e |
| except KeyError as e: |
| raise z from e |
| def outer_raise(): |
| inner_raise() # Marker |
| blocks = boundaries.split(self.get_report(outer_raise)) |
| self.assertEqual(len(blocks), 3) |
| self.assertEqual(blocks[1], cause_message) |
| # The first block is the KeyError raised from the ZeroDivisionError |
| self.assertIn('raise KeyError from e', blocks[0]) |
| self.assertNotIn('1/0', blocks[0]) |
| # The second block (apart from the boundary) is the ZeroDivisionError |
| # re-raised from the KeyError |
| self.assertIn('inner_raise() # Marker', blocks[2]) |
| self.check_zero_div(blocks[2]) |
| |
| def test_syntax_error_offset_at_eol(self): |
| # See #10186. |
| def e(): |
| raise SyntaxError('', ('', 0, 5, 'hello')) |
| msg = self.get_report(e).splitlines() |
| self.assertEqual(msg[-2], " ^") |
| def e(): |
| exec("x = 5 | 4 |") |
| msg = self.get_report(e).splitlines() |
| self.assertEqual(msg[-2], ' ^') |
| |
| def test_syntax_error_no_lineno(self): |
| # See #34463. |
| |
| # Without filename |
| e = SyntaxError('bad syntax') |
| msg = self.get_report(e).splitlines() |
| self.assertEqual(msg, |
| ['SyntaxError: bad syntax']) |
| e.lineno = 100 |
| msg = self.get_report(e).splitlines() |
| self.assertEqual(msg, |
| [' File "<string>", line 100', 'SyntaxError: bad syntax']) |
| |
| # With filename |
| e = SyntaxError('bad syntax') |
| e.filename = 'myfile.py' |
| |
| msg = self.get_report(e).splitlines() |
| self.assertEqual(msg, |
| ['SyntaxError: bad syntax (myfile.py)']) |
| e.lineno = 100 |
| msg = self.get_report(e).splitlines() |
| self.assertEqual(msg, |
| [' File "myfile.py", line 100', 'SyntaxError: bad syntax']) |
| |
| def test_message_none(self): |
| # A message that looks like "None" should not be treated specially |
| err = self.get_report(Exception(None)) |
| self.assertIn('Exception: None\n', err) |
| err = self.get_report(Exception('None')) |
| self.assertIn('Exception: None\n', err) |
| err = self.get_report(Exception()) |
| self.assertIn('Exception\n', err) |
| err = self.get_report(Exception('')) |
| self.assertIn('Exception\n', err) |
| |
| def test_syntax_error_various_offsets(self): |
| for offset in range(-5, 10): |
| for add in [0, 2]: |
| text = " "*add + "text%d" % offset |
| expected = [' File "file.py", line 1'] |
| if offset < 1: |
| expected.append(" %s" % text.lstrip()) |
| elif offset <= 6: |
| expected.append(" %s" % text.lstrip()) |
| expected.append(" %s^" % (" "*(offset-1))) |
| else: |
| expected.append(" %s" % text.lstrip()) |
| expected.append(" %s^" % (" "*5)) |
| expected.append("SyntaxError: msg") |
| expected.append("") |
| err = self.get_report(SyntaxError("msg", ("file.py", 1, offset+add, text))) |
| exp = "\n".join(expected) |
| self.assertEqual(exp, err) |
| |
| def test_exception_with_note(self): |
| e = ValueError(123) |
| vanilla = self.get_report(e) |
| |
| e.add_note('My Note') |
| self.assertEqual(self.get_report(e), vanilla + 'My Note\n') |
| |
| del e.__notes__ |
| e.add_note('') |
| self.assertEqual(self.get_report(e), vanilla + '\n') |
| |
| del e.__notes__ |
| e.add_note('Your Note') |
| self.assertEqual(self.get_report(e), vanilla + 'Your Note\n') |
| |
| del e.__notes__ |
| self.assertEqual(self.get_report(e), vanilla) |
| |
| def test_exception_with_invalid_notes(self): |
| e = ValueError(123) |
| vanilla = self.get_report(e) |
| |
| # non-sequence __notes__ |
| class BadThing: |
| def __str__(self): |
| return 'bad str' |
| |
| def __repr__(self): |
| return 'bad repr' |
| |
| # unprintable, non-sequence __notes__ |
| class Unprintable: |
| def __repr__(self): |
| raise ValueError('bad value') |
| |
| e.__notes__ = BadThing() |
| notes_repr = 'bad repr' |
| self.assertEqual(self.get_report(e), vanilla + notes_repr) |
| |
| e.__notes__ = Unprintable() |
| err_msg = '<__notes__ repr() failed>' |
| self.assertEqual(self.get_report(e), vanilla + err_msg) |
| |
| # non-string item in the __notes__ sequence |
| e.__notes__ = [BadThing(), 'Final Note'] |
| bad_note = 'bad str' |
| self.assertEqual(self.get_report(e), vanilla + bad_note + '\nFinal Note\n') |
| |
| # unprintable, non-string item in the __notes__ sequence |
| e.__notes__ = [Unprintable(), 'Final Note'] |
| err_msg = '<note str() failed>' |
| self.assertEqual(self.get_report(e), vanilla + err_msg + '\nFinal Note\n') |
| |
| def test_exception_with_note_with_multiple_notes(self): |
| e = ValueError(42) |
| vanilla = self.get_report(e) |
| |
| e.add_note('Note 1') |
| e.add_note('Note 2') |
| e.add_note('Note 3') |
| |
| self.assertEqual( |
| self.get_report(e), |
| vanilla + 'Note 1\n' + 'Note 2\n' + 'Note 3\n') |
| |
| del e.__notes__ |
| e.add_note('Note 4') |
| del e.__notes__ |
| e.add_note('Note 5') |
| e.add_note('Note 6') |
| |
| self.assertEqual( |
| self.get_report(e), |
| vanilla + 'Note 5\n' + 'Note 6\n') |
| |
| def test_exception_qualname(self): |
| class A: |
| class B: |
| class X(Exception): |
| def __str__(self): |
| return "I am X" |
| |
| err = self.get_report(A.B.X()) |
| str_value = 'I am X' |
| str_name = '.'.join([A.B.X.__module__, A.B.X.__qualname__]) |
| exp = "%s: %s\n" % (str_name, str_value) |
| self.assertEqual(exp, MODULE_PREFIX + err) |
| |
| def test_exception_modulename(self): |
| class X(Exception): |
| def __str__(self): |
| return "I am X" |
| |
| for modulename in '__main__', 'builtins', 'some_module': |
| X.__module__ = modulename |
| with self.subTest(modulename=modulename): |
| err = self.get_report(X()) |
| str_value = 'I am X' |
| if modulename in ['builtins', '__main__']: |
| str_name = X.__qualname__ |
| else: |
| str_name = '.'.join([X.__module__, X.__qualname__]) |
| exp = "%s: %s\n" % (str_name, str_value) |
| self.assertEqual(exp, err) |
| |
| def test_exception_modulename_not_unicode(self): |
| class X(Exception): |
| def __str__(self): |
| return "I am X" |
| |
| X.__module__ = 42 |
| |
| err = self.get_report(X()) |
| exp = f'<unknown>.{X.__qualname__}: I am X\n' |
| self.assertEqual(exp, err) |
| |
| def test_exception_bad__str__(self): |
| class X(Exception): |
| def __str__(self): |
| 1/0 |
| err = self.get_report(X()) |
| str_value = '<exception str() failed>' |
| str_name = '.'.join([X.__module__, X.__qualname__]) |
| self.assertEqual(MODULE_PREFIX + err, f"{str_name}: {str_value}\n") |
| |
| |
| # #### Exception Groups #### |
| |
| def test_exception_group_basic(self): |
| def exc(): |
| raise ExceptionGroup("eg", [ValueError(1), TypeError(2)]) |
| |
| expected = ( |
| f' + Exception Group Traceback (most recent call last):\n' |
| f' | File "{__file__}", line {self.callable_line}, in get_exception\n' |
| f' | exception_or_callable()\n' |
| f' | File "{__file__}", line {exc.__code__.co_firstlineno + 1}, in exc\n' |
| f' | raise ExceptionGroup("eg", [ValueError(1), TypeError(2)])\n' |
| f' | ExceptionGroup: eg (2 sub-exceptions)\n' |
| f' +-+---------------- 1 ----------------\n' |
| f' | ValueError: 1\n' |
| f' +---------------- 2 ----------------\n' |
| f' | TypeError: 2\n' |
| f' +------------------------------------\n') |
| |
| report = self.get_report(exc) |
| self.assertEqual(report, expected) |
| |
| def test_exception_group_cause(self): |
| def exc(): |
| EG = ExceptionGroup |
| try: |
| raise EG("eg1", [ValueError(1), TypeError(2)]) |
| except Exception as e: |
| raise EG("eg2", [ValueError(3), TypeError(4)]) from e |
| |
| expected = (f' + Exception Group Traceback (most recent call last):\n' |
| f' | File "{__file__}", line {exc.__code__.co_firstlineno + 3}, in exc\n' |
| f' | raise EG("eg1", [ValueError(1), TypeError(2)])\n' |
| f' | ExceptionGroup: eg1 (2 sub-exceptions)\n' |
| f' +-+---------------- 1 ----------------\n' |
| f' | ValueError: 1\n' |
| f' +---------------- 2 ----------------\n' |
| f' | TypeError: 2\n' |
| f' +------------------------------------\n' |
| f'\n' |
| f'The above exception was the direct cause of the following exception:\n' |
| f'\n' |
| f' + Exception Group Traceback (most recent call last):\n' |
| f' | File "{__file__}", line {self.callable_line}, in get_exception\n' |
| f' | exception_or_callable()\n' |
| f' | File "{__file__}", line {exc.__code__.co_firstlineno + 5}, in exc\n' |
| f' | raise EG("eg2", [ValueError(3), TypeError(4)]) from e\n' |
| f' | ExceptionGroup: eg2 (2 sub-exceptions)\n' |
| f' +-+---------------- 1 ----------------\n' |
| f' | ValueError: 3\n' |
| f' +---------------- 2 ----------------\n' |
| f' | TypeError: 4\n' |
| f' +------------------------------------\n') |
| |
| report = self.get_report(exc) |
| self.assertEqual(report, expected) |
| |
| def test_exception_group_context_with_context(self): |
| def exc(): |
| EG = ExceptionGroup |
| try: |
| try: |
| raise EG("eg1", [ValueError(1), TypeError(2)]) |
| except: |
| raise EG("eg2", [ValueError(3), TypeError(4)]) |
| except: |
| raise ImportError(5) |
| |
| expected = ( |
| f' + Exception Group Traceback (most recent call last):\n' |
| f' | File "{__file__}", line {exc.__code__.co_firstlineno + 4}, in exc\n' |
| f' | raise EG("eg1", [ValueError(1), TypeError(2)])\n' |
| f' | ExceptionGroup: eg1 (2 sub-exceptions)\n' |
| f' +-+---------------- 1 ----------------\n' |
| f' | ValueError: 1\n' |
| f' +---------------- 2 ----------------\n' |
| f' | TypeError: 2\n' |
| f' +------------------------------------\n' |
| f'\n' |
| f'During handling of the above exception, another exception occurred:\n' |
| f'\n' |
| f' + Exception Group Traceback (most recent call last):\n' |
| f' | File "{__file__}", line {exc.__code__.co_firstlineno + 6}, in exc\n' |
| f' | raise EG("eg2", [ValueError(3), TypeError(4)])\n' |
| f' | ExceptionGroup: eg2 (2 sub-exceptions)\n' |
| f' +-+---------------- 1 ----------------\n' |
| f' | ValueError: 3\n' |
| f' +---------------- 2 ----------------\n' |
| f' | TypeError: 4\n' |
| f' +------------------------------------\n' |
| f'\n' |
| f'During handling of the above exception, another exception occurred:\n' |
| f'\n' |
| f'Traceback (most recent call last):\n' |
| f' File "{__file__}", line {self.callable_line}, in get_exception\n' |
| f' exception_or_callable()\n' |
| f' File "{__file__}", line {exc.__code__.co_firstlineno + 8}, in exc\n' |
| f' raise ImportError(5)\n' |
| f'ImportError: 5\n') |
| |
| report = self.get_report(exc) |
| self.assertEqual(report, expected) |
| |
| def test_exception_group_nested(self): |
| def exc(): |
| EG = ExceptionGroup |
| VE = ValueError |
| TE = TypeError |
| try: |
| try: |
| raise EG("nested", [TE(2), TE(3)]) |
| except Exception as e: |
| exc = e |
| raise EG("eg", [VE(1), exc, VE(4)]) |
| except: |
| raise EG("top", [VE(5)]) |
| |
| expected = (f' + Exception Group Traceback (most recent call last):\n' |
| f' | File "{__file__}", line {exc.__code__.co_firstlineno + 9}, in exc\n' |
| f' | raise EG("eg", [VE(1), exc, VE(4)])\n' |
| f' | ExceptionGroup: eg (3 sub-exceptions)\n' |
| f' +-+---------------- 1 ----------------\n' |
| f' | ValueError: 1\n' |
| f' +---------------- 2 ----------------\n' |
| f' | Exception Group Traceback (most recent call last):\n' |
| f' | File "{__file__}", line {exc.__code__.co_firstlineno + 6}, in exc\n' |
| f' | raise EG("nested", [TE(2), TE(3)])\n' |
| f' | ExceptionGroup: nested (2 sub-exceptions)\n' |
| f' +-+---------------- 1 ----------------\n' |
| f' | TypeError: 2\n' |
| f' +---------------- 2 ----------------\n' |
| f' | TypeError: 3\n' |
| f' +------------------------------------\n' |
| f' +---------------- 3 ----------------\n' |
| f' | ValueError: 4\n' |
| f' +------------------------------------\n' |
| f'\n' |
| f'During handling of the above exception, another exception occurred:\n' |
| f'\n' |
| f' + Exception Group Traceback (most recent call last):\n' |
| f' | File "{__file__}", line {self.callable_line}, in get_exception\n' |
| f' | exception_or_callable()\n' |
| f' | File "{__file__}", line {exc.__code__.co_firstlineno + 11}, in exc\n' |
| f' | raise EG("top", [VE(5)])\n' |
| f' | ExceptionGroup: top (1 sub-exception)\n' |
| f' +-+---------------- 1 ----------------\n' |
| f' | ValueError: 5\n' |
| f' +------------------------------------\n') |
| |
| report = self.get_report(exc) |
| self.assertEqual(report, expected) |
| |
| def test_exception_group_width_limit(self): |
| excs = [] |
| for i in range(1000): |
| excs.append(ValueError(i)) |
| eg = ExceptionGroup('eg', excs) |
| |
| expected = (' | ExceptionGroup: eg (1000 sub-exceptions)\n' |
| ' +-+---------------- 1 ----------------\n' |
| ' | ValueError: 0\n' |
| ' +---------------- 2 ----------------\n' |
| ' | ValueError: 1\n' |
| ' +---------------- 3 ----------------\n' |
| ' | ValueError: 2\n' |
| ' +---------------- 4 ----------------\n' |
| ' | ValueError: 3\n' |
| ' +---------------- 5 ----------------\n' |
| ' | ValueError: 4\n' |
| ' +---------------- 6 ----------------\n' |
| ' | ValueError: 5\n' |
| ' +---------------- 7 ----------------\n' |
| ' | ValueError: 6\n' |
| ' +---------------- 8 ----------------\n' |
| ' | ValueError: 7\n' |
| ' +---------------- 9 ----------------\n' |
| ' | ValueError: 8\n' |
| ' +---------------- 10 ----------------\n' |
| ' | ValueError: 9\n' |
| ' +---------------- 11 ----------------\n' |
| ' | ValueError: 10\n' |
| ' +---------------- 12 ----------------\n' |
| ' | ValueError: 11\n' |
| ' +---------------- 13 ----------------\n' |
| ' | ValueError: 12\n' |
| ' +---------------- 14 ----------------\n' |
| ' | ValueError: 13\n' |
| ' +---------------- 15 ----------------\n' |
| ' | ValueError: 14\n' |
| ' +---------------- ... ----------------\n' |
| ' | and 985 more exceptions\n' |
| ' +------------------------------------\n') |
| |
| report = self.get_report(eg) |
| self.assertEqual(report, expected) |
| |
| def test_exception_group_depth_limit(self): |
| exc = TypeError('bad type') |
| for i in range(1000): |
| exc = ExceptionGroup( |
| f'eg{i}', |
| [ValueError(i), exc, ValueError(-i)]) |
| |
| expected = (' | ExceptionGroup: eg999 (3 sub-exceptions)\n' |
| ' +-+---------------- 1 ----------------\n' |
| ' | ValueError: 999\n' |
| ' +---------------- 2 ----------------\n' |
| ' | ExceptionGroup: eg998 (3 sub-exceptions)\n' |
| ' +-+---------------- 1 ----------------\n' |
| ' | ValueError: 998\n' |
| ' +---------------- 2 ----------------\n' |
| ' | ExceptionGroup: eg997 (3 sub-exceptions)\n' |
| ' +-+---------------- 1 ----------------\n' |
| ' | ValueError: 997\n' |
| ' +---------------- 2 ----------------\n' |
| ' | ExceptionGroup: eg996 (3 sub-exceptions)\n' |
| ' +-+---------------- 1 ----------------\n' |
| ' | ValueError: 996\n' |
| ' +---------------- 2 ----------------\n' |
| ' | ExceptionGroup: eg995 (3 sub-exceptions)\n' |
| ' +-+---------------- 1 ----------------\n' |
| ' | ValueError: 995\n' |
| ' +---------------- 2 ----------------\n' |
| ' | ExceptionGroup: eg994 (3 sub-exceptions)\n' |
| ' +-+---------------- 1 ----------------\n' |
| ' | ValueError: 994\n' |
| ' +---------------- 2 ----------------\n' |
| ' | ExceptionGroup: eg993 (3 sub-exceptions)\n' |
| ' +-+---------------- 1 ----------------\n' |
| ' | ValueError: 993\n' |
| ' +---------------- 2 ----------------\n' |
| ' | ExceptionGroup: eg992 (3 sub-exceptions)\n' |
| ' +-+---------------- 1 ----------------\n' |
| ' | ValueError: 992\n' |
| ' +---------------- 2 ----------------\n' |
| ' | ExceptionGroup: eg991 (3 sub-exceptions)\n' |
| ' +-+---------------- 1 ----------------\n' |
| ' | ValueError: 991\n' |
| ' +---------------- 2 ----------------\n' |
| ' | ExceptionGroup: eg990 (3 sub-exceptions)\n' |
| ' +-+---------------- 1 ----------------\n' |
| ' | ValueError: 990\n' |
| ' +---------------- 2 ----------------\n' |
| ' | ... (max_group_depth is 10)\n' |
| ' +---------------- 3 ----------------\n' |
| ' | ValueError: -990\n' |
| ' +------------------------------------\n' |
| ' +---------------- 3 ----------------\n' |
| ' | ValueError: -991\n' |
| ' +------------------------------------\n' |
| ' +---------------- 3 ----------------\n' |
| ' | ValueError: -992\n' |
| ' +------------------------------------\n' |
| ' +---------------- 3 ----------------\n' |
| ' | ValueError: -993\n' |
| ' +------------------------------------\n' |
| ' +---------------- 3 ----------------\n' |
| ' | ValueError: -994\n' |
| ' +------------------------------------\n' |
| ' +---------------- 3 ----------------\n' |
| ' | ValueError: -995\n' |
| ' +------------------------------------\n' |
| ' +---------------- 3 ----------------\n' |
| ' | ValueError: -996\n' |
| ' +------------------------------------\n' |
| ' +---------------- 3 ----------------\n' |
| ' | ValueError: -997\n' |
| ' +------------------------------------\n' |
| ' +---------------- 3 ----------------\n' |
| ' | ValueError: -998\n' |
| ' +------------------------------------\n' |
| ' +---------------- 3 ----------------\n' |
| ' | ValueError: -999\n' |
| ' +------------------------------------\n') |
| |
| report = self.get_report(exc) |
| self.assertEqual(report, expected) |
| |
| def test_exception_group_with_notes(self): |
| def exc(): |
| try: |
| excs = [] |
| for msg in ['bad value', 'terrible value']: |
| try: |
| raise ValueError(msg) |
| except ValueError as e: |
| e.add_note(f'the {msg}') |
| excs.append(e) |
| raise ExceptionGroup("nested", excs) |
| except ExceptionGroup as e: |
| e.add_note(('>> Multi line note\n' |
| '>> Because I am such\n' |
| '>> an important exception.\n' |
| '>> empty lines work too\n' |
| '\n' |
| '(that was an empty line)')) |
| raise |
| |
| expected = (f' + Exception Group Traceback (most recent call last):\n' |
| f' | File "{__file__}", line {self.callable_line}, in get_exception\n' |
| f' | exception_or_callable()\n' |
| f' | File "{__file__}", line {exc.__code__.co_firstlineno + 9}, in exc\n' |
| f' | raise ExceptionGroup("nested", excs)\n' |
| f' | ExceptionGroup: nested (2 sub-exceptions)\n' |
| f' | >> Multi line note\n' |
| f' | >> Because I am such\n' |
| f' | >> an important exception.\n' |
| f' | >> empty lines work too\n' |
| f' | \n' |
| f' | (that was an empty line)\n' |
| f' +-+---------------- 1 ----------------\n' |
| f' | Traceback (most recent call last):\n' |
| f' | File "{__file__}", line {exc.__code__.co_firstlineno + 5}, in exc\n' |
| f' | raise ValueError(msg)\n' |
| f' | ValueError: bad value\n' |
| f' | the bad value\n' |
| f' +---------------- 2 ----------------\n' |
| f' | Traceback (most recent call last):\n' |
| f' | File "{__file__}", line {exc.__code__.co_firstlineno + 5}, in exc\n' |
| f' | raise ValueError(msg)\n' |
| f' | ValueError: terrible value\n' |
| f' | the terrible value\n' |
| f' +------------------------------------\n') |
| |
| report = self.get_report(exc) |
| self.assertEqual(report, expected) |
| |
| def test_exception_group_with_multiple_notes(self): |
| def exc(): |
| try: |
| excs = [] |
| for msg in ['bad value', 'terrible value']: |
| try: |
| raise ValueError(msg) |
| except ValueError as e: |
| e.add_note(f'the {msg}') |
| e.add_note(f'Goodbye {msg}') |
| excs.append(e) |
| raise ExceptionGroup("nested", excs) |
| except ExceptionGroup as e: |
| e.add_note(('>> Multi line note\n' |
| '>> Because I am such\n' |
| '>> an important exception.\n' |
| '>> empty lines work too\n' |
| '\n' |
| '(that was an empty line)')) |
| e.add_note('Goodbye!') |
| raise |
| |
| expected = (f' + Exception Group Traceback (most recent call last):\n' |
| f' | File "{__file__}", line {self.callable_line}, in get_exception\n' |
| f' | exception_or_callable()\n' |
| f' | File "{__file__}", line {exc.__code__.co_firstlineno + 10}, in exc\n' |
| f' | raise ExceptionGroup("nested", excs)\n' |
| f' | ExceptionGroup: nested (2 sub-exceptions)\n' |
| f' | >> Multi line note\n' |
| f' | >> Because I am such\n' |
| f' | >> an important exception.\n' |
| f' | >> empty lines work too\n' |
| f' | \n' |
| f' | (that was an empty line)\n' |
| f' | Goodbye!\n' |
| f' +-+---------------- 1 ----------------\n' |
| f' | Traceback (most recent call last):\n' |
| f' | File "{__file__}", line {exc.__code__.co_firstlineno + 5}, in exc\n' |
| f' | raise ValueError(msg)\n' |
| f' | ValueError: bad value\n' |
| f' | the bad value\n' |
| f' | Goodbye bad value\n' |
| f' +---------------- 2 ----------------\n' |
| f' | Traceback (most recent call last):\n' |
| f' | File "{__file__}", line {exc.__code__.co_firstlineno + 5}, in exc\n' |
| f' | raise ValueError(msg)\n' |
| f' | ValueError: terrible value\n' |
| f' | the terrible value\n' |
| f' | Goodbye terrible value\n' |
| f' +------------------------------------\n') |
| |
| report = self.get_report(exc) |
| self.assertEqual(report, expected) |
| |
| def test_KeyboardInterrupt_at_first_line_of_frame(self): |
| # see GH-93249 |
| def f(): |
| return sys._getframe() |
| |
| tb_next = None |
| frame = f() |
| lasti = 0 |
| lineno = f.__code__.co_firstlineno |
| tb = types.TracebackType(tb_next, frame, lasti, lineno) |
| |
| exc = KeyboardInterrupt() |
| exc.__traceback__ = tb |
| |
| expected = (f'Traceback (most recent call last):\n' |
| f' File "{__file__}", line {lineno}, in f\n' |
| f' def f():\n' |
| f'\n' |
| f'KeyboardInterrupt\n') |
| |
| report = self.get_report(exc) |
| # remove trailing writespace: |
| report = '\n'.join([l.rstrip() for l in report.split('\n')]) |
| self.assertEqual(report, expected) |
| |
| |
| class PyExcReportingTests(BaseExceptionReportingTests, unittest.TestCase): |
| # |
| # This checks reporting through the 'traceback' module, with both |
| # format_exception() and print_exception(). |
| # |
| |
| def get_report(self, e): |
| e = self.get_exception(e) |
| s = ''.join( |
| traceback.format_exception(type(e), e, e.__traceback__)) |
| with captured_output("stderr") as sio: |
| traceback.print_exception(type(e), e, e.__traceback__) |
| self.assertEqual(sio.getvalue(), s) |
| return s |
| |
| |
| class CExcReportingTests(BaseExceptionReportingTests, unittest.TestCase): |
| # |
| # This checks built-in reporting by the interpreter. |
| # |
| |
| @cpython_only |
| def get_report(self, e): |
| from _testcapi import exception_print |
| e = self.get_exception(e) |
| with captured_output("stderr") as s: |
| exception_print(e) |
| return s.getvalue() |
| |
| |
| class LimitTests(unittest.TestCase): |
| |
| ''' Tests for limit argument. |
| It's enough to test extact_tb, extract_stack and format_exception ''' |
| |
| def last_raises1(self): |
| raise Exception('Last raised') |
| |
| def last_raises2(self): |
| self.last_raises1() |
| |
| def last_raises3(self): |
| self.last_raises2() |
| |
| def last_raises4(self): |
| self.last_raises3() |
| |
| def last_raises5(self): |
| self.last_raises4() |
| |
| def last_returns_frame1(self): |
| return sys._getframe() |
| |
| def last_returns_frame2(self): |
| return self.last_returns_frame1() |
| |
| def last_returns_frame3(self): |
| return self.last_returns_frame2() |
| |
| def last_returns_frame4(self): |
| return self.last_returns_frame3() |
| |
| def last_returns_frame5(self): |
| return self.last_returns_frame4() |
| |
| def test_extract_stack(self): |
| frame = self.last_returns_frame5() |
| def extract(**kwargs): |
| return traceback.extract_stack(frame, **kwargs) |
| def assertEqualExcept(actual, expected, ignore): |
| self.assertEqual(actual[:ignore], expected[:ignore]) |
| self.assertEqual(actual[ignore+1:], expected[ignore+1:]) |
| self.assertEqual(len(actual), len(expected)) |
| |
| with support.swap_attr(sys, 'tracebacklimit', 1000): |
| nolim = extract() |
| self.assertGreater(len(nolim), 5) |
| self.assertEqual(extract(limit=2), nolim[-2:]) |
| assertEqualExcept(extract(limit=100), nolim[-100:], -5-1) |
| self.assertEqual(extract(limit=-2), nolim[:2]) |
| assertEqualExcept(extract(limit=-100), nolim[:100], len(nolim)-5-1) |
| self.assertEqual(extract(limit=0), []) |
| del sys.tracebacklimit |
| assertEqualExcept(extract(), nolim, -5-1) |
| sys.tracebacklimit = 2 |
| self.assertEqual(extract(), nolim[-2:]) |
| self.assertEqual(extract(limit=3), nolim[-3:]) |
| self.assertEqual(extract(limit=-3), nolim[:3]) |
| sys.tracebacklimit = 0 |
| self.assertEqual(extract(), []) |
| sys.tracebacklimit = -1 |
| self.assertEqual(extract(), []) |
| |
| def test_extract_tb(self): |
| try: |
| self.last_raises5() |
| except Exception: |
| exc_type, exc_value, tb = sys.exc_info() |
| def extract(**kwargs): |
| return traceback.extract_tb(tb, **kwargs) |
| |
| with support.swap_attr(sys, 'tracebacklimit', 1000): |
| nolim = extract() |
| self.assertEqual(len(nolim), 5+1) |
| self.assertEqual(extract(limit=2), nolim[:2]) |
| self.assertEqual(extract(limit=10), nolim) |
| self.assertEqual(extract(limit=-2), nolim[-2:]) |
| self.assertEqual(extract(limit=-10), nolim) |
| self.assertEqual(extract(limit=0), []) |
| del sys.tracebacklimit |
| self.assertEqual(extract(), nolim) |
| sys.tracebacklimit = 2 |
| self.assertEqual(extract(), nolim[:2]) |
| self.assertEqual(extract(limit=3), nolim[:3]) |
| self.assertEqual(extract(limit=-3), nolim[-3:]) |
| sys.tracebacklimit = 0 |
| self.assertEqual(extract(), []) |
| sys.tracebacklimit = -1 |
| self.assertEqual(extract(), []) |
| |
| def test_format_exception(self): |
| try: |
| self.last_raises5() |
| except Exception: |
| exc_type, exc_value, tb = sys.exc_info() |
| # [1:-1] to exclude "Traceback (...)" header and |
| # exception type and value |
| def extract(**kwargs): |
| return traceback.format_exception(exc_type, exc_value, tb, **kwargs)[1:-1] |
| |
| with support.swap_attr(sys, 'tracebacklimit', 1000): |
| nolim = extract() |
| self.assertEqual(len(nolim), 5+1) |
| self.assertEqual(extract(limit=2), nolim[:2]) |
| self.assertEqual(extract(limit=10), nolim) |
| self.assertEqual(extract(limit=-2), nolim[-2:]) |
| self.assertEqual(extract(limit=-10), nolim) |
| self.assertEqual(extract(limit=0), []) |
| del sys.tracebacklimit |
| self.assertEqual(extract(), nolim) |
| sys.tracebacklimit = 2 |
| self.assertEqual(extract(), nolim[:2]) |
| self.assertEqual(extract(limit=3), nolim[:3]) |
| self.assertEqual(extract(limit=-3), nolim[-3:]) |
| sys.tracebacklimit = 0 |
| self.assertEqual(extract(), []) |
| sys.tracebacklimit = -1 |
| self.assertEqual(extract(), []) |
| |
| |
| class MiscTracebackCases(unittest.TestCase): |
| # |
| # Check non-printing functions in traceback module |
| # |
| |
| def test_clear(self): |
| def outer(): |
| middle() |
| def middle(): |
| inner() |
| def inner(): |
| i = 1 |
| 1/0 |
| |
| try: |
| outer() |
| except: |
| type_, value, tb = sys.exc_info() |
| |
| # Initial assertion: there's one local in the inner frame. |
| inner_frame = tb.tb_next.tb_next.tb_next.tb_frame |
| self.assertEqual(len(inner_frame.f_locals), 1) |
| |
| # Clear traceback frames |
| traceback.clear_frames(tb) |
| |
| # Local variable dict should now be empty. |
| self.assertEqual(len(inner_frame.f_locals), 0) |
| |
| def test_extract_stack(self): |
| def extract(): |
| return traceback.extract_stack() |
| result = extract() |
| lineno = extract.__code__.co_firstlineno |
| self.assertEqual(result[-2:], [ |
| (__file__, lineno+2, 'test_extract_stack', 'result = extract()'), |
| (__file__, lineno+1, 'extract', 'return traceback.extract_stack()'), |
| ]) |
| self.assertEqual(len(result[0]), 4) |
| |
| |
| class TestFrame(unittest.TestCase): |
| |
| def test_basics(self): |
| linecache.clearcache() |
| linecache.lazycache("f", globals()) |
| f = traceback.FrameSummary("f", 1, "dummy") |
| self.assertEqual(f, |
| ("f", 1, "dummy", '"""Test cases for traceback module"""')) |
| self.assertEqual(tuple(f), |
| ("f", 1, "dummy", '"""Test cases for traceback module"""')) |
| self.assertEqual(f, traceback.FrameSummary("f", 1, "dummy")) |
| self.assertEqual(f, tuple(f)) |
| # Since tuple.__eq__ doesn't support FrameSummary, the equality |
| # operator fallbacks to FrameSummary.__eq__. |
| self.assertEqual(tuple(f), f) |
| self.assertIsNone(f.locals) |
| self.assertNotEqual(f, object()) |
| self.assertEqual(f, ALWAYS_EQ) |
| |
| def test_lazy_lines(self): |
| linecache.clearcache() |
| f = traceback.FrameSummary("f", 1, "dummy", lookup_line=False) |
| self.assertEqual(None, f._line) |
| linecache.lazycache("f", globals()) |
| self.assertEqual( |
| '"""Test cases for traceback module"""', |
| f.line) |
| |
| def test_no_line(self): |
| f = traceback.FrameSummary("f", None, "dummy") |
| self.assertEqual(f.line, None) |
| |
| def test_explicit_line(self): |
| f = traceback.FrameSummary("f", 1, "dummy", line="line") |
| self.assertEqual("line", f.line) |
| |
| def test_len(self): |
| f = traceback.FrameSummary("f", 1, "dummy", line="line") |
| self.assertEqual(len(f), 4) |
| |
| |
| class TestStack(unittest.TestCase): |
| |
| def test_walk_stack(self): |
| def deeper(): |
| return list(traceback.walk_stack(None)) |
| s1 = list(traceback.walk_stack(None)) |
| s2 = deeper() |
| self.assertEqual(len(s2) - len(s1), 1) |
| self.assertEqual(s2[1:], s1) |
| |
| def test_walk_tb(self): |
| try: |
| 1/0 |
| except Exception: |
| _, _, tb = sys.exc_info() |
| s = list(traceback.walk_tb(tb)) |
| self.assertEqual(len(s), 1) |
| |
| def test_extract_stack(self): |
| s = traceback.StackSummary.extract(traceback.walk_stack(None)) |
| self.assertIsInstance(s, traceback.StackSummary) |
| |
| def test_extract_stack_limit(self): |
| s = traceback.StackSummary.extract(traceback.walk_stack(None), limit=5) |
| self.assertEqual(len(s), 5) |
| |
| def test_extract_stack_lookup_lines(self): |
| linecache.clearcache() |
| linecache.updatecache('/foo.py', globals()) |
| c = test_code('/foo.py', 'method') |
| f = test_frame(c, None, None) |
| s = traceback.StackSummary.extract(iter([(f, 6)]), lookup_lines=True) |
| linecache.clearcache() |
| self.assertEqual(s[0].line, "import sys") |
| |
| def test_extract_stackup_deferred_lookup_lines(self): |
| linecache.clearcache() |
| c = test_code('/foo.py', 'method') |
| f = test_frame(c, None, None) |
| s = traceback.StackSummary.extract(iter([(f, 6)]), lookup_lines=False) |
| self.assertEqual({}, linecache.cache) |
| linecache.updatecache('/foo.py', globals()) |
| self.assertEqual(s[0].line, "import sys") |
| |
| def test_from_list(self): |
| s = traceback.StackSummary.from_list([('foo.py', 1, 'fred', 'line')]) |
| self.assertEqual( |
| [' File "foo.py", line 1, in fred\n line\n'], |
| s.format()) |
| |
| def test_from_list_edited_stack(self): |
| s = traceback.StackSummary.from_list([('foo.py', 1, 'fred', 'line')]) |
| s[0] = ('foo.py', 2, 'fred', 'line') |
| s2 = traceback.StackSummary.from_list(s) |
| self.assertEqual( |
| [' File "foo.py", line 2, in fred\n line\n'], |
| s2.format()) |
| |
| def test_format_smoke(self): |
| # For detailed tests see the format_list tests, which consume the same |
| # code. |
| s = traceback.StackSummary.from_list([('foo.py', 1, 'fred', 'line')]) |
| self.assertEqual( |
| [' File "foo.py", line 1, in fred\n line\n'], |
| s.format()) |
| |
| def test_locals(self): |
| linecache.updatecache('/foo.py', globals()) |
| c = test_code('/foo.py', 'method') |
| f = test_frame(c, globals(), {'something': 1}) |
| s = traceback.StackSummary.extract(iter([(f, 6)]), capture_locals=True) |
| self.assertEqual(s[0].locals, {'something': '1'}) |
| |
| def test_no_locals(self): |
| linecache.updatecache('/foo.py', globals()) |
| c = test_code('/foo.py', 'method') |
| f = test_frame(c, globals(), {'something': 1}) |
| s = traceback.StackSummary.extract(iter([(f, 6)])) |
| self.assertEqual(s[0].locals, None) |
| |
| def test_format_locals(self): |
| def some_inner(k, v): |
| a = 1 |
| b = 2 |
| return traceback.StackSummary.extract( |
| traceback.walk_stack(None), capture_locals=True, limit=1) |
| s = some_inner(3, 4) |
| self.assertEqual( |
| [' File "%s", line %d, in some_inner\n' |
| ' return traceback.StackSummary.extract(\n' |
| ' a = 1\n' |
| ' b = 2\n' |
| ' k = 3\n' |
| ' v = 4\n' % (__file__, some_inner.__code__.co_firstlineno + 3) |
| ], s.format()) |
| |
| def test_custom_format_frame(self): |
| class CustomStackSummary(traceback.StackSummary): |
| def format_frame_summary(self, frame_summary): |
| return f'{frame_summary.filename}:{frame_summary.lineno}' |
| |
| def some_inner(): |
| return CustomStackSummary.extract( |
| traceback.walk_stack(None), limit=1) |
| |
| s = some_inner() |
| self.assertEqual( |
| s.format(), |
| [f'{__file__}:{some_inner.__code__.co_firstlineno + 1}']) |
| |
| def test_dropping_frames(self): |
| def f(): |
| 1/0 |
| |
| def g(): |
| try: |
| f() |
| except: |
| return sys.exc_info() |
| |
| exc_info = g() |
| |
| class Skip_G(traceback.StackSummary): |
| def format_frame_summary(self, frame_summary): |
| if frame_summary.name == 'g': |
| return None |
| return super().format_frame_summary(frame_summary) |
| |
| stack = Skip_G.extract( |
| traceback.walk_tb(exc_info[2])).format() |
| |
| self.assertEqual(len(stack), 1) |
| lno = f.__code__.co_firstlineno + 1 |
| self.assertEqual( |
| stack[0], |
| f' File "{__file__}", line {lno}, in f\n 1/0\n' |
| ) |
| |
| |
| class TestTracebackException(unittest.TestCase): |
| |
| def test_smoke(self): |
| try: |
| 1/0 |
| except Exception: |
| exc_info = sys.exc_info() |
| exc = traceback.TracebackException(*exc_info) |
| expected_stack = traceback.StackSummary.extract( |
| traceback.walk_tb(exc_info[2])) |
| self.assertEqual(None, exc.__cause__) |
| self.assertEqual(None, exc.__context__) |
| self.assertEqual(False, exc.__suppress_context__) |
| self.assertEqual(expected_stack, exc.stack) |
| self.assertEqual(exc_info[0], exc.exc_type) |
| self.assertEqual(str(exc_info[1]), str(exc)) |
| |
| def test_from_exception(self): |
| # Check all the parameters are accepted. |
| def foo(): |
| 1/0 |
| try: |
| foo() |
| except Exception as e: |
| exc_info = sys.exc_info() |
| self.expected_stack = traceback.StackSummary.extract( |
| traceback.walk_tb(exc_info[2]), limit=1, lookup_lines=False, |
| capture_locals=True) |
| self.exc = traceback.TracebackException.from_exception( |
| e, limit=1, lookup_lines=False, capture_locals=True) |
| expected_stack = self.expected_stack |
| exc = self.exc |
| self.assertEqual(None, exc.__cause__) |
| self.assertEqual(None, exc.__context__) |
| self.assertEqual(False, exc.__suppress_context__) |
| self.assertEqual(expected_stack, exc.stack) |
| self.assertEqual(exc_info[0], exc.exc_type) |
| self.assertEqual(str(exc_info[1]), str(exc)) |
| |
| def test_cause(self): |
| try: |
| try: |
| 1/0 |
| finally: |
| exc_info_context = sys.exc_info() |
| exc_context = traceback.TracebackException(*exc_info_context) |
| cause = Exception("cause") |
| raise Exception("uh oh") from cause |
| except Exception: |
| exc_info = sys.exc_info() |
| exc = traceback.TracebackException(*exc_info) |
| expected_stack = traceback.StackSummary.extract( |
| traceback.walk_tb(exc_info[2])) |
| exc_cause = traceback.TracebackException(Exception, cause, None) |
| self.assertEqual(exc_cause, exc.__cause__) |
| self.assertEqual(exc_context, exc.__context__) |
| self.assertEqual(True, exc.__suppress_context__) |
| self.assertEqual(expected_stack, exc.stack) |
| self.assertEqual(exc_info[0], exc.exc_type) |
| self.assertEqual(str(exc_info[1]), str(exc)) |
| |
| def test_context(self): |
| try: |
| try: |
| 1/0 |
| finally: |
| exc_info_context = sys.exc_info() |
| exc_context = traceback.TracebackException(*exc_info_context) |
| raise Exception("uh oh") |
| except Exception: |
| exc_info = sys.exc_info() |
| exc = traceback.TracebackException(*exc_info) |
| expected_stack = traceback.StackSummary.extract( |
| traceback.walk_tb(exc_info[2])) |
| self.assertEqual(None, exc.__cause__) |
| self.assertEqual(exc_context, exc.__context__) |
| self.assertEqual(False, exc.__suppress_context__) |
| self.assertEqual(expected_stack, exc.stack) |
| self.assertEqual(exc_info[0], exc.exc_type) |
| self.assertEqual(str(exc_info[1]), str(exc)) |
| |
| def test_long_context_chain(self): |
| def f(): |
| try: |
| 1/0 |
| except: |
| f() |
| |
| try: |
| f() |
| except RecursionError: |
| exc_info = sys.exc_info() |
| else: |
| self.fail("Exception not raised") |
| |
| te = traceback.TracebackException(*exc_info) |
| res = list(te.format()) |
| |
| # many ZeroDiv errors followed by the RecursionError |
| self.assertGreater(len(res), sys.getrecursionlimit()) |
| self.assertGreater( |
| len([l for l in res if 'ZeroDivisionError:' in l]), |
| sys.getrecursionlimit() * 0.5) |
| self.assertIn( |
| "RecursionError: maximum recursion depth exceeded", res[-1]) |
| |
| def test_compact_with_cause(self): |
| try: |
| try: |
| 1/0 |
| finally: |
| cause = Exception("cause") |
| raise Exception("uh oh") from cause |
| except Exception: |
| exc_info = sys.exc_info() |
| exc = traceback.TracebackException(*exc_info, compact=True) |
| expected_stack = traceback.StackSummary.extract( |
| traceback.walk_tb(exc_info[2])) |
| exc_cause = traceback.TracebackException(Exception, cause, None) |
| self.assertEqual(exc_cause, exc.__cause__) |
| self.assertEqual(None, exc.__context__) |
| self.assertEqual(True, exc.__suppress_context__) |
| self.assertEqual(expected_stack, exc.stack) |
| self.assertEqual(exc_info[0], exc.exc_type) |
| self.assertEqual(str(exc_info[1]), str(exc)) |
| |
| def test_compact_no_cause(self): |
| try: |
| try: |
| 1/0 |
| finally: |
| exc_info_context = sys.exc_info() |
| exc_context = traceback.TracebackException(*exc_info_context) |
| raise Exception("uh oh") |
| except Exception: |
| exc_info = sys.exc_info() |
| exc = traceback.TracebackException(*exc_info, compact=True) |
| expected_stack = traceback.StackSummary.extract( |
| traceback.walk_tb(exc_info[2])) |
| self.assertEqual(None, exc.__cause__) |
| self.assertEqual(exc_context, exc.__context__) |
| self.assertEqual(False, exc.__suppress_context__) |
| self.assertEqual(expected_stack, exc.stack) |
| self.assertEqual(exc_info[0], exc.exc_type) |
| self.assertEqual(str(exc_info[1]), str(exc)) |
| |
| def test_no_refs_to_exception_and_traceback_objects(self): |
| try: |
| 1/0 |
| except Exception: |
| exc_info = sys.exc_info() |
| |
| refcnt1 = sys.getrefcount(exc_info[1]) |
| refcnt2 = sys.getrefcount(exc_info[2]) |
| exc = traceback.TracebackException(*exc_info) |
| self.assertEqual(sys.getrefcount(exc_info[1]), refcnt1) |
| self.assertEqual(sys.getrefcount(exc_info[2]), refcnt2) |
| |
| def test_comparison_basic(self): |
| try: |
| 1/0 |
| except Exception: |
| exc_info = sys.exc_info() |
| exc = traceback.TracebackException(*exc_info) |
| exc2 = traceback.TracebackException(*exc_info) |
| self.assertIsNot(exc, exc2) |
| self.assertEqual(exc, exc2) |
| self.assertNotEqual(exc, object()) |
| self.assertEqual(exc, ALWAYS_EQ) |
| |
| def test_comparison_params_variations(self): |
| def raise_exc(): |
| try: |
| raise ValueError('bad value') |
| except: |
| raise |
| |
| def raise_with_locals(): |
| x, y = 1, 2 |
| raise_exc() |
| |
| try: |
| raise_with_locals() |
| except Exception: |
| exc_info = sys.exc_info() |
| |
| exc = traceback.TracebackException(*exc_info) |
| exc1 = traceback.TracebackException(*exc_info, limit=10) |
| exc2 = traceback.TracebackException(*exc_info, limit=2) |
| |
| self.assertEqual(exc, exc1) # limit=10 gets all frames |
| self.assertNotEqual(exc, exc2) # limit=2 truncates the output |
| |
| # locals change the output |
| exc3 = traceback.TracebackException(*exc_info, capture_locals=True) |
| self.assertNotEqual(exc, exc3) |
| |
| # there are no locals in the innermost frame |
| exc4 = traceback.TracebackException(*exc_info, limit=-1) |
| exc5 = traceback.TracebackException(*exc_info, limit=-1, capture_locals=True) |
| self.assertEqual(exc4, exc5) |
| |
| # there are locals in the next-to-innermost frame |
| exc6 = traceback.TracebackException(*exc_info, limit=-2) |
| exc7 = traceback.TracebackException(*exc_info, limit=-2, capture_locals=True) |
| self.assertNotEqual(exc6, exc7) |
| |
| def test_comparison_equivalent_exceptions_are_equal(self): |
| excs = [] |
| for _ in range(2): |
| try: |
| 1/0 |
| except: |
| excs.append(traceback.TracebackException(*sys.exc_info())) |
| self.assertEqual(excs[0], excs[1]) |
| self.assertEqual(list(excs[0].format()), list(excs[1].format())) |
| |
| def test_unhashable(self): |
| class UnhashableException(Exception): |
| def __eq__(self, other): |
| return True |
| |
| ex1 = UnhashableException('ex1') |
| ex2 = UnhashableException('ex2') |
| try: |
| raise ex2 from ex1 |
| except UnhashableException: |
| try: |
| raise ex1 |
| except UnhashableException: |
| exc_info = sys.exc_info() |
| exc = traceback.TracebackException(*exc_info) |
| formatted = list(exc.format()) |
| self.assertIn('UnhashableException: ex2\n', formatted[2]) |
| self.assertIn('UnhashableException: ex1\n', formatted[6]) |
| |
| def test_limit(self): |
| def recurse(n): |
| if n: |
| recurse(n-1) |
| else: |
| 1/0 |
| try: |
| recurse(10) |
| except Exception: |
| exc_info = sys.exc_info() |
| exc = traceback.TracebackException(*exc_info, limit=5) |
| expected_stack = traceback.StackSummary.extract( |
| traceback.walk_tb(exc_info[2]), limit=5) |
| self.assertEqual(expected_stack, exc.stack) |
| |
| def test_lookup_lines(self): |
| linecache.clearcache() |
| e = Exception("uh oh") |
| c = test_code('/foo.py', 'method') |
| f = test_frame(c, None, None) |
| tb = test_tb(f, 6, None, 0) |
| exc = traceback.TracebackException(Exception, e, tb, lookup_lines=False) |
| self.assertEqual(linecache.cache, {}) |
| linecache.updatecache('/foo.py', globals()) |
| self.assertEqual(exc.stack[0].line, "import sys") |
| |
| def test_locals(self): |
| linecache.updatecache('/foo.py', globals()) |
| e = Exception("uh oh") |
| c = test_code('/foo.py', 'method') |
| f = test_frame(c, globals(), {'something': 1, 'other': 'string'}) |
| tb = test_tb(f, 6, None, 0) |
| exc = traceback.TracebackException( |
| Exception, e, tb, capture_locals=True) |
| self.assertEqual( |
| exc.stack[0].locals, {'something': '1', 'other': "'string'"}) |
| |
| def test_no_locals(self): |
| linecache.updatecache('/foo.py', globals()) |
| e = Exception("uh oh") |
| c = test_code('/foo.py', 'method') |
| f = test_frame(c, globals(), {'something': 1}) |
| tb = test_tb(f, 6, None, 0) |
| exc = traceback.TracebackException(Exception, e, tb) |
| self.assertEqual(exc.stack[0].locals, None) |
| |
| def test_traceback_header(self): |
| # do not print a traceback header if exc_traceback is None |
| # see issue #24695 |
| exc = traceback.TracebackException(Exception, Exception("haven"), None) |
| self.assertEqual(list(exc.format()), ["Exception: haven\n"]) |
| |
| @requires_debug_ranges() |
| def test_print(self): |
| def f(): |
| x = 12 |
| try: |
| x/0 |
| except Exception: |
| return sys.exc_info() |
| exc = traceback.TracebackException(*f(), capture_locals=True) |
| output = StringIO() |
| exc.print(file=output) |
| self.assertEqual( |
| output.getvalue().split('\n')[-5:], |
| [' x/0', |
| ' ~^~', |
| ' x = 12', |
| 'ZeroDivisionError: division by zero', |
| '']) |
| |
| |
| class TestTracebackException_ExceptionGroups(unittest.TestCase): |
| def setUp(self): |
| super().setUp() |
| self.eg_info = self._get_exception_group() |
| |
| def _get_exception_group(self): |
| def f(): |
| 1/0 |
| |
| def g(v): |
| raise ValueError(v) |
| |
| self.lno_f = f.__code__.co_firstlineno |
| self.lno_g = g.__code__.co_firstlineno |
| |
| try: |
| try: |
| try: |
| f() |
| except Exception as e: |
| exc1 = e |
| try: |
| g(42) |
| except Exception as e: |
| exc2 = e |
| raise ExceptionGroup("eg1", [exc1, exc2]) |
| except ExceptionGroup as e: |
| exc3 = e |
| try: |
| g(24) |
| except Exception as e: |
| exc4 = e |
| raise ExceptionGroup("eg2", [exc3, exc4]) |
| except ExceptionGroup: |
| return sys.exc_info() |
| self.fail('Exception Not Raised') |
| |
| def test_exception_group_construction(self): |
| eg_info = self.eg_info |
| teg1 = traceback.TracebackException(*eg_info) |
| teg2 = traceback.TracebackException.from_exception(eg_info[1]) |
| self.assertIsNot(teg1, teg2) |
| self.assertEqual(teg1, teg2) |
| |
| def test_exception_group_format_exception_only(self): |
| teg = traceback.TracebackException(*self.eg_info) |
| formatted = ''.join(teg.format_exception_only()).split('\n') |
| expected = "ExceptionGroup: eg2 (2 sub-exceptions)\n".split('\n') |
| |
| self.assertEqual(formatted, expected) |
| |
| def test_exception_group_format(self): |
| teg = traceback.TracebackException(*self.eg_info) |
| |
| formatted = ''.join(teg.format()).split('\n') |
| lno_f = self.lno_f |
| lno_g = self.lno_g |
| |
| expected = [ |
| f' + Exception Group Traceback (most recent call last):', |
| f' | File "{__file__}", line {lno_g+23}, in _get_exception_group', |
| f' | raise ExceptionGroup("eg2", [exc3, exc4])', |
| f' | ExceptionGroup: eg2 (2 sub-exceptions)', |
| f' +-+---------------- 1 ----------------', |
| f' | Exception Group Traceback (most recent call last):', |
| f' | File "{__file__}", line {lno_g+16}, in _get_exception_group', |
| f' | raise ExceptionGroup("eg1", [exc1, exc2])', |
| f' | ExceptionGroup: eg1 (2 sub-exceptions)', |
| f' +-+---------------- 1 ----------------', |
| f' | Traceback (most recent call last):', |
| f' | File "{__file__}", line {lno_g+9}, in _get_exception_group', |
| f' | f()', |
| f' | File "{__file__}", line {lno_f+1}, in f', |
| f' | 1/0', |
| f' | ~^~', |
| f' | ZeroDivisionError: division by zero', |
| f' +---------------- 2 ----------------', |
| f' | Traceback (most recent call last):', |
| f' | File "{__file__}", line {lno_g+13}, in _get_exception_group', |
| f' | g(42)', |
| f' | File "{__file__}", line {lno_g+1}, in g', |
| f' | raise ValueError(v)', |
| f' | ValueError: 42', |
| f' +------------------------------------', |
| f' +---------------- 2 ----------------', |
| f' | Traceback (most recent call last):', |
| f' | File "{__file__}", line {lno_g+20}, in _get_exception_group', |
| f' | g(24)', |
| f' | File "{__file__}", line {lno_g+1}, in g', |
| f' | raise ValueError(v)', |
| f' | ValueError: 24', |
| f' +------------------------------------', |
| f''] |
| |
| self.assertEqual(formatted, expected) |
| |
| def test_max_group_width(self): |
| excs1 = [] |
| excs2 = [] |
| for i in range(3): |
| excs1.append(ValueError(i)) |
| for i in range(10): |
| excs2.append(TypeError(i)) |
| |
| EG = ExceptionGroup |
| eg = EG('eg', [EG('eg1', excs1), EG('eg2', excs2)]) |
| |
| teg = traceback.TracebackException.from_exception(eg, max_group_width=2) |
| formatted = ''.join(teg.format()).split('\n') |
| |
| expected = [ |
| f' | ExceptionGroup: eg (2 sub-exceptions)', |
| f' +-+---------------- 1 ----------------', |
| f' | ExceptionGroup: eg1 (3 sub-exceptions)', |
| f' +-+---------------- 1 ----------------', |
| f' | ValueError: 0', |
| f' +---------------- 2 ----------------', |
| f' | ValueError: 1', |
| f' +---------------- ... ----------------', |
| f' | and 1 more exception', |
| f' +------------------------------------', |
| f' +---------------- 2 ----------------', |
| f' | ExceptionGroup: eg2 (10 sub-exceptions)', |
| f' +-+---------------- 1 ----------------', |
| f' | TypeError: 0', |
| f' +---------------- 2 ----------------', |
| f' | TypeError: 1', |
| f' +---------------- ... ----------------', |
| f' | and 8 more exceptions', |
| f' +------------------------------------', |
| f''] |
| |
| self.assertEqual(formatted, expected) |
| |
| def test_max_group_depth(self): |
| exc = TypeError('bad type') |
| for i in range(3): |
| exc = ExceptionGroup('exc', [ValueError(-i), exc, ValueError(i)]) |
| |
| teg = traceback.TracebackException.from_exception(exc, max_group_depth=2) |
| formatted = ''.join(teg.format()).split('\n') |
| |
| expected = [ |
| f' | ExceptionGroup: exc (3 sub-exceptions)', |
| f' +-+---------------- 1 ----------------', |
| f' | ValueError: -2', |
| f' +---------------- 2 ----------------', |
| f' | ExceptionGroup: exc (3 sub-exceptions)', |
| f' +-+---------------- 1 ----------------', |
| f' | ValueError: -1', |
| f' +---------------- 2 ----------------', |
| f' | ... (max_group_depth is 2)', |
| f' +---------------- 3 ----------------', |
| f' | ValueError: 1', |
| f' +------------------------------------', |
| f' +---------------- 3 ----------------', |
| f' | ValueError: 2', |
| f' +------------------------------------', |
| f''] |
| |
| self.assertEqual(formatted, expected) |
| |
| def test_comparison(self): |
| try: |
| raise self.eg_info[1] |
| except ExceptionGroup: |
| exc_info = sys.exc_info() |
| for _ in range(5): |
| try: |
| raise exc_info[1] |
| except: |
| exc_info = sys.exc_info() |
| exc = traceback.TracebackException(*exc_info) |
| exc2 = traceback.TracebackException(*exc_info) |
| exc3 = traceback.TracebackException(*exc_info, limit=300) |
| ne = traceback.TracebackException(*exc_info, limit=3) |
| self.assertIsNot(exc, exc2) |
| self.assertEqual(exc, exc2) |
| self.assertEqual(exc, exc3) |
| self.assertNotEqual(exc, ne) |
| self.assertNotEqual(exc, object()) |
| self.assertEqual(exc, ALWAYS_EQ) |
| |
| |
| class MiscTest(unittest.TestCase): |
| |
| def test_all(self): |
| expected = set() |
| denylist = {'print_list'} |
| for name in dir(traceback): |
| if name.startswith('_') or name in denylist: |
| continue |
| module_object = getattr(traceback, name) |
| if getattr(module_object, '__module__', None) == 'traceback': |
| expected.add(name) |
| self.assertCountEqual(traceback.__all__, expected) |
| |
| |
| if __name__ == "__main__": |
| unittest.main() |
