AppPkg/Applications/Python/Python-2.7.2/Lib/lib2to3/tests/data/py3_test_grammar.py

   1 # Python test set -- part 1, grammar.
   2 # This just tests whether the parser accepts them all.
   3
   4 # NOTE: When you run this test as a script from the command line, you
   5 # get warnings about certain hex/oct constants.  Since those are
   6 # issued by the parser, you can't suppress them by adding a
   7 # filterwarnings() call to this module.  Therefore, to shut up the
   8 # regression test, the filterwarnings() call has been added to
   9 # regrtest.py.
  10
  11 from test.support import run_unittest, check_syntax_error
  12 import unittest
  13 import sys
  14 # testing import *
  15 from sys import *
  16
  17 class TokenTests(unittest.TestCase):
  18
  19     def testBackslash(self):
  20         # Backslash means line continuation:
  21         x = 1 \
  22         + 1
  23         self.assertEquals(x, 2, 'backslash for line continuation')
  24
  25         # Backslash does not means continuation in comments :\
  26         x = 0
  27         self.assertEquals(x, 0, 'backslash ending comment')
  28
  29     def testPlainIntegers(self):
  30         self.assertEquals(type(000), type(0))
  31         self.assertEquals(0xff, 255)
  32         self.assertEquals(0o377, 255)
  33         self.assertEquals(2147483647, 0o17777777777)
  34         self.assertEquals(0b1001, 9)
  35         # "0x" is not a valid literal
  36         self.assertRaises(SyntaxError, eval, "0x")
  37         from sys import maxsize
  38         if maxsize == 2147483647:
  39             self.assertEquals(-2147483647-1, -0o20000000000)
  40             # XXX -2147483648
  41             self.assert_(0o37777777777 > 0)
  42             self.assert_(0xffffffff > 0)
  43             self.assert_(0b1111111111111111111111111111111 > 0)
  44             for s in ('2147483648', '0o40000000000', '0x100000000',
  45                       '0b10000000000000000000000000000000'):
  46                 try:
  47                     x = eval(s)
  48                 except OverflowError:
  49                     self.fail("OverflowError on huge integer literal %r" % s)
  50         elif maxsize == 9223372036854775807:
  51             self.assertEquals(-9223372036854775807-1, -0o1000000000000000000000)
  52             self.assert_(0o1777777777777777777777 > 0)
  53             self.assert_(0xffffffffffffffff > 0)
  54             self.assert_(0b11111111111111111111111111111111111111111111111111111111111111 > 0)
  55             for s in '9223372036854775808', '0o2000000000000000000000', \
  56                      '0x10000000000000000', \
  57                      '0b100000000000000000000000000000000000000000000000000000000000000':
  58                 try:
  59                     x = eval(s)
  60                 except OverflowError:
  61                     self.fail("OverflowError on huge integer literal %r" % s)
  62         else:
  63             self.fail('Weird maxsize value %r' % maxsize)
  64
  65     def testLongIntegers(self):
  66         x = 0
  67         x = 0xffffffffffffffff
  68         x = 0Xffffffffffffffff
  69         x = 0o77777777777777777
  70         x = 0O77777777777777777
  71         x = 123456789012345678901234567890
  72         x = 0b100000000000000000000000000000000000000000000000000000000000000000000
  73         x = 0B111111111111111111111111111111111111111111111111111111111111111111111
  74
  75     def testFloats(self):
  76         x = 3.14
  77         x = 314.
  78         x = 0.314
  79         # XXX x = 000.314
  80         x = .314
  81         x = 3e14
  82         x = 3E14
  83         x = 3e-14
  84         x = 3e+14
  85         x = 3.e14
  86         x = .3e14
  87         x = 3.1e4
  88
  89     def testStringLiterals(self):
  90         x = ''; y = ""; self.assert_(len(x) == 0 and x == y)
  91         x = '\''; y = "'"; self.assert_(len(x) == 1 and x == y and ord(x) == 39)
  92         x = '"'; y = "\""; self.assert_(len(x) == 1 and x == y and ord(x) == 34)
  93         x = "doesn't \"shrink\" does it"
  94         y = 'doesn\'t "shrink" does it'
  95         self.assert_(len(x) == 24 and x == y)
  96         x = "does \"shrink\" doesn't it"
  97         y = 'does "shrink" doesn\'t it'
  98         self.assert_(len(x) == 24 and x == y)
  99         x = """
 100 The "quick"
 101 brown fox
 102 jumps over
 103 the 'lazy' dog.
 104 """
 105         y = '\nThe "quick"\nbrown fox\njumps over\nthe \'lazy\' dog.\n'
 106         self.assertEquals(x, y)
 107         y = '''
 108 The "quick"
 109 brown fox
 110 jumps over
 111 the 'lazy' dog.
 112 '''
 113         self.assertEquals(x, y)
 114         y = "\n\
 115 The \"quick\"\n\
 116 brown fox\n\
 117 jumps over\n\
 118 the 'lazy' dog.\n\
 119 "
 120         self.assertEquals(x, y)
 121         y = '\n\
 122 The \"quick\"\n\
 123 brown fox\n\
 124 jumps over\n\
 125 the \'lazy\' dog.\n\
 126 '
 127         self.assertEquals(x, y)
 128
 129     def testEllipsis(self):
 130         x = ...
 131         self.assert_(x is Ellipsis)
 132         self.assertRaises(SyntaxError, eval, ".. .")
 133
 134 class GrammarTests(unittest.TestCase):
 135
 136     # single_input: NEWLINE | simple_stmt | compound_stmt NEWLINE
 137     # XXX can't test in a script -- this rule is only used when interactive
 138
 139     # file_input: (NEWLINE | stmt)* ENDMARKER
 140     # Being tested as this very moment this very module
 141
 142     # expr_input: testlist NEWLINE
 143     # XXX Hard to test -- used only in calls to input()
 144
 145     def testEvalInput(self):
 146         # testlist ENDMARKER
 147         x = eval('1, 0 or 1')
 148
 149     def testFuncdef(self):
 150         ### [decorators] 'def' NAME parameters ['->' test] ':' suite
 151         ### decorator: '@' dotted_name [ '(' [arglist] ')' ] NEWLINE
 152         ### decorators: decorator+
 153         ### parameters: '(' [typedargslist] ')'
 154         ### typedargslist: ((tfpdef ['=' test] ',')*
 155         ###                ('*' [tfpdef] (',' tfpdef ['=' test])* [',' '**' tfpdef] | '**' tfpdef)
 156         ###                | tfpdef ['=' test] (',' tfpdef ['=' test])* [','])
 157         ### tfpdef: NAME [':' test]
 158         ### varargslist: ((vfpdef ['=' test] ',')*
 159         ###              ('*' [vfpdef] (',' vfpdef ['=' test])*  [',' '**' vfpdef] | '**' vfpdef)
 160         ###              | vfpdef ['=' test] (',' vfpdef ['=' test])* [','])
 161         ### vfpdef: NAME
 162         def f1(): pass
 163         f1()
 164         f1(*())
 165         f1(*(), **{})
 166         def f2(one_argument): pass
 167         def f3(two, arguments): pass
 168         self.assertEquals(f2.__code__.co_varnames, ('one_argument',))
 169         self.assertEquals(f3.__code__.co_varnames, ('two', 'arguments'))
 170         def a1(one_arg,): pass
 171         def a2(two, args,): pass
 172         def v0(*rest): pass
 173         def v1(a, *rest): pass
 174         def v2(a, b, *rest): pass
 175
 176         f1()
 177         f2(1)
 178         f2(1,)
 179         f3(1, 2)
 180         f3(1, 2,)
 181         v0()
 182         v0(1)
 183         v0(1,)
 184         v0(1,2)
 185         v0(1,2,3,4,5,6,7,8,9,0)
 186         v1(1)
 187         v1(1,)
 188         v1(1,2)
 189         v1(1,2,3)
 190         v1(1,2,3,4,5,6,7,8,9,0)
 191         v2(1,2)
 192         v2(1,2,3)
 193         v2(1,2,3,4)
 194         v2(1,2,3,4,5,6,7,8,9,0)
 195
 196         def d01(a=1): pass
 197         d01()
 198         d01(1)
 199         d01(*(1,))
 200         d01(**{'a':2})
 201         def d11(a, b=1): pass
 202         d11(1)
 203         d11(1, 2)
 204         d11(1, **{'b':2})
 205         def d21(a, b, c=1): pass
 206         d21(1, 2)
 207         d21(1, 2, 3)
 208         d21(*(1, 2, 3))
 209         d21(1, *(2, 3))
 210         d21(1, 2, *(3,))
 211         d21(1, 2, **{'c':3})
 212         def d02(a=1, b=2): pass
 213         d02()
 214         d02(1)
 215         d02(1, 2)
 216         d02(*(1, 2))
 217         d02(1, *(2,))
 218         d02(1, **{'b':2})
 219         d02(**{'a': 1, 'b': 2})
 220         def d12(a, b=1, c=2): pass
 221         d12(1)
 222         d12(1, 2)
 223         d12(1, 2, 3)
 224         def d22(a, b, c=1, d=2): pass
 225         d22(1, 2)
 226         d22(1, 2, 3)
 227         d22(1, 2, 3, 4)
 228         def d01v(a=1, *rest): pass
 229         d01v()
 230         d01v(1)
 231         d01v(1, 2)
 232         d01v(*(1, 2, 3, 4))
 233         d01v(*(1,))
 234         d01v(**{'a':2})
 235         def d11v(a, b=1, *rest): pass
 236         d11v(1)
 237         d11v(1, 2)
 238         d11v(1, 2, 3)
 239         def d21v(a, b, c=1, *rest): pass
 240         d21v(1, 2)
 241         d21v(1, 2, 3)
 242         d21v(1, 2, 3, 4)
 243         d21v(*(1, 2, 3, 4))
 244         d21v(1, 2, **{'c': 3})
 245         def d02v(a=1, b=2, *rest): pass
 246         d02v()
 247         d02v(1)
 248         d02v(1, 2)
 249         d02v(1, 2, 3)
 250         d02v(1, *(2, 3, 4))
 251         d02v(**{'a': 1, 'b': 2})
 252         def d12v(a, b=1, c=2, *rest): pass
 253         d12v(1)
 254         d12v(1, 2)
 255         d12v(1, 2, 3)
 256         d12v(1, 2, 3, 4)
 257         d12v(*(1, 2, 3, 4))
 258         d12v(1, 2, *(3, 4, 5))
 259         d12v(1, *(2,), **{'c': 3})
 260         def d22v(a, b, c=1, d=2, *rest): pass
 261         d22v(1, 2)
 262         d22v(1, 2, 3)
 263         d22v(1, 2, 3, 4)
 264         d22v(1, 2, 3, 4, 5)
 265         d22v(*(1, 2, 3, 4))
 266         d22v(1, 2, *(3, 4, 5))
 267         d22v(1, *(2, 3), **{'d': 4})
 268
 269         # keyword argument type tests
 270         try:
 271             str('x', **{b'foo':1 })
 272         except TypeError:
 273             pass
 274         else:
 275             self.fail('Bytes should not work as keyword argument names')
 276         # keyword only argument tests
 277         def pos0key1(*, key): return key
 278         pos0key1(key=100)
 279         def pos2key2(p1, p2, *, k1, k2=100): return p1,p2,k1,k2
 280         pos2key2(1, 2, k1=100)
 281         pos2key2(1, 2, k1=100, k2=200)
 282         pos2key2(1, 2, k2=100, k1=200)
 283         def pos2key2dict(p1, p2, *, k1=100, k2, **kwarg): return p1,p2,k1,k2,kwarg
 284         pos2key2dict(1,2,k2=100,tokwarg1=100,tokwarg2=200)
 285         pos2key2dict(1,2,tokwarg1=100,tokwarg2=200, k2=100)
 286
 287         # keyword arguments after *arglist
 288         def f(*args, **kwargs):
 289             return args, kwargs
 290         self.assertEquals(f(1, x=2, *[3, 4], y=5), ((1, 3, 4),
 291                                                     {'x':2, 'y':5}))
 292         self.assertRaises(SyntaxError, eval, "f(1, *(2,3), 4)")
 293         self.assertRaises(SyntaxError, eval, "f(1, x=2, *(3,4), x=5)")
 294
 295         # argument annotation tests
 296         def f(x) -> list: pass
 297         self.assertEquals(f.__annotations__, {'return': list})
 298         def f(x:int): pass
 299         self.assertEquals(f.__annotations__, {'x': int})
 300         def f(*x:str): pass
 301         self.assertEquals(f.__annotations__, {'x': str})
 302         def f(**x:float): pass
 303         self.assertEquals(f.__annotations__, {'x': float})
 304         def f(x, y:1+2): pass
 305         self.assertEquals(f.__annotations__, {'y': 3})
 306         def f(a, b:1, c:2, d): pass
 307         self.assertEquals(f.__annotations__, {'b': 1, 'c': 2})
 308         def f(a, b:1, c:2, d, e:3=4, f=5, *g:6): pass
 309         self.assertEquals(f.__annotations__,
 310                           {'b': 1, 'c': 2, 'e': 3, 'g': 6})
 311         def f(a, b:1, c:2, d, e:3=4, f=5, *g:6, h:7, i=8, j:9=10,
 312               **k:11) -> 12: pass
 313         self.assertEquals(f.__annotations__,
 314                           {'b': 1, 'c': 2, 'e': 3, 'g': 6, 'h': 7, 'j': 9,
 315                            'k': 11, 'return': 12})
 316         # Check for SF Bug #1697248 - mixing decorators and a return annotation
 317         def null(x): return x
 318         @null
 319         def f(x) -> list: pass
 320         self.assertEquals(f.__annotations__, {'return': list})
 321
 322         # test MAKE_CLOSURE with a variety of oparg's
 323         closure = 1
 324         def f(): return closure
 325         def f(x=1): return closure
 326         def f(*, k=1): return closure
 327         def f() -> int: return closure
 328
 329         # Check ast errors in *args and *kwargs
 330         check_syntax_error(self, "f(*g(1=2))")
 331         check_syntax_error(self, "f(**g(1=2))")
 332
 333     def testLambdef(self):
 334         ### lambdef: 'lambda' [varargslist] ':' test
 335         l1 = lambda : 0
 336         self.assertEquals(l1(), 0)
 337         l2 = lambda : a[d] # XXX just testing the expression
 338         l3 = lambda : [2 < x for x in [-1, 3, 0]]
 339         self.assertEquals(l3(), [0, 1, 0])
 340         l4 = lambda x = lambda y = lambda z=1 : z : y() : x()
 341         self.assertEquals(l4(), 1)
 342         l5 = lambda x, y, z=2: x + y + z
 343         self.assertEquals(l5(1, 2), 5)
 344         self.assertEquals(l5(1, 2, 3), 6)
 345         check_syntax_error(self, "lambda x: x = 2")
 346         check_syntax_error(self, "lambda (None,): None")
 347         l6 = lambda x, y, *, k=20: x+y+k
 348         self.assertEquals(l6(1,2), 1+2+20)
 349         self.assertEquals(l6(1,2,k=10), 1+2+10)
 350
 351
 352     ### stmt: simple_stmt | compound_stmt
 353     # Tested below
 354
 355     def testSimpleStmt(self):
 356         ### simple_stmt: small_stmt (';' small_stmt)* [';']
 357         x = 1; pass; del x
 358         def foo():
 359             # verify statements that end with semi-colons
 360             x = 1; pass; del x;
 361         foo()
 362
 363     ### small_stmt: expr_stmt | pass_stmt | del_stmt | flow_stmt | import_stmt | global_stmt | access_stmt
 364     # Tested below
 365
 366     def testExprStmt(self):
 367         # (exprlist '=')* exprlist
 368         1
 369         1, 2, 3
 370         x = 1
 371         x = 1, 2, 3
 372         x = y = z = 1, 2, 3
 373         x, y, z = 1, 2, 3
 374         abc = a, b, c = x, y, z = xyz = 1, 2, (3, 4)
 375
 376         check_syntax_error(self, "x + 1 = 1")
 377         check_syntax_error(self, "a + 1 = b + 2")
 378
 379     def testDelStmt(self):
 380         # 'del' exprlist
 381         abc = [1,2,3]
 382         x, y, z = abc
 383         xyz = x, y, z
 384
 385         del abc
 386         del x, y, (z, xyz)
 387
 388     def testPassStmt(self):
 389         # 'pass'
 390         pass
 391
 392     # flow_stmt: break_stmt | continue_stmt | return_stmt | raise_stmt
 393     # Tested below
 394
 395     def testBreakStmt(self):
 396         # 'break'
 397         while 1: break
 398
 399     def testContinueStmt(self):
 400         # 'continue'
 401         i = 1
 402         while i: i = 0; continue
 403
 404         msg = ""
 405         while not msg:
 406             msg = "ok"
 407             try:
 408                 continue
 409                 msg = "continue failed to continue inside try"
 410             except:
 411                 msg = "continue inside try called except block"
 412         if msg != "ok":
 413             self.fail(msg)
 414
 415         msg = ""
 416         while not msg:
 417             msg = "finally block not called"
 418             try:
 419                 continue
 420             finally:
 421                 msg = "ok"
 422         if msg != "ok":
 423             self.fail(msg)
 424
 425     def test_break_continue_loop(self):
 426         # This test warrants an explanation. It is a test specifically for SF bugs
 427         # #463359 and #462937. The bug is that a 'break' statement executed or
 428         # exception raised inside a try/except inside a loop, *after* a continue
 429         # statement has been executed in that loop, will cause the wrong number of
 430         # arguments to be popped off the stack and the instruction pointer reset to
 431         # a very small number (usually 0.) Because of this, the following test
 432         # *must* written as a function, and the tracking vars *must* be function
 433         # arguments with default values. Otherwise, the test will loop and loop.
 434
 435         def test_inner(extra_burning_oil = 1, count=0):
 436             big_hippo = 2
 437             while big_hippo:
 438                 count += 1
 439                 try:
 440                     if extra_burning_oil and big_hippo == 1:
 441                         extra_burning_oil -= 1
 442                         break
 443                     big_hippo -= 1
 444                     continue
 445                 except:
 446                     raise
 447             if count > 2 or big_hippo != 1:
 448                 self.fail("continue then break in try/except in loop broken!")
 449         test_inner()
 450
 451     def testReturn(self):
 452         # 'return' [testlist]
 453         def g1(): return
 454         def g2(): return 1
 455         g1()
 456         x = g2()
 457         check_syntax_error(self, "class foo:return 1")
 458
 459     def testYield(self):
 460         check_syntax_error(self, "class foo:yield 1")
 461
 462     def testRaise(self):
 463         # 'raise' test [',' test]
 464         try: raise RuntimeError('just testing')
 465         except RuntimeError: pass
 466         try: raise KeyboardInterrupt
 467         except KeyboardInterrupt: pass
 468
 469     def testImport(self):
 470         # 'import' dotted_as_names
 471         import sys
 472         import time, sys
 473         # 'from' dotted_name 'import' ('*' | '(' import_as_names ')' | import_as_names)
 474         from time import time
 475         from time import (time)
 476         # not testable inside a function, but already done at top of the module
 477         # from sys import *
 478         from sys import path, argv
 479         from sys import (path, argv)
 480         from sys import (path, argv,)
 481
 482     def testGlobal(self):
 483         # 'global' NAME (',' NAME)*
 484         global a
 485         global a, b
 486         global one, two, three, four, five, six, seven, eight, nine, ten
 487
 488     def testNonlocal(self):
 489         # 'nonlocal' NAME (',' NAME)*
 490         x = 0
 491         y = 0
 492         def f():
 493             nonlocal x
 494             nonlocal x, y
 495
 496     def testAssert(self):
 497         # assert_stmt: 'assert' test [',' test]
 498         assert 1
 499         assert 1, 1
 500         assert lambda x:x
 501         assert 1, lambda x:x+1
 502         try:
 503             assert 0, "msg"
 504         except AssertionError as e:
 505             self.assertEquals(e.args[0], "msg")
 506         else:
 507             if __debug__:
 508                 self.fail("AssertionError not raised by assert 0")
 509
 510     ### compound_stmt: if_stmt | while_stmt | for_stmt | try_stmt | funcdef | classdef
 511     # Tested below
 512
 513     def testIf(self):
 514         # 'if' test ':' suite ('elif' test ':' suite)* ['else' ':' suite]
 515         if 1: pass
 516         if 1: pass
 517         else: pass
 518         if 0: pass
 519         elif 0: pass
 520         if 0: pass
 521         elif 0: pass
 522         elif 0: pass
 523         elif 0: pass
 524         else: pass
 525
 526     def testWhile(self):
 527         # 'while' test ':' suite ['else' ':' suite]
 528         while 0: pass
 529         while 0: pass
 530         else: pass
 531
 532         # Issue1920: "while 0" is optimized away,
 533         # ensure that the "else" clause is still present.
 534         x = 0
 535         while 0:
 536             x = 1
 537         else:
 538             x = 2
 539         self.assertEquals(x, 2)
 540
 541     def testFor(self):
 542         # 'for' exprlist 'in' exprlist ':' suite ['else' ':' suite]
 543         for i in 1, 2, 3: pass
 544         for i, j, k in (): pass
 545         else: pass
 546         class Squares:
 547             def __init__(self, max):
 548                 self.max = max
 549                 self.sofar = []
 550             def __len__(self): return len(self.sofar)
 551             def __getitem__(self, i):
 552                 if not 0 <= i < self.max: raise IndexError
 553                 n = len(self.sofar)
 554                 while n <= i:
 555                     self.sofar.append(n*n)
 556                     n = n+1
 557                 return self.sofar[i]
 558         n = 0
 559         for x in Squares(10): n = n+x
 560         if n != 285:
 561             self.fail('for over growing sequence')
 562
 563         result = []
 564         for x, in [(1,), (2,), (3,)]:
 565             result.append(x)
 566         self.assertEqual(result, [1, 2, 3])
 567
 568     def testTry(self):
 569         ### try_stmt: 'try' ':' suite (except_clause ':' suite)+ ['else' ':' suite]
 570         ###         | 'try' ':' suite 'finally' ':' suite
 571         ### except_clause: 'except' [expr ['as' expr]]
 572         try:
 573             1/0
 574         except ZeroDivisionError:
 575             pass
 576         else:
 577             pass
 578         try: 1/0
 579         except EOFError: pass
 580         except TypeError as msg: pass
 581         except RuntimeError as msg: pass
 582         except: pass
 583         else: pass
 584         try: 1/0
 585         except (EOFError, TypeError, ZeroDivisionError): pass
 586         try: 1/0
 587         except (EOFError, TypeError, ZeroDivisionError) as msg: pass
 588         try: pass
 589         finally: pass
 590
 591     def testSuite(self):
 592         # simple_stmt | NEWLINE INDENT NEWLINE* (stmt NEWLINE*)+ DEDENT
 593         if 1: pass
 594         if 1:
 595             pass
 596         if 1:
 597             #
 598             #
 599             #
 600             pass
 601             pass
 602             #
 603             pass
 604             #
 605
 606     def testTest(self):
 607         ### and_test ('or' and_test)*
 608         ### and_test: not_test ('and' not_test)*
 609         ### not_test: 'not' not_test | comparison
 610         if not 1: pass
 611         if 1 and 1: pass
 612         if 1 or 1: pass
 613         if not not not 1: pass
 614         if not 1 and 1 and 1: pass
 615         if 1 and 1 or 1 and 1 and 1 or not 1 and 1: pass
 616
 617     def testComparison(self):
 618         ### comparison: expr (comp_op expr)*
 619         ### comp_op: '<'|'>'|'=='|'>='|'<='|'!='|'in'|'not' 'in'|'is'|'is' 'not'
 620         if 1: pass
 621         x = (1 == 1)
 622         if 1 == 1: pass
 623         if 1 != 1: pass
 624         if 1 < 1: pass
 625         if 1 > 1: pass
 626         if 1 <= 1: pass
 627         if 1 >= 1: pass
 628         if 1 is 1: pass
 629         if 1 is not 1: pass
 630         if 1 in (): pass
 631         if 1 not in (): pass
 632         if 1 < 1 > 1 == 1 >= 1 <= 1 != 1 in 1 not in 1 is 1 is not 1: pass
 633
 634     def testBinaryMaskOps(self):
 635         x = 1 & 1
 636         x = 1 ^ 1
 637         x = 1 | 1
 638
 639     def testShiftOps(self):
 640         x = 1 << 1
 641         x = 1 >> 1
 642         x = 1 << 1 >> 1
 643
 644     def testAdditiveOps(self):
 645         x = 1
 646         x = 1 + 1
 647         x = 1 - 1 - 1
 648         x = 1 - 1 + 1 - 1 + 1
 649
 650     def testMultiplicativeOps(self):
 651         x = 1 * 1
 652         x = 1 / 1
 653         x = 1 % 1
 654         x = 1 / 1 * 1 % 1
 655
 656     def testUnaryOps(self):
 657         x = +1
 658         x = -1
 659         x = ~1
 660         x = ~1 ^ 1 & 1 | 1 & 1 ^ -1
 661         x = -1*1/1 + 1*1 - ---1*1
 662
 663     def testSelectors(self):
 664         ### trailer: '(' [testlist] ')' | '[' subscript ']' | '.' NAME
 665         ### subscript: expr | [expr] ':' [expr]
 666
 667         import sys, time
 668         c = sys.path[0]
 669         x = time.time()
 670         x = sys.modules['time'].time()
 671         a = '01234'
 672         c = a[0]
 673         c = a[-1]
 674         s = a[0:5]
 675         s = a[:5]
 676         s = a[0:]
 677         s = a[:]
 678         s = a[-5:]
 679         s = a[:-1]
 680         s = a[-4:-3]
 681         # A rough test of SF bug 1333982.  http://python.org/sf/1333982
 682         # The testing here is fairly incomplete.
 683         # Test cases should include: commas with 1 and 2 colons
 684         d = {}
 685         d[1] = 1
 686         d[1,] = 2
 687         d[1,2] = 3
 688         d[1,2,3] = 4
 689         L = list(d)
 690         L.sort(key=lambda x: x if isinstance(x, tuple) else ())
 691         self.assertEquals(str(L), '[1, (1,), (1, 2), (1, 2, 3)]')
 692
 693     def testAtoms(self):
 694         ### atom: '(' [testlist] ')' | '[' [testlist] ']' | '{' [dictsetmaker] '}' | NAME | NUMBER | STRING
 695         ### dictsetmaker: (test ':' test (',' test ':' test)* [',']) | (test (',' test)* [','])
 696
 697         x = (1)
 698         x = (1 or 2 or 3)
 699         x = (1 or 2 or 3, 2, 3)
 700
 701         x = []
 702         x = [1]
 703         x = [1 or 2 or 3]
 704         x = [1 or 2 or 3, 2, 3]
 705         x = []
 706
 707         x = {}
 708         x = {'one': 1}
 709         x = {'one': 1,}
 710         x = {'one' or 'two': 1 or 2}
 711         x = {'one': 1, 'two': 2}
 712         x = {'one': 1, 'two': 2,}
 713         x = {'one': 1, 'two': 2, 'three': 3, 'four': 4, 'five': 5, 'six': 6}
 714
 715         x = {'one'}
 716         x = {'one', 1,}
 717         x = {'one', 'two', 'three'}
 718         x = {2, 3, 4,}
 719
 720         x = x
 721         x = 'x'
 722         x = 123
 723
 724     ### exprlist: expr (',' expr)* [',']
 725     ### testlist: test (',' test)* [',']
 726     # These have been exercised enough above
 727
 728     def testClassdef(self):
 729         # 'class' NAME ['(' [testlist] ')'] ':' suite
 730         class B: pass
 731         class B2(): pass
 732         class C1(B): pass
 733         class C2(B): pass
 734         class D(C1, C2, B): pass
 735         class C:
 736             def meth1(self): pass
 737             def meth2(self, arg): pass
 738             def meth3(self, a1, a2): pass
 739
 740         # decorator: '@' dotted_name [ '(' [arglist] ')' ] NEWLINE
 741         # decorators: decorator+
 742         # decorated: decorators (classdef | funcdef)
 743         def class_decorator(x): return x
 744         @class_decorator
 745         class G: pass
 746
 747     def testDictcomps(self):
 748         # dictorsetmaker: ( (test ':' test (comp_for |
 749         #                                   (',' test ':' test)* [','])) |
 750         #                   (test (comp_for | (',' test)* [','])) )
 751         nums = [1, 2, 3]
 752         self.assertEqual({i:i+1 for i in nums}, {1: 2, 2: 3, 3: 4})
 753
 754     def testListcomps(self):
 755         # list comprehension tests
 756         nums = [1, 2, 3, 4, 5]
 757         strs = ["Apple", "Banana", "Coconut"]
 758         spcs = ["  Apple", " Banana ", "Coco  nut  "]
 759
 760         self.assertEqual([s.strip() for s in spcs], ['Apple', 'Banana', 'Coco  nut'])
 761         self.assertEqual([3 * x for x in nums], [3, 6, 9, 12, 15])
 762         self.assertEqual([x for x in nums if x > 2], [3, 4, 5])
 763         self.assertEqual([(i, s) for i in nums for s in strs],
 764                          [(1, 'Apple'), (1, 'Banana'), (1, 'Coconut'),
 765                           (2, 'Apple'), (2, 'Banana'), (2, 'Coconut'),
 766                           (3, 'Apple'), (3, 'Banana'), (3, 'Coconut'),
 767                           (4, 'Apple'), (4, 'Banana'), (4, 'Coconut'),
 768                           (5, 'Apple'), (5, 'Banana'), (5, 'Coconut')])
 769         self.assertEqual([(i, s) for i in nums for s in [f for f in strs if "n" in f]],
 770                          [(1, 'Banana'), (1, 'Coconut'), (2, 'Banana'), (2, 'Coconut'),
 771                           (3, 'Banana'), (3, 'Coconut'), (4, 'Banana'), (4, 'Coconut'),
 772                           (5, 'Banana'), (5, 'Coconut')])
 773         self.assertEqual([(lambda a:[a**i for i in range(a+1)])(j) for j in range(5)],
 774                          [[1], [1, 1], [1, 2, 4], [1, 3, 9, 27], [1, 4, 16, 64, 256]])
 775
 776         def test_in_func(l):
 777             return [0 < x < 3 for x in l if x > 2]
 778
 779         self.assertEqual(test_in_func(nums), [False, False, False])
 780
 781         def test_nested_front():
 782             self.assertEqual([[y for y in [x, x + 1]] for x in [1,3,5]],
 783                              [[1, 2], [3, 4], [5, 6]])
 784
 785         test_nested_front()
 786
 787         check_syntax_error(self, "[i, s for i in nums for s in strs]")
 788         check_syntax_error(self, "[x if y]")
 789
 790         suppliers = [
 791           (1, "Boeing"),
 792           (2, "Ford"),
 793           (3, "Macdonalds")
 794         ]
 795
 796         parts = [
 797           (10, "Airliner"),
 798           (20, "Engine"),
 799           (30, "Cheeseburger")
 800         ]
 801
 802         suppart = [
 803           (1, 10), (1, 20), (2, 20), (3, 30)
 804         ]
 805
 806         x = [
 807           (sname, pname)
 808             for (sno, sname) in suppliers
 809               for (pno, pname) in parts
 810                 for (sp_sno, sp_pno) in suppart
 811                   if sno == sp_sno and pno == sp_pno
 812         ]
 813
 814         self.assertEqual(x, [('Boeing', 'Airliner'), ('Boeing', 'Engine'), ('Ford', 'Engine'),
 815                              ('Macdonalds', 'Cheeseburger')])
 816
 817     def testGenexps(self):
 818         # generator expression tests
 819         g = ([x for x in range(10)] for x in range(1))
 820         self.assertEqual(next(g), [x for x in range(10)])
 821         try:
 822             next(g)
 823             self.fail('should produce StopIteration exception')
 824         except StopIteration:
 825             pass
 826
 827         a = 1
 828         try:
 829             g = (a for d in a)
 830             next(g)
 831             self.fail('should produce TypeError')
 832         except TypeError:
 833             pass
 834
 835         self.assertEqual(list((x, y) for x in 'abcd' for y in 'abcd'), [(x, y) for x in 'abcd' for y in 'abcd'])
 836         self.assertEqual(list((x, y) for x in 'ab' for y in 'xy'), [(x, y) for x in 'ab' for y in 'xy'])
 837
 838         a = [x for x in range(10)]
 839         b = (x for x in (y for y in a))
 840         self.assertEqual(sum(b), sum([x for x in range(10)]))
 841
 842         self.assertEqual(sum(x**2 for x in range(10)), sum([x**2 for x in range(10)]))
 843         self.assertEqual(sum(x*x for x in range(10) if x%2), sum([x*x for x in range(10) if x%2]))
 844         self.assertEqual(sum(x for x in (y for y in range(10))), sum([x for x in range(10)]))
 845         self.assertEqual(sum(x for x in (y for y in (z for z in range(10)))), sum([x for x in range(10)]))
 846         self.assertEqual(sum(x for x in [y for y in (z for z in range(10))]), sum([x for x in range(10)]))
 847         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)]))
 848         self.assertEqual(sum(x for x in (y for y in (z for z in range(10) if True) if False) if True), 0)
 849         check_syntax_error(self, "foo(x for x in range(10), 100)")
 850         check_syntax_error(self, "foo(100, x for x in range(10))")
 851
 852     def testComprehensionSpecials(self):
 853         # test for outmost iterable precomputation
 854         x = 10; g = (i for i in range(x)); x = 5
 855         self.assertEqual(len(list(g)), 10)
 856
 857         # This should hold, since we're only precomputing outmost iterable.
 858         x = 10; t = False; g = ((i,j) for i in range(x) if t for j in range(x))
 859         x = 5; t = True;
 860         self.assertEqual([(i,j) for i in range(10) for j in range(5)], list(g))
 861
 862         # Grammar allows multiple adjacent 'if's in listcomps and genexps,
 863         # even though it's silly. Make sure it works (ifelse broke this.)
 864         self.assertEqual([ x for x in range(10) if x % 2 if x % 3 ], [1, 5, 7])
 865         self.assertEqual(list(x for x in range(10) if x % 2 if x % 3), [1, 5, 7])
 866
 867         # verify unpacking single element tuples in listcomp/genexp.
 868         self.assertEqual([x for x, in [(4,), (5,), (6,)]], [4, 5, 6])
 869         self.assertEqual(list(x for x, in [(7,), (8,), (9,)]), [7, 8, 9])
 870
 871     def test_with_statement(self):
 872         class manager(object):
 873             def __enter__(self):
 874                 return (1, 2)
 875             def __exit__(self, *args):
 876                 pass
 877
 878         with manager():
 879             pass
 880         with manager() as x:
 881             pass
 882         with manager() as (x, y):
 883             pass
 884         with manager(), manager():
 885             pass
 886         with manager() as x, manager() as y:
 887             pass
 888         with manager() as x, manager():
 889             pass
 890
 891     def testIfElseExpr(self):
 892         # Test ifelse expressions in various cases
 893         def _checkeval(msg, ret):
 894             "helper to check that evaluation of expressions is done correctly"
 895             print(x)
 896             return ret
 897
 898         # the next line is not allowed anymore
 899         #self.assertEqual([ x() for x in lambda: True, lambda: False if x() ], [True])
 900         self.assertEqual([ x() for x in (lambda: True, lambda: False) if x() ], [True])
 901         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])
 902         self.assertEqual((5 if 1 else _checkeval("check 1", 0)), 5)
 903         self.assertEqual((_checkeval("check 2", 0) if 0 else 5), 5)
 904         self.assertEqual((5 and 6 if 0 else 1), 1)
 905         self.assertEqual(((5 and 6) if 0 else 1), 1)
 906         self.assertEqual((5 and (6 if 1 else 1)), 6)
 907         self.assertEqual((0 or _checkeval("check 3", 2) if 0 else 3), 3)
 908         self.assertEqual((1 or _checkeval("check 4", 2) if 1 else _checkeval("check 5", 3)), 1)
 909         self.assertEqual((0 or 5 if 1 else _checkeval("check 6", 3)), 5)
 910         self.assertEqual((not 5 if 1 else 1), False)
 911         self.assertEqual((not 5 if 0 else 1), 1)
 912         self.assertEqual((6 + 1 if 1 else 2), 7)
 913         self.assertEqual((6 - 1 if 1 else 2), 5)
 914         self.assertEqual((6 * 2 if 1 else 4), 12)
 915         self.assertEqual((6 / 2 if 1 else 3), 3)
 916         self.assertEqual((6 < 4 if 0 else 2), 2)
 917
 918
 919 def test_main():
 920     run_unittest(TokenTests, GrammarTests)
 921
 922 if __name__ == '__main__':
 923     test_main()