mirror of
https://github.com/xonsh/xonsh.git
synced 2025-03-04 08:24:40 +01:00
1800 lines
43 KiB
Python
1800 lines
43 KiB
Python
# -*- coding: utf-8 -*-
|
|
"""Tests the xonsh parser."""
|
|
import os
|
|
import sys
|
|
import ast
|
|
import builtins
|
|
|
|
import pytest
|
|
|
|
from xonsh.ast import pdump
|
|
from xonsh.parser import Parser
|
|
|
|
from tools import VER_FULL, skip_if_py34
|
|
|
|
# a lot of col_offset data changed from Py v3.5.0 -> v3.5.1
|
|
INC_ATTRS = (3, 5, 1) <= VER_FULL
|
|
|
|
@pytest.fixture(autouse=True)
|
|
def xonsh_builtins_autouse(xonsh_builtins):
|
|
return xonsh_builtins
|
|
|
|
PARSER = Parser(lexer_optimize=False, yacc_optimize=False, yacc_debug=True,
|
|
lexer_table='lexer_test_table',
|
|
yacc_table='parser_test_table')
|
|
|
|
|
|
def nodes_equal(x, y):
|
|
__tracebackhide__ = True
|
|
assert type(x) == type(y)
|
|
if isinstance(x, (ast.Expr, ast.FunctionDef, ast.ClassDef)):
|
|
assert x.lineno == y.lineno
|
|
assert x.col_offset == y.col_offset
|
|
for (xname, xval), (yname, yval) in zip(ast.iter_fields(x),
|
|
ast.iter_fields(y)):
|
|
assert xname == yname
|
|
assert type(xval) == type(yval)
|
|
for xchild, ychild in zip(ast.iter_child_nodes(x),
|
|
ast.iter_child_nodes(y)):
|
|
assert nodes_equal(xchild, ychild)
|
|
return True
|
|
|
|
|
|
def check_ast(inp, run=True, mode='eval'):
|
|
__tracebackhide__ = True
|
|
# expect a Python AST
|
|
exp = ast.parse(inp, mode=mode)
|
|
# observe something from xonsh
|
|
obs = PARSER.parse(inp, debug_level=0)
|
|
# Check that they are equal
|
|
assert nodes_equal(exp, obs)
|
|
# round trip by running xonsh AST via Python
|
|
if run:
|
|
exec(compile(obs, '<test-ast>', mode))
|
|
|
|
def check_stmts(inp, run=True, mode='exec'):
|
|
__tracebackhide__ = True
|
|
if not inp.endswith('\n'):
|
|
inp += '\n'
|
|
check_ast(inp, run=run, mode=mode)
|
|
|
|
def check_xonsh_ast(xenv, inp, run=True, mode='eval'):
|
|
__tracebackhide__ = True
|
|
builtins.__xonsh_env__ = xenv
|
|
obs = PARSER.parse(inp)
|
|
if obs is None:
|
|
return # comment only
|
|
bytecode = compile(obs, '<test-xonsh-ast>', mode)
|
|
if run:
|
|
exec(bytecode)
|
|
return True
|
|
|
|
def check_xonsh(xenv, inp, run=True, mode='exec'):
|
|
__tracebackhide__ = True
|
|
if not inp.endswith('\n'):
|
|
inp += '\n'
|
|
check_xonsh_ast(xenv, inp, run=run, mode=mode)
|
|
|
|
#
|
|
# Tests
|
|
#
|
|
|
|
#
|
|
# expressions
|
|
#
|
|
|
|
def test_int_literal():
|
|
check_ast('42')
|
|
|
|
def test_float_literal():
|
|
check_ast('42.0')
|
|
|
|
def test_imag_literal():
|
|
check_ast('42j')
|
|
|
|
def test_float_imag_literal():
|
|
check_ast('42.0j')
|
|
|
|
def test_complex():
|
|
check_ast('42+84j')
|
|
|
|
def test_str_literal():
|
|
check_ast('"hello"')
|
|
|
|
def test_bytes_literal():
|
|
check_ast('b"hello"')
|
|
|
|
def test_unary_plus():
|
|
check_ast('+1')
|
|
|
|
def test_unary_minus():
|
|
check_ast('-1')
|
|
|
|
def test_unary_invert():
|
|
check_ast('~1')
|
|
|
|
def test_binop_plus():
|
|
check_ast('42 + 65')
|
|
|
|
def test_binop_minus():
|
|
check_ast('42 - 65')
|
|
|
|
def test_binop_times():
|
|
check_ast('42 * 65')
|
|
|
|
@skip_if_py34
|
|
def test_binop_matmult():
|
|
check_ast('x @ y', False)
|
|
|
|
def test_binop_div():
|
|
check_ast('42 / 65')
|
|
|
|
def test_binop_mod():
|
|
check_ast('42 % 65')
|
|
|
|
def test_binop_floordiv():
|
|
check_ast('42 // 65')
|
|
|
|
def test_binop_pow():
|
|
check_ast('2 ** 2')
|
|
|
|
def test_plus_pow():
|
|
check_ast('42 + 2 ** 2')
|
|
|
|
def test_plus_plus():
|
|
check_ast('42 + 65 + 6')
|
|
|
|
def test_plus_minus():
|
|
check_ast('42 + 65 - 6')
|
|
|
|
def test_minus_plus():
|
|
check_ast('42 - 65 + 6')
|
|
|
|
def test_minus_minus():
|
|
check_ast('42 - 65 - 6')
|
|
|
|
def test_minus_plus_minus():
|
|
check_ast('42 - 65 + 6 - 28')
|
|
|
|
def test_times_plus():
|
|
check_ast('42 * 65 + 6')
|
|
|
|
def test_plus_times():
|
|
check_ast('42 + 65 * 6')
|
|
|
|
def test_times_times():
|
|
check_ast('42 * 65 * 6')
|
|
|
|
def test_times_div():
|
|
check_ast('42 * 65 / 6')
|
|
|
|
def test_times_div_mod():
|
|
check_ast('42 * 65 / 6 % 28')
|
|
|
|
def test_times_div_mod_floor():
|
|
check_ast('42 * 65 / 6 % 28 // 13')
|
|
|
|
def test_str_str():
|
|
check_ast('"hello" \'mom\'')
|
|
|
|
def test_str_str_str():
|
|
check_ast('"hello" \'mom\' "wow"')
|
|
|
|
def test_str_plus_str():
|
|
check_ast('"hello" + \'mom\'')
|
|
|
|
def test_str_times_int():
|
|
check_ast('"hello" * 20')
|
|
|
|
def test_int_times_str():
|
|
check_ast('2*"hello"')
|
|
|
|
def test_group_plus_times():
|
|
check_ast('(42 + 65) * 20')
|
|
|
|
def test_plus_group_times():
|
|
check_ast('42 + (65 * 20)')
|
|
|
|
def test_group():
|
|
check_ast('(42)')
|
|
|
|
def test_lt():
|
|
check_ast('42 < 65')
|
|
|
|
def test_gt():
|
|
check_ast('42 > 65')
|
|
|
|
def test_eq():
|
|
check_ast('42 == 65')
|
|
|
|
def test_le():
|
|
check_ast('42 <= 65')
|
|
|
|
def test_ge():
|
|
check_ast('42 >= 65')
|
|
|
|
def test_ne():
|
|
check_ast('42 != 65')
|
|
|
|
def test_in():
|
|
check_ast('"4" in "65"')
|
|
|
|
def test_is():
|
|
check_ast('42 is 65')
|
|
|
|
def test_not_in():
|
|
check_ast('"4" not in "65"')
|
|
|
|
def test_is_not():
|
|
check_ast('42 is not 65')
|
|
|
|
def test_lt_lt():
|
|
check_ast('42 < 65 < 105')
|
|
|
|
def test_lt_lt_lt():
|
|
check_ast('42 < 65 < 105 < 77')
|
|
|
|
def test_not():
|
|
check_ast('not 0')
|
|
|
|
def test_or():
|
|
check_ast('1 or 0')
|
|
|
|
def test_or_or():
|
|
check_ast('1 or 0 or 42')
|
|
|
|
def test_and():
|
|
check_ast('1 and 0')
|
|
|
|
def test_and_and():
|
|
check_ast('1 and 0 and 2')
|
|
|
|
def test_and_or():
|
|
check_ast('1 and 0 or 2')
|
|
|
|
def test_or_and():
|
|
check_ast('1 or 0 and 2')
|
|
|
|
def test_group_and_and():
|
|
check_ast('(1 and 0) and 2')
|
|
|
|
def test_group_and_or():
|
|
check_ast('(1 and 0) or 2')
|
|
|
|
def test_if_else_expr():
|
|
check_ast('42 if True else 65')
|
|
|
|
def test_if_else_expr_expr():
|
|
check_ast('42+5 if 1 == 2 else 65-5')
|
|
|
|
def test_str_idx():
|
|
check_ast('"hello"[0]')
|
|
|
|
def test_str_slice():
|
|
check_ast('"hello"[0:3]')
|
|
|
|
def test_str_step():
|
|
check_ast('"hello"[0:3:1]')
|
|
|
|
def test_str_slice_all():
|
|
check_ast('"hello"[:]')
|
|
|
|
def test_str_slice_upper():
|
|
check_ast('"hello"[5:]')
|
|
|
|
def test_str_slice_lower():
|
|
check_ast('"hello"[:3]')
|
|
|
|
def test_str_slice_other():
|
|
check_ast('"hello"[::2]')
|
|
|
|
def test_str_slice_lower_other():
|
|
check_ast('"hello"[:3:2]')
|
|
|
|
def test_str_slice_upper_other():
|
|
check_ast('"hello"[3::2]')
|
|
|
|
def test_str_2slice():
|
|
check_ast('"hello"[0:3,0:3]', False)
|
|
|
|
def test_str_2step():
|
|
check_ast('"hello"[0:3:1,0:4:2]', False)
|
|
|
|
def test_str_2slice_all():
|
|
check_ast('"hello"[:,:]', False)
|
|
|
|
def test_str_2slice_upper():
|
|
check_ast('"hello"[5:,5:]', False)
|
|
|
|
def test_str_2slice_lower():
|
|
check_ast('"hello"[:3,:3]', False)
|
|
|
|
def test_str_2slice_lowerupper():
|
|
check_ast('"hello"[5:,:3]', False)
|
|
|
|
def test_str_2slice_other():
|
|
check_ast('"hello"[::2,::2]', False)
|
|
|
|
def test_str_2slice_lower_other():
|
|
check_ast('"hello"[:3:2,:3:2]', False)
|
|
|
|
def test_str_2slice_upper_other():
|
|
check_ast('"hello"[3::2,3::2]', False)
|
|
|
|
def test_str_3slice():
|
|
check_ast('"hello"[0:3,0:3,0:3]', False)
|
|
|
|
def test_str_3step():
|
|
check_ast('"hello"[0:3:1,0:4:2,1:3:2]', False)
|
|
|
|
def test_str_3slice_all():
|
|
check_ast('"hello"[:,:,:]', False)
|
|
|
|
def test_str_3slice_upper():
|
|
check_ast('"hello"[5:,5:,5:]', False)
|
|
|
|
def test_str_3slice_lower():
|
|
check_ast('"hello"[:3,:3,:3]', False)
|
|
|
|
def test_str_3slice_lowerlowerupper():
|
|
check_ast('"hello"[:3,:3,:3]', False)
|
|
|
|
def test_str_3slice_lowerupperlower():
|
|
check_ast('"hello"[:3,5:,:3]', False)
|
|
|
|
def test_str_3slice_lowerupperupper():
|
|
check_ast('"hello"[:3,5:,5:]', False)
|
|
|
|
def test_str_3slice_upperlowerlower():
|
|
check_ast('"hello"[5:,5:,:3]', False)
|
|
|
|
def test_str_3slice_upperlowerupper():
|
|
check_ast('"hello"[5:,:3,5:]', False)
|
|
|
|
def test_str_3slice_upperupperlower():
|
|
check_ast('"hello"[5:,5:,:3]', False)
|
|
|
|
def test_str_3slice_other():
|
|
check_ast('"hello"[::2,::2,::2]', False)
|
|
|
|
def test_str_3slice_lower_other():
|
|
check_ast('"hello"[:3:2,:3:2,:3:2]', False)
|
|
|
|
def test_str_3slice_upper_other():
|
|
check_ast('"hello"[3::2,3::2,3::2]', False)
|
|
|
|
def test_str_slice_true():
|
|
check_ast('"hello"[0:3,True]', False)
|
|
|
|
def test_str_true_slice():
|
|
check_ast('"hello"[True,0:3]', False)
|
|
|
|
def test_list_empty():
|
|
check_ast('[]')
|
|
|
|
def test_list_one():
|
|
check_ast('[1]')
|
|
|
|
def test_list_one_comma():
|
|
check_ast('[1,]')
|
|
|
|
def test_list_two():
|
|
check_ast('[1, 42]')
|
|
|
|
def test_list_three():
|
|
check_ast('[1, 42, 65]')
|
|
|
|
def test_list_three_comma():
|
|
check_ast('[1, 42, 65,]')
|
|
|
|
def test_list_one_nested():
|
|
check_ast('[[1]]')
|
|
|
|
def test_list_list_four_nested():
|
|
check_ast('[[1], [2], [3], [4]]')
|
|
|
|
def test_list_tuple_three_nested():
|
|
check_ast('[(1,), (2,), (3,)]')
|
|
|
|
def test_list_set_tuple_three_nested():
|
|
check_ast('[{(1,)}, {(2,)}, {(3,)}]')
|
|
|
|
def test_list_tuple_one_nested():
|
|
check_ast('[(1,)]')
|
|
|
|
def test_tuple_tuple_one_nested():
|
|
check_ast('((1,),)')
|
|
|
|
def test_dict_list_one_nested():
|
|
check_ast('{1: [2]}')
|
|
|
|
def test_dict_list_one_nested_comma():
|
|
check_ast('{1: [2],}')
|
|
|
|
def test_dict_tuple_one_nested():
|
|
check_ast('{1: (2,)}')
|
|
|
|
def test_dict_tuple_one_nested_comma():
|
|
check_ast('{1: (2,),}')
|
|
|
|
def test_dict_list_two_nested():
|
|
check_ast('{1: [2], 3: [4]}')
|
|
|
|
def test_set_tuple_one_nested():
|
|
check_ast('{(1,)}')
|
|
|
|
def test_set_tuple_two_nested():
|
|
check_ast('{(1,), (2,)}')
|
|
|
|
def test_tuple_empty():
|
|
check_ast('()')
|
|
|
|
def test_tuple_one_bare():
|
|
check_ast('1,')
|
|
|
|
def test_tuple_two_bare():
|
|
check_ast('1, 42')
|
|
|
|
def test_tuple_three_bare():
|
|
check_ast('1, 42, 65')
|
|
|
|
def test_tuple_three_bare_comma():
|
|
check_ast('1, 42, 65,')
|
|
|
|
def test_tuple_one_comma():
|
|
check_ast('(1,)')
|
|
|
|
def test_tuple_two():
|
|
check_ast('(1, 42)')
|
|
|
|
def test_tuple_three():
|
|
check_ast('(1, 42, 65)')
|
|
|
|
def test_tuple_three_comma():
|
|
check_ast('(1, 42, 65,)')
|
|
|
|
def test_set_one():
|
|
check_ast('{42}')
|
|
|
|
def test_set_one_comma():
|
|
check_ast('{42,}')
|
|
|
|
def test_set_two():
|
|
check_ast('{42, 65}')
|
|
|
|
def test_set_two_comma():
|
|
check_ast('{42, 65,}')
|
|
|
|
def test_set_three():
|
|
check_ast('{42, 65, 45}')
|
|
|
|
def test_dict_empty():
|
|
check_ast('{}')
|
|
|
|
def test_dict_one():
|
|
check_ast('{42: 65}')
|
|
|
|
def test_dict_one_comma():
|
|
check_ast('{42: 65,}')
|
|
|
|
def test_dict_two():
|
|
check_ast('{42: 65, 6: 28}')
|
|
|
|
def test_dict_two_comma():
|
|
check_ast('{42: 65, 6: 28,}')
|
|
|
|
def test_dict_three():
|
|
check_ast('{42: 65, 6: 28, 1: 2}')
|
|
|
|
@skip_if_py34
|
|
def test_dict_from_dict_two_xy():
|
|
check_ast('{"x": 1, **{"y": 2}}')
|
|
|
|
@skip_if_py34
|
|
def test_dict_from_dict_two_x_first():
|
|
check_ast('{"x": 1, **{"x": 2}}')
|
|
|
|
@skip_if_py34
|
|
def test_dict_from_dict_two_x_second():
|
|
check_ast('{**{"x": 2}, "x": 1}')
|
|
|
|
@skip_if_py34
|
|
def test_unpack_range_tuple():
|
|
check_stmts('*range(4),')
|
|
|
|
@skip_if_py34
|
|
def test_unpack_range_tuple_4():
|
|
check_stmts('*range(4), 4')
|
|
|
|
@skip_if_py34
|
|
def test_unpack_range_tuple_parens():
|
|
check_ast('(*range(4),)')
|
|
|
|
@skip_if_py34
|
|
def test_unpack_range_tuple_parens_4():
|
|
check_ast('(*range(4), 4)')
|
|
|
|
@skip_if_py34
|
|
def test_unpack_range_list():
|
|
check_ast('[*range(4)]')
|
|
|
|
@skip_if_py34
|
|
def test_unpack_range_list_4():
|
|
check_ast('[*range(4), 4]')
|
|
|
|
@skip_if_py34
|
|
def test_unpack_range_set():
|
|
check_ast('{*range(4)}')
|
|
|
|
@skip_if_py34
|
|
def test_unpack_range_set_4():
|
|
check_ast('{*range(4), 4}')
|
|
|
|
def test_true():
|
|
check_ast('True')
|
|
|
|
def test_false():
|
|
check_ast('False')
|
|
|
|
def test_none():
|
|
check_ast('None')
|
|
|
|
def test_elipssis():
|
|
check_ast('...')
|
|
|
|
def test_not_implemented_name():
|
|
check_ast('NotImplemented')
|
|
|
|
def test_genexpr():
|
|
check_ast('(x for x in "mom")')
|
|
|
|
def test_genexpr_if():
|
|
check_ast('(x for x in "mom" if True)')
|
|
|
|
def test_genexpr_if_and():
|
|
check_ast('(x for x in "mom" if True and x == "m")')
|
|
|
|
def test_dbl_genexpr():
|
|
check_ast('(x+y for x in "mom" for y in "dad")')
|
|
|
|
def test_genexpr_if_genexpr():
|
|
check_ast('(x+y for x in "mom" if True for y in "dad")')
|
|
|
|
def test_genexpr_if_genexpr_if():
|
|
check_ast('(x+y for x in "mom" if True for y in "dad" if y == "d")')
|
|
|
|
def test_listcomp():
|
|
check_ast('[x for x in "mom"]')
|
|
|
|
def test_listcomp_if():
|
|
check_ast('[x for x in "mom" if True]')
|
|
|
|
def test_listcomp_if_and():
|
|
check_ast('[x for x in "mom" if True and x == "m"]')
|
|
|
|
def test_dbl_listcomp():
|
|
check_ast('[x+y for x in "mom" for y in "dad"]')
|
|
|
|
def test_listcomp_if_listcomp():
|
|
check_ast('[x+y for x in "mom" if True for y in "dad"]')
|
|
|
|
def test_listcomp_if_listcomp_if():
|
|
check_ast('[x+y for x in "mom" if True for y in "dad" if y == "d"]')
|
|
|
|
def test_setcomp():
|
|
check_ast('{x for x in "mom"}')
|
|
|
|
def test_setcomp_if():
|
|
check_ast('{x for x in "mom" if True}')
|
|
|
|
def test_setcomp_if_and():
|
|
check_ast('{x for x in "mom" if True and x == "m"}')
|
|
|
|
def test_dbl_setcomp():
|
|
check_ast('{x+y for x in "mom" for y in "dad"}')
|
|
|
|
def test_setcomp_if_setcomp():
|
|
check_ast('{x+y for x in "mom" if True for y in "dad"}')
|
|
|
|
def test_setcomp_if_setcomp_if():
|
|
check_ast('{x+y for x in "mom" if True for y in "dad" if y == "d"}')
|
|
|
|
def test_dictcomp():
|
|
check_ast('{x: x for x in "mom"}')
|
|
|
|
def test_dictcomp_unpack_parens():
|
|
check_ast('{k: v for (k, v) in {"x": 42}.items()}')
|
|
|
|
def test_dictcomp_unpack_no_parens():
|
|
check_ast('{k: v for k, v in {"x": 42}.items()}')
|
|
|
|
def test_dictcomp_if():
|
|
check_ast('{x: x for x in "mom" if True}')
|
|
|
|
def test_dictcomp_if_and():
|
|
check_ast('{x: x for x in "mom" if True and x == "m"}')
|
|
|
|
def test_dbl_dictcomp():
|
|
check_ast('{x: y for x in "mom" for y in "dad"}')
|
|
|
|
def test_dictcomp_if_dictcomp():
|
|
check_ast('{x: y for x in "mom" if True for y in "dad"}')
|
|
|
|
def test_dictcomp_if_dictcomp_if():
|
|
check_ast('{x: y for x in "mom" if True for y in "dad" if y == "d"}')
|
|
|
|
def test_lambda():
|
|
check_ast('lambda: 42')
|
|
|
|
def test_lambda_x():
|
|
check_ast('lambda x: x')
|
|
|
|
def test_lambda_kwx():
|
|
check_ast('lambda x=42: x')
|
|
|
|
def test_lambda_x_y():
|
|
check_ast('lambda x, y: x')
|
|
|
|
def test_lambda_x_y_z():
|
|
check_ast('lambda x, y, z: x')
|
|
|
|
def test_lambda_x_kwy():
|
|
check_ast('lambda x, y=42: x')
|
|
|
|
def test_lambda_kwx_kwy():
|
|
check_ast('lambda x=65, y=42: x')
|
|
|
|
def test_lambda_kwx_kwy_kwz():
|
|
check_ast('lambda x=65, y=42, z=1: x')
|
|
|
|
def test_lambda_x_comma():
|
|
check_ast('lambda x,: x')
|
|
|
|
def test_lambda_x_y_comma():
|
|
check_ast('lambda x, y,: x')
|
|
|
|
def test_lambda_x_y_z_comma():
|
|
check_ast('lambda x, y, z,: x')
|
|
|
|
def test_lambda_x_kwy_comma():
|
|
check_ast('lambda x, y=42,: x')
|
|
|
|
def test_lambda_kwx_kwy_comma():
|
|
check_ast('lambda x=65, y=42,: x')
|
|
|
|
def test_lambda_kwx_kwy_kwz_comma():
|
|
check_ast('lambda x=65, y=42, z=1,: x')
|
|
|
|
def test_lambda_args():
|
|
check_ast('lambda *args: 42')
|
|
|
|
def test_lambda_args_x():
|
|
check_ast('lambda *args, x: 42')
|
|
|
|
def test_lambda_args_x_y():
|
|
check_ast('lambda *args, x, y: 42')
|
|
|
|
def test_lambda_args_x_kwy():
|
|
check_ast('lambda *args, x, y=10: 42')
|
|
|
|
def test_lambda_args_kwx_y():
|
|
check_ast('lambda *args, x=10, y: 42')
|
|
|
|
def test_lambda_args_kwx_kwy():
|
|
check_ast('lambda *args, x=42, y=65: 42')
|
|
|
|
def test_lambda_x_args():
|
|
check_ast('lambda x, *args: 42')
|
|
|
|
def test_lambda_x_args_y():
|
|
check_ast('lambda x, *args, y: 42')
|
|
|
|
def test_lambda_x_args_y_z():
|
|
check_ast('lambda x, *args, y, z: 42')
|
|
|
|
def test_lambda_kwargs():
|
|
check_ast('lambda **kwargs: 42')
|
|
|
|
def test_lambda_x_kwargs():
|
|
check_ast('lambda x, **kwargs: 42')
|
|
|
|
def test_lambda_x_y_kwargs():
|
|
check_ast('lambda x, y, **kwargs: 42')
|
|
|
|
def test_lambda_x_kwy_kwargs():
|
|
check_ast('lambda x, y=42, **kwargs: 42')
|
|
|
|
def test_lambda_args_kwargs():
|
|
check_ast('lambda *args, **kwargs: 42')
|
|
|
|
def test_lambda_x_args_kwargs():
|
|
check_ast('lambda x, *args, **kwargs: 42')
|
|
|
|
def test_lambda_x_y_args_kwargs():
|
|
check_ast('lambda x, y, *args, **kwargs: 42')
|
|
|
|
def test_lambda_kwx_args_kwargs():
|
|
check_ast('lambda x=10, *args, **kwargs: 42')
|
|
|
|
def test_lambda_x_kwy_args_kwargs():
|
|
check_ast('lambda x, y=42, *args, **kwargs: 42')
|
|
|
|
def test_lambda_x_args_y_kwargs():
|
|
check_ast('lambda x, *args, y, **kwargs: 42')
|
|
|
|
def test_lambda_x_args_kwy_kwargs():
|
|
check_ast('lambda x, *args, y=42, **kwargs: 42')
|
|
|
|
def test_lambda_args_y_kwargs():
|
|
check_ast('lambda *args, y, **kwargs: 42')
|
|
|
|
def test_lambda_star_x():
|
|
check_ast('lambda *, x: 42')
|
|
|
|
def test_lambda_star_x_y():
|
|
check_ast('lambda *, x, y: 42')
|
|
|
|
def test_lambda_star_x_kwargs():
|
|
check_ast('lambda *, x, **kwargs: 42')
|
|
|
|
def test_lambda_star_kwx_kwargs():
|
|
check_ast('lambda *, x=42, **kwargs: 42')
|
|
|
|
def test_lambda_x_star_y():
|
|
check_ast('lambda x, *, y: 42')
|
|
|
|
def test_lambda_x_y_star_z():
|
|
check_ast('lambda x, y, *, z: 42')
|
|
|
|
def test_lambda_x_kwy_star_y():
|
|
check_ast('lambda x, y=42, *, z: 42')
|
|
|
|
def test_lambda_x_kwy_star_kwy():
|
|
check_ast('lambda x, y=42, *, z=65: 42')
|
|
|
|
def test_lambda_x_star_y_kwargs():
|
|
check_ast('lambda x, *, y, **kwargs: 42')
|
|
|
|
def test_call_range():
|
|
check_ast('range(6)')
|
|
|
|
def test_call_range_comma():
|
|
check_ast('range(6,)')
|
|
|
|
def test_call_range_x_y():
|
|
check_ast('range(6, 10)')
|
|
|
|
def test_call_range_x_y_comma():
|
|
check_ast('range(6, 10,)')
|
|
|
|
def test_call_range_x_y_z():
|
|
check_ast('range(6, 10, 2)')
|
|
|
|
def test_call_dict_kwx():
|
|
check_ast('dict(start=10)')
|
|
|
|
def test_call_dict_kwx_comma():
|
|
check_ast('dict(start=10,)')
|
|
|
|
def test_call_dict_kwx_kwy():
|
|
check_ast('dict(start=10, stop=42)')
|
|
|
|
def test_call_tuple_gen():
|
|
check_ast('tuple(x for x in [1, 2, 3])')
|
|
|
|
def test_call_tuple_genifs():
|
|
check_ast('tuple(x for x in [1, 2, 3] if x < 3)')
|
|
|
|
def test_call_range_star():
|
|
check_ast('range(*[1, 2, 3])')
|
|
|
|
def test_call_range_x_star():
|
|
check_ast('range(1, *[2, 3])')
|
|
|
|
def test_call_int():
|
|
check_ast('int(*["42"], base=8)')
|
|
|
|
def test_call_int_base_dict():
|
|
check_ast('int(*["42"], **{"base": 8})')
|
|
|
|
def test_call_dict_kwargs():
|
|
check_ast('dict(**{"base": 8})')
|
|
|
|
@skip_if_py34
|
|
def test_call_list_many_star_args():
|
|
check_ast('min(*[1, 2], 3, *[4, 5])')
|
|
|
|
@skip_if_py34
|
|
def test_call_list_many_starstar_args():
|
|
check_ast('dict(**{"a": 2}, v=3, **{"c": 5})')
|
|
|
|
@skip_if_py34
|
|
def test_call_list_many_star_and_starstar_args():
|
|
check_ast('x(*[("a", 2)], *[("v", 3)], **{"c": 5})', False)
|
|
|
|
def test_call_alot():
|
|
check_ast('x(1, *args, **kwargs)', False)
|
|
|
|
def test_call_alot_next():
|
|
check_ast('x(x=1, *args, **kwargs)', False)
|
|
|
|
def test_call_alot_next_next():
|
|
check_ast('x(x=1, *args, y=42, **kwargs)', False)
|
|
|
|
def test_getattr():
|
|
check_ast('list.append')
|
|
|
|
def test_getattr_getattr():
|
|
check_ast('list.append.__str__')
|
|
|
|
def test_dict_tuple_key():
|
|
check_ast('{(42, 1): 65}')
|
|
|
|
def test_dict_tuple_key_get():
|
|
check_ast('{(42, 1): 65}[42, 1]')
|
|
|
|
def test_dict_tuple_key_get_3():
|
|
check_ast('{(42, 1, 3): 65}[42, 1, 3]')
|
|
|
|
def test_pipe_op():
|
|
check_ast('{42} | {65}')
|
|
|
|
def test_pipe_op_two():
|
|
check_ast('{42} | {65} | {1}')
|
|
|
|
def test_pipe_op_three():
|
|
check_ast('{42} | {65} | {1} | {7}')
|
|
|
|
def test_xor_op():
|
|
check_ast('{42} ^ {65}')
|
|
|
|
def test_xor_op_two():
|
|
check_ast('{42} ^ {65} ^ {1}')
|
|
|
|
def test_xor_op_three():
|
|
check_ast('{42} ^ {65} ^ {1} ^ {7}')
|
|
|
|
def test_xor_pipe():
|
|
check_ast('{42} ^ {65} | {1}')
|
|
|
|
def test_amp_op():
|
|
check_ast('{42} & {65}')
|
|
|
|
def test_amp_op_two():
|
|
check_ast('{42} & {65} & {1}')
|
|
|
|
def test_amp_op_three():
|
|
check_ast('{42} & {65} & {1} & {7}')
|
|
|
|
def test_lshift_op():
|
|
check_ast('42 << 65')
|
|
|
|
def test_lshift_op_two():
|
|
check_ast('42 << 65 << 1')
|
|
|
|
def test_lshift_op_three():
|
|
check_ast('42 << 65 << 1 << 7')
|
|
|
|
def test_rshift_op():
|
|
check_ast('42 >> 65')
|
|
|
|
def test_rshift_op_two():
|
|
check_ast('42 >> 65 >> 1')
|
|
|
|
def test_rshift_op_three():
|
|
check_ast('42 >> 65 >> 1 >> 7')
|
|
|
|
|
|
#
|
|
# statements
|
|
#
|
|
|
|
def test_equals():
|
|
check_stmts('x = 42')
|
|
|
|
def test_equals_semi():
|
|
check_stmts('x = 42;')
|
|
|
|
def test_x_y_equals_semi():
|
|
check_stmts('x = y = 42')
|
|
|
|
def test_equals_two():
|
|
check_stmts('x = 42; y = 65')
|
|
|
|
def test_equals_two_semi():
|
|
check_stmts('x = 42; y = 65;')
|
|
|
|
def test_equals_three():
|
|
check_stmts('x = 42; y = 65; z = 6')
|
|
|
|
def test_equals_three_semi():
|
|
check_stmts('x = 42; y = 65; z = 6;')
|
|
|
|
def test_plus_eq():
|
|
check_stmts('x = 42; x += 65')
|
|
|
|
def test_sub_eq():
|
|
check_stmts('x = 42; x -= 2')
|
|
|
|
def test_times_eq():
|
|
check_stmts('x = 42; x *= 2')
|
|
|
|
@skip_if_py34
|
|
def test_matmult_eq():
|
|
check_stmts('x @= y', False)
|
|
|
|
def test_div_eq():
|
|
check_stmts('x = 42; x /= 2')
|
|
|
|
def test_floordiv_eq():
|
|
check_stmts('x = 42; x //= 2')
|
|
|
|
def test_pow_eq():
|
|
check_stmts('x = 42; x **= 2')
|
|
|
|
def test_mod_eq():
|
|
check_stmts('x = 42; x %= 2')
|
|
|
|
def test_xor_eq():
|
|
check_stmts('x = 42; x ^= 2')
|
|
|
|
def test_ampersand_eq():
|
|
check_stmts('x = 42; x &= 2')
|
|
|
|
def test_bitor_eq():
|
|
check_stmts('x = 42; x |= 2')
|
|
|
|
def test_lshift_eq():
|
|
check_stmts('x = 42; x <<= 2')
|
|
|
|
def test_rshift_eq():
|
|
check_stmts('x = 42; x >>= 2')
|
|
|
|
def test_bare_unpack():
|
|
check_stmts('x, y = 42, 65')
|
|
|
|
def test_lhand_group_unpack():
|
|
check_stmts('(x, y) = 42, 65')
|
|
|
|
def test_rhand_group_unpack():
|
|
check_stmts('x, y = (42, 65)')
|
|
|
|
def test_grouped_unpack():
|
|
check_stmts('(x, y) = (42, 65)')
|
|
|
|
def test_double_grouped_unpack():
|
|
check_stmts('(x, y) = (z, a) = (7, 8)')
|
|
|
|
def test_double_ungrouped_unpack():
|
|
check_stmts('x, y = z, a = 7, 8')
|
|
|
|
def test_stary_eq():
|
|
check_stmts('*y, = [1, 2, 3]')
|
|
|
|
def test_stary_x():
|
|
check_stmts('*y, x = [1, 2, 3]')
|
|
|
|
def test_tuple_x_stary():
|
|
check_stmts('(x, *y) = [1, 2, 3]')
|
|
|
|
def test_list_x_stary():
|
|
check_stmts('[x, *y] = [1, 2, 3]')
|
|
|
|
def test_bare_x_stary():
|
|
check_stmts('x, *y = [1, 2, 3]')
|
|
|
|
def test_bare_x_stary_z():
|
|
check_stmts('x, *y, z = [1, 2, 2, 3]')
|
|
|
|
def test_equals_list():
|
|
check_stmts('x = [42]; x[0] = 65')
|
|
|
|
def test_equals_dict():
|
|
check_stmts('x = {42: 65}; x[42] = 3')
|
|
|
|
def test_equals_attr():
|
|
check_stmts('class X(object):\n pass\nx = X()\nx.a = 65')
|
|
|
|
def test_dict_keys():
|
|
check_stmts('x = {"x": 1}\nx.keys()')
|
|
|
|
def test_assert_msg():
|
|
check_stmts('assert True, "wow mom"')
|
|
|
|
def test_assert():
|
|
check_stmts('assert True')
|
|
|
|
def test_pass():
|
|
check_stmts('pass')
|
|
|
|
def test_del():
|
|
check_stmts('x = 42; del x')
|
|
|
|
def test_del_comma():
|
|
check_stmts('x = 42; del x,')
|
|
|
|
def test_del_two():
|
|
check_stmts('x = 42; y = 65; del x, y')
|
|
|
|
def test_del_two_comma():
|
|
check_stmts('x = 42; y = 65; del x, y,')
|
|
|
|
def test_raise():
|
|
check_stmts('raise', False)
|
|
|
|
def test_raise_x():
|
|
check_stmts('raise TypeError', False)
|
|
|
|
def test_raise_x_from():
|
|
check_stmts('raise TypeError from x', False)
|
|
|
|
def test_import_x():
|
|
check_stmts('import x', False)
|
|
|
|
def test_import_xy():
|
|
check_stmts('import x.y', False)
|
|
|
|
def test_import_xyz():
|
|
check_stmts('import x.y.z', False)
|
|
|
|
def test_from_x_import_y():
|
|
check_stmts('from x import y', False)
|
|
|
|
def test_from_dot_import_y():
|
|
check_stmts('from . import y', False)
|
|
|
|
def test_from_dotx_import_y():
|
|
check_stmts('from .x import y', False)
|
|
|
|
def test_from_dotdotx_import_y():
|
|
check_stmts('from ..x import y', False)
|
|
|
|
def test_from_dotdotdotx_import_y():
|
|
check_stmts('from ...x import y', False)
|
|
|
|
def test_from_dotdotdotdotx_import_y():
|
|
check_stmts('from ....x import y', False)
|
|
|
|
def test_from_import_x_y():
|
|
check_stmts('import x, y', False)
|
|
|
|
def test_from_import_x_y_z():
|
|
check_stmts('import x, y, z', False)
|
|
|
|
def test_from_dot_import_x_y():
|
|
check_stmts('from . import x, y', False)
|
|
|
|
def test_from_dot_import_x_y_z():
|
|
check_stmts('from . import x, y, z', False)
|
|
|
|
def test_from_dot_import_group_x_y():
|
|
check_stmts('from . import (x, y)', False)
|
|
|
|
def test_import_x_as_y():
|
|
check_stmts('import x as y', False)
|
|
|
|
def test_import_xy_as_z():
|
|
check_stmts('import x.y as z', False)
|
|
|
|
def test_import_x_y_as_z():
|
|
check_stmts('import x, y as z', False)
|
|
|
|
def test_import_x_as_y_z():
|
|
check_stmts('import x as y, z', False)
|
|
|
|
def test_import_x_as_y_z_as_a():
|
|
check_stmts('import x as y, z as a', False)
|
|
|
|
def test_from_dot_import_x_as_y():
|
|
check_stmts('from . import x as y', False)
|
|
|
|
def test_from_x_import_star():
|
|
check_stmts('from x import *', False)
|
|
|
|
def test_from_x_import_y_as_z():
|
|
check_stmts('from x import y as z', False)
|
|
|
|
def test_from_x_import_y_as_z_a_as_b():
|
|
check_stmts('from x import y as z, a as b', False)
|
|
|
|
def test_from_dotx_import_y_as_z_a_as_b_c_as_d():
|
|
check_stmts('from .x import y as z, a as b, c as d', False)
|
|
|
|
def test_continue():
|
|
check_stmts('continue', False)
|
|
|
|
def test_break():
|
|
check_stmts('break', False)
|
|
|
|
def test_global():
|
|
check_stmts('global x', False)
|
|
|
|
def test_global_xy():
|
|
check_stmts('global x, y', False)
|
|
|
|
def test_nonlocal_x():
|
|
check_stmts('nonlocal x', False)
|
|
|
|
def test_nonlocal_xy():
|
|
check_stmts('nonlocal x, y', False)
|
|
|
|
def test_yield():
|
|
check_stmts('yield', False)
|
|
|
|
def test_yield_x():
|
|
check_stmts('yield x', False)
|
|
|
|
def test_yield_x_comma():
|
|
check_stmts('yield x,', False)
|
|
|
|
def test_yield_x_y():
|
|
check_stmts('yield x, y', False)
|
|
|
|
def test_yield_from_x():
|
|
check_stmts('yield from x', False)
|
|
|
|
def test_return():
|
|
check_stmts('return', False)
|
|
|
|
def test_return_x():
|
|
check_stmts('return x', False)
|
|
|
|
def test_return_x_comma():
|
|
check_stmts('return x,', False)
|
|
|
|
def test_return_x_y():
|
|
check_stmts('return x, y', False)
|
|
|
|
def test_if_true():
|
|
check_stmts('if True:\n pass')
|
|
|
|
def test_if_true_twolines():
|
|
check_stmts('if True:\n pass\n pass')
|
|
|
|
def test_if_true_twolines_deindent():
|
|
check_stmts('if True:\n pass\n pass\npass')
|
|
|
|
def test_if_true_else():
|
|
check_stmts('if True:\n pass\nelse: \n pass')
|
|
|
|
def test_if_true_x():
|
|
check_stmts('if True:\n x = 42')
|
|
|
|
def test_if_switch():
|
|
check_stmts('x = 42\nif x == 1:\n pass')
|
|
|
|
def test_if_switch_elif1_else():
|
|
check_stmts('x = 42\nif x == 1:\n pass\n'
|
|
'elif x == 2:\n pass\nelse:\n pass')
|
|
|
|
def test_if_switch_elif2_else():
|
|
check_stmts('x = 42\nif x == 1:\n pass\n'
|
|
'elif x == 2:\n pass\n'
|
|
'elif x == 3:\n pass\n'
|
|
'elif x == 4:\n pass\n'
|
|
'else:\n pass')
|
|
|
|
def test_if_nested():
|
|
check_stmts('x = 42\nif x == 1:\n pass\n if x == 4:\n pass')
|
|
|
|
def test_while():
|
|
check_stmts('while False:\n pass')
|
|
|
|
def test_while_else():
|
|
check_stmts('while False:\n pass\nelse:\n pass')
|
|
|
|
def test_for():
|
|
check_stmts('for x in range(6):\n pass')
|
|
|
|
def test_for_zip():
|
|
check_stmts('for x, y in zip(range(6), "123456"):\n pass')
|
|
|
|
def test_for_idx():
|
|
check_stmts('x = [42]\nfor x[0] in range(3):\n pass')
|
|
|
|
def test_for_zip_idx():
|
|
check_stmts('x = [42]\nfor x[0], y in zip(range(6), "123456"):\n'
|
|
' pass')
|
|
|
|
def test_for_attr():
|
|
check_stmts('for x.a in range(3):\n pass', False)
|
|
|
|
def test_for_zip_attr():
|
|
check_stmts('for x.a, y in zip(range(6), "123456"):\n pass', False)
|
|
|
|
def test_for_else():
|
|
check_stmts('for x in range(6):\n pass\nelse: pass')
|
|
|
|
@skip_if_py34
|
|
def test_async_for():
|
|
check_stmts("async def f():\n async for x in y:\n pass\n", False)
|
|
|
|
def test_with():
|
|
check_stmts('with x:\n pass', False)
|
|
|
|
def test_with_as():
|
|
check_stmts('with x as y:\n pass', False)
|
|
|
|
def test_with_xy():
|
|
check_stmts('with x, y:\n pass', False)
|
|
|
|
def test_with_x_as_y_z():
|
|
check_stmts('with x as y, z:\n pass', False)
|
|
|
|
def test_with_x_as_y_a_as_b():
|
|
check_stmts('with x as y, a as b:\n pass', False)
|
|
|
|
def test_with_in_func():
|
|
check_stmts("def f():\n with x:\n pass\n")
|
|
|
|
@skip_if_py34
|
|
def test_async_with():
|
|
check_stmts("async def f():\n async with x as y:\n pass\n", False)
|
|
|
|
def test_try():
|
|
check_stmts('try:\n pass\nexcept:\n pass', False)
|
|
|
|
def test_try_except_t():
|
|
check_stmts('try:\n pass\nexcept TypeError:\n pass', False)
|
|
|
|
def test_try_except_t_as_e():
|
|
check_stmts('try:\n pass\nexcept TypeError as e:\n pass', False)
|
|
|
|
def test_try_except_t_u():
|
|
check_stmts('try:\n pass\nexcept (TypeError, SyntaxError):\n pass', False)
|
|
|
|
def test_try_except_t_u_as_e():
|
|
check_stmts('try:\n pass\nexcept (TypeError, SyntaxError) as e:\n pass', False)
|
|
|
|
def test_try_except_t_except_u():
|
|
check_stmts('try:\n pass\nexcept TypeError:\n pass\n'
|
|
'except SyntaxError as f:\n pass', False)
|
|
|
|
def test_try_except_else():
|
|
check_stmts('try:\n pass\nexcept:\n pass\nelse: pass', False)
|
|
|
|
def test_try_except_finally():
|
|
check_stmts('try:\n pass\nexcept:\n pass\nfinally: pass', False)
|
|
|
|
def test_try_except_else_finally():
|
|
check_stmts('try:\n pass\nexcept:\n pass\nelse:\n pass'
|
|
'\nfinally: pass', False)
|
|
|
|
def test_try_finally():
|
|
check_stmts('try:\n pass\nfinally: pass', False)
|
|
|
|
def test_func():
|
|
check_stmts('def f():\n pass')
|
|
|
|
def test_func_ret():
|
|
check_stmts('def f():\n return')
|
|
|
|
def test_func_ret_42():
|
|
check_stmts('def f():\n return 42')
|
|
|
|
def test_func_ret_42_65():
|
|
check_stmts('def f():\n return 42, 65')
|
|
|
|
def test_func_rarrow():
|
|
check_stmts('def f() -> int:\n pass')
|
|
|
|
def test_func_x():
|
|
check_stmts('def f(x):\n return x')
|
|
|
|
def test_func_kwx():
|
|
check_stmts('def f(x=42):\n return x')
|
|
|
|
def test_func_x_y():
|
|
check_stmts('def f(x, y):\n return x')
|
|
|
|
def test_func_x_y_z():
|
|
check_stmts('def f(x, y, z):\n return x')
|
|
|
|
def test_func_x_kwy():
|
|
check_stmts('def f(x, y=42):\n return x')
|
|
|
|
def test_func_kwx_kwy():
|
|
check_stmts('def f(x=65, y=42):\n return x')
|
|
|
|
def test_func_kwx_kwy_kwz():
|
|
check_stmts('def f(x=65, y=42, z=1):\n return x')
|
|
|
|
def test_func_x_comma():
|
|
check_stmts('def f(x,):\n return x')
|
|
|
|
def test_func_x_y_comma():
|
|
check_stmts('def f(x, y,):\n return x')
|
|
|
|
def test_func_x_y_z_comma():
|
|
check_stmts('def f(x, y, z,):\n return x')
|
|
|
|
def test_func_x_kwy_comma():
|
|
check_stmts('def f(x, y=42,):\n return x')
|
|
|
|
def test_func_kwx_kwy_comma():
|
|
check_stmts('def f(x=65, y=42,):\n return x')
|
|
|
|
def test_func_kwx_kwy_kwz_comma():
|
|
check_stmts('def f(x=65, y=42, z=1,):\n return x')
|
|
|
|
def test_func_args():
|
|
check_stmts('def f(*args):\n return 42')
|
|
|
|
def test_func_args_x():
|
|
check_stmts('def f(*args, x):\n return 42')
|
|
|
|
def test_func_args_x_y():
|
|
check_stmts('def f(*args, x, y):\n return 42')
|
|
|
|
def test_func_args_x_kwy():
|
|
check_stmts('def f(*args, x, y=10):\n return 42')
|
|
|
|
def test_func_args_kwx_y():
|
|
check_stmts('def f(*args, x=10, y):\n return 42')
|
|
|
|
def test_func_args_kwx_kwy():
|
|
check_stmts('def f(*args, x=42, y=65):\n return 42')
|
|
|
|
def test_func_x_args():
|
|
check_stmts('def f(x, *args):\n return 42')
|
|
|
|
def test_func_x_args_y():
|
|
check_stmts('def f(x, *args, y):\n return 42')
|
|
|
|
def test_func_x_args_y_z():
|
|
check_stmts('def f(x, *args, y, z):\n return 42')
|
|
|
|
def test_func_kwargs():
|
|
check_stmts('def f(**kwargs):\n return 42')
|
|
|
|
def test_func_x_kwargs():
|
|
check_stmts('def f(x, **kwargs):\n return 42')
|
|
|
|
def test_func_x_y_kwargs():
|
|
check_stmts('def f(x, y, **kwargs):\n return 42')
|
|
|
|
def test_func_x_kwy_kwargs():
|
|
check_stmts('def f(x, y=42, **kwargs):\n return 42')
|
|
|
|
def test_func_args_kwargs():
|
|
check_stmts('def f(*args, **kwargs):\n return 42')
|
|
|
|
def test_func_x_args_kwargs():
|
|
check_stmts('def f(x, *args, **kwargs):\n return 42')
|
|
|
|
def test_func_x_y_args_kwargs():
|
|
check_stmts('def f(x, y, *args, **kwargs):\n return 42')
|
|
|
|
def test_func_kwx_args_kwargs():
|
|
check_stmts('def f(x=10, *args, **kwargs):\n return 42')
|
|
|
|
def test_func_x_kwy_args_kwargs():
|
|
check_stmts('def f(x, y=42, *args, **kwargs):\n return 42')
|
|
|
|
def test_func_x_args_y_kwargs():
|
|
check_stmts('def f(x, *args, y, **kwargs):\n return 42')
|
|
|
|
def test_func_x_args_kwy_kwargs():
|
|
check_stmts('def f(x, *args, y=42, **kwargs):\n return 42')
|
|
|
|
def test_func_args_y_kwargs():
|
|
check_stmts('def f(*args, y, **kwargs):\n return 42')
|
|
|
|
def test_func_star_x():
|
|
check_stmts('def f(*, x):\n return 42')
|
|
|
|
def test_func_star_x_y():
|
|
check_stmts('def f(*, x, y):\n return 42')
|
|
|
|
def test_func_star_x_kwargs():
|
|
check_stmts('def f(*, x, **kwargs):\n return 42')
|
|
|
|
def test_func_star_kwx_kwargs():
|
|
check_stmts('def f(*, x=42, **kwargs):\n return 42')
|
|
|
|
def test_func_x_star_y():
|
|
check_stmts('def f(x, *, y):\n return 42')
|
|
|
|
def test_func_x_y_star_z():
|
|
check_stmts('def f(x, y, *, z):\n return 42')
|
|
|
|
def test_func_x_kwy_star_y():
|
|
check_stmts('def f(x, y=42, *, z):\n return 42')
|
|
|
|
def test_func_x_kwy_star_kwy():
|
|
check_stmts('def f(x, y=42, *, z=65):\n return 42')
|
|
|
|
def test_func_x_star_y_kwargs():
|
|
check_stmts('def f(x, *, y, **kwargs):\n return 42')
|
|
|
|
def test_func_tx():
|
|
check_stmts('def f(x:int):\n return x')
|
|
|
|
def test_func_txy():
|
|
check_stmts('def f(x:int, y:float=10.0):\n return x')
|
|
|
|
def test_class():
|
|
check_stmts('class X:\n pass')
|
|
|
|
def test_class_obj():
|
|
check_stmts('class X(object):\n pass')
|
|
|
|
def test_class_int_flt():
|
|
check_stmts('class X(int, object):\n pass')
|
|
|
|
def test_class_obj_kw():
|
|
# technically valid syntax, though it will fail to compile
|
|
check_stmts('class X(object=5):\n pass', False)
|
|
|
|
def test_decorator():
|
|
check_stmts('@g\ndef f():\n pass', False)
|
|
|
|
def test_decorator_2():
|
|
check_stmts('@h\n@g\ndef f():\n pass', False)
|
|
|
|
def test_decorator_call():
|
|
check_stmts('@g()\ndef f():\n pass', False)
|
|
|
|
def test_decorator_call_args():
|
|
check_stmts('@g(x, y=10)\ndef f():\n pass', False)
|
|
|
|
def test_decorator_dot_call_args():
|
|
check_stmts('@h.g(x, y=10)\ndef f():\n pass', False)
|
|
|
|
def test_decorator_dot_dot_call_args():
|
|
check_stmts('@i.h.g(x, y=10)\ndef f():\n pass', False)
|
|
|
|
def test_broken_prompt_func():
|
|
code = ('def prompt():\n'
|
|
" return '{user}'.format(\n"
|
|
" user='me')\n")
|
|
check_stmts(code, False)
|
|
|
|
def test_class_with_methods():
|
|
code = ('class Test:\n'
|
|
' def __init__(self):\n'
|
|
' self.msg("hello world")\n'
|
|
' def msg(self, m):\n'
|
|
' print(m)\n')
|
|
check_stmts(code, False)
|
|
|
|
def test_nested_functions():
|
|
code = ('def test(x):\n'
|
|
' def test2(y):\n'
|
|
' return y+x\n'
|
|
' return test2\n')
|
|
check_stmts(code, False)
|
|
|
|
def test_function_blank_line():
|
|
code = ('def foo():\n'
|
|
' ascii_art = [\n'
|
|
' "(╯°□°）╯︵ ┻━┻",\n'
|
|
' "¯\\_(ツ)_/¯",\n'
|
|
' "┻━┻︵ \\(°□°)/ ︵ ┻━┻",\n'
|
|
' ]\n'
|
|
'\n'
|
|
' import random\n'
|
|
' i = random.randint(0,len(ascii_art)) - 1\n'
|
|
' print(" Get to work!")\n'
|
|
' print(ascii_art[i])\n')
|
|
check_stmts(code, False)
|
|
|
|
|
|
@skip_if_py34
|
|
def test_async_func():
|
|
check_stmts('async def f():\n pass\n')
|
|
|
|
@skip_if_py34
|
|
def test_async_decorator():
|
|
check_stmts('@g\nasync def f():\n pass', False)
|
|
|
|
@skip_if_py34
|
|
def test_async_await():
|
|
check_stmts("async def f():\n await fut\n", False)
|
|
|
|
#
|
|
# Xonsh specific syntax
|
|
#
|
|
|
|
def test_dollar_name():
|
|
check_xonsh_ast({'WAKKA': 42}, '$WAKKA')
|
|
|
|
def test_dollar_py():
|
|
check_xonsh({'WAKKA': 42}, 'x = "WAKKA"; y = ${x}')
|
|
|
|
def test_dollar_py_test():
|
|
check_xonsh_ast({'WAKKA': 42}, '${None or "WAKKA"}')
|
|
|
|
def test_dollar_py_recursive_name():
|
|
check_xonsh_ast({'WAKKA': 42, 'JAWAKA': 'WAKKA'}, '${$JAWAKA}')
|
|
|
|
def test_dollar_py_test_recursive_name():
|
|
check_xonsh_ast({'WAKKA': 42, 'JAWAKA': 'WAKKA'}, '${None or $JAWAKA}')
|
|
|
|
def test_dollar_py_test_recursive_test():
|
|
check_xonsh_ast({'WAKKA': 42, 'JAWAKA': 'WAKKA'},
|
|
'${${"JAWA" + $JAWAKA[-2:]}}')
|
|
|
|
def test_dollar_name_set():
|
|
check_xonsh({'WAKKA': 42}, '$WAKKA = 42')
|
|
|
|
def test_dollar_py_set():
|
|
check_xonsh({'WAKKA': 42}, 'x = "WAKKA"; ${x} = 65')
|
|
|
|
def test_dollar_sub():
|
|
check_xonsh_ast({}, '$(ls)', False)
|
|
|
|
def test_dollar_sub_space():
|
|
check_xonsh_ast({}, '$(ls )', False)
|
|
|
|
def test_ls_dot():
|
|
check_xonsh_ast({}, '$(ls .)', False)
|
|
|
|
def test_lambda_in_atparens():
|
|
check_xonsh_ast({}, '$(echo hello | @(lambda a, s=None: "hey!") foo bar baz)', False)
|
|
|
|
def test_nested_madness():
|
|
check_xonsh_ast({}, '$(@$(which echo) ls | @(lambda a, s=None: $(@(s.strip()) @(a[1]))) foo -la baz)', False)
|
|
|
|
def test_ls_dot_nesting():
|
|
check_xonsh_ast({}, '$(ls @(None or "."))', False)
|
|
|
|
def test_ls_dot_nesting_var():
|
|
check_xonsh({}, 'x = "."; $(ls @(None or x))', False)
|
|
|
|
def test_ls_dot_str():
|
|
check_xonsh_ast({}, '$(ls ".")', False)
|
|
|
|
def test_ls_nest_ls():
|
|
check_xonsh_ast({}, '$(ls $(ls))', False)
|
|
|
|
def test_ls_nest_ls_dashl():
|
|
check_xonsh_ast({}, '$(ls $(ls) -l)', False)
|
|
|
|
def test_ls_envvar_strval():
|
|
check_xonsh_ast({'WAKKA': '.'}, '$(ls $WAKKA)', False)
|
|
|
|
def test_ls_envvar_listval():
|
|
check_xonsh_ast({'WAKKA': ['.', '.']}, '$(ls $WAKKA)', False)
|
|
|
|
def test_bang_sub():
|
|
check_xonsh_ast({}, '!(ls)', False)
|
|
|
|
def test_bang_sub_space():
|
|
check_xonsh_ast({}, '!(ls )', False)
|
|
|
|
def test_bang_ls_dot():
|
|
check_xonsh_ast({}, '!(ls .)', False)
|
|
|
|
def test_bang_ls_dot_nesting():
|
|
check_xonsh_ast({}, '!(ls @(None or "."))', False)
|
|
|
|
def test_bang_ls_dot_nesting_var():
|
|
check_xonsh({}, 'x = "."; !(ls @(None or x))', False)
|
|
|
|
def test_bang_ls_dot_str():
|
|
check_xonsh_ast({}, '!(ls ".")', False)
|
|
|
|
def test_bang_ls_nest_ls():
|
|
check_xonsh_ast({}, '!(ls $(ls))', False)
|
|
|
|
def test_bang_ls_nest_ls_dashl():
|
|
check_xonsh_ast({}, '!(ls $(ls) -l)', False)
|
|
|
|
def test_bang_ls_envvar_strval():
|
|
check_xonsh_ast({'WAKKA': '.'}, '!(ls $WAKKA)', False)
|
|
|
|
def test_bang_ls_envvar_listval():
|
|
check_xonsh_ast({'WAKKA': ['.', '.']}, '!(ls $WAKKA)', False)
|
|
|
|
def test_question():
|
|
check_xonsh_ast({}, 'range?')
|
|
|
|
def test_dobquestion():
|
|
check_xonsh_ast({}, 'range??')
|
|
|
|
def test_question_chain():
|
|
check_xonsh_ast({}, 'range?.index?')
|
|
|
|
def test_ls_regex():
|
|
check_xonsh_ast({}, '$(ls `[Ff]+i*LE` -l)', False)
|
|
|
|
def test_backtick():
|
|
check_xonsh_ast({}, 'print(`.*`)', False)
|
|
|
|
def test_ls_regex_octothorpe():
|
|
check_xonsh_ast({}, '$(ls `#[Ff]+i*LE` -l)', False)
|
|
|
|
def test_ls_explicitregex():
|
|
check_xonsh_ast({}, '$(ls r`[Ff]+i*LE` -l)', False)
|
|
|
|
def test_rbacktick():
|
|
check_xonsh_ast({}, 'print(r`.*`)', False)
|
|
|
|
def test_ls_explicitregex_octothorpe():
|
|
check_xonsh_ast({}, '$(ls r`#[Ff]+i*LE` -l)', False)
|
|
|
|
def test_ls_glob():
|
|
check_xonsh_ast({}, '$(ls g`[Ff]+i*LE` -l)', False)
|
|
|
|
def test_gbacktick():
|
|
check_xonsh_ast({}, 'print(g`.*`)', False)
|
|
|
|
def test_ls_glob_octothorpe():
|
|
check_xonsh_ast({}, '$(ls g`#[Ff]+i*LE` -l)', False)
|
|
|
|
def test_ls_customsearch():
|
|
check_xonsh_ast({}, '$(ls @foo`[Ff]+i*LE` -l)', False)
|
|
|
|
def test_custombacktick():
|
|
check_xonsh_ast({}, 'print(@foo`.*`)', False)
|
|
|
|
def test_ls_customsearch_octothorpe():
|
|
check_xonsh_ast({}, '$(ls @foo`#[Ff]+i*LE` -l)', False)
|
|
|
|
def test_injection():
|
|
check_xonsh_ast({}, '$[@$(which python)]', False)
|
|
|
|
def test_rhs_nested_injection():
|
|
check_xonsh_ast({}, '$[ls @$(dirname @$(which python))]', False)
|
|
|
|
def test_backtick_octothorpe():
|
|
check_xonsh_ast({}, 'print(`#.*`)', False)
|
|
|
|
def test_uncaptured_sub():
|
|
check_xonsh_ast({}, '$[ls]', False)
|
|
|
|
def test_hiddenobj_sub():
|
|
check_xonsh_ast({}, '![ls]', False)
|
|
|
|
def test_bang_two_cmds_one_pipe():
|
|
check_xonsh_ast({}, '!(ls | grep wakka)', False)
|
|
|
|
def test_bang_three_cmds_two_pipes():
|
|
check_xonsh_ast({}, '!(ls | grep wakka | grep jawaka)', False)
|
|
|
|
def test_bang_one_cmd_write():
|
|
check_xonsh_ast({}, '!(ls > x.py)', False)
|
|
|
|
def test_bang_one_cmd_append():
|
|
check_xonsh_ast({}, '!(ls >> x.py)', False)
|
|
|
|
def test_bang_two_cmds_write():
|
|
check_xonsh_ast({}, '!(ls | grep wakka > x.py)', False)
|
|
|
|
def test_bang_two_cmds_append():
|
|
check_xonsh_ast({}, '!(ls | grep wakka >> x.py)', False)
|
|
|
|
def test_bang_cmd_background():
|
|
check_xonsh_ast({}, '!(emacs ugggh &)', False)
|
|
|
|
def test_bang_cmd_background_nospace():
|
|
check_xonsh_ast({}, '!(emacs ugggh&)', False)
|
|
|
|
def test_bang_git_quotes_no_space():
|
|
check_xonsh_ast({}, '![git commit -am "wakka"]', False)
|
|
|
|
def test_bang_git_quotes_space():
|
|
check_xonsh_ast({}, '![git commit -am "wakka jawaka"]', False)
|
|
|
|
def test_bang_git_two_quotes_space():
|
|
check_xonsh({}, '![git commit -am "wakka jawaka"]\n'
|
|
'![git commit -am "flock jawaka"]\n', False)
|
|
|
|
def test_bang_git_two_quotes_space_space():
|
|
check_xonsh({}, '![git commit -am "wakka jawaka" ]\n'
|
|
'![git commit -am "flock jawaka milwaka" ]\n', False)
|
|
|
|
def test_bang_ls_quotes_3_space():
|
|
check_xonsh_ast({}, '![ls "wakka jawaka baraka"]', False)
|
|
|
|
def test_two_cmds_one_pipe():
|
|
check_xonsh_ast({}, '$(ls | grep wakka)', False)
|
|
|
|
def test_three_cmds_two_pipes():
|
|
check_xonsh_ast({}, '$(ls | grep wakka | grep jawaka)', False)
|
|
|
|
def test_two_cmds_one_and_brackets():
|
|
check_xonsh_ast({}, '![ls me] and ![grep wakka]', False)
|
|
|
|
def test_three_cmds_two_ands():
|
|
check_xonsh_ast({}, '![ls] and ![grep wakka] and ![grep jawaka]', False)
|
|
|
|
def test_two_cmds_one_doubleamps():
|
|
check_xonsh_ast({}, '![ls] && ![grep wakka]', False)
|
|
|
|
def test_three_cmds_two_doubleamps():
|
|
check_xonsh_ast({}, '![ls] && ![grep wakka] && ![grep jawaka]', False)
|
|
|
|
def test_two_cmds_one_or():
|
|
check_xonsh_ast({}, '![ls] or ![grep wakka]', False)
|
|
|
|
def test_three_cmds_two_ors():
|
|
check_xonsh_ast({}, '![ls] or ![grep wakka] or ![grep jawaka]', False)
|
|
|
|
def test_two_cmds_one_doublepipe():
|
|
check_xonsh_ast({}, '![ls] || ![grep wakka]', False)
|
|
|
|
def test_three_cmds_two_doublepipe():
|
|
check_xonsh_ast({}, '![ls] || ![grep wakka] || ![grep jawaka]', False)
|
|
|
|
def test_one_cmd_write():
|
|
check_xonsh_ast({}, '$(ls > x.py)', False)
|
|
|
|
def test_one_cmd_append():
|
|
check_xonsh_ast({}, '$(ls >> x.py)', False)
|
|
|
|
def test_two_cmds_write():
|
|
check_xonsh_ast({}, '$(ls | grep wakka > x.py)', False)
|
|
|
|
def test_two_cmds_append():
|
|
check_xonsh_ast({}, '$(ls | grep wakka >> x.py)', False)
|
|
|
|
def test_cmd_background():
|
|
check_xonsh_ast({}, '$(emacs ugggh &)', False)
|
|
|
|
def test_cmd_background_nospace():
|
|
check_xonsh_ast({}, '$(emacs ugggh&)', False)
|
|
|
|
def test_git_quotes_no_space():
|
|
check_xonsh_ast({}, '$[git commit -am "wakka"]', False)
|
|
|
|
def test_git_quotes_space():
|
|
check_xonsh_ast({}, '$[git commit -am "wakka jawaka"]', False)
|
|
|
|
def test_git_two_quotes_space():
|
|
check_xonsh({}, '$[git commit -am "wakka jawaka"]\n'
|
|
'$[git commit -am "flock jawaka"]\n', False)
|
|
|
|
def test_git_two_quotes_space_space():
|
|
check_xonsh({}, '$[git commit -am "wakka jawaka" ]\n'
|
|
'$[git commit -am "flock jawaka milwaka" ]\n', False)
|
|
|
|
def test_ls_quotes_3_space():
|
|
check_xonsh_ast({}, '$[ls "wakka jawaka baraka"]', False)
|
|
|
|
def test_echo_comma():
|
|
check_xonsh_ast({}, '![echo ,]', False)
|
|
|
|
def test_echo_internal_comma():
|
|
check_xonsh_ast({}, '![echo 1,2]', False)
|
|
|
|
def test_comment_only():
|
|
check_xonsh_ast({}, '# hello')
|
|
|
|
def test_echo_slash_question():
|
|
check_xonsh_ast({}, '![echo /?]', False)
|
|
|
|
|
|
def test_redirect():
|
|
assert check_xonsh_ast({}, '$[cat < input.txt]', False)
|
|
assert check_xonsh_ast({}, '$[< input.txt cat]', False)
|
|
|
|
@pytest.mark.parametrize('case', ['', 'o', 'out', '1'])
|
|
def test_redirect_output(case):
|
|
assert check_xonsh_ast({}, '$[echo "test" {}> test.txt]'.format(case), False)
|
|
assert check_xonsh_ast({}, '$[< input.txt echo "test" {}> test.txt]'.format(case), False)
|
|
assert check_xonsh_ast({}, '$[echo "test" {}> test.txt < input.txt]'.format(case), False)
|
|
|
|
@pytest.mark.parametrize('case', ['e', 'err', '2'])
|
|
def test_redirect_error(case):
|
|
assert check_xonsh_ast({}, '$[echo "test" {}> test.txt]'.format(case), False)
|
|
assert check_xonsh_ast({}, '$[< input.txt echo "test" {}> test.txt]'.format(case), False)
|
|
assert check_xonsh_ast({}, '$[echo "test" {}> test.txt < input.txt]'.format(case), False)
|
|
|
|
@pytest.mark.parametrize('case', ['a', 'all', '&'])
|
|
def test_redirect_all(case):
|
|
assert check_xonsh_ast({}, '$[echo "test" {}> test.txt]'.format(case), False)
|
|
assert check_xonsh_ast({}, '$[< input.txt echo "test" {}> test.txt]'.format(case), False)
|
|
assert check_xonsh_ast({}, '$[echo "test" {}> test.txt < input.txt]'.format(case), False)
|
|
|
|
@pytest.mark.parametrize('r',
|
|
['e>o', 'e>out', 'err>o', 'err>o',
|
|
' 2>1', 'e>1', 'err>1', '2>out',
|
|
'2>o', 'err>&1', 'e>&1', '2>&1'
|
|
])
|
|
@pytest.mark.parametrize('o', ['', 'o', 'out', '1'])
|
|
def test_redirect_error_to_output(r, o):
|
|
assert check_xonsh_ast({}, '$[echo "test" {} {}> test.txt]'.format(r, o), False)
|
|
assert check_xonsh_ast({}, '$[< input.txt echo "test" {} {}> test.txt]'.format(r, o), False)
|
|
assert check_xonsh_ast({}, '$[echo "test" {} {}> test.txt < input.txt]'.format(r, o), False)
|