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