# 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("""

""")

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("""

""")

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:

""".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("""

""")

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)),

def get_exception(self, callable, slice_start=0, slice_end=-1):

try:

callable()

self.fail("No exception thrown.")

except:

return traceback.format_exc().splitlines()[slice_start:slice_end]

LEGACY = 0

def get_exception(self, callable, slice_start=0, slice_end=-1):

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, self.LEGACY)

return tbstderr.getvalue().splitlines()[slice_start:slice_end]

"""

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 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 = [

"Traceback (most recent call last):",

f" File \"{__file__}\", line {self.callable_line}, in get_exception",

" callable()",

f" File \"{__file__}\", line {f.__code__.co_firstlineno + 2}, in f",

" .method",

" ^^^^^^",

]

self.assertEqual(actual, expected)

def test_multiline_method_call_b(self):

def f():

(None.

method

)()

actual = self.get_exception(f)

expected = [

"Traceback (most recent call last):",

f" File \"{__file__}\", line {self.callable_line}, in get_exception",

" callable()",

f" File \"{__file__}\", line {f.__code__.co_firstlineno + 2}, in f",

" method",

]

self.assertEqual(actual, expected)

def test_multiline_method_call_c(self):

def f():

(None

. method

)()

actual = self.get_exception(f)

expected = [

"Traceback (most recent call last):",

f" File \"{__file__}\", line {self.callable_line}, in get_exception",

" callable()",

f" File \"{__file__}\", line {f.__code__.co_firstlineno + 2}, in f",

" . method",

" ^^^^^^",

]

self.assertEqual(actual, expected)

def test_wide_characters_unicode_with_problematic_byte_offset(self):

def f():

ｗｉｄｔｈ

actual = self.get_exception(f)

expected = [

"Traceback (most recent call last):",

f" File \"{__file__}\", line {self.callable_line}, in get_exception",

" callable()",

f" File \"{__file__}\", line {f.__code__.co_firstlineno + 1}, in 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 = [

"Traceback (most recent call last):",

f" File \"{__file__}\", line {self.callable_line}, in get_exception",

" callable()",

f" File \"{__file__}\", line {f.__code__.co_firstlineno + 2}, in 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 = [

"Traceback (most recent call last):",

f" File \"{__file__}\", line {self.callable_line}, in get_exception",

" callable()",

f" File \"{__file__}\", line {f.__code__.co_firstlineno + 4}, in f",

" print(1, ｗｗｗ(",

" ^^^^",

]

PurePythonExceptionFormattingMixin,

TracebackErrorLocationCaretTestBase,

unittest.TestCase,

):

"""

CAPIExceptionFormattingMixin,

TracebackErrorLocationCaretTestBase,

unittest.TestCase,

):

"""

CAPIExceptionFormattingLegacyMixin,

TracebackErrorLocationCaretTestBase,

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 as e:

tb = e.__traceback__

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))