]> git.proxmox.com Git - mirror_edk2.git/blame - AppPkg/Applications/Python/Python-2.7.2/Lib/lib2to3/tests/test_pytree.py
projects / mirror_edk2.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
EmbeddedPkg: Extend NvVarStoreFormattedLib LIBRARY_CLASS
[mirror_edk2.git] / AppPkg / Applications / Python / Python-2.7.2 / Lib / lib2to3 / tests / test_pytree.py
CommitLineData
4710c53d 1# Copyright 2006 Google, Inc. All Rights Reserved.\r
2# Licensed to PSF under a Contributor Agreement.\r
3\r
4"""Unit tests for pytree.py.\r
5\r
6NOTE: Please *don't* add doc strings to individual test methods!\r
7In verbose mode, printing of the module, class and method name is much\r
8more helpful than printing of (the first line of) the docstring,\r
9especially when debugging a test.\r
10"""\r
11\r
12from __future__ import with_statement\r
13\r
14import sys\r
15import warnings\r
16\r
17# Testing imports\r
18from . import support\r
19\r
20from lib2to3 import pytree\r
21\r
22try:\r
23 sorted\r
24except NameError:\r
25 def sorted(lst):\r
26 l = list(lst)\r
27 l.sort()\r
28 return l\r
29\r
30class TestNodes(support.TestCase):\r
31\r
32 """Unit tests for nodes (Base, Leaf, Node)."""\r
33\r
34 if sys.version_info >= (2,6):\r
35 # warnings.catch_warnings is new in 2.6.\r
36 def test_deprecated_prefix_methods(self):\r
37 l = pytree.Leaf(100, "foo")\r
38 with warnings.catch_warnings(record=True) as w:\r
39 warnings.simplefilter("always", DeprecationWarning)\r
40 self.assertEqual(l.get_prefix(), "")\r
41 l.set_prefix("hi")\r
42 self.assertEqual(l.prefix, "hi")\r
43 self.assertEqual(len(w), 2)\r
44 for warning in w:\r
45 self.assertTrue(warning.category is DeprecationWarning)\r
46 self.assertEqual(str(w[0].message), "get_prefix() is deprecated; " \\r
47 "use the prefix property")\r
48 self.assertEqual(str(w[1].message), "set_prefix() is deprecated; " \\r
49 "use the prefix property")\r
50\r
51 def test_instantiate_base(self):\r
52 if __debug__:\r
53 # Test that instantiating Base() raises an AssertionError\r
54 self.assertRaises(AssertionError, pytree.Base)\r
55\r
56 def test_leaf(self):\r
57 l1 = pytree.Leaf(100, "foo")\r
58 self.assertEqual(l1.type, 100)\r
59 self.assertEqual(l1.value, "foo")\r
60\r
61 def test_leaf_repr(self):\r
62 l1 = pytree.Leaf(100, "foo")\r
63 self.assertEqual(repr(l1), "Leaf(100, 'foo')")\r
64\r
65 def test_leaf_str(self):\r
66 l1 = pytree.Leaf(100, "foo")\r
67 self.assertEqual(str(l1), "foo")\r
68 l2 = pytree.Leaf(100, "foo", context=(" ", (10, 1)))\r
69 self.assertEqual(str(l2), " foo")\r
70\r
71 def test_leaf_str_numeric_value(self):\r
72 # Make sure that the Leaf's value is stringified. Failing to\r
73 # do this can cause a TypeError in certain situations.\r
74 l1 = pytree.Leaf(2, 5)\r
75 l1.prefix = "foo_"\r
76 self.assertEqual(str(l1), "foo_5")\r
77\r
78 def test_leaf_equality(self):\r
79 l1 = pytree.Leaf(100, "foo")\r
80 l2 = pytree.Leaf(100, "foo", context=(" ", (1, 0)))\r
81 self.assertEqual(l1, l2)\r
82 l3 = pytree.Leaf(101, "foo")\r
83 l4 = pytree.Leaf(100, "bar")\r
84 self.assertNotEqual(l1, l3)\r
85 self.assertNotEqual(l1, l4)\r
86\r
87 def test_leaf_prefix(self):\r
88 l1 = pytree.Leaf(100, "foo")\r
89 self.assertEqual(l1.prefix, "")\r
90 self.assertFalse(l1.was_changed)\r
91 l1.prefix = " ##\n\n"\r
92 self.assertEqual(l1.prefix, " ##\n\n")\r
93 self.assertTrue(l1.was_changed)\r
94\r
95 def test_node(self):\r
96 l1 = pytree.Leaf(100, "foo")\r
97 l2 = pytree.Leaf(200, "bar")\r
98 n1 = pytree.Node(1000, [l1, l2])\r
99 self.assertEqual(n1.type, 1000)\r
100 self.assertEqual(n1.children, [l1, l2])\r
101\r
102 def test_node_repr(self):\r
103 l1 = pytree.Leaf(100, "foo")\r
104 l2 = pytree.Leaf(100, "bar", context=(" ", (1, 0)))\r
105 n1 = pytree.Node(1000, [l1, l2])\r
106 self.assertEqual(repr(n1),\r
107 "Node(1000, [%s, %s])" % (repr(l1), repr(l2)))\r
108\r
109 def test_node_str(self):\r
110 l1 = pytree.Leaf(100, "foo")\r
111 l2 = pytree.Leaf(100, "bar", context=(" ", (1, 0)))\r
112 n1 = pytree.Node(1000, [l1, l2])\r
113 self.assertEqual(str(n1), "foo bar")\r
114\r
115 def test_node_prefix(self):\r
116 l1 = pytree.Leaf(100, "foo")\r
117 self.assertEqual(l1.prefix, "")\r
118 n1 = pytree.Node(1000, [l1])\r
119 self.assertEqual(n1.prefix, "")\r
120 n1.prefix = " "\r
121 self.assertEqual(n1.prefix, " ")\r
122 self.assertEqual(l1.prefix, " ")\r
123\r
124 def test_get_suffix(self):\r
125 l1 = pytree.Leaf(100, "foo", prefix="a")\r
126 l2 = pytree.Leaf(100, "bar", prefix="b")\r
127 n1 = pytree.Node(1000, [l1, l2])\r
128\r
129 self.assertEqual(l1.get_suffix(), l2.prefix)\r
130 self.assertEqual(l2.get_suffix(), "")\r
131 self.assertEqual(n1.get_suffix(), "")\r
132\r
133 l3 = pytree.Leaf(100, "bar", prefix="c")\r
134 n2 = pytree.Node(1000, [n1, l3])\r
135\r
136 self.assertEqual(n1.get_suffix(), l3.prefix)\r
137 self.assertEqual(l3.get_suffix(), "")\r
138 self.assertEqual(n2.get_suffix(), "")\r
139\r
140 def test_node_equality(self):\r
141 n1 = pytree.Node(1000, ())\r
142 n2 = pytree.Node(1000, [], context=(" ", (1, 0)))\r
143 self.assertEqual(n1, n2)\r
144 n3 = pytree.Node(1001, ())\r
145 self.assertNotEqual(n1, n3)\r
146\r
147 def test_node_recursive_equality(self):\r
148 l1 = pytree.Leaf(100, "foo")\r
149 l2 = pytree.Leaf(100, "foo")\r
150 n1 = pytree.Node(1000, [l1])\r
151 n2 = pytree.Node(1000, [l2])\r
152 self.assertEqual(n1, n2)\r
153 l3 = pytree.Leaf(100, "bar")\r
154 n3 = pytree.Node(1000, [l3])\r
155 self.assertNotEqual(n1, n3)\r
156\r
157 def test_replace(self):\r
158 l1 = pytree.Leaf(100, "foo")\r
159 l2 = pytree.Leaf(100, "+")\r
160 l3 = pytree.Leaf(100, "bar")\r
161 n1 = pytree.Node(1000, [l1, l2, l3])\r
162 self.assertEqual(n1.children, [l1, l2, l3])\r
163 self.assertTrue(isinstance(n1.children, list))\r
164 self.assertFalse(n1.was_changed)\r
165 l2new = pytree.Leaf(100, "-")\r
166 l2.replace(l2new)\r
167 self.assertEqual(n1.children, [l1, l2new, l3])\r
168 self.assertTrue(isinstance(n1.children, list))\r
169 self.assertTrue(n1.was_changed)\r
170\r
171 def test_replace_with_list(self):\r
172 l1 = pytree.Leaf(100, "foo")\r
173 l2 = pytree.Leaf(100, "+")\r
174 l3 = pytree.Leaf(100, "bar")\r
175 n1 = pytree.Node(1000, [l1, l2, l3])\r
176\r
177 l2.replace([pytree.Leaf(100, "*"), pytree.Leaf(100, "*")])\r
178 self.assertEqual(str(n1), "foo**bar")\r
179 self.assertTrue(isinstance(n1.children, list))\r
180\r
181 def test_leaves(self):\r
182 l1 = pytree.Leaf(100, "foo")\r
183 l2 = pytree.Leaf(100, "bar")\r
184 l3 = pytree.Leaf(100, "fooey")\r
185 n2 = pytree.Node(1000, [l1, l2])\r
186 n3 = pytree.Node(1000, [l3])\r
187 n1 = pytree.Node(1000, [n2, n3])\r
188\r
189 self.assertEqual(list(n1.leaves()), [l1, l2, l3])\r
190\r
191 def test_depth(self):\r
192 l1 = pytree.Leaf(100, "foo")\r
193 l2 = pytree.Leaf(100, "bar")\r
194 n2 = pytree.Node(1000, [l1, l2])\r
195 n3 = pytree.Node(1000, [])\r
196 n1 = pytree.Node(1000, [n2, n3])\r
197\r
198 self.assertEqual(l1.depth(), 2)\r
199 self.assertEqual(n3.depth(), 1)\r
200 self.assertEqual(n1.depth(), 0)\r
201\r
202 def test_post_order(self):\r
203 l1 = pytree.Leaf(100, "foo")\r
204 l2 = pytree.Leaf(100, "bar")\r
205 l3 = pytree.Leaf(100, "fooey")\r
206 c1 = pytree.Node(1000, [l1, l2])\r
207 n1 = pytree.Node(1000, [c1, l3])\r
208 self.assertEqual(list(n1.post_order()), [l1, l2, c1, l3, n1])\r
209\r
210 def test_pre_order(self):\r
211 l1 = pytree.Leaf(100, "foo")\r
212 l2 = pytree.Leaf(100, "bar")\r
213 l3 = pytree.Leaf(100, "fooey")\r
214 c1 = pytree.Node(1000, [l1, l2])\r
215 n1 = pytree.Node(1000, [c1, l3])\r
216 self.assertEqual(list(n1.pre_order()), [n1, c1, l1, l2, l3])\r
217\r
218 def test_changed(self):\r
219 l1 = pytree.Leaf(100, "f")\r
220 self.assertFalse(l1.was_changed)\r
221 l1.changed()\r
222 self.assertTrue(l1.was_changed)\r
223\r
224 l1 = pytree.Leaf(100, "f")\r
225 n1 = pytree.Node(1000, [l1])\r
226 self.assertFalse(n1.was_changed)\r
227 n1.changed()\r
228 self.assertTrue(n1.was_changed)\r
229\r
230 l1 = pytree.Leaf(100, "foo")\r
231 l2 = pytree.Leaf(100, "+")\r
232 l3 = pytree.Leaf(100, "bar")\r
233 n1 = pytree.Node(1000, [l1, l2, l3])\r
234 n2 = pytree.Node(1000, [n1])\r
235 self.assertFalse(l1.was_changed)\r
236 self.assertFalse(n1.was_changed)\r
237 self.assertFalse(n2.was_changed)\r
238\r
239 n1.changed()\r
240 self.assertTrue(n1.was_changed)\r
241 self.assertTrue(n2.was_changed)\r
242 self.assertFalse(l1.was_changed)\r
243\r
244 def test_leaf_constructor_prefix(self):\r
245 for prefix in ("xyz_", ""):\r
246 l1 = pytree.Leaf(100, "self", prefix=prefix)\r
247 self.assertTrue(str(l1), prefix + "self")\r
248 self.assertEqual(l1.prefix, prefix)\r
249\r
250 def test_node_constructor_prefix(self):\r
251 for prefix in ("xyz_", ""):\r
252 l1 = pytree.Leaf(100, "self")\r
253 l2 = pytree.Leaf(100, "foo", prefix="_")\r
254 n1 = pytree.Node(1000, [l1, l2], prefix=prefix)\r
255 self.assertTrue(str(n1), prefix + "self_foo")\r
256 self.assertEqual(n1.prefix, prefix)\r
257 self.assertEqual(l1.prefix, prefix)\r
258 self.assertEqual(l2.prefix, "_")\r
259\r
260 def test_remove(self):\r
261 l1 = pytree.Leaf(100, "foo")\r
262 l2 = pytree.Leaf(100, "foo")\r
263 n1 = pytree.Node(1000, [l1, l2])\r
264 n2 = pytree.Node(1000, [n1])\r
265\r
266 self.assertEqual(n1.remove(), 0)\r
267 self.assertEqual(n2.children, [])\r
268 self.assertEqual(l1.parent, n1)\r
269 self.assertEqual(n1.parent, None)\r
270 self.assertEqual(n2.parent, None)\r
271 self.assertFalse(n1.was_changed)\r
272 self.assertTrue(n2.was_changed)\r
273\r
274 self.assertEqual(l2.remove(), 1)\r
275 self.assertEqual(l1.remove(), 0)\r
276 self.assertEqual(n1.children, [])\r
277 self.assertEqual(l1.parent, None)\r
278 self.assertEqual(n1.parent, None)\r
279 self.assertEqual(n2.parent, None)\r
280 self.assertTrue(n1.was_changed)\r
281 self.assertTrue(n2.was_changed)\r
282\r
283 def test_remove_parentless(self):\r
284 n1 = pytree.Node(1000, [])\r
285 n1.remove()\r
286 self.assertEqual(n1.parent, None)\r
287\r
288 l1 = pytree.Leaf(100, "foo")\r
289 l1.remove()\r
290 self.assertEqual(l1.parent, None)\r
291\r
292 def test_node_set_child(self):\r
293 l1 = pytree.Leaf(100, "foo")\r
294 n1 = pytree.Node(1000, [l1])\r
295\r
296 l2 = pytree.Leaf(100, "bar")\r
297 n1.set_child(0, l2)\r
298 self.assertEqual(l1.parent, None)\r
299 self.assertEqual(l2.parent, n1)\r
300 self.assertEqual(n1.children, [l2])\r
301\r
302 n2 = pytree.Node(1000, [l1])\r
303 n2.set_child(0, n1)\r
304 self.assertEqual(l1.parent, None)\r
305 self.assertEqual(n1.parent, n2)\r
306 self.assertEqual(n2.parent, None)\r
307 self.assertEqual(n2.children, [n1])\r
308\r
309 self.assertRaises(IndexError, n1.set_child, 4, l2)\r
310 # I don't care what it raises, so long as it's an exception\r
311 self.assertRaises(Exception, n1.set_child, 0, list)\r
312\r
313 def test_node_insert_child(self):\r
314 l1 = pytree.Leaf(100, "foo")\r
315 n1 = pytree.Node(1000, [l1])\r
316\r
317 l2 = pytree.Leaf(100, "bar")\r
318 n1.insert_child(0, l2)\r
319 self.assertEqual(l2.parent, n1)\r
320 self.assertEqual(n1.children, [l2, l1])\r
321\r
322 l3 = pytree.Leaf(100, "abc")\r
323 n1.insert_child(2, l3)\r
324 self.assertEqual(n1.children, [l2, l1, l3])\r
325\r
326 # I don't care what it raises, so long as it's an exception\r
327 self.assertRaises(Exception, n1.insert_child, 0, list)\r
328\r
329 def test_node_append_child(self):\r
330 n1 = pytree.Node(1000, [])\r
331\r
332 l1 = pytree.Leaf(100, "foo")\r
333 n1.append_child(l1)\r
334 self.assertEqual(l1.parent, n1)\r
335 self.assertEqual(n1.children, [l1])\r
336\r
337 l2 = pytree.Leaf(100, "bar")\r
338 n1.append_child(l2)\r
339 self.assertEqual(l2.parent, n1)\r
340 self.assertEqual(n1.children, [l1, l2])\r
341\r
342 # I don't care what it raises, so long as it's an exception\r
343 self.assertRaises(Exception, n1.append_child, list)\r
344\r
345 def test_node_next_sibling(self):\r
346 n1 = pytree.Node(1000, [])\r
347 n2 = pytree.Node(1000, [])\r
348 p1 = pytree.Node(1000, [n1, n2])\r
349\r
350 self.assertTrue(n1.next_sibling is n2)\r
351 self.assertEqual(n2.next_sibling, None)\r
352 self.assertEqual(p1.next_sibling, None)\r
353\r
354 def test_leaf_next_sibling(self):\r
355 l1 = pytree.Leaf(100, "a")\r
356 l2 = pytree.Leaf(100, "b")\r
357 p1 = pytree.Node(1000, [l1, l2])\r
358\r
359 self.assertTrue(l1.next_sibling is l2)\r
360 self.assertEqual(l2.next_sibling, None)\r
361 self.assertEqual(p1.next_sibling, None)\r
362\r
363 def test_node_prev_sibling(self):\r
364 n1 = pytree.Node(1000, [])\r
365 n2 = pytree.Node(1000, [])\r
366 p1 = pytree.Node(1000, [n1, n2])\r
367\r
368 self.assertTrue(n2.prev_sibling is n1)\r
369 self.assertEqual(n1.prev_sibling, None)\r
370 self.assertEqual(p1.prev_sibling, None)\r
371\r
372 def test_leaf_prev_sibling(self):\r
373 l1 = pytree.Leaf(100, "a")\r
374 l2 = pytree.Leaf(100, "b")\r
375 p1 = pytree.Node(1000, [l1, l2])\r
376\r
377 self.assertTrue(l2.prev_sibling is l1)\r
378 self.assertEqual(l1.prev_sibling, None)\r
379 self.assertEqual(p1.prev_sibling, None)\r
380\r
381\r
382class TestPatterns(support.TestCase):\r
383\r
384 """Unit tests for tree matching patterns."""\r
385\r
386 def test_basic_patterns(self):\r
387 # Build a tree\r
388 l1 = pytree.Leaf(100, "foo")\r
389 l2 = pytree.Leaf(100, "bar")\r
390 l3 = pytree.Leaf(100, "foo")\r
391 n1 = pytree.Node(1000, [l1, l2])\r
392 n2 = pytree.Node(1000, [l3])\r
393 root = pytree.Node(1000, [n1, n2])\r
394 # Build a pattern matching a leaf\r
395 pl = pytree.LeafPattern(100, "foo", name="pl")\r
396 r = {}\r
397 self.assertFalse(pl.match(root, results=r))\r
398 self.assertEqual(r, {})\r
399 self.assertFalse(pl.match(n1, results=r))\r
400 self.assertEqual(r, {})\r
401 self.assertFalse(pl.match(n2, results=r))\r
402 self.assertEqual(r, {})\r
403 self.assertTrue(pl.match(l1, results=r))\r
404 self.assertEqual(r, {"pl": l1})\r
405 r = {}\r
406 self.assertFalse(pl.match(l2, results=r))\r
407 self.assertEqual(r, {})\r
408 # Build a pattern matching a node\r
409 pn = pytree.NodePattern(1000, [pl], name="pn")\r
410 self.assertFalse(pn.match(root, results=r))\r
411 self.assertEqual(r, {})\r
412 self.assertFalse(pn.match(n1, results=r))\r
413 self.assertEqual(r, {})\r
414 self.assertTrue(pn.match(n2, results=r))\r
415 self.assertEqual(r, {"pn": n2, "pl": l3})\r
416 r = {}\r
417 self.assertFalse(pn.match(l1, results=r))\r
418 self.assertEqual(r, {})\r
419 self.assertFalse(pn.match(l2, results=r))\r
420 self.assertEqual(r, {})\r
421\r
422 def test_wildcard(self):\r
423 # Build a tree for testing\r
424 l1 = pytree.Leaf(100, "foo")\r
425 l2 = pytree.Leaf(100, "bar")\r
426 l3 = pytree.Leaf(100, "foo")\r
427 n1 = pytree.Node(1000, [l1, l2])\r
428 n2 = pytree.Node(1000, [l3])\r
429 root = pytree.Node(1000, [n1, n2])\r
430 # Build a pattern\r
431 pl = pytree.LeafPattern(100, "foo", name="pl")\r
432 pn = pytree.NodePattern(1000, [pl], name="pn")\r
433 pw = pytree.WildcardPattern([[pn], [pl, pl]], name="pw")\r
434 r = {}\r
435 self.assertFalse(pw.match_seq([root], r))\r
436 self.assertEqual(r, {})\r
437 self.assertFalse(pw.match_seq([n1], r))\r
438 self.assertEqual(r, {})\r
439 self.assertTrue(pw.match_seq([n2], r))\r
440 # These are easier to debug\r
441 self.assertEqual(sorted(r.keys()), ["pl", "pn", "pw"])\r
442 self.assertEqual(r["pl"], l1)\r
443 self.assertEqual(r["pn"], n2)\r
444 self.assertEqual(r["pw"], [n2])\r
445 # But this is equivalent\r
446 self.assertEqual(r, {"pl": l1, "pn": n2, "pw": [n2]})\r
447 r = {}\r
448 self.assertTrue(pw.match_seq([l1, l3], r))\r
449 self.assertEqual(r, {"pl": l3, "pw": [l1, l3]})\r
450 self.assertTrue(r["pl"] is l3)\r
451 r = {}\r
452\r
453 def test_generate_matches(self):\r
454 la = pytree.Leaf(1, "a")\r
455 lb = pytree.Leaf(1, "b")\r
456 lc = pytree.Leaf(1, "c")\r
457 ld = pytree.Leaf(1, "d")\r
458 le = pytree.Leaf(1, "e")\r
459 lf = pytree.Leaf(1, "f")\r
460 leaves = [la, lb, lc, ld, le, lf]\r
461 root = pytree.Node(1000, leaves)\r
462 pa = pytree.LeafPattern(1, "a", "pa")\r
463 pb = pytree.LeafPattern(1, "b", "pb")\r
464 pc = pytree.LeafPattern(1, "c", "pc")\r
465 pd = pytree.LeafPattern(1, "d", "pd")\r
466 pe = pytree.LeafPattern(1, "e", "pe")\r
467 pf = pytree.LeafPattern(1, "f", "pf")\r
468 pw = pytree.WildcardPattern([[pa, pb, pc], [pd, pe],\r
469 [pa, pb], [pc, pd], [pe, pf]],\r
470 min=1, max=4, name="pw")\r
471 self.assertEqual([x[0] for x in pw.generate_matches(leaves)],\r
472 [3, 5, 2, 4, 6])\r
473 pr = pytree.NodePattern(type=1000, content=[pw], name="pr")\r
474 matches = list(pytree.generate_matches([pr], [root]))\r
475 self.assertEqual(len(matches), 1)\r
476 c, r = matches[0]\r
477 self.assertEqual(c, 1)\r
478 self.assertEqual(str(r["pr"]), "abcdef")\r
479 self.assertEqual(r["pw"], [la, lb, lc, ld, le, lf])\r
480 for c in "abcdef":\r
481 self.assertEqual(r["p" + c], pytree.Leaf(1, c))\r
482\r
483 def test_has_key_example(self):\r
484 pattern = pytree.NodePattern(331,\r
485 (pytree.LeafPattern(7),\r
486 pytree.WildcardPattern(name="args"),\r
487 pytree.LeafPattern(8)))\r
488 l1 = pytree.Leaf(7, "(")\r
489 l2 = pytree.Leaf(3, "x")\r
490 l3 = pytree.Leaf(8, ")")\r
491 node = pytree.Node(331, [l1, l2, l3])\r
492 r = {}\r
493 self.assertTrue(pattern.match(node, r))\r
494 self.assertEqual(r["args"], [l2])\r
EFI Development Kit II mirror for PVE