# 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 setUp(self):

super().setUp()

self.colorize = _colorize.COLORIZE

_colorize.COLORIZE = False

def tearDown(self):

super().tearDown()

_colorize.COLORIZE = self.colorize

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 syntax_error_with_caret_wide_char(self):

compile("女女女=1; 女女女/", "?", "exec")

def syntax_error_with_caret_wide_char_range(self):

compile("f(x, 女女女 for 女女女 in range(30), z)", "?", "exec")

def test_caret(self):

err = self.get_exception_format(self.syntax_error_with_caret,

SyntaxError)

self.assertEqual(len(err), 4)

self.assertEqual(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_caret_wide_char(self):

err = self.get_exception_format(self.syntax_error_with_caret_wide_char,

SyntaxError)

self.assertIn("^", err[2])

# "女女女=1; 女女女/" has display width 17

self.assertEqual(err[2].find("^"), 4 + 17)

err = self.get_exception_format(self.syntax_error_with_caret_wide_char_range,

SyntaxError)

self.assertIn("^", err[2])

self.assertEqual(err[2].find("^"), 4 + 5)

# "女女女 for 女女女 in range(30)" has display width 30

self.assertEqual(err[2].count("^"), 30)

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

@force_not_colorized

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

def test_format_exception_group_without_show_group(self):

eg = ExceptionGroup('A', [ValueError('B')])

err = traceback.format_exception_only(eg)

self.assertEqual(err, ['ExceptionGroup: A (1 sub-exception)\n'])

def test_format_exception_group(self):

eg = ExceptionGroup('A', [ValueError('B')])

err = traceback.format_exception_only(eg, show_group=True)

self.assertEqual(err, [

'ExceptionGroup: A (1 sub-exception)\n',

' ValueError: B\n',

])

def test_format_base_exception_group(self):

eg = BaseExceptionGroup('A', [BaseException('B')])

err = traceback.format_exception_only(eg, show_group=True)

self.assertEqual(err, [

'BaseExceptionGroup: A (1 sub-exception)\n',

' BaseException: B\n',

])

def test_format_exception_group_with_note(self):

exc = ValueError('B')

exc.add_note('Note')

eg = ExceptionGroup('A', [exc])

err = traceback.format_exception_only(eg, show_group=True)

self.assertEqual(err, [

'ExceptionGroup: A (1 sub-exception)\n',

' ValueError: B\n',

' Note\n',

])

def test_format_exception_group_explicit_class(self):

eg = ExceptionGroup('A', [ValueError('B')])

err = traceback.format_exception_only(ExceptionGroup, eg, show_group=True)

self.assertEqual(err, [

'ExceptionGroup: A (1 sub-exception)\n',

' ValueError: B\n',

])

def test_format_exception_group_multiple_exceptions(self):

eg = ExceptionGroup('A', [ValueError('B'), TypeError('C')])

err = traceback.format_exception_only(eg, show_group=True)

self.assertEqual(err, [

'ExceptionGroup: A (2 sub-exceptions)\n',

' ValueError: B\n',

' TypeError: C\n',

])

def test_format_exception_group_multiline_messages(self):

eg = ExceptionGroup('A\n1', [ValueError('B\n2')])

err = traceback.format_exception_only(eg, show_group=True)

self.assertEqual(err, [

'ExceptionGroup: A\n1 (1 sub-exception)\n',

' ValueError: B\n',

' 2\n',

])

def test_format_exception_group_multiline2_messages(self):

exc = ValueError('B\n\n2\n')

exc.add_note('\nC\n\n3')

eg = ExceptionGroup('A\n\n1\n', [exc, IndexError('D')])

err = traceback.format_exception_only(eg, show_group=True)

self.assertEqual(err, [

'ExceptionGroup: A\n\n1\n (2 sub-exceptions)\n',

' ValueError: B\n',

' \n',

' 2\n',

' \n',

' \n', # first char of `note`

' C\n',

' \n',

' 3\n', # note ends

' IndexError: D\n',

])

def test_format_exception_group_syntax_error(self):

exc = SyntaxError("error", ("x.py", 23, None, "bad syntax"))

eg = ExceptionGroup('A\n1', [exc])

err = traceback.format_exception_only(eg, show_group=True)

self.assertEqual(err, [

'ExceptionGroup: A\n1 (1 sub-exception)\n',

' File "x.py", line 23\n',

' bad syntax\n',

' SyntaxError: error\n',

])

def test_format_exception_group_nested_with_notes(self):

exc = IndexError('D')

exc.add_note('Note\nmultiline')

eg = ExceptionGroup('A', [

ValueError('B'),

ExceptionGroup('C', [exc, LookupError('E')]),

TypeError('F'),

])

err = traceback.format_exception_only(eg, show_group=True)

self.assertEqual(err, [

'ExceptionGroup: A (3 sub-exceptions)\n',

' ValueError: B\n',

' ExceptionGroup: C (2 sub-exceptions)\n',

' IndexError: D\n',

' Note\n',

' multiline\n',

' LookupError: E\n',

' TypeError: F\n',

])

def test_format_exception_group_with_tracebacks(self):

def f():

try:

1 / 0

except ZeroDivisionError as e:

return e

def g():

try:

raise TypeError('g')

except TypeError as e:

return e

eg = ExceptionGroup('A', [

f(),

ExceptionGroup('B', [g()]),

])

err = traceback.format_exception_only(eg, show_group=True)

self.assertEqual(err, [

'ExceptionGroup: A (2 sub-exceptions)\n',

' ZeroDivisionError: division by zero\n',

' ExceptionGroup: B (1 sub-exception)\n',

' TypeError: g\n',

])

def test_format_exception_group_with_cause(self):

def f():

try:

try:

1 / 0

except ZeroDivisionError:

raise ValueError(0)

except Exception as e:

return e

eg = ExceptionGroup('A', [f()])

err = traceback.format_exception_only(eg, show_group=True)

self.assertEqual(err, [

'ExceptionGroup: A (1 sub-exception)\n',

' ValueError: 0\n',

])

def test_format_exception_group_syntax_error_with_custom_values(self):

# See https://github.com/python/cpython/issues/128894

for exc in [

SyntaxError('error', 'abcd'),

SyntaxError('error', [None] * 4),

SyntaxError('error', (1, 2, 3, 4)),

SyntaxError('error', (1, 2, 3, 4)),

SyntaxError('error', (1, 'a', 'b', 2)),

# with end_lineno and end_offset:

SyntaxError('error', 'abcdef'),

SyntaxError('error', [None] * 6),

SyntaxError('error', (1, 2, 3, 4, 5, 6)),

SyntaxError('error', (1, 'a', 'b', 2, 'c', 'd')),

]:

with self.subTest(exc=exc):

err = traceback.format_exception_only(exc, show_group=True)

# Should not raise an exception:

if exc.lineno is not None:

self.assertEqual(len(err), 2)

self.assertTrue(err[0].startswith(' File'))

else:

self.assertEqual(len(err), 1)

self.assertEqual(err[-1], 'SyntaxError: error\n')

@requires_subprocess()

@force_not_colorized

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

self.assertEndsWith(stdout[2], err_line)

actual_err_msg = stdout[3]

self.assertEqual(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' x = 1 / 0',

b' ^^^^^',

b'ZeroDivisionError: division by zero']

self.assertEqual(stderr.splitlines(), expected)

@cpython_only

def test_lost_io_open(self):

# GH-142737: Display the traceback even if io.open is lost

crasher = textwrap.dedent("""\

""")

# Create a temporary script to exercise _Py_FindSourceFile

with temp_dir() as script_dir:

script = make_script(

script_dir=script_dir,

script_basename='tb_test_no_io_open',

source=crasher)

rc, stdout, stderr = assert_python_failure(script)

self.assertEqual(rc, 1) # Make sure it's not a crash

expected = [b'Traceback (most recent call last):',

f' File "{script}", line 6, in <module>'.encode(),

b'RuntimeError: should not crash']

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_print_last(self):

with support.swap_attr(sys, 'last_exc', ValueError(42)):

output = StringIO()

traceback.print_last(file=output)

self.assertEqual(output.getvalue(), "ValueError: 42\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, 'required positional argument'):

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

@support.subTests("arg", [NotImplemented, "invalid syntax"])

def test_format_syntax_error_message(self, arg):

exc = SyntaxError(arg)

lines = traceback.format_exception_only(type(exc), exc)

result = "".join(lines)

self.assertIn(str(arg), result)

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, **kwargs)'))

self.assertEqual(

str(inspect.signature(traceback.format_exception)),

('(exc, /, value=<implicit>, tb=<implicit>, limit=None, '

'chain=True, **kwargs)'))

self.assertEqual(

str(inspect.signature(traceback.format_exception_only)),

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

try:

callable()

except BaseException:

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

else:

self.fail("No exception thrown.")

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'

' ~~~~~~~~^^\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'

' ~~~~~~~~^^\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

foo.__annotations__

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'

' ~~~~~~~~^^\n'

f' File "{__file__}", line {lineno_f+3}, in f_with_type\n'

' foo.__annotations__\n'

f' File "{__file__}", line {lineno_f+1}, in __annotate__\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'

' ~~~~~~~~^^\n'

f' File "{__file__}", line {lineno_f+1}, in f_with_multiline\n'

' if True: raise ValueError(\n'

' ^^^^^^^^^^^^^^^^^\n'

' "error over multiple lines"\n'

' ^^^^^^^^^^^^^^^^^^^^^^^^^^^\n'

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

' ~~~~~~~~^^\n'

f' File "{__file__}", line {lineno_f+2}, in f_with_multiline\n'

' return compile(code, "?", "exec")\n'

' File "?", line 7\n'

' foo(a, z\n'

' ^'

)

result_lines = self.get_exception(f_with_multiline)

self.assertEqual(result_lines, expected_f.splitlines())

# Check custom error messages covering multiple lines

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'

' ~~~~~~~~^^\n'

f' File "{__file__}", line {lineno_f+2}, in f_with_multiline\n'

' return compile(code, "?", "exec")\n'

' File "?", line 3\n'

' "dummy value"\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'

' ~~~~~~~~^^\n'

f' File "{__file__}", line {lineno_f+2}, in f_with_multiline\n'

' 2 + 1 /\n'

' ~~^\n'

' 0\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'

' ~~~~~~~~^^\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'

' ~~~~~~~~^^\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'

' ~~~~~~~~^^\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_spaces_and_parenthesis(self):

def f_with_binary_operator():

a = 1

b = c = ""

return ( a ) +b + c

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'

' ~~~~~~~~^^\n'

f' File "{__file__}", line {lineno_f+3}, in f_with_binary_operator\n'

' return ( a ) +b + c\n'

' ~~~~~~~~~~^~\n'

)

