text: """Tests the xonsh parser."""
  import ast
  import itertools
  import textwrap
  
  import pytest
  
  from xonsh.ast import AST, Call, Pass, Str, With
  from xonsh.parser import Parser
  from xonsh.parsers.fstring_adaptor import FStringAdaptor
  from xonsh.pytest.tools import (
      VER_MAJOR_MINOR,
      nodes_equal,
      skip_if_pre_3_8,
      skip_if_pre_3_10,
  )
  
  
  @pytest.fixture
  def xsh(xession, monkeypatch, parser):
      monkeypatch.setattr(xession.execer, "parser", parser)
      return xession
  
  
  @pytest.fixture(scope="module")
  def parser():
      return Parser(yacc_optimize=False, yacc_debug=True)
  
  
  @pytest.fixture
  def check_ast(parser, xsh):
      def factory(inp, run=True, mode="eval", debug_level=0):
          __tracebackhide__ = True
          # expect a Python AST
          exp = ast.parse(inp, mode=mode)
          # observe something from xonsh
          obs = parser.parse(inp, debug_level=debug_level)
          # 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))
  
      return factory
  
  
  @pytest.fixture
  def check_stmts(check_ast):
      def factory(inp, run=True, mode="exec", debug_level=0):
          __tracebackhide__ = True
          if not inp.endswith("\n"):
              inp += "\n"
          check_ast(inp, run=run, mode=mode, debug_level=debug_level)
  
      return factory
  
  
  @pytest.fixture
  def check_xonsh_ast(xsh, parser):
      def factory(
          xenv,
          inp,
          run=True,
          mode="eval",
          debug_level=0,
          return_obs=False,
          globals=None,
          locals=None,
      ):
          xsh.env.update(xenv)
          obs = parser.parse(inp, debug_level=debug_level)
          if obs is None:
              return  # comment only
          bytecode = compile(obs, "<test-xonsh-ast>", mode)
          if run:
              exec(bytecode, globals, locals)
          return obs if return_obs else True
  
      return factory
  
  
  @pytest.fixture
  def check_xonsh(check_xonsh_ast):
      def factory(xenv, inp, run=True, mode="exec"):
          __tracebackhide__ = True
          if not inp.endswith("\n"):
              inp += "\n"
          check_xonsh_ast(xenv, inp, run=run, mode=mode)
  
      return factory
  
  
  @pytest.fixture
  def eval_code(parser, xsh):
      def factory(inp, mode="eval", **loc_vars):
          obs = parser.parse(inp, debug_level=1)
          bytecode = compile(obs, "<test-xonsh-ast>", mode)
          return eval(bytecode, loc_vars)
  
      return factory
  
  
  #
  # Tests
  #
  
  #
  # expressions
  #
  
  
  def test_int_literal(check_ast):
      check_ast("42")
  
  
  def test_int_literal_underscore(check_ast):
      check_ast("4_2")
  
  
  def test_float_literal(check_ast):
      check_ast("42.0")
  
  
  def test_float_literal_underscore(check_ast):
      check_ast("4_2.4_2")
  
  
  def test_imag_literal(check_ast):
      check_ast("42j")
  
  
  def test_float_imag_literal(check_ast):
      check_ast("42.0j")
  
  
  def test_complex(check_ast):
      check_ast("42+84j")
  
  
  def test_str_literal(check_ast):
      check_ast('"hello"')
  
  
  def test_bytes_literal(check_ast):
      check_ast('b"hello"')
      check_ast('B"hello"')
  
  
  def test_raw_literal(check_ast):
      check_ast('r"hell\\o"')
      check_ast('R"hell\\o"')
  
  
  def test_f_literal(check_ast):
      check_ast('f"wakka{yo}yakka{42}"', run=False)
      check_ast('F"{yo}"', run=False)
  
  
  def test_f_env_var(check_xonsh_ast):
      check_xonsh_ast({}, 'f"{$HOME}"', run=False)
      check_xonsh_ast({}, "f'{$XONSH_DEBUG}'", run=False)
      check_xonsh_ast({}, 'F"{$PATH} and {$XONSH_DEBUG}"', run=False)
  
  
  fstring_adaptor_parameters = [
      ('f"$HOME"', "$HOME"),
      ('f"{0} - {1}"', "0 - 1"),
      ('f"{$HOME}"', "/foo/bar"),
      ('f"{ $HOME }"', "/foo/bar"),
      ("f\"{'$HOME'}\"", "$HOME"),
      ('f"$HOME  = {$HOME}"', "$HOME  = /foo/bar"),
      ("f\"{${'HOME'}}\"", "/foo/bar"),
      ("f'{${$FOO+$BAR}}'", "/foo/bar"),
      ("f\"${$FOO}{$BAR}={f'{$HOME}'}\"", "$HOME=/foo/bar"),
      (
          '''f"""foo
  {f"_{$HOME}_"}
  bar"""''',
          "foo\n_/foo/bar_\nbar",
      ),
      (
          '''f"""foo
  {f"_{${'HOME'}}_"}
  bar"""''',
          "foo\n_/foo/bar_\nbar",
      ),
      (
          '''f"""foo
  {f"_{${ $FOO + $BAR }}_"}
  bar"""''',
          "foo\n_/foo/bar_\nbar",
      ),
  ]
  if VER_MAJOR_MINOR >= (3, 8):
      fstring_adaptor_parameters.append(("f'{$HOME=}'", "$HOME='/foo/bar'"))
  
  
  @pytest.mark.parametrize("inp, exp", fstring_adaptor_parameters)
  def test_fstring_adaptor(inp, exp, xsh, monkeypatch):
      joined_str_node = FStringAdaptor(inp, "f").run()
      assert isinstance(joined_str_node, ast.JoinedStr)
      node = ast.Expression(body=joined_str_node)
      code = compile(node, "<test_fstring_adaptor>", mode="eval")
      xenv = {"HOME": "/foo/bar", "FOO": "HO", "BAR": "ME"}
      for key, val in xenv.items():
          monkeypatch.setitem(xsh.env, key, val)
      obs = eval(code)
      assert exp == obs
  
  
  def test_raw_bytes_literal(check_ast):
      check_ast('br"hell\\o"')
      check_ast('RB"hell\\o"')
      check_ast('Br"hell\\o"')
      check_ast('rB"hell\\o"')
  
  
  def test_unary_plus(check_ast):
      check_ast("+1")
  
  
  def test_unary_minus(check_ast):
      check_ast("-1")
  
  
  def test_unary_invert(check_ast):
      check_ast("~1")
  
  
  def test_binop_plus(check_ast):
      check_ast("42 + 65")
  
  
  def test_binop_minus(check_ast):
      check_ast("42 - 65")
  
  
  def test_binop_times(check_ast):
      check_ast("42 * 65")
  
  
  def test_binop_matmult(check_ast):
      check_ast("x @ y", False)
  
  
  def test_binop_div(check_ast):
      check_ast("42 / 65")
  
  
  def test_binop_mod(check_ast):
      check_ast("42 % 65")
  
  
  def test_binop_floordiv(check_ast):
      check_ast("42 // 65")
  
  
  def test_binop_pow(check_ast):
      check_ast("2 ** 2")
  
  
  def test_plus_pow(check_ast):
      check_ast("42 + 2 ** 2")
  
  
  def test_plus_plus(check_ast):
      check_ast("42 + 65 + 6")
  
  
  def test_plus_minus(check_ast):
      check_ast("42 + 65 - 6")
  
  
  def test_minus_plus(check_ast):
      check_ast("42 - 65 + 6")
  
  
  def test_minus_minus(check_ast):
      check_ast("42 - 65 - 6")
  
  
  def test_minus_plus_minus(check_ast):
      check_ast("42 - 65 + 6 - 28")
  
  
  def test_times_plus(check_ast):
      check_ast("42 * 65 + 6")
  
  
  def test_plus_times(check_ast):
      check_ast("42 + 65 * 6")
  
  
  def test_times_times(check_ast):
      check_ast("42 * 65 * 6")
  
  
  def test_times_div(check_ast):
      check_ast("42 * 65 / 6")
  
  
  def test_times_div_mod(check_ast):
      check_ast("42 * 65 / 6 % 28")
  
  
  def test_times_div_mod_floor(check_ast):
      check_ast("42 * 65 / 6 % 28 // 13")
  
  
  def test_str_str(check_ast):
      check_ast("\"hello\" 'mom'")
  
  
  def test_str_str_str(check_ast):
      check_ast('"hello" \'mom\'    "wow"')
  
  
  def test_str_plus_str(check_ast):
      check_ast("\"hello\" + 'mom'")
  
  
  def test_str_times_int(check_ast):
      check_ast('"hello" * 20')
  
  
  def test_int_times_str(check_ast):
      check_ast('2*"hello"')
  
  
  def test_group_plus_times(check_ast):
      check_ast("(42 + 65) * 20")
  
  
  def test_plus_group_times(check_ast):
      check_ast("42 + (65 * 20)")
  
  
  def test_group(check_ast):
      check_ast("(42)")
  
  
  def test_lt(check_ast):
      check_ast("42 < 65")
  
  
  def test_gt(check_ast):
      check_ast("42 > 65")
  
  
  def test_eq(check_ast):
      check_ast("42 == 65")
  
  
  def test_le(check_ast):
      check_ast("42 <= 65")
  
  
  def test_ge(check_ast):
      check_ast("42 >= 65")
  
  
  def test_ne(check_ast):
      check_ast("42 != 65")
  
  
  def test_in(check_ast):
      check_ast('"4" in "65"')
  
  
  def test_is(check_ast):
      check_ast("int is float")  # avoid PY3.8 SyntaxWarning "is" with a literal
  
  
  def test_not_in(check_ast):
      check_ast('"4" not in "65"')
  
  
  def test_is_not(check_ast):
      check_ast("float is not int")
  
  
  def test_lt_lt(check_ast):
      check_ast("42 < 65 < 105")
  
  
  def test_lt_lt_lt(check_ast):
      check_ast("42 < 65 < 105 < 77")
  
  
  def test_not(check_ast):
      check_ast("not 0")
  
  
  def test_or(check_ast):
      check_ast("1 or 0")
  
  
  def test_or_or(check_ast):
      check_ast("1 or 0 or 42")
  
  
  def test_and(check_ast):
      check_ast("1 and 0")
  
  
  def test_and_and(check_ast):
      check_ast("1 and 0 and 2")
  
  
  def test_and_or(check_ast):
      check_ast("1 and 0 or 2")
  
  
  def test_or_and(check_ast):
      check_ast("1 or 0 and 2")
  
  
  def test_group_and_and(check_ast):
      check_ast("(1 and 0) and 2")
  
  
  def test_group_and_or(check_ast):
      check_ast("(1 and 0) or 2")
  
  
  def test_if_else_expr(check_ast):
      check_ast("42 if True else 65")
  
  
  def test_if_else_expr_expr(check_ast):
      check_ast("42+5 if 1 == 2 else 65-5")
  
  
  def test_subscription_syntaxes(eval_code):
      assert eval_code("[1, 2, 3][-1]") == 3
      assert eval_code("[1, 2, 3][-1]") == 3
      assert eval_code("'string'[-1]") == "g"
  
  
  @pytest.fixture
  def arr_container():
      # like numpy.r_
      class Arr:
          def __getitem__(self, item):
              return item
  
      return Arr()
  
  
  def test_subscription_special_syntaxes(arr_container, eval_code):
      assert eval_code("arr[1, 2, 3]", arr=arr_container) == (1, 2, 3)
      # dataframe
      assert eval_code('arr[["a", "b"]]', arr=arr_container) == ["a", "b"]
  
  
  # todo: enable this test
  @pytest.mark.xfail
  def test_subscription_special_syntaxes_2(arr_container, eval_code):
      # aliases
      d = {}
      eval_code("d[arr.__name__]=True", arr=arr_container, d=d)
      assert d == {"Arr": True}
      # extslice
      assert eval_code('arr[:, "2"]') == 2
  
  
  def test_str_idx(check_ast):
      check_ast('"hello"[0]')
  
  
  def test_str_slice(check_ast):
      check_ast('"hello"[0:3]')
  
  
  def test_str_step(check_ast):
      check_ast('"hello"[0:3:1]')
  
  
  def test_str_slice_all(check_ast):
      check_ast('"hello"[:]')
  
  
  def test_str_slice_upper(check_ast):
      check_ast('"hello"[5:]')
  
  
  def test_str_slice_lower(check_ast):
      check_ast('"hello"[:3]')
  
  
  def test_str_slice_other(check_ast):
      check_ast('"hello"[::2]')
  
  
  def test_str_slice_lower_other(check_ast):
      check_ast('"hello"[:3:2]')
  
  
  def test_str_slice_upper_other(check_ast):
      check_ast('"hello"[3::2]')
  
  
  def test_str_2slice(check_ast):
      check_ast('"hello"[0:3,0:3]', False)
  
  
  def test_str_2step(check_ast):
      check_ast('"hello"[0:3:1,0:4:2]', False)
  
  
  def test_str_2slice_all(check_ast):
      check_ast('"hello"[:,:]', False)
  
  
  def test_str_2slice_upper(check_ast):
      check_ast('"hello"[5:,5:]', False)
  
  
  def test_str_2slice_lower(check_ast):
      check_ast('"hello"[:3,:3]', False)
  
  
  def test_str_2slice_lowerupper(check_ast):
      check_ast('"hello"[5:,:3]', False)
  
  
  def test_str_2slice_other(check_ast):
      check_ast('"hello"[::2,::2]', False)
  
  
  def test_str_2slice_lower_other(check_ast):
      check_ast('"hello"[:3:2,:3:2]', False)
  
  
  def test_str_2slice_upper_other(check_ast):
      check_ast('"hello"[3::2,3::2]', False)
  
  
  def test_str_3slice(check_ast):
      check_ast('"hello"[0:3,0:3,0:3]', False)
  
  
  def test_str_3step(check_ast):
      check_ast('"hello"[0:3:1,0:4:2,1:3:2]', False)
  
  
  def test_str_3slice_all(check_ast):
      check_ast('"hello"[:,:,:]', False)
  
  
  def test_str_3slice_upper(check_ast):
      check_ast('"hello"[5:,5:,5:]', False)
  
  
  def test_str_3slice_lower(check_ast):
      check_ast('"hello"[:3,:3,:3]', False)
  
  
  def test_str_3slice_lowerlowerupper(check_ast):
      check_ast('"hello"[:3,:3,:3]', False)
  
  
  def test_str_3slice_lowerupperlower(check_ast):
      check_ast('"hello"[:3,5:,:3]', False)
  
  
  def test_str_3slice_lowerupperupper(check_ast):
      check_ast('"hello"[:3,5:,5:]', False)
  
  
  def test_str_3slice_upperlowerlower(check_ast):
      check_ast('"hello"[5:,5:,:3]', False)
  
  
  def test_str_3slice_upperlowerupper(check_ast):
      check_ast('"hello"[5:,:3,5:]', False)
  
  
  def test_str_3slice_upperupperlower(check_ast):
      check_ast('"hello"[5:,5:,:3]', False)
  
  
  def test_str_3slice_other(check_ast):
      check_ast('"hello"[::2,::2,::2]', False)
  
  
  def test_str_3slice_lower_other(check_ast):
      check_ast('"hello"[:3:2,:3:2,:3:2]', False)
  
  
  def test_str_3slice_upper_other(check_ast):
      check_ast('"hello"[3::2,3::2,3::2]', False)
  
  
  def test_str_slice_true(check_ast):
      check_ast('"hello"[0:3,True]', False)
  
  
  def test_str_true_slice(check_ast):
      check_ast('"hello"[True,0:3]', False)
  
  
  def test_list_empty(check_ast):
      check_ast("[]")
  
  
  def test_list_one(check_ast):
      check_ast("[1]")
  
  
  def test_list_one_comma(check_ast):
      check_ast("[1,]")
  
  
  def test_list_two(check_ast):
      check_ast("[1, 42]")
  
  
  def test_list_three(check_ast):
      check_ast("[1, 42, 65]")
  
  
  def test_list_three_comma(check_ast):
      check_ast("[1, 42, 65,]")
  
  
  def test_list_one_nested(check_ast):
      check_ast("[[1]]")
  
  
  def test_list_list_four_nested(check_ast):
      check_ast("[[1], [2], [3], [4]]")
  
  
  def test_list_tuple_three_nested(check_ast):
      check_ast("[(1,), (2,), (3,)]")
  
  
  def test_list_set_tuple_three_nested(check_ast):
      check_ast("[{(1,)}, {(2,)}, {(3,)}]")
  
  
  def test_list_tuple_one_nested(check_ast):
      check_ast("[(1,)]")
  
  
  def test_tuple_tuple_one_nested(check_ast):
      check_ast("((1,),)")
  
  
  def test_dict_list_one_nested(check_ast):
      check_ast("{1: [2]}")
  
  
  def test_dict_list_one_nested_comma(check_ast):
      check_ast("{1: [2],}")
  
  
  def test_dict_tuple_one_nested(check_ast):
      check_ast("{1: (2,)}")
  
  
  def test_dict_tuple_one_nested_comma(check_ast):
      check_ast("{1: (2,),}")
  
  
  def test_dict_list_two_nested(check_ast):
      check_ast("{1: [2], 3: [4]}")
  
  
  def test_set_tuple_one_nested(check_ast):
      check_ast("{(1,)}")
  
  
  def test_set_tuple_two_nested(check_ast):
      check_ast("{(1,), (2,)}")
  
  
  def test_tuple_empty(check_ast):
      check_ast("()")
  
  
  def test_tuple_one_bare(check_ast):
      check_ast("1,")
  
  
  def test_tuple_two_bare(check_ast):
      check_ast("1, 42")
  
  
  def test_tuple_three_bare(check_ast):
      check_ast("1, 42, 65")
  
  
  def test_tuple_three_bare_comma(check_ast):
      check_ast("1, 42, 65,")
  
  
  def test_tuple_one_comma(check_ast):
      check_ast("(1,)")
  
  
  def test_tuple_two(check_ast):
      check_ast("(1, 42)")
  
  
  def test_tuple_three(check_ast):
      check_ast("(1, 42, 65)")
  
  
  def test_tuple_three_comma(check_ast):
      check_ast("(1, 42, 65,)")
  
  
  def test_bare_tuple_of_tuples(check_ast):
      check_ast("(),")
      check_ast("((),),(1,)")
      check_ast("(),(),")
      check_ast("[],")
      check_ast("[],[]")
      check_ast("[],()")
      check_ast("(),[],")
      check_ast("((),[()],)")
  
  
  def test_set_one(check_ast):
      check_ast("{42}")
  
  
  def test_set_one_comma(check_ast):
      check_ast("{42,}")
  
  
  def test_set_two(check_ast):
      check_ast("{42, 65}")
  
  
  def test_set_two_comma(check_ast):
      check_ast("{42, 65,}")
  
  
  def test_set_three(check_ast):
      check_ast("{42, 65, 45}")
  
  
  def test_dict_empty(check_ast):
      check_ast("{}")
  
  
  def test_dict_one(check_ast):
      check_ast("{42: 65}")
  
  
  def test_dict_one_comma(check_ast):
      check_ast("{42: 65,}")
  
  
  def test_dict_two(check_ast):
      check_ast("{42: 65, 6: 28}")
  
  
  def test_dict_two_comma(check_ast):
      check_ast("{42: 65, 6: 28,}")
  
  
  def test_dict_three(check_ast):
      check_ast("{42: 65, 6: 28, 1: 2}")
  
  
  def test_dict_from_dict_one(check_ast):
      check_ast('{**{"x": 2}}')
  
  
  def test_dict_from_dict_one_comma(check_ast):
      check_ast('{**{"x": 2},}')
  
  
  def test_dict_from_dict_two_xy(check_ast):
      check_ast('{"x": 1, **{"y": 2}}')
  
  
  def test_dict_from_dict_two_x_first(check_ast):
      check_ast('{"x": 1, **{"x": 2}}')
  
  
  def test_dict_from_dict_two_x_second(check_ast):
      check_ast('{**{"x": 2}, "x": 1}')
  
  
  def test_dict_from_dict_two_x_none(check_ast):
      check_ast('{**{"x": 1}, **{"x": 2}}')
  
  
  @pytest.mark.parametrize("third", [True, False])
  @pytest.mark.parametrize("second", [True, False])
  @pytest.mark.parametrize("first", [True, False])
  def test_dict_from_dict_three_xyz(first, second, third, check_ast):
      val1 = '"x": 1' if first else '**{"x": 1}'
      val2 = '"y": 2' if second else '**{"y": 2}'
      val3 = '"z": 3' if third else '**{"z": 3}'
      check_ast("{" + val1 + "," + val2 + "," + val3 + "}")
  
  
  def test_unpack_range_tuple(check_stmts):
      check_stmts("*range(4),")
  
  
  def test_unpack_range_tuple_4(check_stmts):
      check_stmts("*range(4), 4")
  
  
  def test_unpack_range_tuple_parens(check_ast):
      check_ast("(*range(4),)")
  
  
  def test_unpack_range_tuple_parens_4(check_ast):
      check_ast("(*range(4), 4)")
  
  
  def test_unpack_range_list(check_ast):
      check_ast("[*range(4)]")
  
  
  def test_unpack_range_list_4(check_ast):
      check_ast("[*range(4), 4]")
  
  
  def test_unpack_range_set(check_ast):
      check_ast("{*range(4)}")
  
  
  def test_unpack_range_set_4(check_ast):
      check_ast("{*range(4), 4}")
  
  
  def test_true(check_ast):
      check_ast("True")
  
  
  def test_false(check_ast):
      check_ast("False")
  
  
  def test_none(check_ast):
      check_ast("None")
  
  
  def test_elipssis(check_ast):
      check_ast("...")
  
  
  def test_not_implemented_name(check_ast):
      check_ast("NotImplemented")
  
  
  def test_genexpr(check_ast):
      check_ast('(x for x in "mom")')
  
  
  def test_genexpr_if(check_ast):
      check_ast('(x for x in "mom" if True)')
  
  
  def test_genexpr_if_and(check_ast):
      check_ast('(x for x in "mom" if True and x == "m")')
  
  
  def test_dbl_genexpr(check_ast):
      check_ast('(x+y for x in "mom" for y in "dad")')
  
  
  def test_genexpr_if_genexpr(check_ast):
      check_ast('(x+y for x in "mom" if True for y in "dad")')
  
  
  def test_genexpr_if_genexpr_if(check_ast):
      check_ast('(x+y for x in "mom" if True for y in "dad" if y == "d")')
  
  
  def test_listcomp(check_ast):
      check_ast('[x for x in "mom"]')
  
  
  def test_listcomp_if(check_ast):
      check_ast('[x for x in "mom" if True]')
  
  
  def test_listcomp_if_and(check_ast):
      check_ast('[x for x in "mom" if True and x == "m"]')
  
  
  def test_listcomp_multi_if(check_ast):
      check_ast('[x for x in "mom" if True if x in "mo" if x == "m"]')
  
  
  def test_dbl_listcomp(check_ast):
      check_ast('[x+y for x in "mom" for y in "dad"]')
  
  
  def test_listcomp_if_listcomp(check_ast):
      check_ast('[x+y for x in "mom" if True for y in "dad"]')
  
  
  def test_listcomp_if_listcomp_if(check_ast):
      check_ast('[x+y for x in "mom" if True for y in "dad" if y == "d"]')
  
  
  def test_setcomp(check_ast):
      check_ast('{x for x in "mom"}')
  
  
  def test_setcomp_if(check_ast):
      check_ast('{x for x in "mom" if True}')
  
  
  def test_setcomp_if_and(check_ast):
      check_ast('{x for x in "mom" if True and x == "m"}')
  
  
  def test_dbl_setcomp(check_ast):
      check_ast('{x+y for x in "mom" for y in "dad"}')
  
  
  def test_setcomp_if_setcomp(check_ast):
      check_ast('{x+y for x in "mom" if True for y in "dad"}')
  
  
  def test_setcomp_if_setcomp_if(check_ast):
      check_ast('{x+y for x in "mom" if True for y in "dad" if y == "d"}')
  
  
  def test_dictcomp(check_ast):
      check_ast('{x: x for x in "mom"}')
  
  
  def test_dictcomp_unpack_parens(check_ast):
      check_ast('{k: v for (k, v) in {"x": 42}.items()}')
  
  
  def test_dictcomp_unpack_no_parens(check_ast):
      check_ast('{k: v for k, v in {"x": 42}.items()}')
  
  
  def test_dictcomp_if(check_ast):
      check_ast('{x: x for x in "mom" if True}')
  
  
  def test_dictcomp_if_and(check_ast):
      check_ast('{x: x for x in "mom" if True and x == "m"}')
  
  
  def test_dbl_dictcomp(check_ast):
      check_ast('{x: y for x in "mom" for y in "dad"}')
  
  
  def test_dictcomp_if_dictcomp(check_ast):
      check_ast('{x: y for x in "mom" if True for y in "dad"}')
  
  
  def test_dictcomp_if_dictcomp_if(check_ast):
      check_ast('{x: y for x in "mom" if True for y in "dad" if y == "d"}')
  
  
  def test_lambda(check_ast):
      check_ast("lambda: 42")
  
  
  def test_lambda_x(check_ast):
      check_ast("lambda x: x")
  
  
  def test_lambda_kwx(check_ast):
      check_ast("lambda x=42: x")
  
  
  def test_lambda_x_y(check_ast):
      check_ast("lambda x, y: x")
  
  
  def test_lambda_x_y_z(check_ast):
      check_ast("lambda x, y, z: x")
  
  
  def test_lambda_x_kwy(check_ast):
      check_ast("lambda x, y=42: x")
  
  
  def test_lambda_kwx_kwy(check_ast):
      check_ast("lambda x=65, y=42: x")
  
  
  def test_lambda_kwx_kwy_kwz(check_ast):
      check_ast("lambda x=65, y=42, z=1: x")
  
  
  def test_lambda_x_comma(check_ast):
      check_ast("lambda x,: x")
  
  
  def test_lambda_x_y_comma(check_ast):
      check_ast("lambda x, y,: x")
  
  
  def test_lambda_x_y_z_comma(check_ast):
      check_ast("lambda x, y, z,: x")
  
  
  def test_lambda_x_kwy_comma(check_ast):
      check_ast("lambda x, y=42,: x")
  
  
  def test_lambda_kwx_kwy_comma(check_ast):
      check_ast("lambda x=65, y=42,: x")
  
  
  def test_lambda_kwx_kwy_kwz_comma(check_ast):
      check_ast("lambda x=65, y=42, z=1,: x")
  
  
  def test_lambda_args(check_ast):
      check_ast("lambda *args: 42")
  
  
  def test_lambda_args_x(check_ast):
      check_ast("lambda *args, x: 42")
  
  
  def test_lambda_args_x_y(check_ast):
      check_ast("lambda *args, x, y: 42")
  
  
  def test_lambda_args_x_kwy(check_ast):
      check_ast("lambda *args, x, y=10: 42")
  
  
  def test_lambda_args_kwx_y(check_ast):
      check_ast("lambda *args, x=10, y: 42")
  
  
  def test_lambda_args_kwx_kwy(check_ast):
      check_ast("lambda *args, x=42, y=65: 42")
  
  
  def test_lambda_x_args(check_ast):
      check_ast("lambda x, *args: 42")
  
  
  def test_lambda_x_args_y(check_ast):
      check_ast("lambda x, *args, y: 42")
  
  
  def test_lambda_x_args_y_z(check_ast):
      check_ast("lambda x, *args, y, z: 42")
  
  
  def test_lambda_kwargs(check_ast):
      check_ast("lambda **kwargs: 42")
  
  
  def test_lambda_x_kwargs(check_ast):
      check_ast("lambda x, **kwargs: 42")
  
  
  def test_lambda_x_y_kwargs(check_ast):
      check_ast("lambda x, y, **kwargs: 42")
  
  
  def test_lambda_x_kwy_kwargs(check_ast):
      check_ast("lambda x, y=42, **kwargs: 42")
  
  
  def test_lambda_args_kwargs(check_ast):
      check_ast("lambda *args, **kwargs: 42")
  
  
  def test_lambda_x_args_kwargs(check_ast):
      check_ast("lambda x, *args, **kwargs: 42")
  
  
  def test_lambda_x_y_args_kwargs(check_ast):
      check_ast("lambda x, y, *args, **kwargs: 42")
  
  
  def test_lambda_kwx_args_kwargs(check_ast):
      check_ast("lambda x=10, *args, **kwargs: 42")
  
  
  def test_lambda_x_kwy_args_kwargs(check_ast):
      check_ast("lambda x, y=42, *args, **kwargs: 42")
  
  
  def test_lambda_x_args_y_kwargs(check_ast):
      check_ast("lambda x, *args, y, **kwargs: 42")
  
  
  def test_lambda_x_args_kwy_kwargs(check_ast):
      check_ast("lambda x, *args, y=42, **kwargs: 42")
  
  
  def test_lambda_args_y_kwargs(check_ast):
      check_ast("lambda *args, y, **kwargs: 42")
  
  
  def test_lambda_star_x(check_ast):
      check_ast("lambda *, x: 42")
  
  
  def test_lambda_star_x_y(check_ast):
      check_ast("lambda *, x, y: 42")
  
  
  def test_lambda_star_x_kwargs(check_ast):
      check_ast("lambda *, x, **kwargs: 42")
  
  
  def test_lambda_star_kwx_kwargs(check_ast):
      check_ast("lambda *, x=42, **kwargs: 42")
  
  
  def test_lambda_x_star_y(check_ast):
      check_ast("lambda x, *, y: 42")
  
  
  def test_lambda_x_y_star_z(check_ast):
      check_ast("lambda x, y, *, z: 42")
  
  
  def test_lambda_x_kwy_star_y(check_ast):
      check_ast("lambda x, y=42, *, z: 42")
  
  
  def test_lambda_x_kwy_star_kwy(check_ast):
      check_ast("lambda x, y=42, *, z=65: 42")
  
  
  def test_lambda_x_star_y_kwargs(check_ast):
      check_ast("lambda x, *, y, **kwargs: 42")
  
  
  @skip_if_pre_3_8
  def test_lambda_x_divide_y_star_z_kwargs(check_ast):
      check_ast("lambda x, /, y, *, z, **kwargs: 42")
  
  
  def test_call_range(check_ast):
      check_ast("range(6)")
  
  
  def test_call_range_comma(check_ast):
      check_ast("range(6,)")
  
  
  def test_call_range_x_y(check_ast):
      check_ast("range(6, 10)")
  
  
  def test_call_range_x_y_comma(check_ast):
      check_ast("range(6, 10,)")
  
  
  def test_call_range_x_y_z(check_ast):
      check_ast("range(6, 10, 2)")
  
  
  def test_call_dict_kwx(check_ast):
      check_ast("dict(start=10)")
  
  
  def test_call_dict_kwx_comma(check_ast):
      check_ast("dict(start=10,)")
  
  
  def test_call_dict_kwx_kwy(check_ast):
      check_ast("dict(start=10, stop=42)")
  
  
  def test_call_tuple_gen(check_ast):
      check_ast("tuple(x for x in [1, 2, 3])")
  
  
  def test_call_tuple_genifs(check_ast):
      check_ast("tuple(x for x in [1, 2, 3] if x < 3)")
  
  
  def test_call_range_star(check_ast):
      check_ast("range(*[1, 2, 3])")
  
  
  def test_call_range_x_star(check_ast):
      check_ast("range(1, *[2, 3])")
  
  
  def test_call_int(check_ast):
      check_ast('int(*["42"], base=8)')
  
  
  def test_call_int_base_dict(check_ast):
      check_ast('int(*["42"], **{"base": 8})')
  
  
  def test_call_dict_kwargs(check_ast):
      check_ast('dict(**{"base": 8})')
  
  
  def test_call_list_many_star_args(check_ast):
      check_ast("min(*[1, 2], 3, *[4, 5])")
  
  
  def test_call_list_many_starstar_args(check_ast):
      check_ast('dict(**{"a": 2}, v=3, **{"c": 5})')
  
  
  def test_call_list_many_star_and_starstar_args(check_ast):
      check_ast('x(*[("a", 2)], *[("v", 3)], **{"c": 5})', False)
  
  
  def test_call_alot(check_ast):
      check_ast("x(1, *args, **kwargs)", False)
  
  
  def test_call_alot_next(check_ast):
      check_ast("x(x=1, *args, **kwargs)", False)
  
  
  def test_call_alot_next_next(check_ast):
      check_ast("x(x=1, *args, y=42, **kwargs)", False)
  
  
  def test_getattr(check_ast):
      check_ast("list.append")
  
  
  def test_getattr_getattr(check_ast):
      check_ast("list.append.__str__")
  
  
  def test_dict_tuple_key(check_ast):
      check_ast("{(42, 1): 65}")
  
  
  def test_dict_tuple_key_get(check_ast):
      check_ast("{(42, 1): 65}[42, 1]")
  
  
  def test_dict_tuple_key_get_3(check_ast):
      check_ast("{(42, 1, 3): 65}[42, 1, 3]")
  
  
  def test_pipe_op(check_ast):
      check_ast("{42} | {65}")
  
  
  def test_pipe_op_two(check_ast):
      check_ast("{42} | {65} | {1}")
  
  
  def test_pipe_op_three(check_ast):
      check_ast("{42} | {65} | {1} | {7}")
  
  
  def test_xor_op(check_ast):
      check_ast("{42} ^ {65}")
  
  
  def test_xor_op_two(check_ast):
      check_ast("{42} ^ {65} ^ {1}")
  
  
  def test_xor_op_three(check_ast):
      check_ast("{42} ^ {65} ^ {1} ^ {7}")
  
  
  def test_xor_pipe(check_ast):
      check_ast("{42} ^ {65} | {1}")
  
  
  def test_amp_op(check_ast):
      check_ast("{42} & {65}")
  
  
  def test_amp_op_two(check_ast):
      check_ast("{42} & {65} & {1}")
  
  
  def test_amp_op_three(check_ast):
      check_ast("{42} & {65} & {1} & {7}")
  
  
  def test_lshift_op(check_ast):
      check_ast("42 << 65")
  
  
  def test_lshift_op_two(check_ast):
      check_ast("42 << 65 << 1")
  
  
  def test_lshift_op_three(check_ast):
      check_ast("42 << 65 << 1 << 7")
  
  
  def test_rshift_op(check_ast):
      check_ast("42 >> 65")
  
  
  def test_rshift_op_two(check_ast):
      check_ast("42 >> 65 >> 1")
  
  
  def test_rshift_op_three(check_ast):
      check_ast("42 >> 65 >> 1 >> 7")
  
  
  @skip_if_pre_3_8
  def test_named_expr(check_ast):
      check_ast("(x := 42)")
  
  
  @skip_if_pre_3_8
  def test_named_expr_list(check_ast):
      check_ast("[x := 42, x + 1, x + 2]")
  
  
  #
  # statements
  #
  
  
  def test_equals(check_stmts):
      check_stmts("x = 42")
  
  
  def test_equals_semi(check_stmts):
      check_stmts("x = 42;")
  
  
  def test_x_y_equals_semi(check_stmts):
      check_stmts("x = y = 42")
  
  
  def test_equals_two(check_stmts):
      check_stmts("x = 42; y = 65")
  
  
  def test_equals_two_semi(check_stmts):
      check_stmts("x = 42; y = 65;")
  
  
  def test_equals_three(check_stmts):
      check_stmts("x = 42; y = 65; z = 6")
  
  
  def test_equals_three_semi(check_stmts):
      check_stmts("x = 42; y = 65; z = 6;")
  
  
  def test_plus_eq(check_stmts):
      check_stmts("x = 42; x += 65")
  
  
  def test_sub_eq(check_stmts):
      check_stmts("x = 42; x -= 2")
  
  
  def test_times_eq(check_stmts):
      check_stmts("x = 42; x *= 2")
  
  
  def test_matmult_eq(check_stmts):
      check_stmts("x @= y", False)
  
  
  def test_div_eq(check_stmts):
      check_stmts("x = 42; x /= 2")
  
  
  def test_floordiv_eq(check_stmts):
      check_stmts("x = 42; x //= 2")
  
  
  def test_pow_eq(check_stmts):
      check_stmts("x = 42; x **= 2")
  
  
  def test_mod_eq(check_stmts):
      check_stmts("x = 42; x %= 2")
  
  
  def test_xor_eq(check_stmts):
      check_stmts("x = 42; x ^= 2")
  
  
  def test_ampersand_eq(check_stmts):
      check_stmts("x = 42; x &= 2")
  
  
  def test_bitor_eq(check_stmts):
      check_stmts("x = 42; x |= 2")
  
  
  def test_lshift_eq(check_stmts):
      check_stmts("x = 42; x <<= 2")
  
  
  def test_rshift_eq(check_stmts):
      check_stmts("x = 42; x >>= 2")
  
  
  def test_bare_unpack(check_stmts):
      check_stmts("x, y = 42, 65")
  
  
  def test_lhand_group_unpack(check_stmts):
      check_stmts("(x, y) = 42, 65")
  
  
  def test_rhand_group_unpack(check_stmts):
      check_stmts("x, y = (42, 65)")
  
  
  def test_grouped_unpack(check_stmts):
      check_stmts("(x, y) = (42, 65)")
  
  
  def test_double_grouped_unpack(check_stmts):
      check_stmts("(x, y) = (z, a) = (7, 8)")
  
  
  def test_double_ungrouped_unpack(check_stmts):
      check_stmts("x, y = z, a = 7, 8")
  
  
  def test_stary_eq(check_stmts):
      check_stmts("*y, = [1, 2, 3]")
  
  
  def test_stary_x(check_stmts):
      check_stmts("*y, x = [1, 2, 3]")
  
  
  def test_tuple_x_stary(check_stmts):
      check_stmts("(x, *y) = [1, 2, 3]")
  
  
  def test_list_x_stary(check_stmts):
      check_stmts("[x, *y] = [1, 2, 3]")
  
  
  def test_bare_x_stary(check_stmts):
      check_stmts("x, *y = [1, 2, 3]")
  
  
  def test_bare_x_stary_z(check_stmts):
      check_stmts("x, *y, z = [1, 2, 2, 3]")
  
  
  def test_equals_list(check_stmts):
      check_stmts("x = [42]; x[0] = 65")
  
  
  def test_equals_dict(check_stmts):
      check_stmts("x = {42: 65}; x[42] = 3")
  
  
  def test_equals_attr(check_stmts):
      check_stmts("class X(object):\n  pass\nx = X()\nx.a = 65")
  
  
  def test_equals_annotation(check_stmts):
      check_stmts("x : int = 42")
  
  
  def test_equals_annotation_empty(check_stmts):
      check_stmts("x : int")
  
  
  def test_dict_keys(check_stmts):
      check_stmts('x = {"x": 1}\nx.keys()')
  
  
  def test_assert_msg(check_stmts):
      check_stmts('assert True, "wow mom"')
  
  
  def test_assert(check_stmts):
      check_stmts("assert True")
  
  
  def test_pass(check_stmts):
      check_stmts("pass")
  
  
  def test_del(check_stmts):
      check_stmts("x = 42; del x")
  
  
  def test_del_comma(check_stmts):
      check_stmts("x = 42; del x,")
  
  
  def test_del_two(check_stmts):
      check_stmts("x = 42; y = 65; del x, y")
  
  
  def test_del_two_comma(check_stmts):
      check_stmts("x = 42; y = 65; del x, y,")
  
  
  def test_del_with_parens(check_stmts):
      check_stmts("x = 42; y = 65; del (x, y)")
  
  
  def test_raise(check_stmts):
      check_stmts("raise", False)
  
  
  def test_raise_x(check_stmts):
      check_stmts("raise TypeError", False)
  
  
  def test_raise_x_from(check_stmts):
      check_stmts("raise TypeError from x", False)
  
  
  def test_import_x(check_stmts):
      check_stmts("import x", False)
  
  
  def test_import_xy(check_stmts):
      check_stmts("import x.y", False)
  
  
  def test_import_xyz(check_stmts):
      check_stmts("import x.y.z", False)
  
  
  def test_from_x_import_y(check_stmts):
      check_stmts("from x import y", False)
  
  
  def test_from_dot_import_y(check_stmts):
      check_stmts("from . import y", False)
  
  
  def test_from_dotx_import_y(check_stmts):
      check_stmts("from .x import y", False)
  
  
  def test_from_dotdotx_import_y(check_stmts):
      check_stmts("from ..x import y", False)
  
  
  def test_from_dotdotdotx_import_y(check_stmts):
      check_stmts("from ...x import y", False)
  
  
  def test_from_dotdotdotdotx_import_y(check_stmts):
      check_stmts("from ....x import y", False)
  
  
  def test_from_import_x_y(check_stmts):
      check_stmts("import x, y", False)
  
  
  def test_from_import_x_y_z(check_stmts):
      check_stmts("import x, y, z", False)
  
  
  def test_from_dot_import_x_y(check_stmts):
      check_stmts("from . import x, y", False)
  
  
  def test_from_dot_import_x_y_z(check_stmts):
      check_stmts("from . import x, y, z", False)
  
  
  def test_from_dot_import_group_x_y(check_stmts):
      check_stmts("from . import (x, y)", False)
  
  
  def test_import_x_as_y(check_stmts):
      check_stmts("import x as y", False)
  
  
  def test_import_xy_as_z(check_stmts):
      check_stmts("import x.y as z", False)
  
  
  def test_import_x_y_as_z(check_stmts):
      check_stmts("import x, y as z", False)
  
  
  def test_import_x_as_y_z(check_stmts):
      check_stmts("import x as y, z", False)
  
  
  def test_import_x_as_y_z_as_a(check_stmts):
      check_stmts("import x as y, z as a", False)
  
  
  def test_from_dot_import_x_as_y(check_stmts):
      check_stmts("from . import x as y", False)
  
  
  def test_from_x_import_star(check_stmts):
      check_stmts("from x import *", False)
  
  
  def test_from_x_import_group_x_y_z(check_stmts):
      check_stmts("from x import (x, y, z)", False)
  
  
  def test_from_x_import_group_x_y_z_comma(check_stmts):
      check_stmts("from x import (x, y, z,)", False)
  
  
  def test_from_x_import_y_as_z(check_stmts):
      check_stmts("from x import y as z", False)
  
  
  def test_from_x_import_y_as_z_a_as_b(check_stmts):
      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):
      check_stmts("from .x import y as z, a as b, c as d", False)
  
  
  def test_continue(check_stmts):
      check_stmts("continue", False)
  
  
  def test_break(check_stmts):
      check_stmts("break", False)
  
  
  def test_global(check_stmts):
      check_stmts("global x", False)
  
  
  def test_global_xy(check_stmts):
      check_stmts("global x, y", False)
  
  
  def test_nonlocal_x(check_stmts):
      check_stmts("nonlocal x", False)
  
  
  def test_nonlocal_xy(check_stmts):
      check_stmts("nonlocal x, y", False)
  
  
  def test_yield(check_stmts):
      check_stmts("yield", False)
  
  
  def test_yield_x(check_stmts):
      check_stmts("yield x", False)
  
  
  def test_yield_x_comma(check_stmts):
      check_stmts("yield x,", False)
  
  
  def test_yield_x_y(check_stmts):
      check_stmts("yield x, y", False)
  
  
  @skip_if_pre_3_8
  def test_yield_x_starexpr(check_stmts):
      check_stmts("yield x, *[y, z]", False)
  
  
  def test_yield_from_x(check_stmts):
      check_stmts("yield from x", False)
  
  
  def test_return(check_stmts):
      check_stmts("return", False)
  
  
  def test_return_x(check_stmts):
      check_stmts("return x", False)
  
  
  def test_return_x_comma(check_stmts):
      check_stmts("return x,", False)
  
  
  def test_return_x_y(check_stmts):
      check_stmts("return x, y", False)
  
  
  @skip_if_pre_3_8
  def test_return_x_starexpr(check_stmts):
      check_stmts("return x, *[y, z]", False)
  
  
  def test_if_true(check_stmts):
      check_stmts("if True:\n  pass")
  
  
  def test_if_true_twolines(check_stmts):
      check_stmts("if True:\n  pass\n  pass")
  
  
  def test_if_true_twolines_deindent(check_stmts):
      check_stmts("if True:\n  pass\n  pass\npass")
  
  
  def test_if_true_else(check_stmts):
      check_stmts("if True:\n  pass\nelse: \n  pass")
  
  
  def test_if_true_x(check_stmts):
      check_stmts("if True:\n  x = 42")
  
  
  def test_if_switch(check_stmts):
      check_stmts("x = 42\nif x == 1:\n  pass")
  
  
  def test_if_switch_elif1_else(check_stmts):
      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):
      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):
      check_stmts("x = 42\nif x == 1:\n  pass\n  if x == 4:\n     pass")
  
  
  def test_while(check_stmts):
      check_stmts("while False:\n  pass")
  
  
  def test_while_else(check_stmts):
      check_stmts("while False:\n  pass\nelse:\n  pass")
  
  
  def test_for(check_stmts):
      check_stmts("for x in range(6):\n  pass")
  
  
  def test_for_zip(check_stmts):
      check_stmts('for x, y in zip(range(6), "123456"):\n  pass')
  
  
  def test_for_idx(check_stmts):
      check_stmts("x = [42]\nfor x[0] in range(3):\n  pass")
  
  
  def test_for_zip_idx(check_stmts):
      check_stmts('x = [42]\nfor x[0], y in zip(range(6), "123456"):\n' "  pass")
  
  
  def test_for_attr(check_stmts):
      check_stmts("for x.a in range(3):\n  pass", False)
  
  
  def test_for_zip_attr(check_stmts):
      check_stmts('for x.a, y in zip(range(6), "123456"):\n  pass', False)
  
  
  def test_for_else(check_stmts):
      check_stmts("for x in range(6):\n  pass\nelse:  pass")
  
  
  def test_async_for(check_stmts):
      check_stmts("async def f():\n    async for x in y:\n        pass\n", False)
  
  
  def test_with(check_stmts):
      check_stmts("with x:\n  pass", False)
  
  
  def test_with_as(check_stmts):
      check_stmts("with x as y:\n  pass", False)
  
  
  def test_with_xy(check_stmts):
      check_stmts("with x, y:\n  pass", False)
  
  
  def test_with_x_as_y_z(check_stmts):
      check_stmts("with x as y, z:\n  pass", False)
  
  
  def test_with_x_as_y_a_as_b(check_stmts):
      check_stmts("with x as y, a as b:\n  pass", False)
  
  
  def test_with_in_func(check_stmts):
      check_stmts("def f():\n    with x:\n        pass\n")
  
  
  def test_async_with(check_stmts):
      check_stmts("async def f():\n    async with x as y:\n        pass\n", False)
  
  
  def test_try(check_stmts):
      check_stmts("try:\n  pass\nexcept:\n  pass", False)
  
  
  def test_try_except_t(check_stmts):
      check_stmts("try:\n  pass\nexcept TypeError:\n  pass", False)
  
  
  def test_try_except_t_as_e(check_stmts):
      check_stmts("try:\n  pass\nexcept TypeError as e:\n  pass", False)
  
  
  def test_try_except_t_u(check_stmts):
      check_stmts("try:\n  pass\nexcept (TypeError, SyntaxError):\n  pass", False)
  
  
  def test_try_except_t_u_as_e(check_stmts):
      check_stmts("try:\n  pass\nexcept (TypeError, SyntaxError) as e:\n  pass", False)
  
  
  def test_try_except_t_except_u(check_stmts):
      check_stmts(
          "try:\n  pass\nexcept TypeError:\n  pass\n" "except SyntaxError as f:\n  pass",
          False,
      )
  
  
  def test_try_except_else(check_stmts):
      check_stmts("try:\n  pass\nexcept:\n  pass\nelse:  pass", False)
  
  
  def test_try_except_finally(check_stmts):
      check_stmts("try:\n  pass\nexcept:\n  pass\nfinally:  pass", False)
  
  
  def test_try_except_else_finally(check_stmts):
      check_stmts(
          "try:\n  pass\nexcept:\n  pass\nelse:\n  pass" "\nfinally:  pass", False
      )
  
  
  def test_try_finally(check_stmts):
      check_stmts("try:\n  pass\nfinally:  pass", False)
  
  
  def test_func(check_stmts):
      check_stmts("def f():\n  pass")
  
  
  def test_func_ret(check_stmts):
      check_stmts("def f():\n  return")
  
  
  def test_func_ret_42(check_stmts):
      check_stmts("def f():\n  return 42")
  
  
  def test_func_ret_42_65(check_stmts):
      check_stmts("def f():\n  return 42, 65")
  
  
  def test_func_rarrow(check_stmts):
      check_stmts("def f() -> int:\n  pass")
  
  
  def test_func_x(check_stmts):
      check_stmts("def f(x):\n  return x")
  
  
  def test_func_kwx(check_stmts):
      check_stmts("def f(x=42):\n  return x")
  
  
  def test_func_x_y(check_stmts):
      check_stmts("def f(x, y):\n  return x")
  
  
  def test_func_x_y_z(check_stmts):
      check_stmts("def f(x, y, z):\n  return x")
  
  
  def test_func_x_kwy(check_stmts):
      check_stmts("def f(x, y=42):\n  return x")
  
  
  def test_func_kwx_kwy(check_stmts):
      check_stmts("def f(x=65, y=42):\n  return x")
  
  
  def test_func_kwx_kwy_kwz(check_stmts):
      check_stmts("def f(x=65, y=42, z=1):\n  return x")
  
  
  def test_func_x_comma(check_stmts):
      check_stmts("def f(x,):\n  return x")
  
  
  def test_func_x_y_comma(check_stmts):
      check_stmts("def f(x, y,):\n  return x")
  
  
  def test_func_x_y_z_comma(check_stmts):
      check_stmts("def f(x, y, z,):\n  return x")
  
  
  def test_func_x_kwy_comma(check_stmts):
      check_stmts("def f(x, y=42,):\n  return x")
  
  
  def test_func_kwx_kwy_comma(check_stmts):
      check_stmts("def f(x=65, y=42,):\n  return x")
  
  
  def test_func_kwx_kwy_kwz_comma(check_stmts):
      check_stmts("def f(x=65, y=42, z=1,):\n  return x")
  
  
  def test_func_args(check_stmts):
      check_stmts("def f(*args):\n  return 42")
  
  
  def test_func_args_x(check_stmts):
      check_stmts("def f(*args, x):\n  return 42")
  
  
  def test_func_args_x_y(check_stmts):
      check_stmts("def f(*args, x, y):\n  return 42")
  
  
  def test_func_args_x_kwy(check_stmts):
      check_stmts("def f(*args, x, y=10):\n  return 42")
  
  
  def test_func_args_kwx_y(check_stmts):
      check_stmts("def f(*args, x=10, y):\n  return 42")
  
  
  def test_func_args_kwx_kwy(check_stmts):
      check_stmts("def f(*args, x=42, y=65):\n  return 42")
  
  
  def test_func_x_args(check_stmts):
      check_stmts("def f(x, *args):\n  return 42")
  
  
  def test_func_x_args_y(check_stmts):
      check_stmts("def f(x, *args, y):\n  return 42")
  
  
  def test_func_x_args_y_z(check_stmts):
      check_stmts("def f(x, *args, y, z):\n  return 42")
  
  
  def test_func_kwargs(check_stmts):
      check_stmts("def f(**kwargs):\n  return 42")
  
  
  def test_func_x_kwargs(check_stmts):
      check_stmts("def f(x, **kwargs):\n  return 42")
  
  
  def test_func_x_y_kwargs(check_stmts):
      check_stmts("def f(x, y, **kwargs):\n  return 42")
  
  
  def test_func_x_kwy_kwargs(check_stmts):
      check_stmts("def f(x, y=42, **kwargs):\n  return 42")
  
  
  def test_func_args_kwargs(check_stmts):
      check_stmts("def f(*args, **kwargs):\n  return 42")
  
  
  def test_func_x_args_kwargs(check_stmts):
      check_stmts("def f(x, *args, **kwargs):\n  return 42")
  
  
  def test_func_x_y_args_kwargs(check_stmts):
      check_stmts("def f(x, y, *args, **kwargs):\n  return 42")
  
  
  def test_func_kwx_args_kwargs(check_stmts):
      check_stmts("def f(x=10, *args, **kwargs):\n  return 42")
  
  
  def test_func_x_kwy_args_kwargs(check_stmts):
      check_stmts("def f(x, y=42, *args, **kwargs):\n  return 42")
  
  
  def test_func_x_args_y_kwargs(check_stmts):
      check_stmts("def f(x, *args, y, **kwargs):\n  return 42")
  
  
  def test_func_x_args_kwy_kwargs(check_stmts):
      check_stmts("def f(x, *args, y=42, **kwargs):\n  return 42")
  
  
  def test_func_args_y_kwargs(check_stmts):
      check_stmts("def f(*args, y, **kwargs):\n  return 42")
  
  
  def test_func_star_x(check_stmts):
      check_stmts("def f(*, x):\n  return 42")
  
  
  def test_func_star_x_y(check_stmts):
      check_stmts("def f(*, x, y):\n  return 42")
  
  
  def test_func_star_x_kwargs(check_stmts):
      check_stmts("def f(*, x, **kwargs):\n  return 42")
  
  
  def test_func_star_kwx_kwargs(check_stmts):
      check_stmts("def f(*, x=42, **kwargs):\n  return 42")
  
  
  def test_func_x_star_y(check_stmts):
      check_stmts("def f(x, *, y):\n  return 42")
  
  
  def test_func_x_y_star_z(check_stmts):
      check_stmts("def f(x, y, *, z):\n  return 42")
  
  
  def test_func_x_kwy_star_y(check_stmts):
      check_stmts("def f(x, y=42, *, z):\n  return 42")
  
  
  def test_func_x_kwy_star_kwy(check_stmts):
      check_stmts("def f(x, y=42, *, z=65):\n  return 42")
  
  
  def test_func_x_star_y_kwargs(check_stmts):
      check_stmts("def f(x, *, y, **kwargs):\n  return 42")
  
  
  @skip_if_pre_3_8
  def test_func_x_divide(check_stmts):
      check_stmts("def f(x, /):\n  return 42")
  
  
  @skip_if_pre_3_8
  def test_func_x_divide_y_star_z_kwargs(check_stmts):
      check_stmts("def f(x, /, y, *, z, **kwargs):\n  return 42")
  
  
  def test_func_tx(check_stmts):
      check_stmts("def f(x:int):\n  return x")
  
  
  def test_func_txy(check_stmts):
      check_stmts("def f(x:int, y:float=10.0):\n  return x")
  
  
  def test_class(check_stmts):
      check_stmts("class X:\n  pass")
  
  
  def test_class_obj(check_stmts):
      check_stmts("class X(object):\n  pass")
  
  
  def test_class_int_flt(check_stmts):
      check_stmts("class X(int, object):\n  pass")
  
  
  def test_class_obj_kw(check_stmts):
      # technically valid syntax, though it will fail to compile
      check_stmts("class X(object=5):\n  pass", False)
  
  
  def test_decorator(check_stmts):
      check_stmts("@g\ndef f():\n  pass", False)
  
  
  def test_decorator_2(check_stmts):
      check_stmts("@h\n@g\ndef f():\n  pass", False)
  
  
  def test_decorator_call(check_stmts):
      check_stmts("@g()\ndef f():\n  pass", False)
  
  
  def test_decorator_call_args(check_stmts):
      check_stmts("@g(x, y=10)\ndef f():\n  pass", False)
  
  
  def test_decorator_dot_call_args(check_stmts):
      check_stmts("@h.g(x, y=10)\ndef f():\n  pass", False)
  
  
  def test_decorator_dot_dot_call_args(check_stmts):
      check_stmts("@i.h.g(x, y=10)\ndef f():\n  pass", False)
  
  
  def test_broken_prompt_func(check_stmts):
      code = "def prompt():\n" "    return '{user}'.format(\n" "       user='me')\n"
      check_stmts(code, False)
  
  
  def test_class_with_methods(check_stmts):
      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(check_stmts):
      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(check_stmts):
      code = (
          "def foo():\n"
          "    ascii_art = [\n"
          '        "(╯°□°）╯︵ ┻━┻",\n'
          r'        "¯\\_(ツ)_/¯",'
          "\n"
          r'        "┻━┻︵ \\(°□°)/ ︵ ┻━┻",'
          "\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)
  
  
  def test_async_func(check_stmts):
      check_stmts("async def f():\n  pass\n")
  
  
  def test_async_decorator(check_stmts):
      check_stmts("@g\nasync def f():\n  pass", False)
  
  
  def test_async_await(check_stmts):
      check_stmts("async def f():\n    await fut\n", False)
  
  
  @skip_if_pre_3_8
  def test_named_expr_args(check_stmts):
      check_stmts("id(x := 42)")
  
  
  @skip_if_pre_3_8
  def test_named_expr_if(check_stmts):
      check_stmts("if (x := 42) > 0:\n  x += 1")
  
  
  @skip_if_pre_3_8
  def test_named_expr_elif(check_stmts):
      check_stmts("if False:\n  pass\nelif x := 42:\n  x += 1")
  
  
  @skip_if_pre_3_8
  def test_named_expr_while(check_stmts):
      check_stmts("y = 42\nwhile (x := y) < 43:\n  y += 1")
  
  
  #
  # Xonsh specific syntax
  #
  
  
  def test_path_literal(check_xonsh_ast):
      check_xonsh_ast({}, 'p"/foo"', False)
      check_xonsh_ast({}, 'pr"/foo"', False)
      check_xonsh_ast({}, 'rp"/foo"', False)
      check_xonsh_ast({}, 'pR"/foo"', False)
      check_xonsh_ast({}, 'Rp"/foo"', False)
  
  
  def test_path_fstring_literal(check_xonsh_ast):
      check_xonsh_ast({}, 'pf"/foo"', False)
      check_xonsh_ast({}, 'fp"/foo"', False)
      check_xonsh_ast({}, 'pF"/foo"', False)
      check_xonsh_ast({}, 'Fp"/foo"', False)
      check_xonsh_ast({}, 'pf"/foo{1+1}"', False)
      check_xonsh_ast({}, 'fp"/foo{1+1}"', False)
      check_xonsh_ast({}, 'pF"/foo{1+1}"', False)
      check_xonsh_ast({}, 'Fp"/foo{1+1}"', False)
  
  
  def test_dollar_name(check_xonsh_ast):
      check_xonsh_ast({"WAKKA": 42}, "$WAKKA")
  
  
  def test_dollar_py(check_xonsh):
      check_xonsh({"WAKKA": 42}, 'x = "WAKKA"; y = ${x}')
  
  
  def test_dollar_py_test(check_xonsh_ast):
      check_xonsh_ast({"WAKKA": 42}, '${None or "WAKKA"}')
  
  
  def test_dollar_py_recursive_name(check_xonsh_ast):
      check_xonsh_ast({"WAKKA": 42, "JAWAKA": "WAKKA"}, "${$JAWAKA}")
  
  
  def test_dollar_py_test_recursive_name(check_xonsh_ast):
      check_xonsh_ast({"WAKKA": 42, "JAWAKA": "WAKKA"}, "${None or $JAWAKA}")
  
  
  def test_dollar_py_test_recursive_test(check_xonsh_ast):
      check_xonsh_ast({"WAKKA": 42, "JAWAKA": "WAKKA"}, '${${"JAWA" + $JAWAKA[-2:]}}')
  
  
  def test_dollar_name_set(check_xonsh):
      check_xonsh({"WAKKA": 42}, "$WAKKA = 42")
  
  
  def test_dollar_py_set(check_xonsh):
      check_xonsh({"WAKKA": 42}, 'x = "WAKKA"; ${x} = 65')
  
  
  def test_dollar_sub(check_xonsh_ast):
      check_xonsh_ast({}, "$(ls)", False)
  
  
  @pytest.mark.parametrize(
      "expr",
      [
          "$(ls )",
          "$( ls)",
          "$( ls )",
      ],
  )
  def test_dollar_sub_space(expr, check_xonsh_ast):
      check_xonsh_ast({}, expr, False)
  
  
  def test_ls_dot(check_xonsh_ast):
      check_xonsh_ast({}, "$(ls .)", False)
  
  
  def test_lambda_in_atparens(check_xonsh_ast):
      check_xonsh_ast(
          {}, '$(echo hello | @(lambda a, s=None: "hey!") foo bar baz)', False
      )
  
  
  def test_generator_in_atparens(check_xonsh_ast):
      check_xonsh_ast({}, "$(echo @(i**2 for i in range(20)))", False)
  
  
  def test_bare_tuple_in_atparens(check_xonsh_ast):
      check_xonsh_ast({}, '$(echo @("a", 7))', False)
  
  
  def test_nested_madness(check_xonsh_ast):
      check_xonsh_ast(
          {},
          "$(@$(which echo) ls | @(lambda a, s=None: $(@(s.strip()) @(a[1]))) foo -la baz)",
          False,
      )
  
  
  def test_atparens_intoken(check_xonsh_ast):
      check_xonsh_ast({}, "![echo /x/@(y)/z]", False)
  
  
  def test_ls_dot_nesting(check_xonsh_ast):
      check_xonsh_ast({}, '$(ls @(None or "."))', False)
  
  
  def test_ls_dot_nesting_var(check_xonsh):
      check_xonsh({}, 'x = "."; $(ls @(None or x))', False)
  
  
  def test_ls_dot_str(check_xonsh_ast):
      check_xonsh_ast({}, '$(ls ".")', False)
  
  
  def test_ls_nest_ls(check_xonsh_ast):
      check_xonsh_ast({}, "$(ls $(ls))", False)
  
  
  def test_ls_nest_ls_dashl(check_xonsh_ast):
      check_xonsh_ast({}, "$(ls $(ls) -l)", False)
  
  
  def test_ls_envvar_strval(check_xonsh_ast):
      check_xonsh_ast({"WAKKA": "."}, "$(ls $WAKKA)", False)
  
  
  def test_ls_envvar_listval(check_xonsh_ast):
      check_xonsh_ast({"WAKKA": [".", "."]}, "$(ls $WAKKA)", False)
  
  
  def test_bang_sub(check_xonsh_ast):
      check_xonsh_ast({}, "!(ls)", False)
  
  
  @pytest.mark.parametrize(
      "expr",
      [
          "!(ls )",
          "!( ls)",
          "!( ls )",
      ],
  )
  def test_bang_sub_space(expr, check_xonsh_ast):
      check_xonsh_ast({}, expr, False)
  
  
  def test_bang_ls_dot(check_xonsh_ast):
      check_xonsh_ast({}, "!(ls .)", False)
  
  
  def test_bang_ls_dot_nesting(check_xonsh_ast):
      check_xonsh_ast({}, '!(ls @(None or "."))', False)
  
  
  def test_bang_ls_dot_nesting_var(check_xonsh):
      check_xonsh({}, 'x = "."; !(ls @(None or x))', False)
  
  
  def test_bang_ls_dot_str(check_xonsh_ast):
      check_xonsh_ast({}, '!(ls ".")', False)
  
  
  def test_bang_ls_nest_ls(check_xonsh_ast):
      check_xonsh_ast({}, "!(ls $(ls))", False)
  
  
  def test_bang_ls_nest_ls_dashl(check_xonsh_ast):
      check_xonsh_ast({}, "!(ls $(ls) -l)", False)
  
  
  def test_bang_ls_envvar_strval(check_xonsh_ast):
      check_xonsh_ast({"WAKKA": "."}, "!(ls $WAKKA)", False)
  
  
  def test_bang_ls_envvar_listval(check_xonsh_ast):
      check_xonsh_ast({"WAKKA": [".", "."]}, "!(ls $WAKKA)", False)
  
  
  def test_bang_envvar_args(check_xonsh_ast):
      check_xonsh_ast({"LS": "ls"}, "!($LS .)", False)
  
  
  def test_question(check_xonsh_ast):
      check_xonsh_ast({}, "range?")
  
  
  def test_dobquestion(check_xonsh_ast):
      check_xonsh_ast({}, "range??")
  
  
  def test_question_chain(check_xonsh_ast):
      check_xonsh_ast({}, "range?.index?")
  
  
  def test_ls_regex(check_xonsh_ast):
      check_xonsh_ast({}, "$(ls `[Ff]+i*LE` -l)", False)
  
  
  def test_backtick(check_xonsh_ast):
      check_xonsh_ast({}, "print(`.*`)", False)
  
  
  def test_ls_regex_octothorpe(check_xonsh_ast):
      check_xonsh_ast({}, "$(ls `#[Ff]+i*LE` -l)", False)
  
  
  def test_ls_explicitregex(check_xonsh_ast):
      check_xonsh_ast({}, "$(ls r`[Ff]+i*LE` -l)", False)
  
  
  def test_rbacktick(check_xonsh_ast):
      check_xonsh_ast({}, "print(r`.*`)", False)
  
  
  def test_ls_explicitregex_octothorpe(check_xonsh_ast):
      check_xonsh_ast({}, "$(ls r`#[Ff]+i*LE` -l)", False)
  
  
  def test_ls_glob(check_xonsh_ast):
      check_xonsh_ast({}, "$(ls g`[Ff]+i*LE` -l)", False)
  
  
  def test_gbacktick(check_xonsh_ast):
      check_xonsh_ast({}, "print(g`.*`)", False)
  
  
  def test_pbacktrick(check_xonsh_ast):
      check_xonsh_ast({}, "print(p`.*`)", False)
  
  
  def test_pgbacktick(check_xonsh_ast):
      check_xonsh_ast({}, "print(pg`.*`)", False)
  
  
  def test_prbacktick(check_xonsh_ast):
      check_xonsh_ast({}, "print(pr`.*`)", False)
  
  
  def test_ls_glob_octothorpe(check_xonsh_ast):
      check_xonsh_ast({}, "$(ls g`#[Ff]+i*LE` -l)", False)
  
  
  def test_ls_customsearch(check_xonsh_ast):
      check_xonsh_ast({}, "$(ls @foo`[Ff]+i*LE` -l)", False)
  
  
  def test_custombacktick(check_xonsh_ast):
      check_xonsh_ast({}, "print(@foo`.*`)", False)
  
  
  def test_ls_customsearch_octothorpe(check_xonsh_ast):
      check_xonsh_ast({}, "$(ls @foo`#[Ff]+i*LE` -l)", False)
  
  
  def test_injection(check_xonsh_ast):
      check_xonsh_ast({}, "$[@$(which python)]", False)
  
  
  def test_rhs_nested_injection(check_xonsh_ast):
      check_xonsh_ast({}, "$[ls @$(dirname @$(which python))]", False)
  
  
  def test_merged_injection(check_xonsh_ast):
      tree = check_xonsh_ast({}, "![a@$(echo 1 2)b]", False, return_obs=True)
      assert isinstance(tree, AST)
      func = tree.body.args[0].right.func
      assert func.attr == "list_of_list_of_strs_outer_product"
  
  
  def test_backtick_octothorpe(check_xonsh_ast):
      check_xonsh_ast({}, "print(`#.*`)", False)
  
  
  def test_uncaptured_sub(check_xonsh_ast):
      check_xonsh_ast({}, "$[ls]", False)
  
  
  def test_hiddenobj_sub(check_xonsh_ast):
      check_xonsh_ast({}, "![ls]", False)
  
  
  def test_slash_envarv_echo(check_xonsh_ast):
      check_xonsh_ast({}, "![echo $HOME/place]", False)
  
  
  def test_echo_double_eq(check_xonsh_ast):
      check_xonsh_ast({}, "![echo yo==yo]", False)
  
  
  def test_bang_two_cmds_one_pipe(check_xonsh_ast):
      check_xonsh_ast({}, "!(ls | grep wakka)", False)
  
  
  def test_bang_three_cmds_two_pipes(check_xonsh_ast):
      check_xonsh_ast({}, "!(ls | grep wakka | grep jawaka)", False)
  
  
  def test_bang_one_cmd_write(check_xonsh_ast):
      check_xonsh_ast({}, "!(ls > x.py)", False)
  
  
  def test_bang_one_cmd_append(check_xonsh_ast):
      check_xonsh_ast({}, "!(ls >> x.py)", False)
  
  
  def test_bang_two_cmds_write(check_xonsh_ast):
      check_xonsh_ast({}, "!(ls | grep wakka > x.py)", False)
  
  
  def test_bang_two_cmds_append(check_xonsh_ast):
      check_xonsh_ast({}, "!(ls | grep wakka >> x.py)", False)
  
  
  def test_bang_cmd_background(check_xonsh_ast):
      check_xonsh_ast({}, "!(emacs ugggh &)", False)
  
  
  def test_bang_cmd_background_nospace(check_xonsh_ast):
      check_xonsh_ast({}, "!(emacs ugggh&)", False)
  
  
  def test_bang_git_quotes_no_space(check_xonsh_ast):
      check_xonsh_ast({}, '![git commit -am "wakka"]', False)
  
  
  def test_bang_git_quotes_space(check_xonsh_ast):
      check_xonsh_ast({}, '![git commit -am "wakka jawaka"]', False)
  
  
  def test_bang_git_two_quotes_space(check_xonsh):
      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):
      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):
      check_xonsh_ast({}, '![ls "wakka jawaka baraka"]', False)
  
  
  def test_two_cmds_one_pipe(check_xonsh_ast):
      check_xonsh_ast({}, "$(ls | grep wakka)", False)
  
  
  def test_three_cmds_two_pipes(check_xonsh_ast):
      check_xonsh_ast({}, "$(ls | grep wakka | grep jawaka)", False)
  
  
  def test_two_cmds_one_and_brackets(check_xonsh_ast):
      check_xonsh_ast({}, "![ls me] and ![grep wakka]", False)
  
  
  def test_three_cmds_two_ands(check_xonsh_ast):
      check_xonsh_ast({}, "![ls] and ![grep wakka] and ![grep jawaka]", False)
  
  
  def test_two_cmds_one_doubleamps(check_xonsh_ast):
      check_xonsh_ast({}, "![ls] && ![grep wakka]", False)
  
  
  def test_three_cmds_two_doubleamps(check_xonsh_ast):
      check_xonsh_ast({}, "![ls] && ![grep wakka] && ![grep jawaka]", False)
  
  
  def test_two_cmds_one_or(check_xonsh_ast):
      check_xonsh_ast({}, "![ls] or ![grep wakka]", False)
  
  
  def test_three_cmds_two_ors(check_xonsh_ast):
      check_xonsh_ast({}, "![ls] or ![grep wakka] or ![grep jawaka]", False)
  
  
  def test_two_cmds_one_doublepipe(check_xonsh_ast):
      check_xonsh_ast({}, "![ls] || ![grep wakka]", False)
  
  
  def test_three_cmds_two_doublepipe(check_xonsh_ast):
      check_xonsh_ast({}, "![ls] || ![grep wakka] || ![grep jawaka]", False)
  
  
  def test_one_cmd_write(check_xonsh_ast):
      check_xonsh_ast({}, "$(ls > x.py)", False)
  
  
  def test_one_cmd_append(check_xonsh_ast):
      check_xonsh_ast({}, "$(ls >> x.py)", False)
  
  
  def test_two_cmds_write(check_xonsh_ast):
      check_xonsh_ast({}, "$(ls | grep wakka > x.py)", False)
  
  
  def test_two_cmds_append(check_xonsh_ast):
      check_xonsh_ast({}, "$(ls | grep wakka >> x.py)", False)
  
  
  def test_cmd_background(check_xonsh_ast):
      check_xonsh_ast({}, "$(emacs ugggh &)", False)
  
  
  def test_cmd_background_nospace(check_xonsh_ast):
      check_xonsh_ast({}, "$(emacs ugggh&)", False)
  
  
  def test_git_quotes_no_space(check_xonsh_ast):
      check_xonsh_ast({}, '$[git commit -am "wakka"]', False)
  
  
  def test_git_quotes_space(check_xonsh_ast):
      check_xonsh_ast({}, '$[git commit -am "wakka jawaka"]', False)
  
  
  def test_git_two_quotes_space(check_xonsh):
      check_xonsh(
          {},
          '$[git commit -am "wakka jawaka"]\n' '$[git commit -am "flock jawaka"]\n',
          False,
      )
  
  
  def test_git_two_quotes_space_space(check_xonsh):
      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):
      check_xonsh_ast({}, '$[ls "wakka jawaka baraka"]', False)
  
  
  def test_leading_envvar_assignment(check_xonsh_ast):
      check_xonsh_ast({}, "![$FOO='foo' $BAR=2 echo r'$BAR']", False)
  
  
  def test_echo_comma(check_xonsh_ast):
      check_xonsh_ast({}, "![echo ,]", False)
  
  
  def test_echo_internal_comma(check_xonsh_ast):
      check_xonsh_ast({}, "![echo 1,2]", False)
  
  
  def test_comment_only(check_xonsh_ast):
      check_xonsh_ast({}, "# hello")
  
  
  def test_echo_slash_question(check_xonsh_ast):
      check_xonsh_ast({}, "![echo /?]", False)
  
  
  def test_bad_quotes(check_xonsh_ast):
      with pytest.raises(SyntaxError):
          check_xonsh_ast({}, '![echo """hello]', False)
  
  
  def test_redirect(check_xonsh_ast):
      assert check_xonsh_ast({}, "$[cat < input.txt]", False)
      assert check_xonsh_ast({}, "$[< input.txt cat]", False)
  
  
  @pytest.mark.parametrize(
      "case",
      [
          "![(cat)]",
          "![(cat;)]",
          "![(cd path; ls; cd)]",
          '![(echo "abc"; sleep 1; echo "def")]',
          '![(echo "abc"; sleep 1; echo "def") | grep abc]',
          "![(if True:\n   ls\nelse:\n   echo not true)]",
      ],
  )
  def test_use_subshell(case, check_xonsh_ast):
      check_xonsh_ast({}, case, False, debug_level=0)
  
  
  @pytest.mark.parametrize(
      "case",
      [
          "$[cat < /path/to/input.txt]",
          "$[(cat) < /path/to/input.txt]",
          "$[< /path/to/input.txt cat]",
          "![< /path/to/input.txt]",
          "![< /path/to/input.txt > /path/to/output.txt]",
      ],
  )
  def test_redirect_abspath(case, check_xonsh_ast):
      assert check_xonsh_ast({}, case, False)
  
  
  @pytest.mark.parametrize("case", ["", "o", "out", "1"])
  def test_redirect_output(case, check_xonsh_ast):
      assert check_xonsh_ast({}, f'$[echo "test" {case}> test.txt]', False)
      assert check_xonsh_ast({}, f'$[< input.txt echo "test" {case}> test.txt]', False)
      assert check_xonsh_ast({}, f'$[echo "test" {case}> test.txt < input.txt]', False)
  
  
  @pytest.mark.parametrize("case", ["e", "err", "2"])
  def test_redirect_error(case, check_xonsh_ast):
      assert check_xonsh_ast({}, f'$[echo "test" {case}> test.txt]', False)
      assert check_xonsh_ast({}, f'$[< input.txt echo "test" {case}> test.txt]', False)
      assert check_xonsh_ast({}, f'$[echo "test" {case}> test.txt < input.txt]', False)
  
  
  @pytest.mark.parametrize("case", ["a", "all", "&"])
  def test_redirect_all(case, check_xonsh_ast):
      assert check_xonsh_ast({}, f'$[echo "test" {case}> test.txt]', False)
      assert check_xonsh_ast({}, f'$[< input.txt echo "test" {case}> test.txt]', False)
      assert check_xonsh_ast({}, f'$[echo "test" {case}> test.txt < input.txt]', False)
  
  
  @pytest.mark.parametrize(
      "r",
      [
          "e>o",
          "e>out",
          "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, check_xonsh_ast):
      assert check_xonsh_ast({}, f'$[echo "test" {r} {o}> test.txt]', False)
      assert check_xonsh_ast({}, f'$[< input.txt echo "test" {r} {o}> test.txt]', False)
      assert check_xonsh_ast({}, f'$[echo "test" {r} {o}> test.txt < input.txt]', False)
  
  
  @pytest.mark.parametrize(
      "r",
      [
          "o>e",
          "o>err",
          "out>e",
          "1>2",
          "o>2",
          "out>2",
          "1>err",
          "1>e",
          "out>&2",
          "o>&2",
          "1>&2",
      ],
  )
  @pytest.mark.parametrize("e", ["e", "err", "2"])
  def test_redirect_output_to_error(r, e, check_xonsh_ast):
      assert check_xonsh_ast({}, f'$[echo "test" {r} {e}> test.txt]', False)
      assert check_xonsh_ast({}, f'$[< input.txt echo "test" {r} {e}> test.txt]', False)
      assert check_xonsh_ast({}, f'$[echo "test" {r} {e}> test.txt < input.txt]', False)
  
  
  def test_macro_call_empty(check_xonsh_ast):
      assert check_xonsh_ast({}, "f!()", False)
  
  
  MACRO_ARGS = [
      "x",
      "True",
      "None",
      "import os",
      "x=10",
      '"oh no, mom"',
      "...",
      " ... ",
      "if True:\n  pass",
      "{x: y}",
      "{x: y, 42: 5}",
      "{1, 2, 3,}",
      "(x,y)",
      "(x, y)",
      "((x, y), z)",
      "g()",
      "range(10)",
      "range(1, 10, 2)",
      "()",
      "{}",
      "[]",
      "[1, 2]",
      "@(x)",
      "!(ls -l)",
      "![ls -l]",
      "$(ls -l)",
      "${x + y}",
      "$[ls -l]",
      "@$(which xonsh)",
  ]
  
  
  @pytest.mark.parametrize("s", MACRO_ARGS)
  def test_macro_call_one_arg(check_xonsh_ast, s):
      f = f"f!({s})"
      tree = check_xonsh_ast({}, f, False, return_obs=True)
      assert isinstance(tree, AST)
      args = tree.body.args[1].elts
      assert len(args) == 1
      assert args[0].s == s.strip()
  
  
  @pytest.mark.parametrize("s,t", itertools.product(MACRO_ARGS[::2], MACRO_ARGS[1::2]))
  def test_macro_call_two_args(check_xonsh_ast, s, t):
      f = f"f!({s}, {t})"
      tree = check_xonsh_ast({}, f, False, return_obs=True)
      assert isinstance(tree, AST)
      args = tree.body.args[1].elts
      assert len(args) == 2
      assert args[0].s == s.strip()
      assert args[1].s == t.strip()
  
  
  @pytest.mark.parametrize(
      "s,t,u", itertools.product(MACRO_ARGS[::3], MACRO_ARGS[1::3], MACRO_ARGS[2::3])
  )
  def test_macro_call_three_args(check_xonsh_ast, s, t, u):
      f = f"f!({s}, {t}, {u})"
      tree = check_xonsh_ast({}, f, False, return_obs=True)
      assert isinstance(tree, AST)
      args = tree.body.args[1].elts
      assert len(args) == 3
      assert args[0].s == s.strip()
      assert args[1].s == t.strip()
      assert args[2].s == u.strip()
  
  
  @pytest.mark.parametrize("s", MACRO_ARGS)
  def test_macro_call_one_trailing(check_xonsh_ast, s):
      f = f"f!({s},)"
      tree = check_xonsh_ast({}, f, False, return_obs=True)
      assert isinstance(tree, AST)
      args = tree.body.args[1].elts
      assert len(args) == 1
      assert args[0].s == s.strip()
  
  
  @pytest.mark.parametrize("s", MACRO_ARGS)
  def test_macro_call_one_trailing_space(check_xonsh_ast, s):
      f = f"f!( {s}, )"
      tree = check_xonsh_ast({}, f, False, return_obs=True)
      assert isinstance(tree, AST)
      args = tree.body.args[1].elts
      assert len(args) == 1
      assert args[0].s == s.strip()
  
  
  SUBPROC_MACRO_OC = [("!(", ")"), ("$(", ")"), ("![", "]"), ("$[", "]")]
  
  
  @pytest.mark.parametrize("opener, closer", SUBPROC_MACRO_OC)
  @pytest.mark.parametrize("body", ["echo!", "echo !", "echo ! "])
  def test_empty_subprocbang(opener, closer, body, check_xonsh_ast):
      tree = check_xonsh_ast({}, opener + body + closer, False, return_obs=True)
      assert isinstance(tree, AST)
      cmd = tree.body.args[0].elts
      assert len(cmd) == 2
      assert cmd[1].s == ""
  
  
  @pytest.mark.parametrize("opener, closer", SUBPROC_MACRO_OC)
  @pytest.mark.parametrize("body", ["echo!x", "echo !x", "echo !x", "echo ! x"])
  def test_single_subprocbang(opener, closer, body, check_xonsh_ast):
      tree = check_xonsh_ast({}, opener + body + closer, False, return_obs=True)
      assert isinstance(tree, AST)
      cmd = tree.body.args[0].elts
      assert len(cmd) == 2
      assert cmd[1].s == "x"
  
  
  @pytest.mark.parametrize("opener, closer", SUBPROC_MACRO_OC)
  @pytest.mark.parametrize(
      "body", ["echo -n!x", "echo -n!x", "echo -n !x", "echo -n ! x"]
  )
  def test_arg_single_subprocbang(opener, closer, body, check_xonsh_ast):
      tree = check_xonsh_ast({}, opener + body + closer, False, return_obs=True)
      assert isinstance(tree, AST)
      cmd = tree.body.args[0].elts
      assert len(cmd) == 3
      assert cmd[2].s == "x"
  
  
  @pytest.mark.parametrize("opener, closer", SUBPROC_MACRO_OC)
  @pytest.mark.parametrize("ipener, iloser", [("$(", ")"), ("@$(", ")"), ("$[", "]")])
  @pytest.mark.parametrize(
      "body", ["echo -n!x", "echo -n!x", "echo -n !x", "echo -n ! x"]
  )
  def test_arg_single_subprocbang_nested(
      opener, closer, ipener, iloser, body, check_xonsh_ast
  ):
      tree = check_xonsh_ast({}, opener + body + closer, False, return_obs=True)
      assert isinstance(tree, AST)
      cmd = tree.body.args[0].elts
      assert len(cmd) == 3
      assert cmd[2].s == "x"
  
  
  @pytest.mark.parametrize("opener, closer", SUBPROC_MACRO_OC)
  @pytest.mark.parametrize(
      "body",
      [
          "echo!x + y",
          "echo !x + y",
          "echo !x + y",
          "echo ! x + y",
          "timeit! bang! and more",
          "timeit! recurse() and more",
          "timeit! recurse[] and more",
          "timeit! recurse!() and more",
          "timeit! recurse![] and more",
          "timeit! recurse$() and more",
          "timeit! recurse$[] and more",
          "timeit! recurse!() and more",
          "timeit!!!!",
          "timeit! (!)",
          "timeit! [!]",
          "timeit!!(ls)",
          'timeit!"!)"',
      ],
  )
  def test_many_subprocbang(opener, closer, body, check_xonsh_ast):
      tree = check_xonsh_ast({}, opener + body + closer, False, return_obs=True)
      assert isinstance(tree, AST)
      cmd = tree.body.args[0].elts
      assert len(cmd) == 2
      assert cmd[1].s == body.partition("!")[-1].strip()
  
  
  WITH_BANG_RAWSUITES = [
      "pass\n",
      "x = 42\ny = 12\n",
      'export PATH="yo:momma"\necho $PATH\n',
      ("with q as t:\n" "    v = 10\n" "\n"),
      (
          "with q as t:\n"
          "    v = 10\n"
          "\n"
          "for x in range(6):\n"
          "    if True:\n"
          "        pass\n"
          "    else:\n"
          "        ls -l\n"
          "\n"
          "a = 42\n"
      ),
  ]
  
  
  @pytest.mark.parametrize("body", WITH_BANG_RAWSUITES)
  def test_withbang_single_suite(body, check_xonsh_ast):
      code = "with! x:\n{}".format(textwrap.indent(body, "    "))
      tree = check_xonsh_ast({}, code, False, return_obs=True, mode="exec")
      assert isinstance(tree, AST)
      wither = tree.body[0]
      assert isinstance(wither, With)
      assert len(wither.body) == 1
      assert isinstance(wither.body[0], Pass)
      assert len(wither.items) == 1
      item = wither.items[0]
      s = item.context_expr.args[1].s
      assert s == body
  
  
  @pytest.mark.parametrize("body", WITH_BANG_RAWSUITES)
  def test_withbang_as_single_suite(body, check_xonsh_ast):
      code = "with! x as y:\n{}".format(textwrap.indent(body, "    "))
      tree = check_xonsh_ast({}, code, False, return_obs=True, mode="exec")
      assert isinstance(tree, AST)
      wither = tree.body[0]
      assert isinstance(wither, With)
      assert len(wither.body) == 1
      assert isinstance(wither.body[0], Pass)
      assert len(wither.items) == 1
      item = wither.items[0]
      assert item.optional_vars.id == "y"
      s = item.context_expr.args[1].s
      assert s == body
  
  
  @pytest.mark.parametrize("body", WITH_BANG_RAWSUITES)
  def test_withbang_single_suite_trailing(body, check_xonsh_ast):
      code = "with! x:\n{}\nprint(x)\n".format(textwrap.indent(body, "    "))
      tree = check_xonsh_ast(
          {},
          code,
          False,
          return_obs=True,
          mode="exec",
          # debug_level=100
      )
      assert isinstance(tree, AST)
      wither = tree.body[0]
      assert isinstance(wither, With)
      assert len(wither.body) == 1
      assert isinstance(wither.body[0], Pass)
      assert len(wither.items) == 1
      item = wither.items[0]
      s = item.context_expr.args[1].s
      assert s == body + "\n"
  
  
  WITH_BANG_RAWSIMPLE = [
      "pass",
      "x = 42; y = 12",
      'export PATH="yo:momma"; echo $PATH',
      "[1,\n    2,\n    3]",
  ]
  
  
  @pytest.mark.parametrize("body", WITH_BANG_RAWSIMPLE)
  def test_withbang_single_simple(body, check_xonsh_ast):
      code = f"with! x: {body}\n"
      tree = check_xonsh_ast({}, code, False, return_obs=True, mode="exec")
      assert isinstance(tree, AST)
      wither = tree.body[0]
      assert isinstance(wither, With)
      assert len(wither.body) == 1
      assert isinstance(wither.body[0], Pass)
      assert len(wither.items) == 1
      item = wither.items[0]
      s = item.context_expr.args[1].s
      assert s == body
  
  
  @pytest.mark.parametrize("body", WITH_BANG_RAWSIMPLE)
  def test_withbang_single_simple_opt(body, check_xonsh_ast):
      code = f"with! x as y: {body}\n"
      tree = check_xonsh_ast({}, code, False, return_obs=True, mode="exec")
      assert isinstance(tree, AST)
      wither = tree.body[0]
      assert isinstance(wither, With)
      assert len(wither.body) == 1
      assert isinstance(wither.body[0], Pass)
      assert len(wither.items) == 1
      item = wither.items[0]
      assert item.optional_vars.id == "y"
      s = item.context_expr.args[1].s
      assert s == body
  
  
  @pytest.mark.parametrize("body", WITH_BANG_RAWSUITES)
  def test_withbang_as_many_suite(body, check_xonsh_ast):
      code = "with! x as a, y as b, z as c:\n{}"
      code = code.format(textwrap.indent(body, "    "))
      tree = check_xonsh_ast({}, code, False, return_obs=True, mode="exec")
      assert isinstance(tree, AST)
      wither = tree.body[0]
      assert isinstance(wither, With)
      assert len(wither.body) == 1
      assert isinstance(wither.body[0], Pass)
      assert len(wither.items) == 3
      for i, targ in enumerate("abc"):
          item = wither.items[i]
          assert item.optional_vars.id == targ
          s = item.context_expr.args[1].s
          assert s == body
  
  
  def test_subproc_raw_str_literal(check_xonsh_ast):
      tree = check_xonsh_ast({}, "!(echo '$foo')", run=False, return_obs=True)
      assert isinstance(tree, AST)
      subproc = tree.body
      assert isinstance(subproc.args[0].elts[1], Call)
      assert subproc.args[0].elts[1].func.attr == "expand_path"
  
      tree = check_xonsh_ast({}, "!(echo r'$foo')", run=False, return_obs=True)
      assert isinstance(tree, AST)
      subproc = tree.body
      assert isinstance(subproc.args[0].elts[1], Str)
      assert subproc.args[0].elts[1].s == "$foo"
  
  
  # test invalid expressions
  
  
  def test_syntax_error_del_literal(parser):
      with pytest.raises(SyntaxError):
          parser.parse("del 7")
  
  
  def test_syntax_error_del_constant(parser):
      with pytest.raises(SyntaxError):
          parser.parse("del True")
  
  
  def test_syntax_error_del_emptytuple(parser):
      with pytest.raises(SyntaxError):
          parser.parse("del ()")
  
  
  def test_syntax_error_del_call(parser):
      with pytest.raises(SyntaxError):
          parser.parse("del foo()")
  
  
  def test_syntax_error_del_lambda(parser):
      with pytest.raises(SyntaxError):
          parser.parse('del lambda x: "yay"')
  
  
  def test_syntax_error_del_ifexp(parser):
      with pytest.raises(SyntaxError):
          parser.parse("del x if y else z")
  
  
  @pytest.mark.parametrize(
      "exp",
      [
          "[i for i in foo]",
          "{i for i in foo}",
          "(i for i in foo)",
          "{k:v for k,v in d.items()}",
      ],
  )
  def test_syntax_error_del_comps(parser, exp):
      with pytest.raises(SyntaxError):
          parser.parse(f"del {exp}")
  
  
  @pytest.mark.parametrize("exp", ["x + y", "x and y", "-x"])
  def test_syntax_error_del_ops(parser, exp):
      with pytest.raises(SyntaxError):
          parser.parse(f"del {exp}")
  
  
  @pytest.mark.parametrize("exp", ["x > y", "x > y == z"])
  def test_syntax_error_del_cmp(parser, exp):
      with pytest.raises(SyntaxError):
          parser.parse(f"del {exp}")
  
  
  def test_syntax_error_lonely_del(parser):
      with pytest.raises(SyntaxError):
          parser.parse("del")
  
  
  def test_syntax_error_assign_literal(parser):
      with pytest.raises(SyntaxError):
          parser.parse("7 = x")
  
  
  def test_syntax_error_assign_constant(parser):
      with pytest.raises(SyntaxError):
          parser.parse("True = 8")
  
  
  def test_syntax_error_assign_emptytuple(parser):
      with pytest.raises(SyntaxError):
          parser.parse("() = x")
  
  
  def test_syntax_error_assign_call(parser):
      with pytest.raises(SyntaxError):
          parser.parse("foo() = x")
  
  
  def test_syntax_error_assign_lambda(parser):
      with pytest.raises(SyntaxError):
          parser.parse('lambda x: "yay" = y')
  
  
  def test_syntax_error_assign_ifexp(parser):
      with pytest.raises(SyntaxError):
          parser.parse("x if y else z = 8")
  
  
  @pytest.mark.parametrize(
      "exp",
      [
          "[i for i in foo]",
          "{i for i in foo}",
          "(i for i in foo)",
          "{k:v for k,v in d.items()}",
      ],
  )
  def test_syntax_error_assign_comps(parser, exp):
      with pytest.raises(SyntaxError):
          parser.parse(f"{exp} = z")
  
  
  @pytest.mark.parametrize("exp", ["x + y", "x and y", "-x"])
  def test_syntax_error_assign_ops(parser, exp):
      with pytest.raises(SyntaxError):
          parser.parse(f"{exp} = z")
  
  
  @pytest.mark.parametrize("exp", ["x > y", "x > y == z"])
  def test_syntax_error_assign_cmp(parser, exp):
      with pytest.raises(SyntaxError):
          parser.parse(f"{exp} = a")
  
  
  def test_syntax_error_augassign_literal(parser):
      with pytest.raises(SyntaxError):
          parser.parse("7 += x")
  
  
  def test_syntax_error_augassign_constant(parser):
      with pytest.raises(SyntaxError):
          parser.parse("True += 8")
  
  
  def test_syntax_error_augassign_emptytuple(parser):
      with pytest.raises(SyntaxError):
          parser.parse("() += x")
  
  
  def test_syntax_error_augassign_call(parser):
      with pytest.raises(SyntaxError):
          parser.parse("foo() += x")
  
  
  def test_syntax_error_augassign_lambda(parser):
      with pytest.raises(SyntaxError):
          parser.parse('lambda x: "yay" += y')
  
  
  def test_syntax_error_augassign_ifexp(parser):
      with pytest.raises(SyntaxError):
          parser.parse("x if y else z += 8")
  
  
  @pytest.mark.parametrize(
      "exp",
      [
          "[i for i in foo]",
          "{i for i in foo}",
          "(i for i in foo)",
          "{k:v for k,v in d.items()}",
      ],
  )
  def test_syntax_error_augassign_comps(parser, exp):
      with pytest.raises(SyntaxError):
          parser.parse(f"{exp} += z")
  
  
  @pytest.mark.parametrize("exp", ["x + y", "x and y", "-x"])
  def test_syntax_error_augassign_ops(parser, exp):
      with pytest.raises(SyntaxError):
          parser.parse(f"{exp} += z")
  
  
  @pytest.mark.parametrize("exp", ["x > y", "x > y +=+= z"])
  def test_syntax_error_augassign_cmp(parser, exp):
      with pytest.raises(SyntaxError):
          parser.parse(f"{exp} += a")
  
  
  def test_syntax_error_bar_kwonlyargs(parser):
      with pytest.raises(SyntaxError):
          parser.parse("def spam(*):\n   pass\n", mode="exec")
  
  
  @skip_if_pre_3_8
  def test_syntax_error_bar_posonlyargs(parser):
      with pytest.raises(SyntaxError):
          parser.parse("def spam(/):\n   pass\n", mode="exec")
  
  
  @skip_if_pre_3_8
  def test_syntax_error_bar_posonlyargs_no_comma(parser):
      with pytest.raises(SyntaxError):
          parser.parse("def spam(x /, y):\n   pass\n", mode="exec")
  
  
  def test_syntax_error_nondefault_follows_default(parser):
      with pytest.raises(SyntaxError):
          parser.parse("def spam(x=1, y):\n   pass\n", mode="exec")
  
  
  @skip_if_pre_3_8
  def test_syntax_error_posonly_nondefault_follows_default(parser):
      with pytest.raises(SyntaxError):
          parser.parse("def spam(x, y=1, /, z):\n   pass\n", mode="exec")
  
  
  def test_syntax_error_lambda_nondefault_follows_default(parser):
      with pytest.raises(SyntaxError):
          parser.parse("lambda x=1, y: x", mode="exec")
  
  
  @skip_if_pre_3_8
  def test_syntax_error_lambda_posonly_nondefault_follows_default(parser):
      with pytest.raises(SyntaxError):
          parser.parse("lambda x, y=1, /, z: x", mode="exec")
  
  
  def test_get_repo_url(parser):
      parser.parse(
          "def get_repo_url():\n"
          "    raw = $(git remote get-url --push origin).rstrip()\n"
          "    return raw.replace('https://github.com/', '')\n"
      )
  
  
  # match statement
  # (tests asserting that pure python match statements produce the same ast with the xonsh parser as they do with the python parser)
  
  
  def test_match_and_case_are_not_keywords(check_stmts):
      check_stmts(
          """
  match = 1
  case = 2
  def match():
      pass
  class case():
      pass
  """
      )
  
  
  @skip_if_pre_3_10
  def test_match_literal_pattern(check_stmts):
      check_stmts(
          """match 1:
      case 1j:
          pass
      case 2.718+3.141j:
          pass
      case -2.718-3.141j:
          pass
      case 2:
          pass
      case -2:
          pass
      case "One" 'Two':
          pass
      case None:
          pass
      case True:
          pass
      case False:
          pass
  """,
          run=False,
      )
  
  
  @skip_if_pre_3_10
  def test_match_or_pattern(check_stmts):
      check_stmts(
          """match 1:
      case 1j | 2 | "One" | 'Two' | None | True | False:
          pass
  """,
          run=False,
      )
  
  
  @skip_if_pre_3_10
  def test_match_as_pattern(check_stmts):
      check_stmts(
          """match 1:
      case 1j | 2 | "One" | 'Two' | None | True | False as target:
          pass
      case 2 as target:
          pass
  """,
          run=False,
      )
  
  
  @skip_if_pre_3_10
  def test_match_group_pattern(check_stmts):
      check_stmts(
          """match 1:
      case (None):
          pass
      case ((None)):
          pass
      case (1 | 2 as x) as x:
          pass
  """,
          run=False,
      )
  
  
  @skip_if_pre_3_10
  def test_match_capture_and_wildcard_pattern(check_stmts):
      check_stmts(
          """match 1:
      case _:
          pass
      case x:
          pass
  """,
          run=False,
      )
  
  
  @skip_if_pre_3_10
  def test_match_value_pattern(check_stmts):
      check_stmts(
          """match 1:
      case math.pi:
          pass
      case a.b.c.d:
          pass
  """,
          run=False,
      )
  
  
  @skip_if_pre_3_10
  def test_match_mapping_pattern(check_stmts):
      check_stmts(
          """match _:
      case {}:
          pass
      case {x.y:y}:
          pass
      case {x.y:y,}:
          pass
      case {x.y:y,"a":a}:
          pass
      case {x.y:y,"a":a,}:
          pass
      case {x.y:y,"a":a,**end}:
          pass
      case {x.y:y,"a":a,**end,}:
          pass
      case {**end}:
          pass
      case {**end,}:
          pass
      case {1:1, "two":two, three.three: {}, 4:None, **end}:
          pass
  """,
          run=False,
      )
  
  
  @skip_if_pre_3_10
  def test_match_class_pattern(check_stmts):
      check_stmts(
          """match _:
      case classs():
          pass
      case x.classs():
          pass
      case classs("subpattern"):
          pass
      case classs("subpattern",):
          pass
      case classs("subpattern",2):
          pass
      case classs("subpattern",2,):
          pass
      case classs(a = b):
          pass
      case classs(a = b,):
          pass
      case classs(a = b, b = c):
          pass
      case classs(a = b, b = c,):
          pass
      case classs(1,2,3,a = b):
          pass
      case classs(1,2,3,a = b,):
          pass
      case classs(1,2,3,a = b, b = c):
          pass
      case classs(1,2,3,a = b, b = c,):
          pass
  """,
          run=False,
      )
  
  
  @skip_if_pre_3_10
  def test_match_sequence_pattern(check_stmts):
      check_stmts(
          """match 1:
      case (): # empty sequence pattern
          pass
      case (1): # group pattern
          pass
      case (1,): # length one sequence
          pass
      case (1,2):
          pass
      case (1,2,):
          pass
      case (1,2,3):
          pass
      case (1,2,3,):
          pass
      case []:
          pass
      case [1]:
          pass
      case [1,]:
          pass
      case [1,2]:
          pass
      case [1,2,3]:
          pass
      case [1,2,3,]:
          pass
      case [*x, *_]: # star patterns
          pass
      case 1,: # top level sequence patterns
          pass
      case *x,:
          pass
      case *_,*_:
          pass
  """,
          run=False,
      )
  
  
  @skip_if_pre_3_10
  def test_match_subject(check_stmts):
      check_stmts(
          """
  match 1:
      case 1:
          pass
  match 1,:
      case 1:
          pass
  match 1,2:
      case 1:
          pass
  match 1,2,:
      case 1:
          pass
  match (1,2):
      case 1:
          pass
  match *x,:
      case 1:
          pass
  match (...[...][...]):
      case 1:
          pass
  """,
          run=False,
      )
  