def test2(self):
prog_text_2 = """\
def wrong2():
print(x)
global x
"""
check_syntax_error(self, prog_text_2)
def test2(self):
prog_text_2 = """\
def wrong2():
print(x)
global x
"""
check_syntax_error(self, prog_text_2, lineno=3, offset=4)
def test_genexps(self):
# generator expression tests
g = ([x for x in range(10)] for x in range(1))
self.assertEqual(next(g), [x for x in range(10)])
try:
next(g)
self.fail('should produce StopIteration exception')
except StopIteration:
pass
a = 1
try:
g = (a for d in a)
next(g)
self.fail('should produce TypeError')
except TypeError:
pass
self.assertEqual(list((x, y) for x in 'abcd' for y in 'abcd'), [(x, y) for x in 'abcd' for y in 'abcd'])
self.assertEqual(list((x, y) for x in 'ab' for y in 'xy'), [(x, y) for x in 'ab' for y in 'xy'])
a = [x for x in range(10)]
b = (x for x in (y for y in a))
self.assertEqual(sum(b), sum([x for x in range(10)]))
self.assertEqual(sum(x**2 for x in range(10)), sum([x**2 for x in range(10)]))
self.assertEqual(sum(x*x for x in range(10) if x%2), sum([x*x for x in range(10) if x%2]))
self.assertEqual(sum(x for x in (y for y in range(10))), sum([x for x in range(10)]))
self.assertEqual(sum(x for x in (y for y in (z for z in range(10)))), sum([x for x in range(10)]))
self.assertEqual(sum(x for x in [y for y in (z for z in range(10))]), sum([x for x in range(10)]))
self.assertEqual(sum(x for x in (y for y in (z for z in range(10) if True)) if True), sum([x for x in range(10)]))
self.assertEqual(sum(x for x in (y for y in (z for z in range(10) if True) if False) if True), 0)
check_syntax_error(self, "foo(x for x in range(10), 100)")
check_syntax_error(self, "foo(100, x for x in range(10))")
def test_lambdef(self):
### lambdef: 'lambda' [varargslist] ':' test
l1 = lambda : 0
self.assertEqual(l1(), 0)
l2 = lambda : a[d] # XXX just testing the expression
l3 = lambda : [2 < x for x in [-1, 3, 0]]
self.assertEqual(l3(), [0, 1, 0])
l4 = lambda x = lambda y = lambda z=1 : z : y() : x()
self.assertEqual(l4(), 1)
l5 = lambda x, y, z=2: x + y + z
self.assertEqual(l5(1, 2), 5)
self.assertEqual(l5(1, 2, 3), 6)
check_syntax_error(self, "lambda x: x = 2")
check_syntax_error(self, "lambda (None,): None")
l6 = lambda x, y, *, k=20: x+y+k
self.assertEqual(l6(1,2), 1+2+20)
self.assertEqual(l6(1,2,k=10), 1+2+10)
# check that trailing commas are permitted
l10 = lambda a,: 0
l11 = lambda *args,: 0
l12 = lambda **kwds,: 0
l13 = lambda a, *args,: 0
l14 = lambda a, **kwds,: 0
l15 = lambda *args, b,: 0
l16 = lambda *, b,: 0
l17 = lambda *args, **kwds,: 0
l18 = lambda a, *args, b,: 0
l19 = lambda a, *, b,: 0
l20 = lambda a, *args, **kwds,: 0
l21 = lambda *args, b, **kwds,: 0
l22 = lambda *, b, **kwds,: 0
l23 = lambda a, *args, b, **kwds,: 0
l24 = lambda a, *, b, **kwds,: 0
def test_return(self):
# 'return' [testlist]
def g1(): return
def g2(): return 1
g1()
x = g2()
check_syntax_error(self, "class foo:return 1")
def test3(self):
prog_text_3 = """\
def wrong3():
print(x)
x = 2
global x
"""
check_syntax_error(self, prog_text_3)
def test1(self):
prog_text_1 = """\
def wrong1():
a = 1
b = 2
global a
global b
"""
check_syntax_error(self, prog_text_1)
def test_expr_stmt(self):
# (exprlist '=')* exprlist
1
1, 2, 3
x = 1
x = 1, 2, 3
x = y = z = 1, 2, 3
x, y, z = 1, 2, 3
abc = a, b, c = x, y, z = xyz = 1, 2, (3, 4)
check_syntax_error(self, "x + 1 = 1")
check_syntax_error(self, "a + 1 = b + 2")
def testUnoptimizedNamespaces(self):
check_syntax_error(self, """if 1:
def unoptimized_clash1(strip):
def f(s):
from sys import *
return getrefcount(s) # ambiguity: free or local
return f
""")
check_syntax_error(self, """if 1:
def unoptimized_clash2():
from sys import *
def f(s):
return getrefcount(s) # ambiguity: global or local
return f
""")
check_syntax_error(self, """if 1:
def unoptimized_clash2():
from sys import *
def g():
def f(s):
return getrefcount(s) # ambiguity: global or local
return f
""")
check_syntax_error(self, """if 1:
def f():
def g():
from sys import *
return getrefcount # global or local?
""")
def testLambdef(self):
### lambdef: 'lambda' [varargslist] ':' test
l1 = lambda : 0
self.assertEquals(l1(), 0)
l2 = lambda : a[d] # XXX just testing the expression
l3 = lambda : [2 < x for x in [-1, 3, 0]]
self.assertEquals(l3(), [0, 1, 0])
l4 = lambda x = lambda y = lambda z=1 : z : y() : x()
self.assertEquals(l4(), 1)
l5 = lambda x, y, z=2: x + y + z
self.assertEquals(l5(1, 2), 5)
self.assertEquals(l5(1, 2, 3), 6)
check_syntax_error(self, "lambda x: x = 2")
check_syntax_error(self, "lambda (None,): None")
l6 = lambda x, y, *, k=20: x+y+k
self.assertEquals(l6(1,2), 1+2+20)
self.assertEquals(l6(1,2,k=10), 1+2+10)
def test_check_syntax_error(self):
support.check_syntax_error(self, "def class", lineno=1, offset=9)
with self.assertRaises(AssertionError):
support.check_syntax_error(self, "x=1")
def test_check_syntax_error(self):
support.check_syntax_error(self, "def class")
with self.assertRaises(AssertionError):
support.check_syntax_error(self, "x=1")
def test_funcdef(self):
### [decorators] 'def' NAME parameters ['->' test] ':' suite
### decorator: '@' dotted_name [ '(' [arglist] ')' ] NEWLINE
### decorators: decorator+
### parameters: '(' [typedargslist] ')'
### typedargslist: ((tfpdef ['=' test] ',')*
### ('*' [tfpdef] (',' tfpdef ['=' test])* [',' '**' tfpdef] | '**' tfpdef)
### | tfpdef ['=' test] (',' tfpdef ['=' test])* [','])
### tfpdef: NAME [':' test]
### varargslist: ((vfpdef ['=' test] ',')*
### ('*' [vfpdef] (',' vfpdef ['=' test])* [',' '**' vfpdef] | '**' vfpdef)
### | vfpdef ['=' test] (',' vfpdef ['=' test])* [','])
### vfpdef: NAME
def f1():
pass
f1()
f1(*())
f1(*(), **{})
def f2(one_argument):
pass
def f3(two, arguments):
pass
self.assertEqual(f2.__code__.co_varnames, ("one_argument",))
self.assertEqual(f3.__code__.co_varnames, ("two", "arguments"))
def a1(one_arg,):
pass
def a2(two, args):
pass
def v0(*rest):
pass
def v1(a, *rest):
pass
def v2(a, b, *rest):
pass
f1()
f2(1)
f2(1)
f3(1, 2)
f3(1, 2)
v0()
v0(1)
v0(1)
v0(1, 2)
v0(1, 2, 3, 4, 5, 6, 7, 8, 9, 0)
v1(1)
v1(1)
v1(1, 2)
v1(1, 2, 3)
v1(1, 2, 3, 4, 5, 6, 7, 8, 9, 0)
v2(1, 2)
v2(1, 2, 3)
v2(1, 2, 3, 4)
v2(1, 2, 3, 4, 5, 6, 7, 8, 9, 0)
def d01(a=1):
pass
d01()
d01(1)
d01(*(1,))
d01(**{"a": 2})
def d11(a, b=1):
pass
d11(1)
d11(1, 2)
d11(1, **{"b": 2})
def d21(a, b, c=1):
pass
d21(1, 2)
d21(1, 2, 3)
d21(*(1, 2, 3))
d21(1, *(2, 3))
d21(1, 2, *(3,))
d21(1, 2, **{"c": 3})
def d02(a=1, b=2):
pass
d02()
d02(1)
d02(1, 2)
d02(*(1, 2))
d02(1, *(2,))
d02(1, **{"b": 2})
d02(**{"a": 1, "b": 2})
def d12(a, b=1, c=2):
pass
d12(1)
d12(1, 2)
d12(1, 2, 3)
def d22(a, b, c=1, d=2):
pass
d22(1, 2)
d22(1, 2, 3)
d22(1, 2, 3, 4)
def d01v(a=1, *rest):
pass
d01v()
d01v(1)
d01v(1, 2)
d01v(*(1, 2, 3, 4))
d01v(*(1,))
d01v(**{"a": 2})
def d11v(a, b=1, *rest):
pass
d11v(1)
d11v(1, 2)
d11v(1, 2, 3)
def d21v(a, b, c=1, *rest):
pass
d21v(1, 2)
d21v(1, 2, 3)
d21v(1, 2, 3, 4)
d21v(*(1, 2, 3, 4))
d21v(1, 2, **{"c": 3})
def d02v(a=1, b=2, *rest):
pass
d02v()
d02v(1)
d02v(1, 2)
d02v(1, 2, 3)
d02v(1, *(2, 3, 4))
d02v(**{"a": 1, "b": 2})
def d12v(a, b=1, c=2, *rest):
pass
d12v(1)
d12v(1, 2)
d12v(1, 2, 3)
d12v(1, 2, 3, 4)
d12v(*(1, 2, 3, 4))
d12v(1, 2, *(3, 4, 5))
d12v(1, *(2,), **{"c": 3})
def d22v(a, b, c=1, d=2, *rest):
pass
d22v(1, 2)
d22v(1, 2, 3)
d22v(1, 2, 3, 4)
d22v(1, 2, 3, 4, 5)
d22v(*(1, 2, 3, 4))
d22v(1, 2, *(3, 4, 5))
d22v(1, *(2, 3), **{"d": 4})
# keyword argument type tests
try:
str("x", **{b"foo": 1})
except TypeError:
pass
else:
self.fail("Bytes should not work as keyword argument names")
# keyword only argument tests
def pos0key1(*, key):
return key
pos0key1(key=100)
def pos2key2(p1, p2, *, k1, k2=100):
return p1, p2, k1, k2
pos2key2(1, 2, k1=100)
pos2key2(1, 2, k1=100, k2=200)
pos2key2(1, 2, k2=100, k1=200)
def pos2key2dict(p1, p2, *, k1=100, k2, **kwarg):
return p1, p2, k1, k2, kwarg
pos2key2dict(1, 2, k2=100, tokwarg1=100, tokwarg2=200)
pos2key2dict(1, 2, tokwarg1=100, tokwarg2=200, k2=100)
# keyword arguments after *arglist
def f(*args, **kwargs):
return args, kwargs
self.assertEqual(f(1, x=2, *[3, 4], y=5), ((1, 3, 4), {"x": 2, "y": 5}))
self.assertRaises(SyntaxError, eval, "f(1, *(2,3), 4)")
self.assertRaises(SyntaxError, eval, "f(1, x=2, *(3,4), x=5)")
# argument annotation tests
def f(x) -> list:
pass
self.assertEqual(f.__annotations__, {"return": list})
def f(x: int):
pass
self.assertEqual(f.__annotations__, {"x": int})
def f(*x: str):
pass
self.assertEqual(f.__annotations__, {"x": str})
def f(**x: float):
pass
self.assertEqual(f.__annotations__, {"x": float})
def f(x, y: 1 + 2):
pass
self.assertEqual(f.__annotations__, {"y": 3})
def f(a, b: 1, c: 2, d):
pass
self.assertEqual(f.__annotations__, {"b": 1, "c": 2})
def f(a, b: 1, c: 2, d, e: 3 = 4, f=5, *g: 6):
pass
self.assertEqual(f.__annotations__, {"b": 1, "c": 2, "e": 3, "g": 6})
def f(a, b: 1, c: 2, d, e: 3 = 4, f=5, *g: 6, h: 7, i=8, j: 9 = 10, **k: 11) -> 12:
pass
self.assertEqual(f.__annotations__, {"b": 1, "c": 2, "e": 3, "g": 6, "h": 7, "j": 9, "k": 11, "return": 12})
# Check for issue #20625 -- annotations mangling
class Spam:
def f(self, *, __kw: 1):
pass
class Ham(Spam):
pass
self.assertEqual(Spam.f.__annotations__, {"_Spam__kw": 1})
self.assertEqual(Ham.f.__annotations__, {"_Spam__kw": 1})
# Check for SF Bug #1697248 - mixing decorators and a return annotation
def null(x):
return x
@null
def f(x) -> list:
pass
self.assertEqual(f.__annotations__, {"return": list})
# test MAKE_CLOSURE with a variety of oparg's
closure = 1
def f():
return closure
def f(x=1):
return closure
def f(*, k=1):
return closure
def f() -> int:
return closure
# Check ast errors in *args and *kwargs
check_syntax_error(self, "f(*g(1=2))")
check_syntax_error(self, "f(**g(1=2))")
def test2(self):
prog_text_2 = 'def wrong2():\n print(x)\n global x\n'
check_syntax_error(self, prog_text_2, lineno=3, offset=4)
def test_funcdef(self):
### [decorators] 'def' NAME parameters ['->' test] ':' suite
### decorator: '@' dotted_name [ '(' [arglist] ')' ] NEWLINE
### decorators: decorator+
### parameters: '(' [typedargslist] ')'
### typedargslist: ((tfpdef ['=' test] ',')*
### ('*' [tfpdef] (',' tfpdef ['=' test])* [',' '**' tfpdef] | '**' tfpdef)
### | tfpdef ['=' test] (',' tfpdef ['=' test])* [','])
### tfpdef: NAME [':' test]
### varargslist: ((vfpdef ['=' test] ',')*
### ('*' [vfpdef] (',' vfpdef ['=' test])* [',' '**' vfpdef] | '**' vfpdef)
### | vfpdef ['=' test] (',' vfpdef ['=' test])* [','])
### vfpdef: NAME
def f1(): pass
f1()
f1(*())
f1(*(), **{})
def f2(one_argument): pass
def f3(two, arguments): pass
self.assertEqual(f2.__code__.co_varnames, ('one_argument',))
self.assertEqual(f3.__code__.co_varnames, ('two', 'arguments'))
def a1(one_arg,): pass
def a2(two, args,): pass
def v0(*rest): pass
def v1(a, *rest): pass
def v2(a, b, *rest): pass
f1()
f2(1)
f2(1,)
f3(1, 2)
f3(1, 2,)
v0()
v0(1)
v0(1,)
v0(1,2)
v0(1,2,3,4,5,6,7,8,9,0)
v1(1)
v1(1,)
v1(1,2)
v1(1,2,3)
v1(1,2,3,4,5,6,7,8,9,0)
v2(1,2)
v2(1,2,3)
v2(1,2,3,4)
v2(1,2,3,4,5,6,7,8,9,0)
def d01(a=1): pass
d01()
d01(1)
d01(*(1,))
d01(*[] or [2])
d01(*() or (), *{} and (), **() or {})
d01(**{'a':2})
d01(**{'a':2} or {})
def d11(a, b=1): pass
d11(1)
d11(1, 2)
d11(1, **{'b':2})
def d21(a, b, c=1): pass
d21(1, 2)
d21(1, 2, 3)
d21(*(1, 2, 3))
d21(1, *(2, 3))
d21(1, 2, *(3,))
d21(1, 2, **{'c':3})
def d02(a=1, b=2): pass
d02()
d02(1)
d02(1, 2)
d02(*(1, 2))
d02(1, *(2,))
d02(1, **{'b':2})
d02(**{'a': 1, 'b': 2})
def d12(a, b=1, c=2): pass
d12(1)
d12(1, 2)
d12(1, 2, 3)
def d22(a, b, c=1, d=2): pass
d22(1, 2)
d22(1, 2, 3)
d22(1, 2, 3, 4)
def d01v(a=1, *rest): pass
d01v()
d01v(1)
d01v(1, 2)
d01v(*(1, 2, 3, 4))
d01v(*(1,))
d01v(**{'a':2})
def d11v(a, b=1, *rest): pass
d11v(1)
d11v(1, 2)
d11v(1, 2, 3)
def d21v(a, b, c=1, *rest): pass
d21v(1, 2)
d21v(1, 2, 3)
d21v(1, 2, 3, 4)
d21v(*(1, 2, 3, 4))
d21v(1, 2, **{'c': 3})
def d02v(a=1, b=2, *rest): pass
d02v()
d02v(1)
d02v(1, 2)
d02v(1, 2, 3)
d02v(1, *(2, 3, 4))
d02v(**{'a': 1, 'b': 2})
def d12v(a, b=1, c=2, *rest): pass
d12v(1)
d12v(1, 2)
d12v(1, 2, 3)
d12v(1, 2, 3, 4)
d12v(*(1, 2, 3, 4))
d12v(1, 2, *(3, 4, 5))
d12v(1, *(2,), **{'c': 3})
def d22v(a, b, c=1, d=2, *rest): pass
d22v(1, 2)
d22v(1, 2, 3)
d22v(1, 2, 3, 4)
d22v(1, 2, 3, 4, 5)
d22v(*(1, 2, 3, 4))
d22v(1, 2, *(3, 4, 5))
d22v(1, *(2, 3), **{'d': 4})
# keyword argument type tests
try:
str('x', **{b'foo':1 })
except TypeError:
pass
else:
self.fail('Bytes should not work as keyword argument names')
# keyword only argument tests
def pos0key1(*, key): return key
pos0key1(key=100)
def pos2key2(p1, p2, *, k1, k2=100): return p1,p2,k1,k2
pos2key2(1, 2, k1=100)
pos2key2(1, 2, k1=100, k2=200)
pos2key2(1, 2, k2=100, k1=200)
def pos2key2dict(p1, p2, *, k1=100, k2, **kwarg): return p1,p2,k1,k2,kwarg
pos2key2dict(1,2,k2=100,tokwarg1=100,tokwarg2=200)
pos2key2dict(1,2,tokwarg1=100,tokwarg2=200, k2=100)
self.assertRaises(SyntaxError, eval, "def f(*): pass")
self.assertRaises(SyntaxError, eval, "def f(*,): pass")
self.assertRaises(SyntaxError, eval, "def f(*, **kwds): pass")
# keyword arguments after *arglist
def f(*args, **kwargs):
return args, kwargs
self.assertEqual(f(1, x=2, *[3, 4], y=5), ((1, 3, 4),
{'x':2, 'y':5}))
self.assertEqual(f(1, *(2,3), 4), ((1, 2, 3, 4), {}))
self.assertRaises(SyntaxError, eval, "f(1, x=2, *(3,4), x=5)")
self.assertEqual(f(**{'eggs':'scrambled', 'spam':'fried'}),
((), {'eggs':'scrambled', 'spam':'fried'}))
self.assertEqual(f(spam='fried', **{'eggs':'scrambled'}),
((), {'eggs':'scrambled', 'spam':'fried'}))
# argument annotation tests
def f(x) -> list: pass
self.assertEqual(f.__annotations__, {'return': list})
def f(x: int): pass
self.assertEqual(f.__annotations__, {'x': int})
def f(*x: str): pass
self.assertEqual(f.__annotations__, {'x': str})
def f(**x: float): pass
self.assertEqual(f.__annotations__, {'x': float})
def f(x, y: 1+2): pass
self.assertEqual(f.__annotations__, {'y': 3})
def f(a, b: 1, c: 2, d): pass
self.assertEqual(f.__annotations__, {'b': 1, 'c': 2})
def f(a, b: 1, c: 2, d, e: 3 = 4, f=5, *g: 6): pass
self.assertEqual(f.__annotations__,
{'b': 1, 'c': 2, 'e': 3, 'g': 6})
def f(a, b: 1, c: 2, d, e: 3 = 4, f=5, *g: 6, h: 7, i=8, j: 9 = 10,
**k: 11) -> 12: pass
self.assertEqual(f.__annotations__,
{'b': 1, 'c': 2, 'e': 3, 'g': 6, 'h': 7, 'j': 9,
'k': 11, 'return': 12})
# Check for issue #20625 -- annotations mangling
class Spam:
def f(self, *, __kw: 1):
pass
class Ham(Spam): pass
self.assertEqual(Spam.f.__annotations__, {'_Spam__kw': 1})
self.assertEqual(Ham.f.__annotations__, {'_Spam__kw': 1})
# Check for SF Bug #1697248 - mixing decorators and a return annotation
def null(x): return x
@null
def f(x) -> list: pass
self.assertEqual(f.__annotations__, {'return': list})
# test closures with a variety of opargs
closure = 1
def f(): return closure
def f(x=1): return closure
def f(*, k=1): return closure
def f() -> int: return closure
# Check ast errors in *args and *kwargs
check_syntax_error(self, "f(*g(1=2))")
check_syntax_error(self, "f(**g(1=2))")
# Check trailing commas are permitted in funcdef argument list
def f(a,): pass
def f(*args,): pass
def f(**kwds,): pass
def f(a, *args,): pass
def f(a, **kwds,): pass
def f(*args, b,): pass
def f(*, b,): pass
def f(*args, **kwds,): pass
def f(a, *args, b,): pass
def f(a, *, b,): pass
def f(a, *args, **kwds,): pass
def f(*args, b, **kwds,): pass
def f(*, b, **kwds,): pass
def f(a, *args, b, **kwds,): pass
def f(a, *, b, **kwds,): pass
def testUnoptimizedNamespaces(self):
check_syntax_error(self, """\
def unoptimized_clash1(strip):
def f(s):
from string import *
return strip(s) # ambiguity: free or local
return f
""")
check_syntax_error(self, """\
def unoptimized_clash2():
from string import *
def f(s):
return strip(s) # ambiguity: global or local
return f
""")
check_syntax_error(self, """\
def unoptimized_clash2():
from string import *
def g():
def f(s):
return strip(s) # ambiguity: global or local
return f
""")
# XXX could allow this for exec with const argument, but what's the point
check_syntax_error(self, """\
def error(y):
exec "a = 1"
def f(x):
return x + y
return f
""")
check_syntax_error(self, """\
def f(x):
def g():
return x
del x # can't del name
""")
check_syntax_error(self, """\
def f():
def g():
from string import *
return strip # global or local?
""")
# and verify a few cases that should work
exec("""
def noproblem1():
from string import *
f = lambda x:x
def noproblem2():
from string import *
def f(x):
return x + 1
def noproblem3():
from string import *
def f(x):
global y
y = x
""")
def test_check_syntax_error(self):
support.check_syntax_error(self, "def class")
self.assertRaises(AssertionError, support.check_syntax_error, self, "1")
def test_yield(self):
# Allowed as standalone statement
def g(): yield 1
def g(): yield from ()
# Allowed as RHS of assignment
def g(): x = yield 1
def g(): x = yield from ()
# Ordinary yield accepts implicit tuples
def g(): yield 1, 1
def g(): x = yield 1, 1
# 'yield from' does not
check_syntax_error(self, "def g(): yield from (), 1")
check_syntax_error(self, "def g(): x = yield from (), 1")
# Requires parentheses as subexpression
def g(): 1, (yield 1)
def g(): 1, (yield from ())
check_syntax_error(self, "def g(): 1, yield 1")
check_syntax_error(self, "def g(): 1, yield from ()")
# Requires parentheses as call argument
def g(): f((yield 1))
def g(): f((yield 1), 1)
def g(): f((yield from ()))
def g(): f((yield from ()), 1)
check_syntax_error(self, "def g(): f(yield 1)")
check_syntax_error(self, "def g(): f(yield 1, 1)")
check_syntax_error(self, "def g(): f(yield from ())")
check_syntax_error(self, "def g(): f(yield from (), 1)")
# Not allowed at top level
check_syntax_error(self, "yield")
check_syntax_error(self, "yield from")
# Not allowed at class scope
check_syntax_error(self, "class foo:yield 1")
check_syntax_error(self, "class foo:yield from ()")
# Check annotation refleak on SyntaxError
check_syntax_error(self, "def g(a:(yield)): pass")
def test_invalid_syntax_lambda(self):
if use_old_parser():
check_syntax_error(
self, "lambda a, b = 5, /, c: None",
"non-default argument follows default argument")
check_syntax_error(
self, "lambda a = 5, b, /, c: None",
"non-default argument follows default argument")
check_syntax_error(
self, "lambda a = 5, b, /: None",
"non-default argument follows default argument")
check_syntax_error(self, "lambda *args, /: None")
check_syntax_error(self, "lambda *args, a, /: None")
check_syntax_error(self, "lambda **kwargs, /: None")
check_syntax_error(self, "lambda /, a = 1: None")
check_syntax_error(self, "lambda /, a: None")
check_syntax_error(self, "lambda /: None")
check_syntax_error(self, "lambda *, a, /: None")
check_syntax_error(self, "lambda *, /, a: None")
check_syntax_error(self, "lambda a, /, a: None",
"duplicate argument 'a' in function definition")
check_syntax_error(self, "lambda a, /, *, a: None",
"duplicate argument 'a' in function definition")
check_syntax_error(self, "lambda a, /, b, /: None")
check_syntax_error(self, "lambda a, /, b, /, c: None")
check_syntax_error(self, "lambda a, /, b, /, c, *, d: None")
check_syntax_error(self, "lambda a, *, b, /, c: None")
def test_listcomps(self):
# list comprehension tests
nums = [1, 2, 3, 4, 5]
strs = ["Apple", "Banana", "Coconut"]
spcs = [" Apple", " Banana ", "Coco nut "]
self.assertEqual([s.strip() for s in spcs], ['Apple', 'Banana', 'Coco nut'])
self.assertEqual([3 * x for x in nums], [3, 6, 9, 12, 15])
self.assertEqual([x for x in nums if x > 2], [3, 4, 5])
self.assertEqual([(i, s) for i in nums for s in strs],
[(1, 'Apple'), (1, 'Banana'), (1, 'Coconut'),
(2, 'Apple'), (2, 'Banana'), (2, 'Coconut'),
(3, 'Apple'), (3, 'Banana'), (3, 'Coconut'),
(4, 'Apple'), (4, 'Banana'), (4, 'Coconut'),
(5, 'Apple'), (5, 'Banana'), (5, 'Coconut')])
self.assertEqual([(i, s) for i in nums for s in [f for f in strs if "n" in f]],
[(1, 'Banana'), (1, 'Coconut'), (2, 'Banana'), (2, 'Coconut'),
(3, 'Banana'), (3, 'Coconut'), (4, 'Banana'), (4, 'Coconut'),
(5, 'Banana'), (5, 'Coconut')])
self.assertEqual([(lambda a:[a**i for i in range(a+1)])(j) for j in range(5)],
[[1], [1, 1], [1, 2, 4], [1, 3, 9, 27], [1, 4, 16, 64, 256]])
def test_in_func(l):
return [0 < x < 3 for x in l if x > 2]
self.assertEqual(test_in_func(nums), [False, False, False])
def test_nested_front():
self.assertEqual([[y for y in [x, x + 1]] for x in [1,3,5]],
[[1, 2], [3, 4], [5, 6]])
test_nested_front()
check_syntax_error(self, "[i, s for i in nums for s in strs]")
check_syntax_error(self, "[x if y]")
suppliers = [
(1, "Boeing"),
(2, "Ford"),
(3, "Macdonalds")
]
parts = [
(10, "Airliner"),
(20, "Engine"),
(30, "Cheeseburger")
]
suppart = [
(1, 10), (1, 20), (2, 20), (3, 30)
]
x = [
(sname, pname)
for (sno, sname) in suppliers
for (pno, pname) in parts
for (sp_sno, sp_pno) in suppart
if sno == sp_sno and pno == sp_pno
]
self.assertEqual(x, [('Boeing', 'Airliner'), ('Boeing', 'Engine'), ('Ford', 'Engine'),
('Macdonalds', 'Cheeseburger')])
def test_check_syntax_error(self):
support.check_syntax_error(self, "def class")
with self.assertRaises(AssertionError):
support.check_syntax_error(self, "x=1")
def test_yield(self):
def g():
yield 1
def g():
yield from ()
def g():
x = yield 1
def g():
x = yield from ()
def g():
yield 1, 1
def g():
x = yield 1, 1
check_syntax_error(self, 'def g(): yield from (), 1')
check_syntax_error(self, 'def g(): x = yield from (), 1')
def g():
1, (yield 1)
def g():
1, (yield from ())
check_syntax_error(self, 'def g(): 1, yield 1')
check_syntax_error(self, 'def g(): 1, yield from ()')
def g():
f((yield 1))
def g():
f((yield 1), 1)
def g():
f((yield from ()))
def g():
f((yield from ()), 1)
check_syntax_error(self, 'def g(): f(yield 1)')
check_syntax_error(self, 'def g(): f(yield 1, 1)')
check_syntax_error(self, 'def g(): f(yield from ())')
check_syntax_error(self, 'def g(): f(yield from (), 1)')
check_syntax_error(self, 'yield')
check_syntax_error(self, 'yield from')
check_syntax_error(self, 'class foo:yield 1')
check_syntax_error(self, 'class foo:yield from ()')
check_syntax_error(self, 'def g(a:(yield)): pass')
def test_funcdef(self):
def f1():
pass
f1()
f1(*())
f1(*(), **{})
def f2(one_argument):
pass
def f3(two, arguments):
pass
self.assertEqual(f2.__code__.co_varnames, ('one_argument', ))
self.assertEqual(f3.__code__.co_varnames, ('two', 'arguments'))
def a1(one_arg):
pass
def a2(two, args):
pass
def v0(*rest):
pass
def v1(a, *rest):
pass
def v2(a, b, *rest):
pass
f1()
f2(1)
f2(1)
f3(1, 2)
f3(1, 2)
v0()
v0(1)
v0(1)
v0(1, 2)
v0(1, 2, 3, 4, 5, 6, 7, 8, 9, 0)
v1(1)
v1(1)
v1(1, 2)
v1(1, 2, 3)
v1(1, 2, 3, 4, 5, 6, 7, 8, 9, 0)
v2(1, 2)
v2(1, 2, 3)
v2(1, 2, 3, 4)
v2(1, 2, 3, 4, 5, 6, 7, 8, 9, 0)
def d01(a=1):
pass
d01()
d01(1)
d01(*(1, ))
d01(*([] or [2]))
d01(*(() or ()), *({} and ()), **() or {})
d01(**{'a': 2})
d01(**{'a': 2} or {})
def d11(a, b=1):
pass
d11(1)
d11(1, 2)
d11(1, **{'b': 2})
def d21(a, b, c=1):
pass
d21(1, 2)
d21(1, 2, 3)
d21(*(1, 2, 3))
d21(1, *(2, 3))
d21(1, 2, *(3, ))
d21(1, 2, **{'c': 3})
def d02(a=1, b=2):
pass
d02()
d02(1)
d02(1, 2)
d02(*(1, 2))
d02(1, *(2, ))
d02(1, **{'b': 2})
d02(**{'a': 1, 'b': 2})
def d12(a, b=1, c=2):
pass
d12(1)
d12(1, 2)
d12(1, 2, 3)
def d22(a, b, c=1, d=2):
pass
d22(1, 2)
d22(1, 2, 3)
d22(1, 2, 3, 4)
def d01v(a=1, *rest):
pass
d01v()
d01v(1)
d01v(1, 2)
d01v(*(1, 2, 3, 4))
d01v(*(1, ))
d01v(**{'a': 2})
def d11v(a, b=1, *rest):
pass
d11v(1)
d11v(1, 2)
d11v(1, 2, 3)
def d21v(a, b, c=1, *rest):
pass
d21v(1, 2)
d21v(1, 2, 3)
d21v(1, 2, 3, 4)
d21v(*(1, 2, 3, 4))
d21v(1, 2, **{'c': 3})
def d02v(a=1, b=2, *rest):
pass
d02v()
d02v(1)
d02v(1, 2)
d02v(1, 2, 3)
d02v(1, *(2, 3, 4))
d02v(**{'a': 1, 'b': 2})
def d12v(a, b=1, c=2, *rest):
pass
d12v(1)
d12v(1, 2)
d12v(1, 2, 3)
d12v(1, 2, 3, 4)
d12v(*(1, 2, 3, 4))
d12v(1, 2, *(3, 4, 5))
d12v(1, *(2, ), **{'c': 3})
def d22v(a, b, c=1, d=2, *rest):
pass
d22v(1, 2)
d22v(1, 2, 3)
d22v(1, 2, 3, 4)
d22v(1, 2, 3, 4, 5)
d22v(*(1, 2, 3, 4))
d22v(1, 2, *(3, 4, 5))
d22v(1, *(2, 3), **{'d': 4})
try:
str('x', **{b'foo': 1})
except TypeError:
pass
else:
self.fail('Bytes should not work as keyword argument names')
def pos0key1(*, key):
return key
pos0key1(key=100)
def pos2key2(p1, p2, *, k1, k2=100):
return p1, p2, k1, k2
pos2key2(1, 2, k1=100)
pos2key2(1, 2, k1=100, k2=200)
pos2key2(1, 2, k2=100, k1=200)
def pos2key2dict(p1, p2, *, k1=100, k2, **kwarg):
return p1, p2, k1, k2, kwarg
pos2key2dict(1, 2, k2=100, tokwarg1=100, tokwarg2=200)
pos2key2dict(1, 2, tokwarg1=100, tokwarg2=200, k2=100)
self.assertRaises(SyntaxError, eval, 'def f(*): pass')
self.assertRaises(SyntaxError, eval, 'def f(*,): pass')
self.assertRaises(SyntaxError, eval, 'def f(*, **kwds): pass')
def f(*args, **kwargs):
return args, kwargs
self.assertEqual(f(1, *[3, 4], x=2, y=5), ((1, 3, 4), {
'x': 2,
'y': 5
}))
self.assertEqual(f(1, *(2, 3), 4), ((1, 2, 3, 4), {}))
self.assertRaises(SyntaxError, eval, 'f(1, x=2, *(3,4), x=5)')
self.assertEqual(f(**{
'eggs': 'scrambled',
'spam': 'fried'
}), ((), {
'eggs': 'scrambled',
'spam': 'fried'
}))
self.assertEqual(f(spam='fried', **{'eggs': 'scrambled'}),
((), {
'eggs': 'scrambled',
'spam': 'fried'
}))
def f(x) -> list:
pass
self.assertEqual(f.__annotations__, {'return': list})
def f(x: int):
pass
self.assertEqual(f.__annotations__, {'x': int})
def f(*x: str):
pass
self.assertEqual(f.__annotations__, {'x': str})
def f(**x: float):
pass
self.assertEqual(f.__annotations__, {'x': float})
def f(x, y: (1 + 2)):
pass
self.assertEqual(f.__annotations__, {'y': 3})
def f(a, b: (1), c: (2), d):
pass
self.assertEqual(f.__annotations__, {'b': 1, 'c': 2})
def f(a, b: (1), c: (2), d, e: (3) = 4, f=5, *g: (6)):
pass
self.assertEqual(f.__annotations__, {'b': 1, 'c': 2, 'e': 3, 'g': 6})
def f(a,
b: (1),
c: (2),
d,
e: (3) = 4,
f=5,
*g: (6),
h: (7),
i=8,
j: (9) = 10,
**k: (11)) -> (12):
pass
self.assertEqual(f.__annotations__, {
'b': 1,
'c': 2,
'e': 3,
'g': 6,
'h': 7,
'j': 9,
'k': 11,
'return': 12
})
class Spam:
def f(self, *, __kw: (1)):
pass
class Ham(Spam):
pass
self.assertEqual(Spam.f.__annotations__, {'_Spam__kw': 1})
self.assertEqual(Ham.f.__annotations__, {'_Spam__kw': 1})
def null(x):
return x
@null
def f(x) -> list:
pass
self.assertEqual(f.__annotations__, {'return': list})
closure = 1
def f():
return closure
def f(x=1):
return closure
def f(*, k=1):
return closure
def f() -> int:
return closure
check_syntax_error(self, 'f(*g(1=2))')
check_syntax_error(self, 'f(**g(1=2))')
def f(a):
pass
def f(*args):
pass
def f(**kwds):
pass
def f(a, *args):
pass
def f(a, **kwds):
pass
def f(*args, b):
pass
def f(*, b):
pass
def f(*args, **kwds):
pass
def f(a, *args, b):
pass
def f(a, *, b):
pass
def f(a, *args, **kwds):
pass
def f(*args, b, **kwds):
pass
def f(*, b, **kwds):
pass
def f(a, *args, b, **kwds):
pass
def f(a, *, b, **kwds):
pass
def test_var_annot_syntax_errors(self):
check_syntax_error(self, 'def f: int')
check_syntax_error(self, 'x: int: str')
check_syntax_error(self, 'def f():\n nonlocal x: int\n')
check_syntax_error(self, '[x, 0]: int\n')
check_syntax_error(self, 'f(): int\n')
check_syntax_error(self, '(x,): int')
check_syntax_error(self, 'def f():\n (x, y): int = (1, 2)\n')
check_syntax_error(self, 'def f():\n x: int\n global x\n')
check_syntax_error(self, 'def f():\n global x\n x: int\n')
def test1(self):
prog_text_1 = (
'def wrong1():\n a = 1\n b = 2\n global a\n global b\n'
)
check_syntax_error(self, prog_text_1, lineno=4, offset=4)
def testYield(self):
check_syntax_error(self, "class foo:yield 1")
def test_var_annot_syntax_errors(self):
# parser pass
check_syntax_error(self, "def f: int")
check_syntax_error(self, "x: int: str")
check_syntax_error(self, "def f():\n" " nonlocal x: int\n")
# AST pass
check_syntax_error(self, "[x, 0]: int\n")
check_syntax_error(self, "f(): int\n")
check_syntax_error(self, "(x,): int")
check_syntax_error(self, "def f():\n" " (x, y): int = (1, 2)\n")
# symtable pass
check_syntax_error(self, "def f():\n" " x: int\n" " global x\n")
check_syntax_error(self, "def f():\n" " global x\n" " x: int\n")
def test_listcomps(self):
# list comprehension tests
nums = [1, 2, 3, 4, 5]
strs = ["Apple", "Banana", "Coconut"]
spcs = [" Apple", " Banana ", "Coco nut "]
self.assertEqual([s.strip() for s in spcs], ['Apple', 'Banana', 'Coco nut'])
self.assertEqual([3 * x for x in nums], [3, 6, 9, 12, 15])
self.assertEqual([x for x in nums if x > 2], [3, 4, 5])
self.assertEqual([(i, s) for i in nums for s in strs],
[(1, 'Apple'), (1, 'Banana'), (1, 'Coconut'),
(2, 'Apple'), (2, 'Banana'), (2, 'Coconut'),
(3, 'Apple'), (3, 'Banana'), (3, 'Coconut'),
(4, 'Apple'), (4, 'Banana'), (4, 'Coconut'),
(5, 'Apple'), (5, 'Banana'), (5, 'Coconut')])
self.assertEqual([(i, s) for i in nums for s in [f for f in strs if "n" in f]],
[(1, 'Banana'), (1, 'Coconut'), (2, 'Banana'), (2, 'Coconut'),
(3, 'Banana'), (3, 'Coconut'), (4, 'Banana'), (4, 'Coconut'),
(5, 'Banana'), (5, 'Coconut')])
self.assertEqual([(lambda a:[a**i for i in range(a+1)])(j) for j in range(5)],
[[1], [1, 1], [1, 2, 4], [1, 3, 9, 27], [1, 4, 16, 64, 256]])
def test_in_func(l):
return [0 < x < 3 for x in l if x > 2]
self.assertEqual(test_in_func(nums), [False, False, False])
def test_nested_front():
self.assertEqual([[y for y in [x, x + 1]] for x in [1,3,5]],
[[1, 2], [3, 4], [5, 6]])
test_nested_front()
check_syntax_error(self, "[i, s for i in nums for s in strs]")
check_syntax_error(self, "[x if y]")
suppliers = [
(1, "Boeing"),
(2, "Ford"),
(3, "Macdonalds")
]
parts = [
(10, "Airliner"),
(20, "Engine"),
(30, "Cheeseburger")
]
suppart = [
(1, 10), (1, 20), (2, 20), (3, 30)
]
x = [
(sname, pname)
for (sno, sname) in suppliers
for (pno, pname) in parts
for (sp_sno, sp_pno) in suppart
if sno == sp_sno and pno == sp_pno
]
self.assertEqual(x, [('Boeing', 'Airliner'), ('Boeing', 'Engine'), ('Ford', 'Engine'),
('Macdonalds', 'Cheeseburger')])
def testFuncdef(self):
### [decorators] 'def' NAME parameters ['->' test] ':' suite
### decorator: '@' dotted_name [ '(' [arglist] ')' ] NEWLINE
### decorators: decorator+
### parameters: '(' [typedargslist] ')'
### typedargslist: ((tfpdef ['=' test] ',')*
### ('*' [tfpdef] (',' tfpdef ['=' test])* [',' '**' tfpdef] | '**' tfpdef)
### | tfpdef ['=' test] (',' tfpdef ['=' test])* [','])
### tfpdef: NAME [':' test]
### varargslist: ((vfpdef ['=' test] ',')*
### ('*' [vfpdef] (',' vfpdef ['=' test])* [',' '**' vfpdef] | '**' vfpdef)
### | vfpdef ['=' test] (',' vfpdef ['=' test])* [','])
### vfpdef: NAME
def f1():
pass
f1()
f1(*())
f1(*(), **{})
def f2(one_argument):
pass
def f3(two, arguments):
pass
self.assertEquals(f2.__code__.co_varnames, ('one_argument', ))
self.assertEquals(f3.__code__.co_varnames, ('two', 'arguments'))
def a1(one_arg, ):
pass
def a2(
two,
args,
):
pass
def v0(*rest):
pass
def v1(a, *rest):
pass
def v2(a, b, *rest):
pass
f1()
f2(1)
f2(1, )
f3(1, 2)
f3(
1,
2,
)
v0()
v0(1)
v0(1, )
v0(1, 2)
v0(1, 2, 3, 4, 5, 6, 7, 8, 9, 0)
v1(1)
v1(1, )
v1(1, 2)
v1(1, 2, 3)
v1(1, 2, 3, 4, 5, 6, 7, 8, 9, 0)
v2(1, 2)
v2(1, 2, 3)
v2(1, 2, 3, 4)
v2(1, 2, 3, 4, 5, 6, 7, 8, 9, 0)
def d01(a=1):
pass
d01()
d01(1)
d01(*(1, ))
d01(**{'a': 2})
def d11(a, b=1):
pass
d11(1)
d11(1, 2)
d11(1, **{'b': 2})
def d21(a, b, c=1):
pass
d21(1, 2)
d21(1, 2, 3)
d21(*(1, 2, 3))
d21(1, *(2, 3))
d21(1, 2, *(3, ))
d21(1, 2, **{'c': 3})
def d02(a=1, b=2):
pass
d02()
d02(1)
d02(1, 2)
d02(*(1, 2))
d02(1, *(2, ))
d02(1, **{'b': 2})
d02(**{'a': 1, 'b': 2})
def d12(a, b=1, c=2):
pass
d12(1)
d12(1, 2)
d12(1, 2, 3)
def d22(a, b, c=1, d=2):
pass
d22(1, 2)
d22(1, 2, 3)
d22(1, 2, 3, 4)
def d01v(a=1, *rest):
pass
d01v()
d01v(1)
d01v(1, 2)
d01v(*(1, 2, 3, 4))
d01v(*(1, ))
d01v(**{'a': 2})
def d11v(a, b=1, *rest):
pass
d11v(1)
d11v(1, 2)
d11v(1, 2, 3)
def d21v(a, b, c=1, *rest):
pass
d21v(1, 2)
d21v(1, 2, 3)
d21v(1, 2, 3, 4)
d21v(*(1, 2, 3, 4))
d21v(1, 2, **{'c': 3})
def d02v(a=1, b=2, *rest):
pass
d02v()
d02v(1)
d02v(1, 2)
d02v(1, 2, 3)
d02v(1, *(2, 3, 4))
d02v(**{'a': 1, 'b': 2})
def d12v(a, b=1, c=2, *rest):
pass
d12v(1)
d12v(1, 2)
d12v(1, 2, 3)
d12v(1, 2, 3, 4)
d12v(*(1, 2, 3, 4))
d12v(1, 2, *(3, 4, 5))
d12v(1, *(2, ), **{'c': 3})
def d22v(a, b, c=1, d=2, *rest):
pass
d22v(1, 2)
d22v(1, 2, 3)
d22v(1, 2, 3, 4)
d22v(1, 2, 3, 4, 5)
d22v(*(1, 2, 3, 4))
d22v(1, 2, *(3, 4, 5))
d22v(1, *(2, 3), **{'d': 4})
# keyword argument type tests
try:
str('x', **{b'foo': 1})
except TypeError:
pass
else:
self.fail('Bytes should not work as keyword argument names')
# keyword only argument tests
def pos0key1(*, key):
return key
pos0key1(key=100)
def pos2key2(p1, p2, *, k1, k2=100):
return p1, p2, k1, k2
pos2key2(1, 2, k1=100)
pos2key2(1, 2, k1=100, k2=200)
pos2key2(1, 2, k2=100, k1=200)
def pos2key2dict(p1, p2, *, k1=100, k2, **kwarg):
return p1, p2, k1, k2, kwarg
pos2key2dict(1, 2, k2=100, tokwarg1=100, tokwarg2=200)
pos2key2dict(1, 2, tokwarg1=100, tokwarg2=200, k2=100)
# keyword arguments after *arglist
def f(*args, **kwargs):
return args, kwargs
self.assertEquals(f(1, x=2, *[3, 4], y=5), ((1, 3, 4), {
'x': 2,
'y': 5
}))
self.assertRaises(SyntaxError, eval, "f(1, *(2,3), 4)")
self.assertRaises(SyntaxError, eval, "f(1, x=2, *(3,4), x=5)")
# argument annotation tests
def f(x) -> list:
pass
self.assertEquals(f.__annotations__, {'return': list})
def f(x: int):
pass
self.assertEquals(f.__annotations__, {'x': int})
def f(*x: str):
pass
self.assertEquals(f.__annotations__, {'x': str})
def f(**x: float):
pass
self.assertEquals(f.__annotations__, {'x': float})
def f(x, y: 1 + 2):
pass
self.assertEquals(f.__annotations__, {'y': 3})
def f(a, b: 1, c: 2, d):
pass
self.assertEquals(f.__annotations__, {'b': 1, 'c': 2})
def f(a, b: 1, c: 2, d, e: 3 = 4, f=5, *g: 6):
pass
self.assertEquals(f.__annotations__, {'b': 1, 'c': 2, 'e': 3, 'g': 6})
def f(a,
b: 1,
c: 2,
d,
e: 3 = 4,
f=5,
*g: 6,
h: 7,
i=8,
j: 9 = 10,
**k: 11) -> 12:
pass
self.assertEquals(f.__annotations__, {
'b': 1,
'c': 2,
'e': 3,
'g': 6,
'h': 7,
'j': 9,
'k': 11,
'return': 12
})
# Check for SF Bug #1697248 - mixing decorators and a return annotation
def null(x):
return x
@null
def f(x) -> list:
pass
self.assertEquals(f.__annotations__, {'return': list})
# test closures with a variety of oparg's
closure = 1
def f():
return closure
def f(x=1):
return closure
def f(*, k=1):
return closure
def f() -> int:
return closure
# Check ast errors in *args and *kwargs
check_syntax_error(self, "f(*g(1=2))")
check_syntax_error(self, "f(**g(1=2))")
def test_var_annot_syntax_errors(self):
# parser pass
check_syntax_error(self, "def f: int")
check_syntax_error(self, "x: int: str")
check_syntax_error(self, "def f():\n"
" nonlocal x: int\n")
# AST pass
check_syntax_error(self, "[x, 0]: int\n")
check_syntax_error(self, "f(): int\n")
check_syntax_error(self, "(x,): int")
check_syntax_error(self, "def f():\n"
" (x, y): int = (1, 2)\n")
# symtable pass
check_syntax_error(self, "def f():\n"
" x: int\n"
" global x\n")
check_syntax_error(self, "def f():\n"
" global x\n"
" x: int\n")
def testYield(self):
check_syntax_error(self, "class foo:yield 1")
def test3(self):
prog_text_3 = 'def wrong3():\n print(x)\n x = 2\n global x\n'
check_syntax_error(self, prog_text_3, lineno=4, offset=4)
def test_check_syntax_error(self):
support.check_syntax_error(self, "def class", lineno=1, offset=9)
with self.assertRaises(AssertionError):
support.check_syntax_error(self, "x=1")
def test_invalid_syntax_errors_async(self):
if use_old_parser():
check_syntax_error(
self, "async def f(a, b = 5, /, c): pass",
"non-default argument follows default argument")
check_syntax_error(
self, "async def f(a = 5, b, /, c): pass",
"non-default argument follows default argument")
check_syntax_error(
self, "async def f(a = 5, b=1, /, c, d=2): pass",
"non-default argument follows default argument")
check_syntax_error(
self, "async def f(a = 5, b, /): pass",
"non-default argument follows default argument")
check_syntax_error(self, "async def f(*args, /): pass")
check_syntax_error(self, "async def f(*args, a, /): pass")
check_syntax_error(self, "async def f(**kwargs, /): pass")
check_syntax_error(self, "async def f(/, a = 1): pass")
check_syntax_error(self, "async def f(/, a): pass")
check_syntax_error(self, "async def f(/): pass")
check_syntax_error(self, "async def f(*, a, /): pass")
check_syntax_error(self, "async def f(*, /, a): pass")
check_syntax_error(self, "async def f(a, /, a): pass",
"duplicate argument 'a' in function definition")
check_syntax_error(self, "async def f(a, /, *, a): pass",
"duplicate argument 'a' in function definition")
check_syntax_error(self, "async def f(a, b/2, c): pass")
check_syntax_error(self, "async def f(a, /, c, /): pass")
check_syntax_error(self, "async def f(a, /, c, /, d): pass")
check_syntax_error(self, "async def f(a, /, c, /, d, *, e): pass")
check_syntax_error(self, "async def f(a, *, c, /, d, e): pass")
def test_check_syntax_error(self):
support.check_syntax_error(self, "def class")
self.assertRaises(AssertionError, support.check_syntax_error, self,
"1")
def test_yield(self):
# Allowed as standalone statement
def g():
yield 1
def g():
yield from ()
# Allowed as RHS of assignment
def g():
x = yield 1
def g():
x = yield from ()
# Ordinary yield accepts implicit tuples
def g():
yield 1, 1
def g():
x = yield 1, 1
# 'yield from' does not
check_syntax_error(self, "def g(): yield from (), 1")
check_syntax_error(self, "def g(): x = yield from (), 1")
# Requires parentheses as subexpression
def g():
1, (yield 1)
def g():
1, (yield from ())
check_syntax_error(self, "def g(): 1, yield 1")
check_syntax_error(self, "def g(): 1, yield from ()")
# Requires parentheses as call argument
def g():
f((yield 1))
def g():
f((yield 1), 1)
def g():
f((yield from ()))
def g():
f((yield from ()), 1)
check_syntax_error(self, "def g(): f(yield 1)")
check_syntax_error(self, "def g(): f(yield 1, 1)")
check_syntax_error(self, "def g(): f(yield from ())")
check_syntax_error(self, "def g(): f(yield from (), 1)")
# Not allowed at top level
check_syntax_error(self, "yield")
check_syntax_error(self, "yield from")
# Not allowed at class scope
check_syntax_error(self, "class foo:yield 1")
check_syntax_error(self, "class foo:yield from ()")
# Check annotation refleak on SyntaxError
check_syntax_error(self, "def g(a:(yield)): pass")
def testGenexps(self):
# generator expression tests
g = ([x for x in range(10)] for x in range(1))
self.assertEqual(next(g), [x for x in range(10)])
try:
next(g)
self.fail("should produce StopIteration exception")
except StopIteration:
pass
a = 1
try:
g = (a for d in a)
next(g)
self.fail("should produce TypeError")
except TypeError:
pass
self.assertEqual(
list((x, y) for x in "abcd" for y in "abcd"),
[(x, y) for x in "abcd" for y in "abcd"],
)
self.assertEqual(
list((x, y) for x in "ab" for y in "xy"),
[(x, y) for x in "ab" for y in "xy"],
)
a = [x for x in range(10)]
b = (x for x in (y for y in a))
self.assertEqual(sum(b), sum([x for x in range(10)]))
self.assertEqual(
sum(x ** 2 for x in range(10)), sum([x ** 2 for x in range(10)])
)
self.assertEqual(
sum(x * x for x in range(10) if x % 2),
sum([x * x for x in range(10) if x % 2]),
)
self.assertEqual(
sum(x for x in (y for y in range(10))), sum([x for x in range(10)])
)
self.assertEqual(
sum(x for x in (y for y in (z for z in range(10)))),
sum([x for x in range(10)]),
)
self.assertEqual(
sum(x for x in [y for y in (z for z in range(10))]),
sum([x for x in range(10)]),
)
self.assertEqual(
sum(x for x in (y for y in (z for z in range(10) if True)) if True),
sum([x for x in range(10)]),
)
self.assertEqual(
sum(
x for x in (y for y in (z for z in range(10) if True) if False) if True
),
0,
)
check_syntax_error(self, "foo(x for x in range(10), 100)")
check_syntax_error(self, "foo(100, x for x in range(10))")
