AppPkg/Applications/Python/Python-2.7.2/Lib/test/test_grammar.py

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