Gitiles
Code Review Sign In
gerrit-public.fairphone.software / platform / external / python / cpython3 / c9c0f201fed21efcf669dbbf5f923eaf0eeb1db9 / . / Lib / test / test_parser.py
blob: 9e5d5c1ea41cbadaf6c5a39bc69349d0166ca165 [file] [log] [blame]
Fred Drake79ca79d2000-08-21 22:30:53 +0000[diff] [blame]1import parser
Benjamin Petersonc0747cf2008-11-03 20:31:38 +0000[diff] [blame]2import os
Fred Drake58422e52001-06-04 03:56:24 +0000[diff] [blame]3import unittest
Christian Heimesb186d002008-03-18 15:15:01 +0000[diff] [blame]4import sys
Mark Dickinson211c6252009-02-01 10:28:51 +0000[diff] [blame]5import operator
Benjamin Petersonee8712c2008-05-20 21:35:26 +0000[diff] [blame]6from test import support
Fred Drake79ca79d2000-08-21 22:30:53 +0000[diff] [blame]7
8#
9# First, we test that we can generate trees from valid source fragments,
10# and that these valid trees are indeed allowed by the tree-loading side
11# of the parser module.
12#
13
Fred Drake58422e52001-06-04 03:56:24 +0000[diff] [blame]14class RoundtripLegalSyntaxTestCase(unittest.TestCase):
Guido van Rossum32c2ae72002-08-22 19:45:32 +0000[diff] [blame]15
Fred Drake58422e52001-06-04 03:56:24 +0000[diff] [blame]16 def roundtrip(self, f, s):
17 st1 = f(s)
18 t = st1.totuple()
19 try:
Fred Drake6e4f2c02001-07-17 19:33:25 +0000[diff] [blame]20 st2 = parser.sequence2st(t)
Guido van Rossumb940e112007-01-10 16:19:56 +0000[diff] [blame]21 except parser.ParserError as why:
Anthony Baxterc2a5a632004-08-02 06:10:11 +0000[diff] [blame]22 self.fail("could not roundtrip %r: %s" % (s, why))
Fred Drake79ca79d2000-08-21 22:30:53 +0000[diff] [blame]23
Fred Drake58422e52001-06-04 03:56:24 +0000[diff] [blame]24 self.assertEquals(t, st2.totuple(),
25 "could not re-generate syntax tree")
Fred Drake28f739a2000-08-25 22:42:40 +0000[diff] [blame]26
Fred Drake58422e52001-06-04 03:56:24 +0000[diff] [blame]27 def check_expr(self, s):
28 self.roundtrip(parser.expr, s)
Fred Drake28f739a2000-08-25 22:42:40 +0000[diff] [blame]29
Benjamin Petersonf216c942008-10-31 02:28:05 +0000[diff] [blame]30 def test_flags_passed(self):
31 # The unicode literals flags has to be passed from the paser to AST
32 # generation.
33 suite = parser.suite("from __future__ import unicode_literals; x = ''")
34 code = suite.compile()
35 scope = {}
36 exec(code, {}, scope)
37 self.assertTrue(isinstance(scope["x"], str))
38
Fred Drake58422e52001-06-04 03:56:24 +0000[diff] [blame]39 def check_suite(self, s):
40 self.roundtrip(parser.suite, s)
Fred Drake28f739a2000-08-25 22:42:40 +0000[diff] [blame]41
Fred Drakecf580c72001-07-17 03:01:29 +0000[diff] [blame]42 def test_yield_statement(self):
Tim Peters496563a2002-04-01 00:28:59 +0000[diff] [blame]43 self.check_suite("def f(): yield 1")
Phillip J. Eby0d6615f2005-08-02 00:46:46 +0000[diff] [blame]44 self.check_suite("def f(): yield")
45 self.check_suite("def f(): x += yield")
46 self.check_suite("def f(): x = yield 1")
47 self.check_suite("def f(): x = y = yield 1")
48 self.check_suite("def f(): x = yield")
49 self.check_suite("def f(): x = y = yield")
50 self.check_suite("def f(): 1 + (yield)*2")
51 self.check_suite("def f(): (yield 1)*2")
Tim Peters496563a2002-04-01 00:28:59 +0000[diff] [blame]52 self.check_suite("def f(): return; yield 1")
53 self.check_suite("def f(): yield 1; return")
54 self.check_suite("def f():\n"
Fred Drakecf580c72001-07-17 03:01:29 +0000[diff] [blame]55 " for x in range(30):\n"
56 " yield x\n")
Phillip J. Eby0d6615f2005-08-02 00:46:46 +0000[diff] [blame]57 self.check_suite("def f():\n"
58 " if (yield):\n"
59 " yield x\n")
Fred Drakecf580c72001-07-17 03:01:29 +0000[diff] [blame]60
Fred Drake58422e52001-06-04 03:56:24 +0000[diff] [blame]61 def test_expressions(self):
62 self.check_expr("foo(1)")
63 self.check_expr("[1, 2, 3]")
64 self.check_expr("[x**3 for x in range(20)]")
65 self.check_expr("[x**3 for x in range(20) if x % 3]")
Thomas Wouters49fd7fa2006-04-21 10:40:58 +0000[diff] [blame]66 self.check_expr("[x**3 for x in range(20) if x % 2 if x % 3]")
67 self.check_expr("list(x**3 for x in range(20))")
68 self.check_expr("list(x**3 for x in range(20) if x % 3)")
69 self.check_expr("list(x**3 for x in range(20) if x % 2 if x % 3)")
Fred Drake58422e52001-06-04 03:56:24 +0000[diff] [blame]70 self.check_expr("foo(*args)")
71 self.check_expr("foo(*args, **kw)")
72 self.check_expr("foo(**kw)")
73 self.check_expr("foo(key=value)")
74 self.check_expr("foo(key=value, *args)")
75 self.check_expr("foo(key=value, *args, **kw)")
76 self.check_expr("foo(key=value, **kw)")
77 self.check_expr("foo(a, b, c, *args)")
78 self.check_expr("foo(a, b, c, *args, **kw)")
79 self.check_expr("foo(a, b, c, **kw)")
Benjamin Peterson3938a902008-08-20 02:33:00 +0000[diff] [blame]80 self.check_expr("foo(a, *args, keyword=23)")
Fred Drake58422e52001-06-04 03:56:24 +0000[diff] [blame]81 self.check_expr("foo + bar")
Michael W. Hudson5e83b7a2003-01-29 14:20:23 +0000[diff] [blame]82 self.check_expr("foo - bar")
83 self.check_expr("foo * bar")
84 self.check_expr("foo / bar")
85 self.check_expr("foo // bar")
Fred Drake58422e52001-06-04 03:56:24 +0000[diff] [blame]86 self.check_expr("lambda: 0")
87 self.check_expr("lambda x: 0")
88 self.check_expr("lambda *y: 0")
89 self.check_expr("lambda *y, **z: 0")
90 self.check_expr("lambda **z: 0")
91 self.check_expr("lambda x, y: 0")
92 self.check_expr("lambda foo=bar: 0")
93 self.check_expr("lambda foo=bar, spaz=nifty+spit: 0")
94 self.check_expr("lambda foo=bar, **z: 0")
95 self.check_expr("lambda foo=bar, blaz=blat+2, **z: 0")
96 self.check_expr("lambda foo=bar, blaz=blat+2, *y, **z: 0")
97 self.check_expr("lambda x, *y, **z: 0")
Raymond Hettinger354433a2004-05-19 08:20:33 +0000[diff] [blame]98 self.check_expr("(x for x in range(10))")
99 self.check_expr("foo(x for x in range(10))")
Fred Drake79ca79d2000-08-21 22:30:53 +0000[diff] [blame]100
Fred Drake58422e52001-06-04 03:56:24 +0000[diff] [blame]101 def test_simple_expression(self):
102 # expr_stmt
103 self.check_suite("a")
Fred Drake79ca79d2000-08-21 22:30:53 +0000[diff] [blame]104
Fred Drake58422e52001-06-04 03:56:24 +0000[diff] [blame]105 def test_simple_assignments(self):
106 self.check_suite("a = b")
107 self.check_suite("a = b = c = d = e")
Fred Drake28f739a2000-08-25 22:42:40 +0000[diff] [blame]108
Fred Drake58422e52001-06-04 03:56:24 +0000[diff] [blame]109 def test_simple_augmented_assignments(self):
110 self.check_suite("a += b")
111 self.check_suite("a -= b")
112 self.check_suite("a *= b")
113 self.check_suite("a /= b")
Michael W. Hudson5e83b7a2003-01-29 14:20:23 +0000[diff] [blame]114 self.check_suite("a //= b")
Fred Drake58422e52001-06-04 03:56:24 +0000[diff] [blame]115 self.check_suite("a %= b")
116 self.check_suite("a &= b")
117 self.check_suite("a |= b")
118 self.check_suite("a ^= b")
119 self.check_suite("a <<= b")
120 self.check_suite("a >>= b")
121 self.check_suite("a **= b")
Fred Drakee3fb18c2001-01-07 06:02:19 +0000[diff] [blame]122
Fred Drake58422e52001-06-04 03:56:24 +0000[diff] [blame]123 def test_function_defs(self):
124 self.check_suite("def f(): pass")
125 self.check_suite("def f(*args): pass")
126 self.check_suite("def f(*args, **kw): pass")
127 self.check_suite("def f(**kw): pass")
128 self.check_suite("def f(foo=bar): pass")
129 self.check_suite("def f(foo=bar, *args): pass")
130 self.check_suite("def f(foo=bar, *args, **kw): pass")
131 self.check_suite("def f(foo=bar, **kw): pass")
Fred Drakee3fb18c2001-01-07 06:02:19 +0000[diff] [blame]132
Fred Drake58422e52001-06-04 03:56:24 +0000[diff] [blame]133 self.check_suite("def f(a, b): pass")
134 self.check_suite("def f(a, b, *args): pass")
135 self.check_suite("def f(a, b, *args, **kw): pass")
136 self.check_suite("def f(a, b, **kw): pass")
137 self.check_suite("def f(a, b, foo=bar): pass")
138 self.check_suite("def f(a, b, foo=bar, *args): pass")
139 self.check_suite("def f(a, b, foo=bar, *args, **kw): pass")
140 self.check_suite("def f(a, b, foo=bar, **kw): pass")
Fred Drakee3fb18c2001-01-07 06:02:19 +0000[diff] [blame]141
Anthony Baxterc2a5a632004-08-02 06:10:11 +0000[diff] [blame]142 self.check_suite("@staticmethod\n"
143 "def f(): pass")
144 self.check_suite("@staticmethod\n"
145 "@funcattrs(x, y)\n"
146 "def f(): pass")
147 self.check_suite("@funcattrs()\n"
148 "def f(): pass")
149
Brett Cannonf4189912005-04-09 02:30:16 +0000[diff] [blame]150 def test_class_defs(self):
151 self.check_suite("class foo():pass")
Guido van Rossumfc158e22007-11-15 19:17:28 +0000[diff] [blame]152 self.check_suite("class foo(object):pass")
Tim Peterse8906822005-04-20 17:45:13 +0000[diff] [blame]153
Fred Drake58422e52001-06-04 03:56:24 +0000[diff] [blame]154 def test_import_from_statement(self):
155 self.check_suite("from sys.path import *")
156 self.check_suite("from sys.path import dirname")
Anthony Baxter1a4ddae2004-08-31 10:07:13 +0000[diff] [blame]157 self.check_suite("from sys.path import (dirname)")
158 self.check_suite("from sys.path import (dirname,)")
Fred Drake58422e52001-06-04 03:56:24 +0000[diff] [blame]159 self.check_suite("from sys.path import dirname as my_dirname")
Anthony Baxter1a4ddae2004-08-31 10:07:13 +0000[diff] [blame]160 self.check_suite("from sys.path import (dirname as my_dirname)")
161 self.check_suite("from sys.path import (dirname as my_dirname,)")
Fred Drake58422e52001-06-04 03:56:24 +0000[diff] [blame]162 self.check_suite("from sys.path import dirname, basename")
Anthony Baxter1a4ddae2004-08-31 10:07:13 +0000[diff] [blame]163 self.check_suite("from sys.path import (dirname, basename)")
164 self.check_suite("from sys.path import (dirname, basename,)")
Fred Drake58422e52001-06-04 03:56:24 +0000[diff] [blame]165 self.check_suite(
166 "from sys.path import dirname as my_dirname, basename")
167 self.check_suite(
Anthony Baxter1a4ddae2004-08-31 10:07:13 +0000[diff] [blame]168 "from sys.path import (dirname as my_dirname, basename)")
169 self.check_suite(
170 "from sys.path import (dirname as my_dirname, basename,)")
171 self.check_suite(
Fred Drake58422e52001-06-04 03:56:24 +0000[diff] [blame]172 "from sys.path import dirname, basename as my_basename")
Anthony Baxter1a4ddae2004-08-31 10:07:13 +0000[diff] [blame]173 self.check_suite(
174 "from sys.path import (dirname, basename as my_basename)")
175 self.check_suite(
176 "from sys.path import (dirname, basename as my_basename,)")
Benjamin Petersonc0747cf2008-11-03 20:31:38 +0000[diff] [blame]177 self.check_suite("from .bogus import x")
Fred Drakee3fb18c2001-01-07 06:02:19 +0000[diff] [blame]178
Fred Drake58422e52001-06-04 03:56:24 +0000[diff] [blame]179 def test_basic_import_statement(self):
180 self.check_suite("import sys")
181 self.check_suite("import sys as system")
182 self.check_suite("import sys, math")
183 self.check_suite("import sys as system, math")
184 self.check_suite("import sys, math as my_math")
Fred Drake79ca79d2000-08-21 22:30:53 +0000[diff] [blame]185
Neal Norwitz9caf9c02003-02-10 01:54:06 +0000[diff] [blame]186 def test_pep263(self):
187 self.check_suite("# -*- coding: iso-8859-1 -*-\n"
188 "pass\n")
189
190 def test_assert(self):
191 self.check_suite("assert alo < ahi and blo < bhi\n")
192
Benjamin Peterson4469d0c2008-11-30 22:46:23 +0000[diff] [blame]193 def test_with(self):
194 self.check_suite("with open('x'): pass\n")
195 self.check_suite("with open('x') as f: pass\n")
Georg Brandl0c315622009-05-25 21:10:36 +0000[diff] [blame]196 self.check_suite("with open('x') as f, open('y') as g: pass\n")
Benjamin Peterson4469d0c2008-11-30 22:46:23 +0000[diff] [blame]197
Georg Brandleee31162008-12-07 15:15:22 +0000[diff] [blame]198 def test_try_stmt(self):
199 self.check_suite("try: pass\nexcept: pass\n")
200 self.check_suite("try: pass\nfinally: pass\n")
201 self.check_suite("try: pass\nexcept A: pass\nfinally: pass\n")
202 self.check_suite("try: pass\nexcept A: pass\nexcept: pass\n"
203 "finally: pass\n")
204 self.check_suite("try: pass\nexcept: pass\nelse: pass\n")
205 self.check_suite("try: pass\nexcept: pass\nelse: pass\n"
206 "finally: pass\n")
207
Thomas Wouters89f507f2006-12-13 04:49:30 +0000[diff] [blame]208 def test_position(self):
209 # An absolutely minimal test of position information. Better
210 # tests would be a big project.
211 code = "def f(x):\n return x + 1\n"
212 st1 = parser.suite(code)
213 st2 = st1.totuple(line_info=1, col_info=1)
214
215 def walk(tree):
216 node_type = tree[0]
217 next = tree[1]
218 if isinstance(next, tuple):
219 for elt in tree[1:]:
220 for x in walk(elt):
221 yield x
222 else:
223 yield tree
224
225 terminals = list(walk(st2))
226 self.assertEqual([
227 (1, 'def', 1, 0),
228 (1, 'f', 1, 4),
229 (7, '(', 1, 5),
230 (1, 'x', 1, 6),
231 (8, ')', 1, 7),
232 (11, ':', 1, 8),
233 (4, '', 1, 9),
234 (5, '', 2, -1),
235 (1, 'return', 2, 4),
236 (1, 'x', 2, 11),
237 (14, '+', 2, 13),
238 (2, '1', 2, 15),
239 (4, '', 2, 16),
240 (6, '', 2, -1),
241 (4, '', 2, -1),
242 (0, '', 2, -1)],
243 terminals)
244
245
Fred Drake79ca79d2000-08-21 22:30:53 +0000[diff] [blame]246#
247# Second, we take *invalid* trees and make sure we get ParserError
248# rejections for them.
249#
250
Fred Drake58422e52001-06-04 03:56:24 +0000[diff] [blame]251class IllegalSyntaxTestCase(unittest.TestCase):
Guido van Rossum32c2ae72002-08-22 19:45:32 +0000[diff] [blame]252
Fred Drake58422e52001-06-04 03:56:24 +0000[diff] [blame]253 def check_bad_tree(self, tree, label):
254 try:
Fred Drake6e4f2c02001-07-17 19:33:25 +0000[diff] [blame]255 parser.sequence2st(tree)
Fred Drake58422e52001-06-04 03:56:24 +0000[diff] [blame]256 except parser.ParserError:
257 pass
258 else:
259 self.fail("did not detect invalid tree for %r" % label)
Fred Drake79ca79d2000-08-21 22:30:53 +0000[diff] [blame]260
Fred Drake58422e52001-06-04 03:56:24 +0000[diff] [blame]261 def test_junk(self):
262 # not even remotely valid:
263 self.check_bad_tree((1, 2, 3), "<junk>")
264
Fred Drakecf580c72001-07-17 03:01:29 +0000[diff] [blame]265 def test_illegal_yield_1(self):
Guido van Rossum32c2ae72002-08-22 19:45:32 +0000[diff] [blame]266 # Illegal yield statement: def f(): return 1; yield 1
Fred Drakecf580c72001-07-17 03:01:29 +0000[diff] [blame]267 tree = \
268 (257,
269 (264,
270 (285,
271 (259,
272 (1, 'def'),
273 (1, 'f'),
274 (260, (7, '('), (8, ')')),
275 (11, ':'),
276 (291,
277 (4, ''),
278 (5, ''),
279 (264,
280 (265,
281 (266,
282 (272,
283 (275,
284 (1, 'return'),
285 (313,
286 (292,
287 (293,
288 (294,
289 (295,
290 (297,
291 (298,
292 (299,
293 (300,
294 (301,
295 (302, (303, (304, (305, (2, '1')))))))))))))))))),
296 (264,
297 (265,
298 (266,
299 (272,
300 (276,
301 (1, 'yield'),
302 (313,
303 (292,
304 (293,
305 (294,
306 (295,
307 (297,
308 (298,
309 (299,
310 (300,
311 (301,
312 (302,
313 (303, (304, (305, (2, '1')))))))))))))))))),
314 (4, ''))),
315 (6, ''))))),
316 (4, ''),
317 (0, ''))))
318 self.check_bad_tree(tree, "def f():\n return 1\n yield 1")
319
320 def test_illegal_yield_2(self):
Guido van Rossum32c2ae72002-08-22 19:45:32 +0000[diff] [blame]321 # Illegal return in generator: def f(): return 1; yield 1
Fred Drakecf580c72001-07-17 03:01:29 +0000[diff] [blame]322 tree = \
323 (257,
324 (264,
325 (265,
326 (266,
327 (278,
328 (1, 'from'),
329 (281, (1, '__future__')),
330 (1, 'import'),
331 (279, (1, 'generators')))),
332 (4, ''))),
333 (264,
334 (285,
335 (259,
336 (1, 'def'),
337 (1, 'f'),
338 (260, (7, '('), (8, ')')),
339 (11, ':'),
340 (291,
341 (4, ''),
342 (5, ''),
343 (264,
344 (265,
345 (266,
346 (272,
347 (275,
348 (1, 'return'),
349 (313,
350 (292,
351 (293,
352 (294,
353 (295,
354 (297,
355 (298,
356 (299,
357 (300,
358 (301,
359 (302, (303, (304, (305, (2, '1')))))))))))))))))),
360 (264,
361 (265,
362 (266,
363 (272,
364 (276,
365 (1, 'yield'),
366 (313,
367 (292,
368 (293,
369 (294,
370 (295,
371 (297,
372 (298,
373 (299,
374 (300,
375 (301,
376 (302,
377 (303, (304, (305, (2, '1')))))))))))))))))),
378 (4, ''))),
379 (6, ''))))),
380 (4, ''),
381 (0, ''))))
382 self.check_bad_tree(tree, "def f():\n return 1\n yield 1")
383
Fred Drake58422e52001-06-04 03:56:24 +0000[diff] [blame]384 def test_a_comma_comma_c(self):
Guido van Rossum32c2ae72002-08-22 19:45:32 +0000[diff] [blame]385 # Illegal input: a,,c
Fred Drake58422e52001-06-04 03:56:24 +0000[diff] [blame]386 tree = \
387 (258,
388 (311,
389 (290,
390 (291,
391 (292,
392 (293,
393 (295,
394 (296,
395 (297,
396 (298, (299, (300, (301, (302, (303, (1, 'a')))))))))))))),
397 (12, ','),
398 (12, ','),
399 (290,
400 (291,
401 (292,
402 (293,
403 (295,
404 (296,
405 (297,
406 (298, (299, (300, (301, (302, (303, (1, 'c'))))))))))))))),
407 (4, ''),
408 (0, ''))
409 self.check_bad_tree(tree, "a,,c")
410
411 def test_illegal_operator(self):
Guido van Rossum32c2ae72002-08-22 19:45:32 +0000[diff] [blame]412 # Illegal input: a $= b
Fred Drake58422e52001-06-04 03:56:24 +0000[diff] [blame]413 tree = \
414 (257,
415 (264,
416 (265,
417 (266,
418 (267,
419 (312,
420 (291,
421 (292,
422 (293,
423 (294,
424 (296,
425 (297,
426 (298,
427 (299,
428 (300, (301, (302, (303, (304, (1, 'a'))))))))))))))),
429 (268, (37, '$=')),
430 (312,
431 (291,
432 (292,
433 (293,
434 (294,
435 (296,
436 (297,
437 (298,
438 (299,
439 (300, (301, (302, (303, (304, (1, 'b'))))))))))))))))),
440 (4, ''))),
441 (0, ''))
442 self.check_bad_tree(tree, "a $= b")
Fred Drake79ca79d2000-08-21 22:30:53 +0000[diff] [blame]443
Neal Norwitz9caf9c02003-02-10 01:54:06 +0000[diff] [blame]444 def test_malformed_global(self):
445 #doesn't have global keyword in ast
446 tree = (257,
447 (264,
448 (265,
449 (266,
450 (282, (1, 'foo'))), (4, ''))),
451 (4, ''),
Tim Petersf2715e02003-02-19 02:35:07 +0000[diff] [blame]452 (0, ''))
Neal Norwitz9caf9c02003-02-10 01:54:06 +0000[diff] [blame]453 self.check_bad_tree(tree, "malformed global ast")
Fred Drake79ca79d2000-08-21 22:30:53 +0000[diff] [blame]454
Jeremy Hylton3e0055f2005-10-20 19:59:25 +0000[diff] [blame]455
456class CompileTestCase(unittest.TestCase):
457
458 # These tests are very minimal. :-(
459
460 def test_compile_expr(self):
461 st = parser.expr('2 + 3')
462 code = parser.compilest(st)
463 self.assertEquals(eval(code), 5)
464
465 def test_compile_suite(self):
466 st = parser.suite('x = 2; y = x + 3')
467 code = parser.compilest(st)
468 globs = {}
Georg Brandl7cae87c2006-09-06 06:51:57 +0000[diff] [blame]469 exec(code, globs)
Jeremy Hylton3e0055f2005-10-20 19:59:25 +0000[diff] [blame]470 self.assertEquals(globs['y'], 5)
471
472 def test_compile_error(self):
473 st = parser.suite('1 = 3 + 4')
474 self.assertRaises(SyntaxError, parser.compilest, st)
475
Guido van Rossumb5a755e2007-07-18 18:15:48 +0000[diff] [blame]476 def test_compile_badunicode(self):
Guido van Rossum7eb6ca52007-07-18 21:00:22 +0000[diff] [blame]477 st = parser.suite('a = "\\U12345678"')
Guido van Rossumb5a755e2007-07-18 18:15:48 +0000[diff] [blame]478 self.assertRaises(SyntaxError, parser.compilest, st)
Guido van Rossum7eb6ca52007-07-18 21:00:22 +0000[diff] [blame]479 st = parser.suite('a = "\\u1"')
Guido van Rossumb5a755e2007-07-18 18:15:48 +0000[diff] [blame]480 self.assertRaises(SyntaxError, parser.compilest, st)
481
Christian Heimes90c3d9b2008-02-23 13:18:03 +0000[diff] [blame]482class ParserStackLimitTestCase(unittest.TestCase):
483 """try to push the parser to/over it's limits.
484 see http://bugs.python.org/issue1881 for a discussion
485 """
486 def _nested_expression(self, level):
487 return "["*level+"]"*level
488
489 def test_deeply_nested_list(self):
490 # XXX used to be 99 levels in 2.x
491 e = self._nested_expression(93)
492 st = parser.expr(e)
493 st.compile()
494
495 def test_trigger_memory_error(self):
496 e = self._nested_expression(100)
Christian Heimesb186d002008-03-18 15:15:01 +0000[diff] [blame]497 print("Expecting 's_push: parser stack overflow' in next line",
498 file=sys.stderr)
Antoine Pitrou88909542009-06-29 13:54:42 +0000[diff] [blame]499 sys.stderr.flush()
Christian Heimes90c3d9b2008-02-23 13:18:03 +0000[diff] [blame]500 self.assertRaises(MemoryError, parser.expr, e)
501
Mark Dickinson211c6252009-02-01 10:28:51 +0000[diff] [blame]502class STObjectTestCase(unittest.TestCase):
503 """Test operations on ST objects themselves"""
504
505 def test_comparisons(self):
506 # ST objects should support order and equality comparisons
507 st1 = parser.expr('2 + 3')
508 st2 = parser.suite('x = 2; y = x + 3')
509 st3 = parser.expr('list(x**3 for x in range(20))')
510 st1_copy = parser.expr('2 + 3')
511 st2_copy = parser.suite('x = 2; y = x + 3')
512 st3_copy = parser.expr('list(x**3 for x in range(20))')
513
514 # exercise fast path for object identity
515 self.assertEquals(st1 == st1, True)
516 self.assertEquals(st2 == st2, True)
517 self.assertEquals(st3 == st3, True)
518 # slow path equality
519 self.assertEqual(st1, st1_copy)
520 self.assertEqual(st2, st2_copy)
521 self.assertEqual(st3, st3_copy)
522 self.assertEquals(st1 == st2, False)
523 self.assertEquals(st1 == st3, False)
524 self.assertEquals(st2 == st3, False)
525 self.assertEquals(st1 != st1, False)
526 self.assertEquals(st2 != st2, False)
527 self.assertEquals(st3 != st3, False)
528 self.assertEquals(st1 != st1_copy, False)
529 self.assertEquals(st2 != st2_copy, False)
530 self.assertEquals(st3 != st3_copy, False)
531 self.assertEquals(st2 != st1, True)
532 self.assertEquals(st1 != st3, True)
533 self.assertEquals(st3 != st2, True)
534 # we don't particularly care what the ordering is; just that
535 # it's usable and self-consistent
536 self.assertEquals(st1 < st2, not (st2 <= st1))
537 self.assertEquals(st1 < st3, not (st3 <= st1))
538 self.assertEquals(st2 < st3, not (st3 <= st2))
539 self.assertEquals(st1 < st2, st2 > st1)
540 self.assertEquals(st1 < st3, st3 > st1)
541 self.assertEquals(st2 < st3, st3 > st2)
542 self.assertEquals(st1 <= st2, st2 >= st1)
543 self.assertEquals(st3 <= st1, st1 >= st3)
544 self.assertEquals(st2 <= st3, st3 >= st2)
545 # transitivity
546 bottom = min(st1, st2, st3)
547 top = max(st1, st2, st3)
548 mid = sorted([st1, st2, st3])[1]
Benjamin Petersonc9c0f202009-06-30 23:06:06 +0000[diff] [blame^]549 self.assertTrue(bottom < mid)
550 self.assertTrue(bottom < top)
551 self.assertTrue(mid < top)
552 self.assertTrue(bottom <= mid)
553 self.assertTrue(bottom <= top)
554 self.assertTrue(mid <= top)
555 self.assertTrue(bottom <= bottom)
556 self.assertTrue(mid <= mid)
557 self.assertTrue(top <= top)
Mark Dickinson211c6252009-02-01 10:28:51 +0000[diff] [blame]558 # interaction with other types
559 self.assertEquals(st1 == 1588.602459, False)
560 self.assertEquals('spanish armada' != st2, True)
561 self.assertRaises(TypeError, operator.ge, st3, None)
562 self.assertRaises(TypeError, operator.le, False, st1)
563 self.assertRaises(TypeError, operator.lt, st1, 1815)
564 self.assertRaises(TypeError, operator.gt, b'waterloo', st2)
565
566
567 # XXX tests for pickling and unpickling of ST objects should go here
568
569
Fred Drake2e2be372001-09-20 21:33:42 +0000[diff] [blame]570def test_main():
Benjamin Petersonee8712c2008-05-20 21:35:26 +0000[diff] [blame]571 support.run_unittest(
Walter Dörwald21d3a322003-05-01 17:45:56 +0000[diff] [blame]572 RoundtripLegalSyntaxTestCase,
Jeremy Hylton3e0055f2005-10-20 19:59:25 +0000[diff] [blame]573 IllegalSyntaxTestCase,
574 CompileTestCase,
Christian Heimes90c3d9b2008-02-23 13:18:03 +0000[diff] [blame]575 ParserStackLimitTestCase,
Mark Dickinson211c6252009-02-01 10:28:51 +0000[diff] [blame]576 STObjectTestCase,
Walter Dörwald21d3a322003-05-01 17:45:56 +0000[diff] [blame]577 )
Fred Drake2e2be372001-09-20 21:33:42 +0000[diff] [blame]578
579
580if __name__ == "__main__":
581 test_main()