14710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm# Python test set -- part 1, grammar. 24710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm# This just tests whether the parser accepts them all. 34710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 44710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm# NOTE: When you run this test as a script from the command line, you 54710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm# get warnings about certain hex/oct constants. Since those are 64710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm# issued by the parser, you can't suppress them by adding a 74710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm# filterwarnings() call to this module. Therefore, to shut up the 84710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm# regression test, the filterwarnings() call has been added to 94710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm# regrtest.py. 104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmfrom test.support import run_unittest, check_syntax_error 124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmimport unittest 134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmimport sys 144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm# testing import * 154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmfrom sys import * 164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmclass TokenTests(unittest.TestCase): 184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def testBackslash(self): 204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # Backslash means line continuation: 214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = 1 \ 224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm + 1 234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEquals(x, 2, 'backslash for line continuation') 244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # Backslash does not means continuation in comments :\ 264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = 0 274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEquals(x, 0, 'backslash ending comment') 284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def testPlainIntegers(self): 304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEquals(type(000), type(0)) 314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEquals(0xff, 255) 324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEquals(0o377, 255) 334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEquals(2147483647, 0o17777777777) 344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEquals(0b1001, 9) 354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # "0x" is not a valid literal 364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(SyntaxError, eval, "0x") 374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm from sys import maxsize 384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if maxsize == 2147483647: 394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEquals(-2147483647-1, -0o20000000000) 404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # XXX -2147483648 414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assert_(0o37777777777 > 0) 424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assert_(0xffffffff > 0) 434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assert_(0b1111111111111111111111111111111 > 0) 444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for s in ('2147483648', '0o40000000000', '0x100000000', 454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm '0b10000000000000000000000000000000'): 464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm try: 474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = eval(s) 484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm except OverflowError: 494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.fail("OverflowError on huge integer literal %r" % s) 504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm elif maxsize == 9223372036854775807: 514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEquals(-9223372036854775807-1, -0o1000000000000000000000) 524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assert_(0o1777777777777777777777 > 0) 534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assert_(0xffffffffffffffff > 0) 544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assert_(0b11111111111111111111111111111111111111111111111111111111111111 > 0) 554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for s in '9223372036854775808', '0o2000000000000000000000', \ 564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm '0x10000000000000000', \ 574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm '0b100000000000000000000000000000000000000000000000000000000000000': 584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm try: 594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = eval(s) 604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm except OverflowError: 614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.fail("OverflowError on huge integer literal %r" % s) 624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else: 634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.fail('Weird maxsize value %r' % maxsize) 644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def testLongIntegers(self): 664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = 0 674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = 0xffffffffffffffff 684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = 0Xffffffffffffffff 694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = 0o77777777777777777 704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = 0O77777777777777777 714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = 123456789012345678901234567890 724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = 0b100000000000000000000000000000000000000000000000000000000000000000000 734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = 0B111111111111111111111111111111111111111111111111111111111111111111111 744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def testFloats(self): 764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = 3.14 774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = 314. 784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = 0.314 794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # XXX x = 000.314 804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = .314 814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = 3e14 824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = 3E14 834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = 3e-14 844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = 3e+14 854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = 3.e14 864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = .3e14 874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = 3.1e4 884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def testStringLiterals(self): 904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = ''; y = ""; self.assert_(len(x) == 0 and x == y) 914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = '\''; y = "'"; self.assert_(len(x) == 1 and x == y and ord(x) == 39) 924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = '"'; y = "\""; self.assert_(len(x) == 1 and x == y and ord(x) == 34) 934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = "doesn't \"shrink\" does it" 944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm y = 'doesn\'t "shrink" does it' 954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assert_(len(x) == 24 and x == y) 964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = "does \"shrink\" doesn't it" 974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm y = 'does "shrink" doesn\'t it' 984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assert_(len(x) == 24 and x == y) 994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = """ 1004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmThe "quick" 1014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmbrown fox 1024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmjumps over 1034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmthe 'lazy' dog. 1044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm""" 1054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm y = '\nThe "quick"\nbrown fox\njumps over\nthe \'lazy\' dog.\n' 1064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEquals(x, y) 1074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm y = ''' 1084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmThe "quick" 1094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmbrown fox 1104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmjumps over 1114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmthe 'lazy' dog. 1124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm''' 1134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEquals(x, y) 1144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm y = "\n\ 1154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmThe \"quick\"\n\ 1164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmbrown fox\n\ 1174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmjumps over\n\ 1184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmthe 'lazy' dog.\n\ 1194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm" 1204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEquals(x, y) 1214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm y = '\n\ 1224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmThe \"quick\"\n\ 1234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmbrown fox\n\ 1244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmjumps over\n\ 1254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmthe \'lazy\' dog.\n\ 1264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm' 1274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEquals(x, y) 1284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 1294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def testEllipsis(self): 1304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = ... 1314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assert_(x is Ellipsis) 1324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(SyntaxError, eval, ".. .") 1334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 1344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmclass GrammarTests(unittest.TestCase): 1354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 1364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # single_input: NEWLINE | simple_stmt | compound_stmt NEWLINE 1374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # XXX can't test in a script -- this rule is only used when interactive 1384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 1394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # file_input: (NEWLINE | stmt)* ENDMARKER 1404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # Being tested as this very moment this very module 1414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 1424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # expr_input: testlist NEWLINE 1434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # XXX Hard to test -- used only in calls to input() 1444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 1454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def testEvalInput(self): 1464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # testlist ENDMARKER 1474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = eval('1, 0 or 1') 1484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 1494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def testFuncdef(self): 1504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ### [decorators] 'def' NAME parameters ['->' test] ':' suite 1514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ### decorator: '@' dotted_name [ '(' [arglist] ')' ] NEWLINE 1524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ### decorators: decorator+ 1534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ### parameters: '(' [typedargslist] ')' 1544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ### typedargslist: ((tfpdef ['=' test] ',')* 1554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ### ('*' [tfpdef] (',' tfpdef ['=' test])* [',' '**' tfpdef] | '**' tfpdef) 1564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ### | tfpdef ['=' test] (',' tfpdef ['=' test])* [',']) 1574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ### tfpdef: NAME [':' test] 1584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ### varargslist: ((vfpdef ['=' test] ',')* 1594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ### ('*' [vfpdef] (',' vfpdef ['=' test])* [',' '**' vfpdef] | '**' vfpdef) 1604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ### | vfpdef ['=' test] (',' vfpdef ['=' test])* [',']) 1614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ### vfpdef: NAME 1624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def f1(): pass 1634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm f1() 1644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm f1(*()) 1654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm f1(*(), **{}) 1664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def f2(one_argument): pass 1674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def f3(two, arguments): pass 1684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEquals(f2.__code__.co_varnames, ('one_argument',)) 1694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEquals(f3.__code__.co_varnames, ('two', 'arguments')) 1704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def a1(one_arg,): pass 1714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def a2(two, args,): pass 1724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def v0(*rest): pass 1734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def v1(a, *rest): pass 1744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def v2(a, b, *rest): pass 1754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 1764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm f1() 1774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm f2(1) 1784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm f2(1,) 1794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm f3(1, 2) 1804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm f3(1, 2,) 1814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm v0() 1824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm v0(1) 1834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm v0(1,) 1844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm v0(1,2) 1854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm v0(1,2,3,4,5,6,7,8,9,0) 1864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm v1(1) 1874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm v1(1,) 1884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm v1(1,2) 1894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm v1(1,2,3) 1904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm v1(1,2,3,4,5,6,7,8,9,0) 1914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm v2(1,2) 1924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm v2(1,2,3) 1934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm v2(1,2,3,4) 1944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm v2(1,2,3,4,5,6,7,8,9,0) 1954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 1964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def d01(a=1): pass 1974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm d01() 1984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm d01(1) 1994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm d01(*(1,)) 2004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm d01(**{'a':2}) 2014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def d11(a, b=1): pass 2024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm d11(1) 2034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm d11(1, 2) 2044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm d11(1, **{'b':2}) 2054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def d21(a, b, c=1): pass 2064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm d21(1, 2) 2074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm d21(1, 2, 3) 2084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm d21(*(1, 2, 3)) 2094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm d21(1, *(2, 3)) 2104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm d21(1, 2, *(3,)) 2114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm d21(1, 2, **{'c':3}) 2124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def d02(a=1, b=2): pass 2134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm d02() 2144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm d02(1) 2154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm d02(1, 2) 2164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm d02(*(1, 2)) 2174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm d02(1, *(2,)) 2184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm d02(1, **{'b':2}) 2194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm d02(**{'a': 1, 'b': 2}) 2204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def d12(a, b=1, c=2): pass 2214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm d12(1) 2224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm d12(1, 2) 2234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm d12(1, 2, 3) 2244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def d22(a, b, c=1, d=2): pass 2254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm d22(1, 2) 2264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm d22(1, 2, 3) 2274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm d22(1, 2, 3, 4) 2284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def d01v(a=1, *rest): pass 2294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm d01v() 2304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm d01v(1) 2314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm d01v(1, 2) 2324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm d01v(*(1, 2, 3, 4)) 2334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm d01v(*(1,)) 2344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm d01v(**{'a':2}) 2354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def d11v(a, b=1, *rest): pass 2364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm d11v(1) 2374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm d11v(1, 2) 2384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm d11v(1, 2, 3) 2394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def d21v(a, b, c=1, *rest): pass 2404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm d21v(1, 2) 2414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm d21v(1, 2, 3) 2424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm d21v(1, 2, 3, 4) 2434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm d21v(*(1, 2, 3, 4)) 2444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm d21v(1, 2, **{'c': 3}) 2454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def d02v(a=1, b=2, *rest): pass 2464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm d02v() 2474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm d02v(1) 2484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm d02v(1, 2) 2494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm d02v(1, 2, 3) 2504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm d02v(1, *(2, 3, 4)) 2514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm d02v(**{'a': 1, 'b': 2}) 2524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def d12v(a, b=1, c=2, *rest): pass 2534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm d12v(1) 2544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm d12v(1, 2) 2554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm d12v(1, 2, 3) 2564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm d12v(1, 2, 3, 4) 2574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm d12v(*(1, 2, 3, 4)) 2584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm d12v(1, 2, *(3, 4, 5)) 2594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm d12v(1, *(2,), **{'c': 3}) 2604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def d22v(a, b, c=1, d=2, *rest): pass 2614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm d22v(1, 2) 2624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm d22v(1, 2, 3) 2634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm d22v(1, 2, 3, 4) 2644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm d22v(1, 2, 3, 4, 5) 2654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm d22v(*(1, 2, 3, 4)) 2664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm d22v(1, 2, *(3, 4, 5)) 2674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm d22v(1, *(2, 3), **{'d': 4}) 2684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 2694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # keyword argument type tests 2704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm try: 2714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm str('x', **{b'foo':1 }) 2724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm except TypeError: 2734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm pass 2744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else: 2754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.fail('Bytes should not work as keyword argument names') 2764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # keyword only argument tests 2774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def pos0key1(*, key): return key 2784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm pos0key1(key=100) 2794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def pos2key2(p1, p2, *, k1, k2=100): return p1,p2,k1,k2 2804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm pos2key2(1, 2, k1=100) 2814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm pos2key2(1, 2, k1=100, k2=200) 2824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm pos2key2(1, 2, k2=100, k1=200) 2834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def pos2key2dict(p1, p2, *, k1=100, k2, **kwarg): return p1,p2,k1,k2,kwarg 2844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm pos2key2dict(1,2,k2=100,tokwarg1=100,tokwarg2=200) 2854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm pos2key2dict(1,2,tokwarg1=100,tokwarg2=200, k2=100) 2864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 2874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # keyword arguments after *arglist 2884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def f(*args, **kwargs): 2894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return args, kwargs 2904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEquals(f(1, x=2, *[3, 4], y=5), ((1, 3, 4), 2914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm {'x':2, 'y':5})) 2924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(SyntaxError, eval, "f(1, *(2,3), 4)") 2934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(SyntaxError, eval, "f(1, x=2, *(3,4), x=5)") 2944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 2954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # argument annotation tests 2964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def f(x) -> list: pass 2974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEquals(f.__annotations__, {'return': list}) 2984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def f(x:int): pass 2994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEquals(f.__annotations__, {'x': int}) 3004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def f(*x:str): pass 3014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEquals(f.__annotations__, {'x': str}) 3024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def f(**x:float): pass 3034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEquals(f.__annotations__, {'x': float}) 3044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def f(x, y:1+2): pass 3054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEquals(f.__annotations__, {'y': 3}) 3064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def f(a, b:1, c:2, d): pass 3074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEquals(f.__annotations__, {'b': 1, 'c': 2}) 3084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def f(a, b:1, c:2, d, e:3=4, f=5, *g:6): pass 3094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEquals(f.__annotations__, 3104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm {'b': 1, 'c': 2, 'e': 3, 'g': 6}) 3114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def f(a, b:1, c:2, d, e:3=4, f=5, *g:6, h:7, i=8, j:9=10, 3124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm **k:11) -> 12: pass 3134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEquals(f.__annotations__, 3144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm {'b': 1, 'c': 2, 'e': 3, 'g': 6, 'h': 7, 'j': 9, 3154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 'k': 11, 'return': 12}) 3164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # Check for SF Bug #1697248 - mixing decorators and a return annotation 3174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def null(x): return x 3184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm @null 3194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def f(x) -> list: pass 3204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEquals(f.__annotations__, {'return': list}) 3214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 3224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # test MAKE_CLOSURE with a variety of oparg's 3234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm closure = 1 3244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def f(): return closure 3254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def f(x=1): return closure 3264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def f(*, k=1): return closure 3274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def f() -> int: return closure 3284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 3294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # Check ast errors in *args and *kwargs 3304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm check_syntax_error(self, "f(*g(1=2))") 3314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm check_syntax_error(self, "f(**g(1=2))") 3324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 3334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def testLambdef(self): 3344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ### lambdef: 'lambda' [varargslist] ':' test 3354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm l1 = lambda : 0 3364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEquals(l1(), 0) 3374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm l2 = lambda : a[d] # XXX just testing the expression 3384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm l3 = lambda : [2 < x for x in [-1, 3, 0]] 3394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEquals(l3(), [0, 1, 0]) 3404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm l4 = lambda x = lambda y = lambda z=1 : z : y() : x() 3414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEquals(l4(), 1) 3424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm l5 = lambda x, y, z=2: x + y + z 3434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEquals(l5(1, 2), 5) 3444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEquals(l5(1, 2, 3), 6) 3454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm check_syntax_error(self, "lambda x: x = 2") 3464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm check_syntax_error(self, "lambda (None,): None") 3474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm l6 = lambda x, y, *, k=20: x+y+k 3484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEquals(l6(1,2), 1+2+20) 3494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEquals(l6(1,2,k=10), 1+2+10) 3504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 3514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 3524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ### stmt: simple_stmt | compound_stmt 3534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # Tested below 3544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 3554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def testSimpleStmt(self): 3564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ### simple_stmt: small_stmt (';' small_stmt)* [';'] 3574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = 1; pass; del x 3584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def foo(): 3594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # verify statements that end with semi-colons 3604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = 1; pass; del x; 3614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm foo() 3624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 3634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ### small_stmt: expr_stmt | pass_stmt | del_stmt | flow_stmt | import_stmt | global_stmt | access_stmt 3644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # Tested below 3654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 3664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def testExprStmt(self): 3674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # (exprlist '=')* exprlist 3684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 1 3694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 1, 2, 3 3704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = 1 3714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = 1, 2, 3 3724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = y = z = 1, 2, 3 3734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x, y, z = 1, 2, 3 3744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm abc = a, b, c = x, y, z = xyz = 1, 2, (3, 4) 3754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 3764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm check_syntax_error(self, "x + 1 = 1") 3774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm check_syntax_error(self, "a + 1 = b + 2") 3784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 3794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def testDelStmt(self): 3804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # 'del' exprlist 3814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm abc = [1,2,3] 3824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x, y, z = abc 3834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm xyz = x, y, z 3844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 3854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm del abc 3864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm del x, y, (z, xyz) 3874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 3884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def testPassStmt(self): 3894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # 'pass' 3904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm pass 3914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 3924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # flow_stmt: break_stmt | continue_stmt | return_stmt | raise_stmt 3934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # Tested below 3944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 3954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def testBreakStmt(self): 3964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # 'break' 3974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm while 1: break 3984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 3994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def testContinueStmt(self): 4004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # 'continue' 4014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm i = 1 4024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm while i: i = 0; continue 4034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 4044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm msg = "" 4054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm while not msg: 4064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm msg = "ok" 4074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm try: 4084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm continue 4094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm msg = "continue failed to continue inside try" 4104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm except: 4114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm msg = "continue inside try called except block" 4124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if msg != "ok": 4134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.fail(msg) 4144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 4154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm msg = "" 4164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm while not msg: 4174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm msg = "finally block not called" 4184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm try: 4194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm continue 4204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm finally: 4214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm msg = "ok" 4224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if msg != "ok": 4234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.fail(msg) 4244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 4254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_break_continue_loop(self): 4264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # This test warrants an explanation. It is a test specifically for SF bugs 4274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # #463359 and #462937. The bug is that a 'break' statement executed or 4284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # exception raised inside a try/except inside a loop, *after* a continue 4294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # statement has been executed in that loop, will cause the wrong number of 4304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # arguments to be popped off the stack and the instruction pointer reset to 4314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # a very small number (usually 0.) Because of this, the following test 4324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # *must* written as a function, and the tracking vars *must* be function 4334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # arguments with default values. Otherwise, the test will loop and loop. 4344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 4354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_inner(extra_burning_oil = 1, count=0): 4364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm big_hippo = 2 4374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm while big_hippo: 4384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm count += 1 4394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm try: 4404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if extra_burning_oil and big_hippo == 1: 4414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm extra_burning_oil -= 1 4424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm break 4434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm big_hippo -= 1 4444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm continue 4454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm except: 4464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm raise 4474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if count > 2 or big_hippo != 1: 4484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.fail("continue then break in try/except in loop broken!") 4494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm test_inner() 4504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 4514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def testReturn(self): 4524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # 'return' [testlist] 4534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def g1(): return 4544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def g2(): return 1 4554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm g1() 4564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = g2() 4574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm check_syntax_error(self, "class foo:return 1") 4584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 4594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def testYield(self): 4604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm check_syntax_error(self, "class foo:yield 1") 4614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 4624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def testRaise(self): 4634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # 'raise' test [',' test] 4644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm try: raise RuntimeError('just testing') 4654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm except RuntimeError: pass 4664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm try: raise KeyboardInterrupt 4674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm except KeyboardInterrupt: pass 4684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 4694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def testImport(self): 4704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # 'import' dotted_as_names 4714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm import sys 4724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm import time, sys 4734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # 'from' dotted_name 'import' ('*' | '(' import_as_names ')' | import_as_names) 4744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm from time import time 4754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm from time import (time) 4764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # not testable inside a function, but already done at top of the module 4774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # from sys import * 4784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm from sys import path, argv 4794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm from sys import (path, argv) 4804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm from sys import (path, argv,) 4814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 4824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def testGlobal(self): 4834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # 'global' NAME (',' NAME)* 4844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm global a 4854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm global a, b 4864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm global one, two, three, four, five, six, seven, eight, nine, ten 4874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 4884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def testNonlocal(self): 4894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # 'nonlocal' NAME (',' NAME)* 4904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = 0 4914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm y = 0 4924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def f(): 4934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm nonlocal x 4944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm nonlocal x, y 4954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 4964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def testAssert(self): 4974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # assert_stmt: 'assert' test [',' test] 4984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm assert 1 4994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm assert 1, 1 5004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm assert lambda x:x 5014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm assert 1, lambda x:x+1 5024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm try: 5034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm assert 0, "msg" 5044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm except AssertionError as e: 5054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEquals(e.args[0], "msg") 5064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else: 5074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if __debug__: 5084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.fail("AssertionError not raised by assert 0") 5094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 5104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ### compound_stmt: if_stmt | while_stmt | for_stmt | try_stmt | funcdef | classdef 5114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # Tested below 5124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 5134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def testIf(self): 5144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # 'if' test ':' suite ('elif' test ':' suite)* ['else' ':' suite] 5154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if 1: pass 5164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if 1: pass 5174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else: pass 5184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if 0: pass 5194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm elif 0: pass 5204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if 0: pass 5214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm elif 0: pass 5224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm elif 0: pass 5234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm elif 0: pass 5244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else: pass 5254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 5264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def testWhile(self): 5274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # 'while' test ':' suite ['else' ':' suite] 5284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm while 0: pass 5294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm while 0: pass 5304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else: pass 5314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 5324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # Issue1920: "while 0" is optimized away, 5334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # ensure that the "else" clause is still present. 5344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = 0 5354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm while 0: 5364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = 1 5374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else: 5384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = 2 5394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEquals(x, 2) 5404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 5414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def testFor(self): 5424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # 'for' exprlist 'in' exprlist ':' suite ['else' ':' suite] 5434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for i in 1, 2, 3: pass 5444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for i, j, k in (): pass 5454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else: pass 5464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm class Squares: 5474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def __init__(self, max): 5484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.max = max 5494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.sofar = [] 5504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def __len__(self): return len(self.sofar) 5514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def __getitem__(self, i): 5524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if not 0 <= i < self.max: raise IndexError 5534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm n = len(self.sofar) 5544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm while n <= i: 5554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.sofar.append(n*n) 5564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm n = n+1 5574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return self.sofar[i] 5584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm n = 0 5594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for x in Squares(10): n = n+x 5604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if n != 285: 5614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.fail('for over growing sequence') 5624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 5634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm result = [] 5644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for x, in [(1,), (2,), (3,)]: 5654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm result.append(x) 5664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(result, [1, 2, 3]) 5674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 5684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def testTry(self): 5694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ### try_stmt: 'try' ':' suite (except_clause ':' suite)+ ['else' ':' suite] 5704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ### | 'try' ':' suite 'finally' ':' suite 5714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ### except_clause: 'except' [expr ['as' expr]] 5724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm try: 5734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 1/0 5744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm except ZeroDivisionError: 5754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm pass 5764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else: 5774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm pass 5784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm try: 1/0 5794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm except EOFError: pass 5804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm except TypeError as msg: pass 5814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm except RuntimeError as msg: pass 5824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm except: pass 5834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else: pass 5844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm try: 1/0 5854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm except (EOFError, TypeError, ZeroDivisionError): pass 5864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm try: 1/0 5874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm except (EOFError, TypeError, ZeroDivisionError) as msg: pass 5884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm try: pass 5894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm finally: pass 5904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 5914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def testSuite(self): 5924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # simple_stmt | NEWLINE INDENT NEWLINE* (stmt NEWLINE*)+ DEDENT 5934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if 1: pass 5944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if 1: 5954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm pass 5964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if 1: 5974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # 5984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # 5994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # 6004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm pass 6014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm pass 6024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # 6034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm pass 6044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # 6054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 6064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def testTest(self): 6074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ### and_test ('or' and_test)* 6084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ### and_test: not_test ('and' not_test)* 6094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ### not_test: 'not' not_test | comparison 6104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if not 1: pass 6114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if 1 and 1: pass 6124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if 1 or 1: pass 6134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if not not not 1: pass 6144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if not 1 and 1 and 1: pass 6154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if 1 and 1 or 1 and 1 and 1 or not 1 and 1: pass 6164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 6174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def testComparison(self): 6184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ### comparison: expr (comp_op expr)* 6194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ### comp_op: '<'|'>'|'=='|'>='|'<='|'!='|'in'|'not' 'in'|'is'|'is' 'not' 6204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if 1: pass 6214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = (1 == 1) 6224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if 1 == 1: pass 6234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if 1 != 1: pass 6244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if 1 < 1: pass 6254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if 1 > 1: pass 6264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if 1 <= 1: pass 6274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if 1 >= 1: pass 6284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if 1 is 1: pass 6294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if 1 is not 1: pass 6304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if 1 in (): pass 6314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if 1 not in (): pass 6324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if 1 < 1 > 1 == 1 >= 1 <= 1 != 1 in 1 not in 1 is 1 is not 1: pass 6334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 6344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def testBinaryMaskOps(self): 6354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = 1 & 1 6364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = 1 ^ 1 6374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = 1 | 1 6384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 6394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def testShiftOps(self): 6404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = 1 << 1 6414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = 1 >> 1 6424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = 1 << 1 >> 1 6434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 6444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def testAdditiveOps(self): 6454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = 1 6464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = 1 + 1 6474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = 1 - 1 - 1 6484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = 1 - 1 + 1 - 1 + 1 6494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 6504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def testMultiplicativeOps(self): 6514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = 1 * 1 6524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = 1 / 1 6534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = 1 % 1 6544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = 1 / 1 * 1 % 1 6554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 6564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def testUnaryOps(self): 6574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = +1 6584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = -1 6594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = ~1 6604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = ~1 ^ 1 & 1 | 1 & 1 ^ -1 6614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = -1*1/1 + 1*1 - ---1*1 6624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 6634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def testSelectors(self): 6644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ### trailer: '(' [testlist] ')' | '[' subscript ']' | '.' NAME 6654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ### subscript: expr | [expr] ':' [expr] 6664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 6674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm import sys, time 6684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm c = sys.path[0] 6694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = time.time() 6704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = sys.modules['time'].time() 6714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm a = '01234' 6724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm c = a[0] 6734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm c = a[-1] 6744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm s = a[0:5] 6754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm s = a[:5] 6764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm s = a[0:] 6774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm s = a[:] 6784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm s = a[-5:] 6794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm s = a[:-1] 6804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm s = a[-4:-3] 6814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # A rough test of SF bug 1333982. http://python.org/sf/1333982 6824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # The testing here is fairly incomplete. 6834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # Test cases should include: commas with 1 and 2 colons 6844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm d = {} 6854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm d[1] = 1 6864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm d[1,] = 2 6874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm d[1,2] = 3 6884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm d[1,2,3] = 4 6894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm L = list(d) 6904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm L.sort(key=lambda x: x if isinstance(x, tuple) else ()) 6914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEquals(str(L), '[1, (1,), (1, 2), (1, 2, 3)]') 6924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 6934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def testAtoms(self): 6944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ### atom: '(' [testlist] ')' | '[' [testlist] ']' | '{' [dictsetmaker] '}' | NAME | NUMBER | STRING 6954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ### dictsetmaker: (test ':' test (',' test ':' test)* [',']) | (test (',' test)* [',']) 6964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 6974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = (1) 6984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = (1 or 2 or 3) 6994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = (1 or 2 or 3, 2, 3) 7004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 7014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = [] 7024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = [1] 7034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = [1 or 2 or 3] 7044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = [1 or 2 or 3, 2, 3] 7054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = [] 7064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 7074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = {} 7084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = {'one': 1} 7094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = {'one': 1,} 7104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = {'one' or 'two': 1 or 2} 7114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = {'one': 1, 'two': 2} 7124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = {'one': 1, 'two': 2,} 7134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = {'one': 1, 'two': 2, 'three': 3, 'four': 4, 'five': 5, 'six': 6} 7144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 7154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = {'one'} 7164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = {'one', 1,} 7174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = {'one', 'two', 'three'} 7184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = {2, 3, 4,} 7194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 7204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = x 7214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = 'x' 7224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = 123 7234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 7244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ### exprlist: expr (',' expr)* [','] 7254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ### testlist: test (',' test)* [','] 7264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # These have been exercised enough above 7274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 7284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def testClassdef(self): 7294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # 'class' NAME ['(' [testlist] ')'] ':' suite 7304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm class B: pass 7314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm class B2(): pass 7324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm class C1(B): pass 7334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm class C2(B): pass 7344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm class D(C1, C2, B): pass 7354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm class C: 7364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def meth1(self): pass 7374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def meth2(self, arg): pass 7384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def meth3(self, a1, a2): pass 7394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 7404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # decorator: '@' dotted_name [ '(' [arglist] ')' ] NEWLINE 7414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # decorators: decorator+ 7424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # decorated: decorators (classdef | funcdef) 7434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def class_decorator(x): return x 7444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm @class_decorator 7454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm class G: pass 7464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 7474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def testDictcomps(self): 7484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # dictorsetmaker: ( (test ':' test (comp_for | 7494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # (',' test ':' test)* [','])) | 7504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # (test (comp_for | (',' test)* [','])) ) 7514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm nums = [1, 2, 3] 7524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual({i:i+1 for i in nums}, {1: 2, 2: 3, 3: 4}) 7534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 7544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def testListcomps(self): 7554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # list comprehension tests 7564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm nums = [1, 2, 3, 4, 5] 7574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm strs = ["Apple", "Banana", "Coconut"] 7584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm spcs = [" Apple", " Banana ", "Coco nut "] 7594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 7604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual([s.strip() for s in spcs], ['Apple', 'Banana', 'Coco nut']) 7614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual([3 * x for x in nums], [3, 6, 9, 12, 15]) 7624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual([x for x in nums if x > 2], [3, 4, 5]) 7634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual([(i, s) for i in nums for s in strs], 7644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm [(1, 'Apple'), (1, 'Banana'), (1, 'Coconut'), 7654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm (2, 'Apple'), (2, 'Banana'), (2, 'Coconut'), 7664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm (3, 'Apple'), (3, 'Banana'), (3, 'Coconut'), 7674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm (4, 'Apple'), (4, 'Banana'), (4, 'Coconut'), 7684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm (5, 'Apple'), (5, 'Banana'), (5, 'Coconut')]) 7694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual([(i, s) for i in nums for s in [f for f in strs if "n" in f]], 7704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm [(1, 'Banana'), (1, 'Coconut'), (2, 'Banana'), (2, 'Coconut'), 7714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm (3, 'Banana'), (3, 'Coconut'), (4, 'Banana'), (4, 'Coconut'), 7724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm (5, 'Banana'), (5, 'Coconut')]) 7734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual([(lambda a:[a**i for i in range(a+1)])(j) for j in range(5)], 7744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm [[1], [1, 1], [1, 2, 4], [1, 3, 9, 27], [1, 4, 16, 64, 256]]) 7754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 7764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_in_func(l): 7774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return [0 < x < 3 for x in l if x > 2] 7784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 7794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(test_in_func(nums), [False, False, False]) 7804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 7814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_nested_front(): 7824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual([[y for y in [x, x + 1]] for x in [1,3,5]], 7834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm [[1, 2], [3, 4], [5, 6]]) 7844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 7854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm test_nested_front() 7864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 7874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm check_syntax_error(self, "[i, s for i in nums for s in strs]") 7884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm check_syntax_error(self, "[x if y]") 7894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 7904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm suppliers = [ 7914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm (1, "Boeing"), 7924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm (2, "Ford"), 7934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm (3, "Macdonalds") 7944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ] 7954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 7964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm parts = [ 7974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm (10, "Airliner"), 7984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm (20, "Engine"), 7994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm (30, "Cheeseburger") 8004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ] 8014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 8024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm suppart = [ 8034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm (1, 10), (1, 20), (2, 20), (3, 30) 8044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ] 8054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 8064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = [ 8074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm (sname, pname) 8084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for (sno, sname) in suppliers 8094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for (pno, pname) in parts 8104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for (sp_sno, sp_pno) in suppart 8114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if sno == sp_sno and pno == sp_pno 8124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ] 8134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 8144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(x, [('Boeing', 'Airliner'), ('Boeing', 'Engine'), ('Ford', 'Engine'), 8154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ('Macdonalds', 'Cheeseburger')]) 8164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 8174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def testGenexps(self): 8184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # generator expression tests 8194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm g = ([x for x in range(10)] for x in range(1)) 8204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(next(g), [x for x in range(10)]) 8214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm try: 8224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm next(g) 8234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.fail('should produce StopIteration exception') 8244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm except StopIteration: 8254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm pass 8264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 8274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm a = 1 8284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm try: 8294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm g = (a for d in a) 8304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm next(g) 8314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.fail('should produce TypeError') 8324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm except TypeError: 8334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm pass 8344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 8354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(list((x, y) for x in 'abcd' for y in 'abcd'), [(x, y) for x in 'abcd' for y in 'abcd']) 8364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(list((x, y) for x in 'ab' for y in 'xy'), [(x, y) for x in 'ab' for y in 'xy']) 8374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 8384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm a = [x for x in range(10)] 8394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm b = (x for x in (y for y in a)) 8404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(sum(b), sum([x for x in range(10)])) 8414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 8424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(sum(x**2 for x in range(10)), sum([x**2 for x in range(10)])) 8434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(sum(x*x for x in range(10) if x%2), sum([x*x for x in range(10) if x%2])) 8444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(sum(x for x in (y for y in range(10))), sum([x for x in range(10)])) 8454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(sum(x for x in (y for y in (z for z in range(10)))), sum([x for x in range(10)])) 8464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(sum(x for x in [y for y in (z for z in range(10))]), sum([x for x in range(10)])) 8474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 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)])) 8484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(sum(x for x in (y for y in (z for z in range(10) if True) if False) if True), 0) 8494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm check_syntax_error(self, "foo(x for x in range(10), 100)") 8504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm check_syntax_error(self, "foo(100, x for x in range(10))") 8514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 8524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def testComprehensionSpecials(self): 8534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # test for outmost iterable precomputation 8544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = 10; g = (i for i in range(x)); x = 5 8554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(len(list(g)), 10) 8564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 8574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # This should hold, since we're only precomputing outmost iterable. 8584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = 10; t = False; g = ((i,j) for i in range(x) if t for j in range(x)) 8594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = 5; t = True; 8604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual([(i,j) for i in range(10) for j in range(5)], list(g)) 8614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 8624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # Grammar allows multiple adjacent 'if's in listcomps and genexps, 8634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # even though it's silly. Make sure it works (ifelse broke this.) 8644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual([ x for x in range(10) if x % 2 if x % 3 ], [1, 5, 7]) 8654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(list(x for x in range(10) if x % 2 if x % 3), [1, 5, 7]) 8664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 8674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # verify unpacking single element tuples in listcomp/genexp. 8684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual([x for x, in [(4,), (5,), (6,)]], [4, 5, 6]) 8694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(list(x for x, in [(7,), (8,), (9,)]), [7, 8, 9]) 8704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 8714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_with_statement(self): 8724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm class manager(object): 8734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def __enter__(self): 8744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return (1, 2) 8754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def __exit__(self, *args): 8764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm pass 8774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 8784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm with manager(): 8794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm pass 8804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm with manager() as x: 8814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm pass 8824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm with manager() as (x, y): 8834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm pass 8844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm with manager(), manager(): 8854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm pass 8864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm with manager() as x, manager() as y: 8874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm pass 8884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm with manager() as x, manager(): 8894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm pass 8904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 8914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def testIfElseExpr(self): 8924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # Test ifelse expressions in various cases 8934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def _checkeval(msg, ret): 8944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "helper to check that evaluation of expressions is done correctly" 8954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm print(x) 8964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return ret 8974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 8984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # the next line is not allowed anymore 8994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm #self.assertEqual([ x() for x in lambda: True, lambda: False if x() ], [True]) 9004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual([ x() for x in (lambda: True, lambda: False) if x() ], [True]) 9014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual([ x(False) for x in (lambda x: False if x else True, lambda x: True if x else False) if x(False) ], [True]) 9024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual((5 if 1 else _checkeval("check 1", 0)), 5) 9034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual((_checkeval("check 2", 0) if 0 else 5), 5) 9044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual((5 and 6 if 0 else 1), 1) 9054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(((5 and 6) if 0 else 1), 1) 9064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual((5 and (6 if 1 else 1)), 6) 9074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual((0 or _checkeval("check 3", 2) if 0 else 3), 3) 9084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual((1 or _checkeval("check 4", 2) if 1 else _checkeval("check 5", 3)), 1) 9094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual((0 or 5 if 1 else _checkeval("check 6", 3)), 5) 9104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual((not 5 if 1 else 1), False) 9114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual((not 5 if 0 else 1), 1) 9124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual((6 + 1 if 1 else 2), 7) 9134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual((6 - 1 if 1 else 2), 5) 9144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual((6 * 2 if 1 else 4), 12) 9154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual((6 / 2 if 1 else 3), 3) 9164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual((6 < 4 if 0 else 2), 2) 9174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 9184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 9194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmdef test_main(): 9204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm run_unittest(TokenTests, GrammarTests) 9214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 9224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmif __name__ == '__main__': 9234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm test_main() 924