result_lines = self.get_exception(f_with_binary_operator)

self.assertEqual(result_lines, expected_error.splitlines())

def test_caret_for_binary_operators_multiline(self):

def f_with_binary_operator():

b = 1

c = ""

a = b \

+\

c # test

return a

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'

' ~~~~~~~~^^\n'

f' File "{__file__}", line {lineno_f+3}, in f_with_binary_operator\n'

' a = b \\\n'

' ~~~~~~\n'

' +\\\n'

' ^~\n'

' c # test\n'

' ~\n'

)

result_lines = self.get_exception(f_with_binary_operator)

self.assertEqual(result_lines, expected_error.splitlines())

def test_caret_for_binary_operators_multiline_two_char(self):

def f_with_binary_operator():

b = 1

c = ""

a = (

(b # test +

) \

# +

<< (c # test

\

) # test

)

return a

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'

' ~~~~~~~~^^\n'

f' File "{__file__}", line {lineno_f+4}, in f_with_binary_operator\n'

' (b # test +\n'

' ~~~~~~~~~~~~\n'

' ) \\\n'

' ~~~~\n'

' # +\n'

' ~~~\n'

' << (c # test\n'

' ^^~~~~~~~~~~~\n'

' \\\n'

' ~\n'

' ) # test\n'

' ~\n'

)

result_lines = self.get_exception(f_with_binary_operator)

self.assertEqual(result_lines, expected_error.splitlines())

def test_caret_for_binary_operators_multiline_with_unicode(self):

def f_with_binary_operator():

b = 1

a = ("ááá" +

"áá") + b

return a

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'

' ~~~~~~~~^^\n'

f' File "{__file__}", line {lineno_f+2}, in f_with_binary_operator\n'

' a = ("ááá" +\n'

' ~~~~~~~~\n'

' "áá") + b\n'

' ~~~~~~^~~\n'

)

result_lines = self.get_exception(f_with_binary_operator)

self.assertEqual(result_lines, expected_error.splitlines())