From 0d0dec2a91fa02b5681bcb64641c085eeec07477 Mon Sep 17 00:00:00 2001 From: Padraic Fanning Date: Sun, 14 Feb 2021 20:46:56 -0500 Subject: [PATCH] Add expected failures to failed/errored tests --- Lib/test/test_ast.py | 186 +++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 186 insertions(+) diff --git a/Lib/test/test_ast.py b/Lib/test/test_ast.py index c70fa9663..73125b4cf 100644 --- a/Lib/test/test_ast.py +++ b/Lib/test/test_ast.py @@ -263,6 +263,8 @@ class AST_Tests(unittest.TestCase): elif value is not None: self._assertTrueorder(value, parent_pos) + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_AST_objects(self): x = ast.AST() self.assertEqual(x._fields, ()) @@ -277,6 +279,8 @@ class AST_Tests(unittest.TestCase): # "_ast.AST constructor takes 0 positional arguments" ast.AST(2) + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_AST_garbage_collection(self): class X: pass @@ -325,6 +329,8 @@ class AST_Tests(unittest.TestCase): mod.body[0].module = " __future__ ".strip() compile(mod, "", "exec") + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_base_classes(self): self.assertTrue(issubclass(ast.For, ast.stmt)) self.assertTrue(issubclass(ast.Name, ast.expr)) @@ -333,6 +339,8 @@ class AST_Tests(unittest.TestCase): self.assertTrue(issubclass(ast.comprehension, ast.AST)) self.assertTrue(issubclass(ast.Gt, ast.AST)) + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_field_attr_existence(self): for name, item in ast.__dict__.items(): if isinstance(item, type) and name != 'AST' and name[0].isupper(): @@ -340,6 +348,8 @@ class AST_Tests(unittest.TestCase): if isinstance(x, ast.AST): self.assertEqual(type(x._fields), tuple) + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_arguments(self): x = ast.arguments() self.assertEqual(x._fields, ('posonlyargs', 'args', 'vararg', 'kwonlyargs', @@ -357,6 +367,8 @@ class AST_Tests(unittest.TestCase): x._fields = 666 self.assertEqual(x._fields, 666) + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_classattrs(self): x = ast.Num() self.assertEqual(x._fields, ('value', 'kind')) @@ -500,6 +512,8 @@ class AST_Tests(unittest.TestCase): x = ast.Module(body, []) self.assertEqual(x.body, body) + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_nodeclasses(self): # Zero arguments constructor explicitly allowed x = ast.BinOp() @@ -544,6 +558,8 @@ class AST_Tests(unittest.TestCase): x = ast.BinOp(1, 2, 3, foobarbaz=42) self.assertEqual(x.foobarbaz, 42) + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_no_fields(self): # this used to fail because Sub._fields was None x = ast.Sub() @@ -564,6 +580,8 @@ class AST_Tests(unittest.TestCase): ast2 = mod.loads(mod.dumps(ast, protocol)) self.assertEqual(to_tuple(ast2), to_tuple(ast)) + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_invalid_sum(self): pos = dict(lineno=2, col_offset=3) m = ast.Module([ast.Expr(ast.expr(**pos), **pos)], []) @@ -571,6 +589,8 @@ class AST_Tests(unittest.TestCase): compile(m, "", "exec") self.assertIn("but got <_ast.expr", str(cm.exception)) + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_invalid_identitifer(self): m = ast.Module([ast.Expr(ast.Name(42, ast.Load()))], []) ast.fix_missing_locations(m) @@ -578,6 +598,8 @@ class AST_Tests(unittest.TestCase): compile(m, "", "exec") self.assertIn("identifier must be of type str", str(cm.exception)) + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_empty_yield_from(self): # Issue 16546: yield from value is not optional. empty_yield_from = ast.parse("def f():\n yield from g()") @@ -596,6 +618,8 @@ class AST_Tests(unittest.TestCase): with support.swap_attr(unicodedata, 'normalize', bad_normalize): self.assertRaises(TypeError, ast.parse, '\u03D5') + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_issue18374_binop_col_offset(self): tree = ast.parse('4+5+6+7') parent_binop = tree.body[0].value @@ -627,16 +651,22 @@ class AST_Tests(unittest.TestCase): self.assertEqual(grandchild_binop.end_col_offset, 3) self.assertEqual(grandchild_binop.end_lineno, 1) + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_issue39579_dotted_name_end_col_offset(self): tree = ast.parse('@a.b.c\ndef f(): pass') attr_b = tree.body[0].decorator_list[0].value self.assertEqual(attr_b.end_col_offset, 4) + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_issue40614_feature_version(self): ast.parse('f"{x=}"', feature_version=(3, 8)) with self.assertRaises(SyntaxError): ast.parse('f"{x=}"', feature_version=(3, 7)) + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_constant_as_name(self): for constant in "True", "False", "None": expr = ast.Expression(ast.Name(constant, ast.Load())) @@ -653,6 +683,8 @@ class ASTHelpers_Test(unittest.TestCase): b = compile('foo(1 + 1)', '', 'exec', ast.PyCF_ONLY_AST) self.assertEqual(ast.dump(a), ast.dump(b)) + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_parse_in_error(self): try: 1/0 @@ -661,6 +693,8 @@ class ASTHelpers_Test(unittest.TestCase): ast.literal_eval(r"'\U'") self.assertIsNotNone(e.exception.__context__) + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_dump(self): node = ast.parse('spam(eggs, "and cheese")') self.assertEqual(ast.dump(node), @@ -711,6 +745,8 @@ class ASTHelpers_Test(unittest.TestCase): "Raise(cause=Name('e', Load()))" ) + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_copy_location(self): src = ast.parse('1 + 1', mode='eval') src.body.right = ast.copy_location(ast.Num(2), src.body.right) @@ -730,6 +766,8 @@ class ASTHelpers_Test(unittest.TestCase): self.assertEqual(new.lineno, 1) self.assertEqual(new.col_offset, 1) + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_fix_missing_locations(self): src = ast.parse('write("spam")') src.body.append(ast.Expr(ast.Call(ast.Name('spam', ast.Load()), @@ -750,6 +788,8 @@ class ASTHelpers_Test(unittest.TestCase): "type_ignores=[])" ) + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_increment_lineno(self): src = ast.parse('1 + 1', mode='eval') self.assertEqual(ast.increment_lineno(src, n=3), src) @@ -832,6 +872,8 @@ class ASTHelpers_Test(unittest.TestCase): node = ast.parse('async def foo():\n x = "not docstring"') self.assertIsNone(ast.get_docstring(node.body[0])) + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_multi_line_docstring_col_offset_and_lineno_issue16806(self): node = ast.parse( '"""line one\nline two"""\n\n' @@ -851,18 +893,24 @@ class ASTHelpers_Test(unittest.TestCase): self.assertEqual(node.body[2].col_offset, 0) self.assertEqual(node.body[2].lineno, 13) + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_elif_stmt_start_position(self): node = ast.parse('if a:\n pass\nelif b:\n pass\n') elif_stmt = node.body[0].orelse[0] self.assertEqual(elif_stmt.lineno, 3) self.assertEqual(elif_stmt.col_offset, 0) + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_elif_stmt_start_position_with_else(self): node = ast.parse('if a:\n pass\nelif b:\n pass\nelse:\n pass\n') elif_stmt = node.body[0].orelse[0] self.assertEqual(elif_stmt.lineno, 3) self.assertEqual(elif_stmt.col_offset, 0) + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_starred_expr_end_position_within_call(self): node = ast.parse('f(*[0, 1])') starred_expr = node.body[0].value.args[0] @@ -914,6 +962,8 @@ class ASTHelpers_Test(unittest.TestCase): malformed = ast.Dict(keys=[ast.Constant(1)], values=[ast.Constant(2), ast.Constant(3)]) self.assertRaises(ValueError, ast.literal_eval, malformed) + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_bad_integer(self): # issue13436: Bad error message with invalid numeric values body = [ast.ImportFrom(module='time', @@ -925,6 +975,8 @@ class ASTHelpers_Test(unittest.TestCase): compile(mod, 'test', 'exec') self.assertIn("invalid integer value: None", str(cm.exception)) + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_level_as_none(self): body = [ast.ImportFrom(module='time', names=[ast.alias(name='sleep')], @@ -957,6 +1009,8 @@ class ASTValidatorTests(unittest.TestCase): mod = ast.Module([stmt], []) self.mod(mod, msg) + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_module(self): m = ast.Interactive([ast.Expr(ast.Name("x", ast.Store()))]) self.mod(m, "must have Load context", "single") @@ -997,6 +1051,8 @@ class ASTValidatorTests(unittest.TestCase): kw_defaults=[None, ast.Name("x", ast.Store())]), "must have Load context") + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_funcdef(self): a = ast.arguments([], [], None, [], [], None, []) f = ast.FunctionDef("x", a, [], [], None) @@ -1011,6 +1067,8 @@ class ASTValidatorTests(unittest.TestCase): return ast.FunctionDef("x", args, [ast.Pass()], [], None) self._check_arguments(fac, self.stmt) + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_classdef(self): def cls(bases=None, keywords=None, body=None, decorator_list=None): if bases is None: @@ -1032,12 +1090,16 @@ class ASTValidatorTests(unittest.TestCase): self.stmt(cls(decorator_list=[ast.Name("x", ast.Store())]), "must have Load context") + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_delete(self): self.stmt(ast.Delete([]), "empty targets on Delete") self.stmt(ast.Delete([None]), "None disallowed") self.stmt(ast.Delete([ast.Name("x", ast.Load())]), "must have Del context") + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_assign(self): self.stmt(ast.Assign([], ast.Num(3)), "empty targets on Assign") self.stmt(ast.Assign([None], ast.Num(3)), "None disallowed") @@ -1047,6 +1109,8 @@ class ASTValidatorTests(unittest.TestCase): ast.Name("y", ast.Store())), "must have Load context") + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_augassign(self): aug = ast.AugAssign(ast.Name("x", ast.Load()), ast.Add(), ast.Name("y", ast.Load())) @@ -1055,6 +1119,8 @@ class ASTValidatorTests(unittest.TestCase): ast.Name("y", ast.Store())) self.stmt(aug, "must have Load context") + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_for(self): x = ast.Name("x", ast.Store()) y = ast.Name("y", ast.Load()) @@ -1068,6 +1134,8 @@ class ASTValidatorTests(unittest.TestCase): self.stmt(ast.For(x, y, [e], []), "must have Load context") self.stmt(ast.For(x, y, [p], [e]), "must have Load context") + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_while(self): self.stmt(ast.While(ast.Num(3), [], []), "empty body on While") self.stmt(ast.While(ast.Name("x", ast.Store()), [ast.Pass()], []), @@ -1076,6 +1144,8 @@ class ASTValidatorTests(unittest.TestCase): [ast.Expr(ast.Name("x", ast.Store()))]), "must have Load context") + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_if(self): self.stmt(ast.If(ast.Num(3), [], []), "empty body on If") i = ast.If(ast.Name("x", ast.Store()), [ast.Pass()], []) @@ -1086,6 +1156,8 @@ class ASTValidatorTests(unittest.TestCase): [ast.Expr(ast.Name("x", ast.Store()))]) self.stmt(i, "must have Load context") + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_with(self): p = ast.Pass() self.stmt(ast.With([], [p]), "empty items on With") @@ -1096,6 +1168,8 @@ class ASTValidatorTests(unittest.TestCase): i = ast.withitem(ast.Num(3), ast.Name("x", ast.Load())) self.stmt(ast.With([i], [p]), "must have Store context") + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_raise(self): r = ast.Raise(None, ast.Num(3)) self.stmt(r, "Raise with cause but no exception") @@ -1104,6 +1178,8 @@ class ASTValidatorTests(unittest.TestCase): r = ast.Raise(ast.Num(4), ast.Name("x", ast.Store())) self.stmt(r, "must have Load context") + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_try(self): p = ast.Pass() t = ast.Try([], [], [], [p]) @@ -1124,6 +1200,8 @@ class ASTValidatorTests(unittest.TestCase): t = ast.Try([p], e, [p], [ast.Expr(ast.Name("x", ast.Store()))]) self.stmt(t, "must have Load context") + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_assert(self): self.stmt(ast.Assert(ast.Name("x", ast.Store()), None), "must have Load context") @@ -1131,20 +1209,30 @@ class ASTValidatorTests(unittest.TestCase): ast.Name("y", ast.Store())) self.stmt(assrt, "must have Load context") + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_import(self): self.stmt(ast.Import([]), "empty names on Import") + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_importfrom(self): imp = ast.ImportFrom(None, [ast.alias("x", None)], -42) self.stmt(imp, "Negative ImportFrom level") self.stmt(ast.ImportFrom(None, [], 0), "empty names on ImportFrom") + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_global(self): self.stmt(ast.Global([]), "empty names on Global") + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_nonlocal(self): self.stmt(ast.Nonlocal([]), "empty names on Nonlocal") + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_expr(self): e = ast.Expr(ast.Name("x", ast.Store())) self.stmt(e, "must have Load context") @@ -1160,10 +1248,14 @@ class ASTValidatorTests(unittest.TestCase): b = ast.BoolOp(ast.And(), [ast.Num(4), ast.Name("x", ast.Store())]) self.expr(b, "must have Load context") + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_unaryop(self): u = ast.UnaryOp(ast.Not(), ast.Name("x", ast.Store())) self.expr(u, "must have Load context") + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_lambda(self): a = ast.arguments([], [], None, [], [], None, []) self.expr(ast.Lambda(a, ast.Name("x", ast.Store())), @@ -1172,18 +1264,24 @@ class ASTValidatorTests(unittest.TestCase): return ast.Lambda(args, ast.Name("x", ast.Load())) self._check_arguments(fac, self.expr) + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_ifexp(self): l = ast.Name("x", ast.Load()) s = ast.Name("y", ast.Store()) for args in (s, l, l), (l, s, l), (l, l, s): self.expr(ast.IfExp(*args), "must have Load context") + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_dict(self): d = ast.Dict([], [ast.Name("x", ast.Load())]) self.expr(d, "same number of keys as values") d = ast.Dict([ast.Name("x", ast.Load())], [None]) self.expr(d, "None disallowed") + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_set(self): self.expr(ast.Set([None]), "None disallowed") s = ast.Set([ast.Name("x", ast.Store())]) @@ -1213,15 +1311,23 @@ class ASTValidatorTests(unittest.TestCase): return fac(ast.Name("x", ast.Store()), gens) self._check_comprehension(wrap) + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_listcomp(self): self._simple_comp(ast.ListComp) + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_setcomp(self): self._simple_comp(ast.SetComp) + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_generatorexp(self): self._simple_comp(ast.GeneratorExp) + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_dictcomp(self): g = ast.comprehension(ast.Name("y", ast.Store()), ast.Name("p", ast.Load()), [], 0) @@ -1237,6 +1343,8 @@ class ASTValidatorTests(unittest.TestCase): return ast.DictComp(k, v, comps) self._check_comprehension(factory) + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_yield(self): self.expr(ast.Yield(ast.Name("x", ast.Store())), "must have Load") self.expr(ast.YieldFrom(ast.Name("x", ast.Store())), "must have Load") @@ -1253,6 +1361,8 @@ class ASTValidatorTests(unittest.TestCase): comp = ast.Compare(left, [ast.In()], [ast.Num("blah")]) self.expr(comp) + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_call(self): func = ast.Name("x", ast.Load()) args = [ast.Name("y", ast.Load())] @@ -1265,6 +1375,8 @@ class ASTValidatorTests(unittest.TestCase): call = ast.Call(func, args, bad_keywords) self.expr(call, "must have Load context") + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_num(self): class subint(int): pass @@ -1277,10 +1389,14 @@ class ASTValidatorTests(unittest.TestCase): for obj in subint(), subfloat(), subcomplex(): self.expr(ast.Num(obj), "invalid type", exc=TypeError) + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_attribute(self): attr = ast.Attribute(ast.Name("x", ast.Store()), "y", ast.Load()) self.expr(attr, "must have Load context") + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_subscript(self): sub = ast.Subscript(ast.Name("x", ast.Store()), ast.Index(ast.Num(3)), ast.Load()) @@ -1299,6 +1415,8 @@ class ASTValidatorTests(unittest.TestCase): sl = ast.ExtSlice([ast.Index(s)]) self.expr(ast.Subscript(x, sl, ast.Load()), "must have Load context") + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_starred(self): left = ast.List([ast.Starred(ast.Name("x", ast.Load()), ast.Store())], ast.Store()) @@ -1310,15 +1428,21 @@ class ASTValidatorTests(unittest.TestCase): self.expr(fac([ast.Name("x", ast.Store())], ast.Load()), "must have Load context") + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_list(self): self._sequence(ast.List) + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_tuple(self): self._sequence(ast.Tuple) def test_nameconstant(self): self.expr(ast.NameConstant(4)) + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_stdlib_validates(self): stdlib = os.path.dirname(ast.__file__) tests = [fn for fn in os.listdir(stdlib) if fn.endswith(".py")] @@ -1349,18 +1473,24 @@ class ConstantTests(unittest.TestCase): exec(code, ns) return ns['x'] + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_validation(self): with self.assertRaises(TypeError) as cm: self.compile_constant([1, 2, 3]) self.assertEqual(str(cm.exception), "got an invalid type in Constant: list") + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_singletons(self): for const in (None, False, True, Ellipsis, b'', frozenset()): with self.subTest(const=const): value = self.compile_constant(const) self.assertIs(value, const) + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_values(self): nested_tuple = (1,) nested_frozenset = frozenset({1}) @@ -1376,6 +1506,8 @@ class ConstantTests(unittest.TestCase): result = self.compile_constant(value) self.assertEqual(result, value) + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_assign_to_constant(self): tree = ast.parse("x = 1") @@ -1447,6 +1579,8 @@ class ConstantTests(unittest.TestCase): self.assertEqual(ast.literal_eval(binop), 10+20j) + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_string_kind(self): c = ast.parse('"x"', mode='eval').body self.assertEqual(c.value, "x") @@ -1483,6 +1617,8 @@ class EndPositionTests(unittest.TestCase): # and a right hand side of an assignment statement. return ast.parse(s).body[0].value + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_lambda(self): s = 'lambda x, *y: None' lam = self._parse_value(s) @@ -1490,6 +1626,8 @@ class EndPositionTests(unittest.TestCase): self._check_content(s, lam.args.args[0], 'x') self._check_content(s, lam.args.vararg, 'y') + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_func_def(self): s = dedent(''' def func(x: int, @@ -1506,6 +1644,8 @@ class EndPositionTests(unittest.TestCase): self._check_content(s, fdef.args.kwarg, 'kwargs: Any') self._check_content(s, fdef.args.kwarg.annotation, 'Any') + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_call(self): s = 'func(x, y=2, **kw)' call = self._parse_value(s) @@ -1513,12 +1653,16 @@ class EndPositionTests(unittest.TestCase): self._check_content(s, call.keywords[0].value, '2') self._check_content(s, call.keywords[1].value, 'kw') + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_call_noargs(self): s = 'x[0]()' call = self._parse_value(s) self._check_content(s, call.func, 'x[0]') self._check_end_pos(call, 1, 6) + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_class_def(self): s = dedent(''' class C(A, B): @@ -1529,11 +1673,15 @@ class EndPositionTests(unittest.TestCase): self._check_content(s, cdef.bases[1], 'B') self._check_content(s, cdef.body[0], 'x: int = 0') + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_class_kw(self): s = 'class S(metaclass=abc.ABCMeta): pass' cdef = ast.parse(s).body[0] self._check_content(s, cdef.keywords[0].value, 'abc.ABCMeta') + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_multi_line_str(self): s = dedent(''' x = """Some multi-line text. @@ -1544,6 +1692,8 @@ class EndPositionTests(unittest.TestCase): self._check_end_pos(assign, 3, 40) self._check_end_pos(assign.value, 3, 40) + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_continued_str(self): s = dedent(''' x = "first part" \\ @@ -1553,6 +1703,8 @@ class EndPositionTests(unittest.TestCase): self._check_end_pos(assign, 2, 13) self._check_end_pos(assign.value, 2, 13) + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_suites(self): # We intentionally put these into the same string to check # that empty lines are not part of the suite. @@ -1597,12 +1749,16 @@ class EndPositionTests(unittest.TestCase): self._check_content(s, try_stmt.body[0], 'raise RuntimeError') self._check_content(s, try_stmt.handlers[0].type, 'TypeError') + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_fstring(self): s = 'x = f"abc {x + y} abc"' fstr = self._parse_value(s) binop = fstr.values[1].value self._check_content(s, binop, 'x + y') + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_fstring_multi_line(self): s = dedent(''' f"""Some multi-line text. @@ -1619,6 +1775,8 @@ class EndPositionTests(unittest.TestCase): self._check_content(s, binop.left, 'arg_one') self._check_content(s, binop.right, 'arg_two') + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_import_from_multi_line(self): s = dedent(''' from x.y.z import ( @@ -1628,6 +1786,8 @@ class EndPositionTests(unittest.TestCase): imp = ast.parse(s).body[0] self._check_end_pos(imp, 3, 1) + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_slices(self): s1 = 'f()[1, 2] [0]' s2 = 'x[ a.b: c.d]' @@ -1645,6 +1805,8 @@ class EndPositionTests(unittest.TestCase): self._check_content(sm, im.slice.dims[1].lower, 'g ()') self._check_end_pos(im, 3, 3) + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_binop(self): s = dedent(''' (1 * 2 + (3 ) + @@ -1657,6 +1819,8 @@ class EndPositionTests(unittest.TestCase): self._check_content(s, binop.left, '1 * 2 + (3 )') self._check_content(s, binop.left.right, '3') + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_boolop(self): s = dedent(''' if (one_condition and @@ -1668,6 +1832,8 @@ class EndPositionTests(unittest.TestCase): self._check_content(s, bop.values[1], 'other_condition or yet_another_one') + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_tuples(self): s1 = 'x = () ;' s2 = 'x = 1 , ;' @@ -1683,12 +1849,16 @@ class EndPositionTests(unittest.TestCase): self._check_content(s3, t3, '(1 , 2 )') self._check_end_pos(tm, 3, 1) + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_attribute_spaces(self): s = 'func(x. y .z)' call = self._parse_value(s) self._check_content(s, call, s) self._check_content(s, call.args[0], 'x. y .z') + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_redundant_parenthesis(self): s = '( ( ( a + b ) ) )' v = ast.parse(s).body[0].value @@ -1699,6 +1869,8 @@ class EndPositionTests(unittest.TestCase): self.assertEqual(type(v).__name__, 'BinOp') self._check_content(s2, v, 'a + b') + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_trailers_with_redundant_parenthesis(self): tests = ( ('( ( ( a ) ) ) ( )', 'Call'), @@ -1716,6 +1888,8 @@ class EndPositionTests(unittest.TestCase): self.assertEqual(type(v).__name__, t) self._check_content(s2, v, s) + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_displays(self): s1 = '[{}, {1, }, {1, 2,} ]' s2 = '{a: b, f (): g () ,}' @@ -1727,6 +1901,8 @@ class EndPositionTests(unittest.TestCase): self._check_content(s2, c2.keys[1], 'f ()') self._check_content(s2, c2.values[1], 'g ()') + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_comprehensions(self): s = dedent(''' x = [{x for x, y in stuff @@ -1739,6 +1915,8 @@ class EndPositionTests(unittest.TestCase): self._check_content(s, cmp.elt.generators[0].ifs[0], 'cond.x') self._check_content(s, cmp.elt.generators[0].target, 'x, y') + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_yield_await(self): s = dedent(''' async def f(): @@ -1749,6 +1927,8 @@ class EndPositionTests(unittest.TestCase): self._check_content(s, fdef.body[0].value, 'yield x') self._check_content(s, fdef.body[1].value, 'await y') + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_source_segment_multi(self): s_orig = dedent(''' x = ( @@ -1763,6 +1943,8 @@ class EndPositionTests(unittest.TestCase): binop = self._parse_value(s_orig) self.assertEqual(ast.get_source_segment(s_orig, binop.left), s_tuple) + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_source_segment_padded(self): s_orig = dedent(''' class C: @@ -1775,6 +1957,8 @@ class EndPositionTests(unittest.TestCase): self.assertEqual(ast.get_source_segment(s_orig, cdef.body[0], padded=True), s_method) + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_source_segment_endings(self): s = 'v = 1\r\nw = 1\nx = 1\n\ry = 1\rz = 1\r\n' v, w, x, y, z = ast.parse(s).body @@ -1784,6 +1968,8 @@ class EndPositionTests(unittest.TestCase): self._check_content(s, y, 'y = 1') self._check_content(s, z, 'z = 1') + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_source_segment_tabs(self): s = dedent(''' class C: