mirror of
https://github.com/python/cpython
synced 2024-09-19 14:51:29 +00:00
715 lines
24 KiB
Python
715 lines
24 KiB
Python
"""Tests for the unparse.py script in the Tools/parser directory."""
|
|
|
|
import unittest
|
|
import test.support
|
|
import pathlib
|
|
import random
|
|
import tokenize
|
|
import ast
|
|
|
|
|
|
def read_pyfile(filename):
|
|
"""Read and return the contents of a Python source file (as a
|
|
string), taking into account the file encoding."""
|
|
with tokenize.open(filename) as stream:
|
|
return stream.read()
|
|
|
|
|
|
for_else = """\
|
|
def f():
|
|
for x in range(10):
|
|
break
|
|
else:
|
|
y = 2
|
|
z = 3
|
|
"""
|
|
|
|
while_else = """\
|
|
def g():
|
|
while True:
|
|
break
|
|
else:
|
|
y = 2
|
|
z = 3
|
|
"""
|
|
|
|
relative_import = """\
|
|
from . import fred
|
|
from .. import barney
|
|
from .australia import shrimp as prawns
|
|
"""
|
|
|
|
nonlocal_ex = """\
|
|
def f():
|
|
x = 1
|
|
def g():
|
|
nonlocal x
|
|
x = 2
|
|
y = 7
|
|
def h():
|
|
nonlocal x, y
|
|
"""
|
|
|
|
# also acts as test for 'except ... as ...'
|
|
raise_from = """\
|
|
try:
|
|
1 / 0
|
|
except ZeroDivisionError as e:
|
|
raise ArithmeticError from e
|
|
"""
|
|
|
|
class_decorator = """\
|
|
@f1(arg)
|
|
@f2
|
|
class Foo: pass
|
|
"""
|
|
|
|
elif1 = """\
|
|
if cond1:
|
|
suite1
|
|
elif cond2:
|
|
suite2
|
|
else:
|
|
suite3
|
|
"""
|
|
|
|
elif2 = """\
|
|
if cond1:
|
|
suite1
|
|
elif cond2:
|
|
suite2
|
|
"""
|
|
|
|
try_except_finally = """\
|
|
try:
|
|
suite1
|
|
except ex1:
|
|
suite2
|
|
except ex2:
|
|
suite3
|
|
else:
|
|
suite4
|
|
finally:
|
|
suite5
|
|
"""
|
|
|
|
try_except_star_finally = """\
|
|
try:
|
|
suite1
|
|
except* ex1:
|
|
suite2
|
|
except* ex2:
|
|
suite3
|
|
else:
|
|
suite4
|
|
finally:
|
|
suite5
|
|
"""
|
|
|
|
with_simple = """\
|
|
with f():
|
|
suite1
|
|
"""
|
|
|
|
with_as = """\
|
|
with f() as x:
|
|
suite1
|
|
"""
|
|
|
|
with_two_items = """\
|
|
with f() as x, g() as y:
|
|
suite1
|
|
"""
|
|
|
|
docstring_prefixes = (
|
|
"",
|
|
"class foo:\n ",
|
|
"def foo():\n ",
|
|
"async def foo():\n ",
|
|
)
|
|
|
|
class ASTTestCase(unittest.TestCase):
|
|
def assertASTEqual(self, ast1, ast2):
|
|
# Ensure the comparisons start at an AST node
|
|
self.assertIsInstance(ast1, ast.AST)
|
|
self.assertIsInstance(ast2, ast.AST)
|
|
|
|
# An AST comparison routine modeled after ast.dump(), but
|
|
# instead of string building, it traverses the two trees
|
|
# in lock-step.
|
|
def traverse_compare(a, b, missing=object()):
|
|
if type(a) is not type(b):
|
|
self.fail(f"{type(a)!r} is not {type(b)!r}")
|
|
if isinstance(a, ast.AST):
|
|
for field in a._fields:
|
|
value1 = getattr(a, field, missing)
|
|
value2 = getattr(b, field, missing)
|
|
# Singletons are equal by definition, so further
|
|
# testing can be skipped.
|
|
if value1 is not value2:
|
|
traverse_compare(value1, value2)
|
|
elif isinstance(a, list):
|
|
try:
|
|
for node1, node2 in zip(a, b, strict=True):
|
|
traverse_compare(node1, node2)
|
|
except ValueError:
|
|
# Attempt a "pretty" error ala assertSequenceEqual()
|
|
len1 = len(a)
|
|
len2 = len(b)
|
|
if len1 > len2:
|
|
what = "First"
|
|
diff = len1 - len2
|
|
else:
|
|
what = "Second"
|
|
diff = len2 - len1
|
|
msg = f"{what} list contains {diff} additional elements."
|
|
raise self.failureException(msg) from None
|
|
elif a != b:
|
|
self.fail(f"{a!r} != {b!r}")
|
|
traverse_compare(ast1, ast2)
|
|
|
|
def check_ast_roundtrip(self, code1, **kwargs):
|
|
with self.subTest(code1=code1, ast_parse_kwargs=kwargs):
|
|
ast1 = ast.parse(code1, **kwargs)
|
|
code2 = ast.unparse(ast1)
|
|
ast2 = ast.parse(code2, **kwargs)
|
|
self.assertASTEqual(ast1, ast2)
|
|
|
|
def check_invalid(self, node, raises=ValueError):
|
|
with self.subTest(node=node):
|
|
self.assertRaises(raises, ast.unparse, node)
|
|
|
|
def get_source(self, code1, code2=None):
|
|
code2 = code2 or code1
|
|
code1 = ast.unparse(ast.parse(code1))
|
|
return code1, code2
|
|
|
|
def check_src_roundtrip(self, code1, code2=None):
|
|
code1, code2 = self.get_source(code1, code2)
|
|
with self.subTest(code1=code1, code2=code2):
|
|
self.assertEqual(code2, code1)
|
|
|
|
def check_src_dont_roundtrip(self, code1, code2=None):
|
|
code1, code2 = self.get_source(code1, code2)
|
|
with self.subTest(code1=code1, code2=code2):
|
|
self.assertNotEqual(code2, code1)
|
|
|
|
class UnparseTestCase(ASTTestCase):
|
|
# Tests for specific bugs found in earlier versions of unparse
|
|
|
|
def test_fstrings(self):
|
|
self.check_ast_roundtrip("f'a'")
|
|
self.check_ast_roundtrip("f'{{}}'")
|
|
self.check_ast_roundtrip("f'{{5}}'")
|
|
self.check_ast_roundtrip("f'{{5}}5'")
|
|
self.check_ast_roundtrip("f'X{{}}X'")
|
|
self.check_ast_roundtrip("f'{a}'")
|
|
self.check_ast_roundtrip("f'{ {1:2}}'")
|
|
self.check_ast_roundtrip("f'a{a}a'")
|
|
self.check_ast_roundtrip("f'a{a}{a}a'")
|
|
self.check_ast_roundtrip("f'a{a}a{a}a'")
|
|
self.check_ast_roundtrip("f'{a!r}x{a!s}12{{}}{a!a}'")
|
|
self.check_ast_roundtrip("f'{a:10}'")
|
|
self.check_ast_roundtrip("f'{a:100_000{10}}'")
|
|
self.check_ast_roundtrip("f'{a!r:10}'")
|
|
self.check_ast_roundtrip("f'{a:a{b}10}'")
|
|
self.check_ast_roundtrip(
|
|
"f'a{b}{c!s}{d!r}{e!a}{f:a}{g:a{b}}{h!s:a}"
|
|
"{j!s:{a}b}{k!s:a{b}c}{l!a:{b}c{d}}{x+y=}'"
|
|
)
|
|
|
|
def test_fstrings_special_chars(self):
|
|
# See issue 25180
|
|
self.check_ast_roundtrip(r"""f'{f"{0}"*3}'""")
|
|
self.check_ast_roundtrip(r"""f'{f"{y}"*3}'""")
|
|
self.check_ast_roundtrip("""f''""")
|
|
self.check_ast_roundtrip('''f"""'end' "quote\\""""''')
|
|
|
|
def test_fstrings_complicated(self):
|
|
# See issue 28002
|
|
self.check_ast_roundtrip("""f'''{"'"}'''""")
|
|
self.check_ast_roundtrip('''f\'\'\'-{f"""*{f"+{f'.{x}.'}+"}*"""}-\'\'\'''')
|
|
self.check_ast_roundtrip('''f\'\'\'-{f"""*{f"+{f'.{x}.'}+"}*"""}-'single quote\\'\'\'\'''')
|
|
self.check_ast_roundtrip('f"""{\'\'\'\n\'\'\'}"""')
|
|
self.check_ast_roundtrip('f"""{g(\'\'\'\n\'\'\')}"""')
|
|
self.check_ast_roundtrip('''f"a\\r\\nb"''')
|
|
self.check_ast_roundtrip('''f"\\u2028{'x'}"''')
|
|
|
|
def test_strings(self):
|
|
self.check_ast_roundtrip("u'foo'")
|
|
self.check_ast_roundtrip("r'foo'")
|
|
self.check_ast_roundtrip("b'foo'")
|
|
|
|
def test_del_statement(self):
|
|
self.check_ast_roundtrip("del x, y, z")
|
|
|
|
def test_shifts(self):
|
|
self.check_ast_roundtrip("45 << 2")
|
|
self.check_ast_roundtrip("13 >> 7")
|
|
|
|
def test_for_else(self):
|
|
self.check_ast_roundtrip(for_else)
|
|
|
|
def test_while_else(self):
|
|
self.check_ast_roundtrip(while_else)
|
|
|
|
def test_unary_parens(self):
|
|
self.check_ast_roundtrip("(-1)**7")
|
|
self.check_ast_roundtrip("(-1.)**8")
|
|
self.check_ast_roundtrip("(-1j)**6")
|
|
self.check_ast_roundtrip("not True or False")
|
|
self.check_ast_roundtrip("True or not False")
|
|
|
|
def test_integer_parens(self):
|
|
self.check_ast_roundtrip("3 .__abs__()")
|
|
|
|
def test_huge_float(self):
|
|
self.check_ast_roundtrip("1e1000")
|
|
self.check_ast_roundtrip("-1e1000")
|
|
self.check_ast_roundtrip("1e1000j")
|
|
self.check_ast_roundtrip("-1e1000j")
|
|
|
|
def test_nan(self):
|
|
self.assertASTEqual(
|
|
ast.parse(ast.unparse(ast.Constant(value=float('nan')))),
|
|
ast.parse('1e1000 - 1e1000')
|
|
)
|
|
|
|
def test_min_int(self):
|
|
self.check_ast_roundtrip(str(-(2 ** 31)))
|
|
self.check_ast_roundtrip(str(-(2 ** 63)))
|
|
|
|
def test_imaginary_literals(self):
|
|
self.check_ast_roundtrip("7j")
|
|
self.check_ast_roundtrip("-7j")
|
|
self.check_ast_roundtrip("0j")
|
|
self.check_ast_roundtrip("-0j")
|
|
|
|
def test_lambda_parentheses(self):
|
|
self.check_ast_roundtrip("(lambda: int)()")
|
|
|
|
def test_chained_comparisons(self):
|
|
self.check_ast_roundtrip("1 < 4 <= 5")
|
|
self.check_ast_roundtrip("a is b is c is not d")
|
|
|
|
def test_function_arguments(self):
|
|
self.check_ast_roundtrip("def f(): pass")
|
|
self.check_ast_roundtrip("def f(a): pass")
|
|
self.check_ast_roundtrip("def f(b = 2): pass")
|
|
self.check_ast_roundtrip("def f(a, b): pass")
|
|
self.check_ast_roundtrip("def f(a, b = 2): pass")
|
|
self.check_ast_roundtrip("def f(a = 5, b = 2): pass")
|
|
self.check_ast_roundtrip("def f(*, a = 1, b = 2): pass")
|
|
self.check_ast_roundtrip("def f(*, a = 1, b): pass")
|
|
self.check_ast_roundtrip("def f(*, a, b = 2): pass")
|
|
self.check_ast_roundtrip("def f(a, b = None, *, c, **kwds): pass")
|
|
self.check_ast_roundtrip("def f(a=2, *args, c=5, d, **kwds): pass")
|
|
self.check_ast_roundtrip("def f(*args, **kwargs): pass")
|
|
|
|
def test_relative_import(self):
|
|
self.check_ast_roundtrip(relative_import)
|
|
|
|
def test_nonlocal(self):
|
|
self.check_ast_roundtrip(nonlocal_ex)
|
|
|
|
def test_raise_from(self):
|
|
self.check_ast_roundtrip(raise_from)
|
|
|
|
def test_bytes(self):
|
|
self.check_ast_roundtrip("b'123'")
|
|
|
|
def test_annotations(self):
|
|
self.check_ast_roundtrip("def f(a : int): pass")
|
|
self.check_ast_roundtrip("def f(a: int = 5): pass")
|
|
self.check_ast_roundtrip("def f(*args: [int]): pass")
|
|
self.check_ast_roundtrip("def f(**kwargs: dict): pass")
|
|
self.check_ast_roundtrip("def f() -> None: pass")
|
|
|
|
def test_set_literal(self):
|
|
self.check_ast_roundtrip("{'a', 'b', 'c'}")
|
|
|
|
def test_empty_set(self):
|
|
self.assertASTEqual(
|
|
ast.parse(ast.unparse(ast.Set(elts=[]))),
|
|
ast.parse('{*()}')
|
|
)
|
|
|
|
def test_set_comprehension(self):
|
|
self.check_ast_roundtrip("{x for x in range(5)}")
|
|
|
|
def test_dict_comprehension(self):
|
|
self.check_ast_roundtrip("{x: x*x for x in range(10)}")
|
|
|
|
def test_class_decorators(self):
|
|
self.check_ast_roundtrip(class_decorator)
|
|
|
|
def test_class_definition(self):
|
|
self.check_ast_roundtrip("class A(metaclass=type, *[], **{}): pass")
|
|
|
|
def test_elifs(self):
|
|
self.check_ast_roundtrip(elif1)
|
|
self.check_ast_roundtrip(elif2)
|
|
|
|
def test_try_except_finally(self):
|
|
self.check_ast_roundtrip(try_except_finally)
|
|
|
|
def test_try_except_star_finally(self):
|
|
self.check_ast_roundtrip(try_except_star_finally)
|
|
|
|
def test_starred_assignment(self):
|
|
self.check_ast_roundtrip("a, *b, c = seq")
|
|
self.check_ast_roundtrip("a, (*b, c) = seq")
|
|
self.check_ast_roundtrip("a, *b[0], c = seq")
|
|
self.check_ast_roundtrip("a, *(b, c) = seq")
|
|
|
|
def test_with_simple(self):
|
|
self.check_ast_roundtrip(with_simple)
|
|
|
|
def test_with_as(self):
|
|
self.check_ast_roundtrip(with_as)
|
|
|
|
def test_with_two_items(self):
|
|
self.check_ast_roundtrip(with_two_items)
|
|
|
|
def test_dict_unpacking_in_dict(self):
|
|
# See issue 26489
|
|
self.check_ast_roundtrip(r"""{**{'y': 2}, 'x': 1}""")
|
|
self.check_ast_roundtrip(r"""{**{'y': 2}, **{'x': 1}}""")
|
|
|
|
def test_slices(self):
|
|
self.check_ast_roundtrip("a[i]")
|
|
self.check_ast_roundtrip("a[i,]")
|
|
self.check_ast_roundtrip("a[i, j]")
|
|
# The AST for these next two both look like `a[(*a,)]`
|
|
self.check_ast_roundtrip("a[(*a,)]")
|
|
self.check_ast_roundtrip("a[*a]")
|
|
self.check_ast_roundtrip("a[b, *a]")
|
|
self.check_ast_roundtrip("a[*a, c]")
|
|
self.check_ast_roundtrip("a[b, *a, c]")
|
|
self.check_ast_roundtrip("a[*a, *a]")
|
|
self.check_ast_roundtrip("a[b, *a, *a]")
|
|
self.check_ast_roundtrip("a[*a, b, *a]")
|
|
self.check_ast_roundtrip("a[*a, *a, b]")
|
|
self.check_ast_roundtrip("a[b, *a, *a, c]")
|
|
self.check_ast_roundtrip("a[(a:=b)]")
|
|
self.check_ast_roundtrip("a[(a:=b,c)]")
|
|
self.check_ast_roundtrip("a[()]")
|
|
self.check_ast_roundtrip("a[i:j]")
|
|
self.check_ast_roundtrip("a[:j]")
|
|
self.check_ast_roundtrip("a[i:]")
|
|
self.check_ast_roundtrip("a[i:j:k]")
|
|
self.check_ast_roundtrip("a[:j:k]")
|
|
self.check_ast_roundtrip("a[i::k]")
|
|
self.check_ast_roundtrip("a[i:j,]")
|
|
self.check_ast_roundtrip("a[i:j, k]")
|
|
|
|
def test_invalid_raise(self):
|
|
self.check_invalid(ast.Raise(exc=None, cause=ast.Name(id="X")))
|
|
|
|
def test_invalid_fstring_value(self):
|
|
self.check_invalid(
|
|
ast.JoinedStr(
|
|
values=[
|
|
ast.Name(id="test"),
|
|
ast.Constant(value="test")
|
|
]
|
|
)
|
|
)
|
|
|
|
def test_invalid_fstring_backslash(self):
|
|
self.check_invalid(ast.FormattedValue(value=ast.Constant(value="\\\\")))
|
|
|
|
def test_invalid_yield_from(self):
|
|
self.check_invalid(ast.YieldFrom(value=None))
|
|
|
|
def test_docstrings(self):
|
|
docstrings = (
|
|
'this ends with double quote"',
|
|
'this includes a """triple quote"""',
|
|
'\r',
|
|
'\\r',
|
|
'\t',
|
|
'\\t',
|
|
'\n',
|
|
'\\n',
|
|
'\r\\r\t\\t\n\\n',
|
|
'""">>> content = \"\"\"blabla\"\"\" <<<"""',
|
|
r'foo\n\x00',
|
|
"' \\'\\'\\'\"\"\" \"\"\\'\\' \\'",
|
|
'🐍⛎𩸽üéş^\\\\X\\\\BB\N{LONG RIGHTWARDS SQUIGGLE ARROW}'
|
|
)
|
|
for docstring in docstrings:
|
|
# check as Module docstrings for easy testing
|
|
self.check_ast_roundtrip(f"'''{docstring}'''")
|
|
|
|
def test_constant_tuples(self):
|
|
self.check_src_roundtrip(ast.Constant(value=(1,), kind=None), "(1,)")
|
|
self.check_src_roundtrip(
|
|
ast.Constant(value=(1, 2, 3), kind=None), "(1, 2, 3)"
|
|
)
|
|
|
|
def test_function_type(self):
|
|
for function_type in (
|
|
"() -> int",
|
|
"(int, int) -> int",
|
|
"(Callable[complex], More[Complex(call.to_typevar())]) -> None"
|
|
):
|
|
self.check_ast_roundtrip(function_type, mode="func_type")
|
|
|
|
def test_type_comments(self):
|
|
for statement in (
|
|
"a = 5 # type:",
|
|
"a = 5 # type: int",
|
|
"a = 5 # type: int and more",
|
|
"def x(): # type: () -> None\n\tpass",
|
|
"def x(y): # type: (int) -> None and more\n\tpass",
|
|
"async def x(): # type: () -> None\n\tpass",
|
|
"async def x(y): # type: (int) -> None and more\n\tpass",
|
|
"for x in y: # type: int\n\tpass",
|
|
"async for x in y: # type: int\n\tpass",
|
|
"with x(): # type: int\n\tpass",
|
|
"async with x(): # type: int\n\tpass"
|
|
):
|
|
self.check_ast_roundtrip(statement, type_comments=True)
|
|
|
|
def test_type_ignore(self):
|
|
for statement in (
|
|
"a = 5 # type: ignore",
|
|
"a = 5 # type: ignore and more",
|
|
"def x(): # type: ignore\n\tpass",
|
|
"def x(y): # type: ignore and more\n\tpass",
|
|
"async def x(): # type: ignore\n\tpass",
|
|
"async def x(y): # type: ignore and more\n\tpass",
|
|
"for x in y: # type: ignore\n\tpass",
|
|
"async for x in y: # type: ignore\n\tpass",
|
|
"with x(): # type: ignore\n\tpass",
|
|
"async with x(): # type: ignore\n\tpass"
|
|
):
|
|
self.check_ast_roundtrip(statement, type_comments=True)
|
|
|
|
|
|
class CosmeticTestCase(ASTTestCase):
|
|
"""Test if there are cosmetic issues caused by unnecessary additions"""
|
|
|
|
def test_simple_expressions_parens(self):
|
|
self.check_src_roundtrip("(a := b)")
|
|
self.check_src_roundtrip("await x")
|
|
self.check_src_roundtrip("x if x else y")
|
|
self.check_src_roundtrip("lambda x: x")
|
|
self.check_src_roundtrip("1 + 1")
|
|
self.check_src_roundtrip("1 + 2 / 3")
|
|
self.check_src_roundtrip("(1 + 2) / 3")
|
|
self.check_src_roundtrip("(1 + 2) * 3 + 4 * (5 + 2)")
|
|
self.check_src_roundtrip("(1 + 2) * 3 + 4 * (5 + 2) ** 2")
|
|
self.check_src_roundtrip("~x")
|
|
self.check_src_roundtrip("x and y")
|
|
self.check_src_roundtrip("x and y and z")
|
|
self.check_src_roundtrip("x and (y and x)")
|
|
self.check_src_roundtrip("(x and y) and z")
|
|
self.check_src_roundtrip("(x ** y) ** z ** q")
|
|
self.check_src_roundtrip("x >> y")
|
|
self.check_src_roundtrip("x << y")
|
|
self.check_src_roundtrip("x >> y and x >> z")
|
|
self.check_src_roundtrip("x + y - z * q ^ t ** k")
|
|
self.check_src_roundtrip("P * V if P and V else n * R * T")
|
|
self.check_src_roundtrip("lambda P, V, n: P * V == n * R * T")
|
|
self.check_src_roundtrip("flag & (other | foo)")
|
|
self.check_src_roundtrip("not x == y")
|
|
self.check_src_roundtrip("x == (not y)")
|
|
self.check_src_roundtrip("yield x")
|
|
self.check_src_roundtrip("yield from x")
|
|
self.check_src_roundtrip("call((yield x))")
|
|
self.check_src_roundtrip("return x + (yield x)")
|
|
|
|
def test_class_bases_and_keywords(self):
|
|
self.check_src_roundtrip("class X:\n pass")
|
|
self.check_src_roundtrip("class X(A):\n pass")
|
|
self.check_src_roundtrip("class X(A, B, C, D):\n pass")
|
|
self.check_src_roundtrip("class X(x=y):\n pass")
|
|
self.check_src_roundtrip("class X(metaclass=z):\n pass")
|
|
self.check_src_roundtrip("class X(x=y, z=d):\n pass")
|
|
self.check_src_roundtrip("class X(A, x=y):\n pass")
|
|
self.check_src_roundtrip("class X(A, **kw):\n pass")
|
|
self.check_src_roundtrip("class X(*args):\n pass")
|
|
self.check_src_roundtrip("class X(*args, **kwargs):\n pass")
|
|
|
|
def test_fstrings(self):
|
|
self.check_src_roundtrip('''f\'\'\'-{f"""*{f"+{f'.{x}.'}+"}*"""}-\'\'\'''')
|
|
self.check_src_roundtrip('''f"\\u2028{'x'}"''')
|
|
self.check_src_roundtrip(r"f'{x}\n'")
|
|
self.check_src_roundtrip('''f''\'{"""\n"""}\\n''\'''')
|
|
self.check_src_roundtrip('''f''\'{f"""{x}\n"""}\\n''\'''')
|
|
|
|
def test_docstrings(self):
|
|
docstrings = (
|
|
'"""simple doc string"""',
|
|
'''"""A more complex one
|
|
with some newlines"""''',
|
|
'''"""Foo bar baz
|
|
|
|
empty newline"""''',
|
|
'"""With some \t"""',
|
|
'"""Foo "bar" baz """',
|
|
'"""\\r"""',
|
|
'""""""',
|
|
'"""\'\'\'"""',
|
|
'"""\'\'\'\'\'\'"""',
|
|
'"""🐍⛎𩸽üéş^\\\\X\\\\BB⟿"""',
|
|
'"""end in single \'quote\'"""',
|
|
"'''end in double \"quote\"'''",
|
|
'"""almost end in double "quote"."""',
|
|
)
|
|
|
|
for prefix in docstring_prefixes:
|
|
for docstring in docstrings:
|
|
self.check_src_roundtrip(f"{prefix}{docstring}")
|
|
|
|
def test_docstrings_negative_cases(self):
|
|
# Test some cases that involve strings in the children of the
|
|
# first node but aren't docstrings to make sure we don't have
|
|
# False positives.
|
|
docstrings_negative = (
|
|
'a = """false"""',
|
|
'"""false""" + """unless its optimized"""',
|
|
'1 + 1\n"""false"""',
|
|
'f"""no, top level but f-fstring"""'
|
|
)
|
|
for prefix in docstring_prefixes:
|
|
for negative in docstrings_negative:
|
|
# this cases should be result with single quote
|
|
# rather then triple quoted docstring
|
|
src = f"{prefix}{negative}"
|
|
self.check_ast_roundtrip(src)
|
|
self.check_src_dont_roundtrip(src)
|
|
|
|
def test_unary_op_factor(self):
|
|
for prefix in ("+", "-", "~"):
|
|
self.check_src_roundtrip(f"{prefix}1")
|
|
for prefix in ("not",):
|
|
self.check_src_roundtrip(f"{prefix} 1")
|
|
|
|
def test_slices(self):
|
|
self.check_src_roundtrip("a[()]")
|
|
self.check_src_roundtrip("a[1]")
|
|
self.check_src_roundtrip("a[1, 2]")
|
|
# Note that `a[*a]`, `a[*a,]`, and `a[(*a,)]` all evaluate to the same
|
|
# thing at runtime and have the same AST, but only `a[*a,]` passes
|
|
# this test, because that's what `ast.unparse` produces.
|
|
self.check_src_roundtrip("a[*a,]")
|
|
self.check_src_roundtrip("a[1, *a]")
|
|
self.check_src_roundtrip("a[*a, 2]")
|
|
self.check_src_roundtrip("a[1, *a, 2]")
|
|
self.check_src_roundtrip("a[*a, *a]")
|
|
self.check_src_roundtrip("a[1, *a, *a]")
|
|
self.check_src_roundtrip("a[*a, 1, *a]")
|
|
self.check_src_roundtrip("a[*a, *a, 1]")
|
|
self.check_src_roundtrip("a[1, *a, *a, 2]")
|
|
self.check_src_roundtrip("a[1:2, *a]")
|
|
self.check_src_roundtrip("a[*a, 1:2]")
|
|
|
|
def test_lambda_parameters(self):
|
|
self.check_src_roundtrip("lambda: something")
|
|
self.check_src_roundtrip("four = lambda: 2 + 2")
|
|
self.check_src_roundtrip("lambda x: x * 2")
|
|
self.check_src_roundtrip("square = lambda n: n ** 2")
|
|
self.check_src_roundtrip("lambda x, y: x + y")
|
|
self.check_src_roundtrip("add = lambda x, y: x + y")
|
|
self.check_src_roundtrip("lambda x, y, /, z, q, *, u: None")
|
|
self.check_src_roundtrip("lambda x, *y, **z: None")
|
|
|
|
def test_star_expr_assign_target(self):
|
|
for source_type, source in [
|
|
("single assignment", "{target} = foo"),
|
|
("multiple assignment", "{target} = {target} = bar"),
|
|
("for loop", "for {target} in foo:\n pass"),
|
|
("async for loop", "async for {target} in foo:\n pass")
|
|
]:
|
|
for target in [
|
|
"a",
|
|
"a,",
|
|
"a, b",
|
|
"a, *b, c",
|
|
"a, (b, c), d",
|
|
"a, (b, c, d), *e",
|
|
"a, (b, *c, d), e",
|
|
"a, (b, *c, (d, e), f), g",
|
|
"[a]",
|
|
"[a, b]",
|
|
"[a, *b, c]",
|
|
"[a, [b, c], d]",
|
|
"[a, [b, c, d], *e]",
|
|
"[a, [b, *c, d], e]",
|
|
"[a, [b, *c, [d, e], f], g]",
|
|
"a, [b, c], d",
|
|
"[a, b, (c, d), (e, f)]",
|
|
"a, b, [*c], d, e"
|
|
]:
|
|
with self.subTest(source_type=source_type, target=target):
|
|
self.check_src_roundtrip(source.format(target=target))
|
|
|
|
def test_star_expr_assign_target_multiple(self):
|
|
self.check_src_roundtrip("() = []")
|
|
self.check_src_roundtrip("[] = ()")
|
|
self.check_src_roundtrip("() = [a] = c, = [d] = e, f = () = g = h")
|
|
self.check_src_roundtrip("a = b = c = d")
|
|
self.check_src_roundtrip("a, b = c, d = e, f = g")
|
|
self.check_src_roundtrip("[a, b] = [c, d] = [e, f] = g")
|
|
self.check_src_roundtrip("a, b = [c, d] = e, f = g")
|
|
|
|
|
|
|
|
class DirectoryTestCase(ASTTestCase):
|
|
"""Test roundtrip behaviour on all files in Lib and Lib/test."""
|
|
|
|
lib_dir = pathlib.Path(__file__).parent / ".."
|
|
test_directories = (lib_dir, lib_dir / "test")
|
|
run_always_files = {"test_grammar.py", "test_syntax.py", "test_compile.py",
|
|
"test_ast.py", "test_asdl_parser.py", "test_fstring.py",
|
|
"test_patma.py"}
|
|
|
|
_files_to_test = None
|
|
|
|
@classmethod
|
|
def files_to_test(cls):
|
|
|
|
if cls._files_to_test is not None:
|
|
return cls._files_to_test
|
|
|
|
items = [
|
|
item.resolve()
|
|
for directory in cls.test_directories
|
|
for item in directory.glob("*.py")
|
|
if not item.name.startswith("bad")
|
|
]
|
|
|
|
# Test limited subset of files unless the 'cpu' resource is specified.
|
|
if not test.support.is_resource_enabled("cpu"):
|
|
|
|
tests_to_run_always = {item for item in items if
|
|
item.name in cls.run_always_files}
|
|
|
|
items = set(random.sample(items, 10))
|
|
|
|
# Make sure that at least tests that heavily use grammar features are
|
|
# always considered in order to reduce the chance of missing something.
|
|
items = list(items | tests_to_run_always)
|
|
|
|
# bpo-31174: Store the names sample to always test the same files.
|
|
# It prevents false alarms when hunting reference leaks.
|
|
cls._files_to_test = items
|
|
|
|
return items
|
|
|
|
def test_files(self):
|
|
for item in self.files_to_test():
|
|
if test.support.verbose:
|
|
print(f"Testing {item.absolute()}")
|
|
|
|
with self.subTest(filename=item):
|
|
source = read_pyfile(item)
|
|
self.check_ast_roundtrip(source)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
unittest.main()
|