Gitiles
Code Review Sign In
gerrit-public.fairphone.software / platform / external / python / cpython3 / f396ecf3b841fa8b0e66ca13b83c0d23f62c0bcc / . / Lib / test / test_parser.py
blob: 86ede3e635d4e034e05ac05c9f1989438afb21ae [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")
196
Georg Brandleee31162008-12-07 15:15:22 +0000[diff] [blame]197 def test_try_stmt(self):
198 self.check_suite("try: pass\nexcept: pass\n")
199 self.check_suite("try: pass\nfinally: pass\n")
200 self.check_suite("try: pass\nexcept A: pass\nfinally: pass\n")
201 self.check_suite("try: pass\nexcept A: pass\nexcept: pass\n"
202 "finally: pass\n")
203 self.check_suite("try: pass\nexcept: pass\nelse: pass\n")
204 self.check_suite("try: pass\nexcept: pass\nelse: pass\n"
205 "finally: pass\n")
206
Thomas Wouters89f507f2006-12-13 04:49:30 +0000[diff] [blame]207 def test_position(self):
208 # An absolutely minimal test of position information. Better
209 # tests would be a big project.
210 code = "def f(x):\n return x + 1\n"
211 st1 = parser.suite(code)
212 st2 = st1.totuple(line_info=1, col_info=1)
213
214 def walk(tree):
215 node_type = tree[0]
216 next = tree[1]
217 if isinstance(next, tuple):
218 for elt in tree[1:]:
219 for x in walk(elt):
220 yield x
221 else:
222 yield tree
223
224 terminals = list(walk(st2))
225 self.assertEqual([
226 (1, 'def', 1, 0),
227 (1, 'f', 1, 4),
228 (7, '(', 1, 5),
229 (1, 'x', 1, 6),
230 (8, ')', 1, 7),
231 (11, ':', 1, 8),
232 (4, '', 1, 9),
233 (5, '', 2, -1),
234 (1, 'return', 2, 4),
235 (1, 'x', 2, 11),
236 (14, '+', 2, 13),
237 (2, '1', 2, 15),
238 (4, '', 2, 16),
239 (6, '', 2, -1),
240 (4, '', 2, -1),
241 (0, '', 2, -1)],
242 terminals)
243
244
Fred Drake79ca79d2000-08-21 22:30:53 +0000[diff] [blame]245#
246# Second, we take *invalid* trees and make sure we get ParserError
247# rejections for them.
248#
249
Fred Drake58422e52001-06-04 03:56:24 +0000[diff] [blame]250class IllegalSyntaxTestCase(unittest.TestCase):
Guido van Rossum32c2ae72002-08-22 19:45:32 +0000[diff] [blame]251
Fred Drake58422e52001-06-04 03:56:24 +0000[diff] [blame]252 def check_bad_tree(self, tree, label):
253 try:
Fred Drake6e4f2c02001-07-17 19:33:25 +0000[diff] [blame]254 parser.sequence2st(tree)
Fred Drake58422e52001-06-04 03:56:24 +0000[diff] [blame]255 except parser.ParserError:
256 pass
257 else:
258 self.fail("did not detect invalid tree for %r" % label)
Fred Drake79ca79d2000-08-21 22:30:53 +0000[diff] [blame]259
Fred Drake58422e52001-06-04 03:56:24 +0000[diff] [blame]260 def test_junk(self):
261 # not even remotely valid:
262 self.check_bad_tree((1, 2, 3), "<junk>")
263
Fred Drakecf580c72001-07-17 03:01:29 +0000[diff] [blame]264 def test_illegal_yield_1(self):
Guido van Rossum32c2ae72002-08-22 19:45:32 +0000[diff] [blame]265 # Illegal yield statement: def f(): return 1; yield 1
Fred Drakecf580c72001-07-17 03:01:29 +0000[diff] [blame]266 tree = \
267 (257,
268 (264,
269 (285,
270 (259,
271 (1, 'def'),
272 (1, 'f'),
273 (260, (7, '('), (8, ')')),
274 (11, ':'),
275 (291,
276 (4, ''),
277 (5, ''),
278 (264,
279 (265,
280 (266,
281 (272,
282 (275,
283 (1, 'return'),
284 (313,
285 (292,
286 (293,
287 (294,
288 (295,
289 (297,
290 (298,
291 (299,
292 (300,
293 (301,
294 (302, (303, (304, (305, (2, '1')))))))))))))))))),
295 (264,
296 (265,
297 (266,
298 (272,
299 (276,
300 (1, 'yield'),
301 (313,
302 (292,
303 (293,
304 (294,
305 (295,
306 (297,
307 (298,
308 (299,
309 (300,
310 (301,
311 (302,
312 (303, (304, (305, (2, '1')))))))))))))))))),
313 (4, ''))),
314 (6, ''))))),
315 (4, ''),
316 (0, ''))))
317 self.check_bad_tree(tree, "def f():\n return 1\n yield 1")
318
319 def test_illegal_yield_2(self):
Guido van Rossum32c2ae72002-08-22 19:45:32 +0000[diff] [blame]320 # Illegal return in generator: def f(): return 1; yield 1
Fred Drakecf580c72001-07-17 03:01:29 +0000[diff] [blame]321 tree = \
322 (257,
323 (264,
324 (265,
325 (266,
326 (278,
327 (1, 'from'),
328 (281, (1, '__future__')),
329 (1, 'import'),
330 (279, (1, 'generators')))),
331 (4, ''))),
332 (264,
333 (285,
334 (259,
335 (1, 'def'),
336 (1, 'f'),
337 (260, (7, '('), (8, ')')),
338 (11, ':'),
339 (291,
340 (4, ''),
341 (5, ''),
342 (264,
343 (265,
344 (266,
345 (272,
346 (275,
347 (1, 'return'),
348 (313,
349 (292,
350 (293,
351 (294,
352 (295,
353 (297,
354 (298,
355 (299,
356 (300,
357 (301,
358 (302, (303, (304, (305, (2, '1')))))))))))))))))),
359 (264,
360 (265,
361 (266,
362 (272,
363 (276,
364 (1, 'yield'),
365 (313,
366 (292,
367 (293,
368 (294,
369 (295,
370 (297,
371 (298,
372 (299,
373 (300,
374 (301,
375 (302,
376 (303, (304, (305, (2, '1')))))))))))))))))),
377 (4, ''))),
378 (6, ''))))),
379 (4, ''),
380 (0, ''))))
381 self.check_bad_tree(tree, "def f():\n return 1\n yield 1")
382
Fred Drake58422e52001-06-04 03:56:24 +0000[diff] [blame]383 def test_a_comma_comma_c(self):
Guido van Rossum32c2ae72002-08-22 19:45:32 +0000[diff] [blame]384 # Illegal input: a,,c
Fred Drake58422e52001-06-04 03:56:24 +0000[diff] [blame]385 tree = \
386 (258,
387 (311,
388 (290,
389 (291,
390 (292,
391 (293,
392 (295,
393 (296,
394 (297,
395 (298, (299, (300, (301, (302, (303, (1, 'a')))))))))))))),
396 (12, ','),
397 (12, ','),
398 (290,
399 (291,
400 (292,
401 (293,
402 (295,
403 (296,
404 (297,
405 (298, (299, (300, (301, (302, (303, (1, 'c'))))))))))))))),
406 (4, ''),
407 (0, ''))
408 self.check_bad_tree(tree, "a,,c")
409
410 def test_illegal_operator(self):
Guido van Rossum32c2ae72002-08-22 19:45:32 +0000[diff] [blame]411 # Illegal input: a $= b
Fred Drake58422e52001-06-04 03:56:24 +0000[diff] [blame]412 tree = \
413 (257,
414 (264,
415 (265,
416 (266,
417 (267,
418 (312,
419 (291,
420 (292,
421 (293,
422 (294,
423 (296,
424 (297,
425 (298,
426 (299,
427 (300, (301, (302, (303, (304, (1, 'a'))))))))))))))),
428 (268, (37, '$=')),
429 (312,
430 (291,
431 (292,
432 (293,
433 (294,
434 (296,
435 (297,
436 (298,
437 (299,
438 (300, (301, (302, (303, (304, (1, 'b'))))))))))))))))),
439 (4, ''))),
440 (0, ''))
441 self.check_bad_tree(tree, "a $= b")
Fred Drake79ca79d2000-08-21 22:30:53 +0000[diff] [blame]442
Neal Norwitz9caf9c02003-02-10 01:54:06 +0000[diff] [blame]443 def test_malformed_global(self):
444 #doesn't have global keyword in ast
445 tree = (257,
446 (264,
447 (265,
448 (266,
449 (282, (1, 'foo'))), (4, ''))),
450 (4, ''),
Tim Petersf2715e02003-02-19 02:35:07 +0000[diff] [blame]451 (0, ''))
Neal Norwitz9caf9c02003-02-10 01:54:06 +0000[diff] [blame]452 self.check_bad_tree(tree, "malformed global ast")
Fred Drake79ca79d2000-08-21 22:30:53 +0000[diff] [blame]453
Jeremy Hylton3e0055f2005-10-20 19:59:25 +0000[diff] [blame]454
455class CompileTestCase(unittest.TestCase):
456
457 # These tests are very minimal. :-(
458
459 def test_compile_expr(self):
460 st = parser.expr('2 + 3')
461 code = parser.compilest(st)
462 self.assertEquals(eval(code), 5)
463
464 def test_compile_suite(self):
465 st = parser.suite('x = 2; y = x + 3')
466 code = parser.compilest(st)
467 globs = {}
Georg Brandl7cae87c2006-09-06 06:51:57 +0000[diff] [blame]468 exec(code, globs)
Jeremy Hylton3e0055f2005-10-20 19:59:25 +0000[diff] [blame]469 self.assertEquals(globs['y'], 5)
470
471 def test_compile_error(self):
472 st = parser.suite('1 = 3 + 4')
473 self.assertRaises(SyntaxError, parser.compilest, st)
474
Guido van Rossumb5a755e2007-07-18 18:15:48 +0000[diff] [blame]475 def test_compile_badunicode(self):
Guido van Rossum7eb6ca52007-07-18 21:00:22 +0000[diff] [blame]476 st = parser.suite('a = "\\U12345678"')
Guido van Rossumb5a755e2007-07-18 18:15:48 +0000[diff] [blame]477 self.assertRaises(SyntaxError, parser.compilest, st)
Guido van Rossum7eb6ca52007-07-18 21:00:22 +0000[diff] [blame]478 st = parser.suite('a = "\\u1"')
Guido van Rossumb5a755e2007-07-18 18:15:48 +0000[diff] [blame]479 self.assertRaises(SyntaxError, parser.compilest, st)
480
Christian Heimes90c3d9b2008-02-23 13:18:03 +0000[diff] [blame]481class ParserStackLimitTestCase(unittest.TestCase):
482 """try to push the parser to/over it's limits.
483 see http://bugs.python.org/issue1881 for a discussion
484 """
485 def _nested_expression(self, level):
486 return "["*level+"]"*level
487
488 def test_deeply_nested_list(self):
489 # XXX used to be 99 levels in 2.x
490 e = self._nested_expression(93)
491 st = parser.expr(e)
492 st.compile()
493
494 def test_trigger_memory_error(self):
495 e = self._nested_expression(100)
Christian Heimesb186d002008-03-18 15:15:01 +0000[diff] [blame]496 print("Expecting 's_push: parser stack overflow' in next line",
497 file=sys.stderr)
Christian Heimes90c3d9b2008-02-23 13:18:03 +0000[diff] [blame]498 self.assertRaises(MemoryError, parser.expr, e)
499
Mark Dickinson211c6252009-02-01 10:28:51 +0000[diff] [blame]500class STObjectTestCase(unittest.TestCase):
501 """Test operations on ST objects themselves"""
502
503 def test_comparisons(self):
504 # ST objects should support order and equality comparisons
505 st1 = parser.expr('2 + 3')
506 st2 = parser.suite('x = 2; y = x + 3')
507 st3 = parser.expr('list(x**3 for x in range(20))')
508 st1_copy = parser.expr('2 + 3')
509 st2_copy = parser.suite('x = 2; y = x + 3')
510 st3_copy = parser.expr('list(x**3 for x in range(20))')
511
512 # exercise fast path for object identity
513 self.assertEquals(st1 == st1, True)
514 self.assertEquals(st2 == st2, True)
515 self.assertEquals(st3 == st3, True)
516 # slow path equality
517 self.assertEqual(st1, st1_copy)
518 self.assertEqual(st2, st2_copy)
519 self.assertEqual(st3, st3_copy)
520 self.assertEquals(st1 == st2, False)
521 self.assertEquals(st1 == st3, False)
522 self.assertEquals(st2 == st3, False)
523 self.assertEquals(st1 != st1, False)
524 self.assertEquals(st2 != st2, False)
525 self.assertEquals(st3 != st3, False)
526 self.assertEquals(st1 != st1_copy, False)
527 self.assertEquals(st2 != st2_copy, False)
528 self.assertEquals(st3 != st3_copy, False)
529 self.assertEquals(st2 != st1, True)
530 self.assertEquals(st1 != st3, True)
531 self.assertEquals(st3 != st2, True)
532 # we don't particularly care what the ordering is; just that
533 # it's usable and self-consistent
534 self.assertEquals(st1 < st2, not (st2 <= st1))
535 self.assertEquals(st1 < st3, not (st3 <= st1))
536 self.assertEquals(st2 < st3, not (st3 <= st2))
537 self.assertEquals(st1 < st2, st2 > st1)
538 self.assertEquals(st1 < st3, st3 > st1)
539 self.assertEquals(st2 < st3, st3 > st2)
540 self.assertEquals(st1 <= st2, st2 >= st1)
541 self.assertEquals(st3 <= st1, st1 >= st3)
542 self.assertEquals(st2 <= st3, st3 >= st2)
543 # transitivity
544 bottom = min(st1, st2, st3)
545 top = max(st1, st2, st3)
546 mid = sorted([st1, st2, st3])[1]
547 self.assert_(bottom < mid)
548 self.assert_(bottom < top)
549 self.assert_(mid < top)
550 self.assert_(bottom <= mid)
551 self.assert_(bottom <= top)
552 self.assert_(mid <= top)
553 self.assert_(bottom <= bottom)
554 self.assert_(mid <= mid)
555 self.assert_(top <= top)
556 # interaction with other types
557 self.assertEquals(st1 == 1588.602459, False)
558 self.assertEquals('spanish armada' != st2, True)
559 self.assertRaises(TypeError, operator.ge, st3, None)
560 self.assertRaises(TypeError, operator.le, False, st1)
561 self.assertRaises(TypeError, operator.lt, st1, 1815)
562 self.assertRaises(TypeError, operator.gt, b'waterloo', st2)
563
564
565 # XXX tests for pickling and unpickling of ST objects should go here
566
567
Fred Drake2e2be372001-09-20 21:33:42 +0000[diff] [blame]568def test_main():
Benjamin Petersonee8712c2008-05-20 21:35:26 +0000[diff] [blame]569 support.run_unittest(
Walter Dörwald21d3a322003-05-01 17:45:56 +0000[diff] [blame]570 RoundtripLegalSyntaxTestCase,
Jeremy Hylton3e0055f2005-10-20 19:59:25 +0000[diff] [blame]571 IllegalSyntaxTestCase,
572 CompileTestCase,
Christian Heimes90c3d9b2008-02-23 13:18:03 +0000[diff] [blame]573 ParserStackLimitTestCase,
Mark Dickinson211c6252009-02-01 10:28:51 +0000[diff] [blame]574 STObjectTestCase,
Walter Dörwald21d3a322003-05-01 17:45:56 +0000[diff] [blame]575 )
Fred Drake2e2be372001-09-20 21:33:42 +0000[diff] [blame]576
577
578if __name__ == "__main__":
579 test_main()