source: python/trunk/Lib/test/test_grammar.py

Last change on this file was 391, checked in by dmik, 11 years ago

python: Merge vendor 2.7.6 to trunk.
  • Property svn:eol-style set to native
File size: 31.9 KB
Line 
1# Python test set -- part 1, grammar.
2# This just tests whether the parser accepts them all.
3
4from test.test_support import run_unittest, check_syntax_error, \
5 check_py3k_warnings
6import unittest
7import sys
8# testing import *
9from sys import *
10
11
12class 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 = """
89The "quick"
90brown fox
91jumps over
92the 'lazy' dog.
93"""
94 y = '\nThe "quick"\nbrown fox\njumps over\nthe \'lazy\' dog.\n'
95 self.assertEqual(x, y)
96 y = '''
97The "quick"
98brown fox
99jumps over
100the 'lazy' dog.
101'''
102 self.assertEqual(x, y)
103 y = "\n\
104The \"quick\"\n\
105brown fox\n\
106jumps over\n\
107the 'lazy' dog.\n\
108"
109 self.assertEqual(x, y)
110 y = '\n\
111The \"quick\"\n\
112brown fox\n\
113jumps over\n\
114the \'lazy\' dog.\n\
115'
116 self.assertEqual(x, y)
117
118
119class 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(), '''\
3931 2 3
3941 2 3
3951 1 1
3961 2 3
3971 2 3
3981 1 1
399hello 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
555 try:
556 assert True
557 except AssertionError as e:
558 self.fail("'assert True' should not have raised an AssertionError")
559
560 try:
561 assert True, 'this should always pass'
562 except AssertionError as e:
563 self.fail("'assert True, msg' should not have "
564 "raised an AssertionError")
565
566 # these tests fail if python is run with -O, so check __debug__
567 @unittest.skipUnless(__debug__, "Won't work if __debug__ is False")
568 def testAssert2(self):
569 try:
570 assert 0, "msg"
571 except AssertionError, e:
572 self.assertEqual(e.args[0], "msg")
573 else:
574 self.fail("AssertionError not raised by assert 0")
575
576 try:
577 assert False
578 except AssertionError as e:
579 self.assertEqual(len(e.args), 0)
580 else:
581 self.fail("AssertionError not raised by 'assert False'")
582
583
584 ### compound_stmt: if_stmt | while_stmt | for_stmt | try_stmt | funcdef | classdef
585 # Tested below
586
587 def testIf(self):
588 # 'if' test ':' suite ('elif' test ':' suite)* ['else' ':' suite]
589 if 1: pass
590 if 1: pass
591 else: pass
592 if 0: pass
593 elif 0: pass
594 if 0: pass
595 elif 0: pass
596 elif 0: pass
597 elif 0: pass
598 else: pass
599
600 def testWhile(self):
601 # 'while' test ':' suite ['else' ':' suite]
602 while 0: pass
603 while 0: pass
604 else: pass
605
606 # Issue1920: "while 0" is optimized away,
607 # ensure that the "else" clause is still present.
608 x = 0
609 while 0:
610 x = 1
611 else:
612 x = 2
613 self.assertEqual(x, 2)
614
615 def testFor(self):
616 # 'for' exprlist 'in' exprlist ':' suite ['else' ':' suite]
617 for i in 1, 2, 3: pass
618 for i, j, k in (): pass
619 else: pass
620 class Squares:
621 def __init__(self, max):
622 self.max = max
623 self.sofar = []
624 def __len__(self): return len(self.sofar)
625 def __getitem__(self, i):
626 if not 0 <= i < self.max: raise IndexError
627 n = len(self.sofar)
628 while n <= i:
629 self.sofar.append(n*n)
630 n = n+1
631 return self.sofar[i]
632 n = 0
633 for x in Squares(10): n = n+x
634 if n != 285:
635 self.fail('for over growing sequence')
636
637 result = []
638 for x, in [(1,), (2,), (3,)]:
639 result.append(x)
640 self.assertEqual(result, [1, 2, 3])
641
642 def testTry(self):
643 ### try_stmt: 'try' ':' suite (except_clause ':' suite)+ ['else' ':' suite]
644 ### | 'try' ':' suite 'finally' ':' suite
645 ### except_clause: 'except' [expr [('as' | ',') expr]]
646 try:
647 1/0
648 except ZeroDivisionError:
649 pass
650 else:
651 pass
652 try: 1/0
653 except EOFError: pass
654 except TypeError as msg: pass
655 except RuntimeError, msg: pass
656 except: pass
657 else: pass
658 try: 1/0
659 except (EOFError, TypeError, ZeroDivisionError): pass
660 try: 1/0
661 except (EOFError, TypeError, ZeroDivisionError), msg: pass
662 try: pass
663 finally: pass
664
665 def testSuite(self):
666 # simple_stmt | NEWLINE INDENT NEWLINE* (stmt NEWLINE*)+ DEDENT
667 if 1: pass
668 if 1:
669 pass
670 if 1:
671 #
672 #
673 #
674 pass
675 pass
676 #
677 pass
678 #
679
680 def testTest(self):
681 ### and_test ('or' and_test)*
682 ### and_test: not_test ('and' not_test)*
683 ### not_test: 'not' not_test | comparison
684 if not 1: pass
685 if 1 and 1: pass
686 if 1 or 1: pass
687 if not not not 1: pass
688 if not 1 and 1 and 1: pass
689 if 1 and 1 or 1 and 1 and 1 or not 1 and 1: pass
690
691 def testComparison(self):
692 ### comparison: expr (comp_op expr)*
693 ### comp_op: '<'|'>'|'=='|'>='|'<='|'<>'|'!='|'in'|'not' 'in'|'is'|'is' 'not'
694 if 1: pass
695 x = (1 == 1)
696 if 1 == 1: pass
697 if 1 != 1: pass
698 if 1 < 1: pass
699 if 1 > 1: pass
700 if 1 <= 1: pass
701 if 1 >= 1: pass
702 if 1 is 1: pass
703 if 1 is not 1: pass
704 if 1 in (): pass
705 if 1 not in (): pass
706 if 1 < 1 > 1 == 1 >= 1 <= 1 != 1 in 1 not in 1 is 1 is not 1: pass
707 # Silence Py3k warning
708 if eval('1 <> 1'): pass
709 if eval('1 < 1 > 1 == 1 >= 1 <= 1 <> 1 != 1 in 1 not in 1 is 1 is not 1'): pass
710
711 def testBinaryMaskOps(self):
712 x = 1 & 1
713 x = 1 ^ 1
714 x = 1 | 1
715
716 def testShiftOps(self):
717 x = 1 << 1
718 x = 1 >> 1
719 x = 1 << 1 >> 1
720
721 def testAdditiveOps(self):
722 x = 1
723 x = 1 + 1
724 x = 1 - 1 - 1
725 x = 1 - 1 + 1 - 1 + 1
726
727 def testMultiplicativeOps(self):
728 x = 1 * 1
729 x = 1 / 1
730 x = 1 % 1
731 x = 1 / 1 * 1 % 1
732
733 def testUnaryOps(self):
734 x = +1
735 x = -1
736 x = ~1
737 x = ~1 ^ 1 & 1 | 1 & 1 ^ -1
738 x = -1*1/1 + 1*1 - ---1*1
739
740 def testSelectors(self):
741 ### trailer: '(' [testlist] ')' | '[' subscript ']' | '.' NAME
742 ### subscript: expr | [expr] ':' [expr]
743
744 import sys, time
745 c = sys.path[0]
746 x = time.time()
747 x = sys.modules['time'].time()
748 a = '01234'
749 c = a[0]
750 c = a[-1]
751 s = a[0:5]
752 s = a[:5]
753 s = a[0:]
754 s = a[:]
755 s = a[-5:]
756 s = a[:-1]
757 s = a[-4:-3]
758 # A rough test of SF bug 1333982. http://python.org/sf/1333982
759 # The testing here is fairly incomplete.
760 # Test cases should include: commas with 1 and 2 colons
761 d = {}
762 d[1] = 1
763 d[1,] = 2
764 d[1,2] = 3
765 d[1,2,3] = 4
766 L = list(d)
767 L.sort()
768 self.assertEqual(str(L), '[1, (1,), (1, 2), (1, 2, 3)]')
769
770 def testAtoms(self):
771 ### atom: '(' [testlist] ')' | '[' [testlist] ']' | '{' [dictmaker] '}' | '`' testlist '`' | NAME | NUMBER | STRING
772 ### dictorsetmaker: (test ':' test (',' test ':' test)* [',']) | (test (',' test)* [','])
773
774 x = (1)
775 x = (1 or 2 or 3)
776 x = (1 or 2 or 3, 2, 3)
777
778 x = []
779 x = [1]
780 x = [1 or 2 or 3]
781 x = [1 or 2 or 3, 2, 3]
782 x = []
783
784 x = {}
785 x = {'one': 1}
786 x = {'one': 1,}
787 x = {'one' or 'two': 1 or 2}
788 x = {'one': 1, 'two': 2}
789 x = {'one': 1, 'two': 2,}
790 x = {'one': 1, 'two': 2, 'three': 3, 'four': 4, 'five': 5, 'six': 6}
791
792 x = {'one'}
793 x = {'one', 1,}
794 x = {'one', 'two', 'three'}
795 x = {2, 3, 4,}
796
797 # Silence Py3k warning
798 x = eval('`x`')
799 x = eval('`1 or 2 or 3`')
800 self.assertEqual(eval('`1,2`'), '(1, 2)')
801
802 x = x
803 x = 'x'
804 x = 123
805
806 ### exprlist: expr (',' expr)* [',']
807 ### testlist: test (',' test)* [',']
808 # These have been exercised enough above
809
810 def testClassdef(self):
811 # 'class' NAME ['(' [testlist] ')'] ':' suite
812 class B: pass
813 class B2(): pass
814 class C1(B): pass
815 class C2(B): pass
816 class D(C1, C2, B): pass
817 class C:
818 def meth1(self): pass
819 def meth2(self, arg): pass
820 def meth3(self, a1, a2): pass
821 # decorator: '@' dotted_name [ '(' [arglist] ')' ] NEWLINE
822 # decorators: decorator+
823 # decorated: decorators (classdef | funcdef)
824 def class_decorator(x):
825 x.decorated = True
826 return x
827 @class_decorator
828 class G:
829 pass
830 self.assertEqual(G.decorated, True)
831
832 def testDictcomps(self):
833 # dictorsetmaker: ( (test ':' test (comp_for |
834 # (',' test ':' test)* [','])) |
835 # (test (comp_for | (',' test)* [','])) )
836 nums = [1, 2, 3]
837 self.assertEqual({i:i+1 for i in nums}, {1: 2, 2: 3, 3: 4})
838
839 def testListcomps(self):
840 # list comprehension tests
841 nums = [1, 2, 3, 4, 5]
842 strs = ["Apple", "Banana", "Coconut"]
843 spcs = [" Apple", " Banana ", "Coco nut "]
844
845 self.assertEqual([s.strip() for s in spcs], ['Apple', 'Banana', 'Coco nut'])
846 self.assertEqual([3 * x for x in nums], [3, 6, 9, 12, 15])
847 self.assertEqual([x for x in nums if x > 2], [3, 4, 5])
848 self.assertEqual([(i, s) for i in nums for s in strs],
849 [(1, 'Apple'), (1, 'Banana'), (1, 'Coconut'),
850 (2, 'Apple'), (2, 'Banana'), (2, 'Coconut'),
851 (3, 'Apple'), (3, 'Banana'), (3, 'Coconut'),
852 (4, 'Apple'), (4, 'Banana'), (4, 'Coconut'),
853 (5, 'Apple'), (5, 'Banana'), (5, 'Coconut')])
854 self.assertEqual([(i, s) for i in nums for s in [f for f in strs if "n" in f]],
855 [(1, 'Banana'), (1, 'Coconut'), (2, 'Banana'), (2, 'Coconut'),
856 (3, 'Banana'), (3, 'Coconut'), (4, 'Banana'), (4, 'Coconut'),
857 (5, 'Banana'), (5, 'Coconut')])
858 self.assertEqual([(lambda a:[a**i for i in range(a+1)])(j) for j in range(5)],
859 [[1], [1, 1], [1, 2, 4], [1, 3, 9, 27], [1, 4, 16, 64, 256]])
860
861 def test_in_func(l):
862 return [None < x < 3 for x in l if x > 2]
863
864 self.assertEqual(test_in_func(nums), [False, False, False])
865
866 def test_nested_front():
867 self.assertEqual([[y for y in [x, x + 1]] for x in [1,3,5]],
868 [[1, 2], [3, 4], [5, 6]])
869
870 test_nested_front()
871
872 check_syntax_error(self, "[i, s for i in nums for s in strs]")
873 check_syntax_error(self, "[x if y]")
874
875 suppliers = [
876 (1, "Boeing"),
877 (2, "Ford"),
878 (3, "Macdonalds")
879 ]
880
881 parts = [
882 (10, "Airliner"),
883 (20, "Engine"),
884 (30, "Cheeseburger")
885 ]
886
887 suppart = [
888 (1, 10), (1, 20), (2, 20), (3, 30)
889 ]
890
891 x = [
892 (sname, pname)
893 for (sno, sname) in suppliers
894 for (pno, pname) in parts
895 for (sp_sno, sp_pno) in suppart
896 if sno == sp_sno and pno == sp_pno
897 ]
898
899 self.assertEqual(x, [('Boeing', 'Airliner'), ('Boeing', 'Engine'), ('Ford', 'Engine'),
900 ('Macdonalds', 'Cheeseburger')])
901
902 def testGenexps(self):
903 # generator expression tests
904 g = ([x for x in range(10)] for x in range(1))
905 self.assertEqual(g.next(), [x for x in range(10)])
906 try:
907 g.next()
908 self.fail('should produce StopIteration exception')
909 except StopIteration:
910 pass
911
912 a = 1
913 try:
914 g = (a for d in a)
915 g.next()
916 self.fail('should produce TypeError')
917 except TypeError:
918 pass
919
920 self.assertEqual(list((x, y) for x in 'abcd' for y in 'abcd'), [(x, y) for x in 'abcd' for y in 'abcd'])
921 self.assertEqual(list((x, y) for x in 'ab' for y in 'xy'), [(x, y) for x in 'ab' for y in 'xy'])
922
923 a = [x for x in range(10)]
924 b = (x for x in (y for y in a))
925 self.assertEqual(sum(b), sum([x for x in range(10)]))
926
927 self.assertEqual(sum(x**2 for x in range(10)), sum([x**2 for x in range(10)]))
928 self.assertEqual(sum(x*x for x in range(10) if x%2), sum([x*x for x in range(10) if x%2]))
929 self.assertEqual(sum(x for x in (y for y in range(10))), sum([x for x in range(10)]))
930 self.assertEqual(sum(x for x in (y for y in (z for z in range(10)))), sum([x for x in range(10)]))
931 self.assertEqual(sum(x for x in [y for y in (z for z in range(10))]), sum([x for x in range(10)]))
932 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)]))
933 self.assertEqual(sum(x for x in (y for y in (z for z in range(10) if True) if False) if True), 0)
934 check_syntax_error(self, "foo(x for x in range(10), 100)")
935 check_syntax_error(self, "foo(100, x for x in range(10))")
936
937 def testComprehensionSpecials(self):
938 # test for outmost iterable precomputation
939 x = 10; g = (i for i in range(x)); x = 5
940 self.assertEqual(len(list(g)), 10)
941
942 # This should hold, since we're only precomputing outmost iterable.
943 x = 10; t = False; g = ((i,j) for i in range(x) if t for j in range(x))
944 x = 5; t = True;
945 self.assertEqual([(i,j) for i in range(10) for j in range(5)], list(g))
946
947 # Grammar allows multiple adjacent 'if's in listcomps and genexps,
948 # even though it's silly. Make sure it works (ifelse broke this.)
949 self.assertEqual([ x for x in range(10) if x % 2 if x % 3 ], [1, 5, 7])
950 self.assertEqual(list(x for x in range(10) if x % 2 if x % 3), [1, 5, 7])
951
952 # verify unpacking single element tuples in listcomp/genexp.
953 self.assertEqual([x for x, in [(4,), (5,), (6,)]], [4, 5, 6])
954 self.assertEqual(list(x for x, in [(7,), (8,), (9,)]), [7, 8, 9])
955
956 def test_with_statement(self):
957 class manager(object):
958 def __enter__(self):
959 return (1, 2)
960 def __exit__(self, *args):
961 pass
962
963 with manager():
964 pass
965 with manager() as x:
966 pass
967 with manager() as (x, y):
968 pass
969 with manager(), manager():
970 pass
971 with manager() as x, manager() as y:
972 pass
973 with manager() as x, manager():
974 pass
975
976 def testIfElseExpr(self):
977 # Test ifelse expressions in various cases
978 def _checkeval(msg, ret):
979 "helper to check that evaluation of expressions is done correctly"
980 print x
981 return ret
982
983 self.assertEqual([ x() for x in lambda: True, lambda: False if x() ], [True])
984 self.assertEqual([ x() for x in (lambda: True, lambda: False) if x() ], [True])
985 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])
986 self.assertEqual((5 if 1 else _checkeval("check 1", 0)), 5)
987 self.assertEqual((_checkeval("check 2", 0) if 0 else 5), 5)
988 self.assertEqual((5 and 6 if 0 else 1), 1)
989 self.assertEqual(((5 and 6) if 0 else 1), 1)
990 self.assertEqual((5 and (6 if 1 else 1)), 6)
991 self.assertEqual((0 or _checkeval("check 3", 2) if 0 else 3), 3)
992 self.assertEqual((1 or _checkeval("check 4", 2) if 1 else _checkeval("check 5", 3)), 1)
993 self.assertEqual((0 or 5 if 1 else _checkeval("check 6", 3)), 5)
994 self.assertEqual((not 5 if 1 else 1), False)
995 self.assertEqual((not 5 if 0 else 1), 1)
996 self.assertEqual((6 + 1 if 1 else 2), 7)
997 self.assertEqual((6 - 1 if 1 else 2), 5)
998 self.assertEqual((6 * 2 if 1 else 4), 12)
999 self.assertEqual((6 / 2 if 1 else 3), 3)
1000 self.assertEqual((6 < 4 if 0 else 2), 2)
1001
1002 def test_paren_evaluation(self):
1003 self.assertEqual(16 // (4 // 2), 8)
1004 self.assertEqual((16 // 4) // 2, 2)
1005 self.assertEqual(16 // 4 // 2, 2)
1006 self.assertTrue(False is (2 is 3))
1007 self.assertFalse((False is 2) is 3)
1008 self.assertFalse(False is 2 is 3)
1009
1010
1011def test_main():
1012 with check_py3k_warnings(
1013 ("backquote not supported", SyntaxWarning),
1014 ("tuple parameter unpacking has been removed", SyntaxWarning),
1015 ("parenthesized argument names are invalid", SyntaxWarning),
1016 ("classic int division", DeprecationWarning),
1017 (".+ not supported in 3.x", DeprecationWarning)):
1018 run_unittest(TokenTests, GrammarTests)
1019
1020if __name__ == '__main__':
1021 test_main()
Note: See TracBrowser for help on using the repository browser.