Python code coverage for Lib/lib2to3/tests/data/py2_test_grammar.py

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