+++ /dev/null
-# Copyright 2006 Google, Inc. All Rights Reserved.\r
-# Licensed to PSF under a Contributor Agreement.\r
-\r
-"""Unit tests for pytree.py.\r
-\r
-NOTE: Please *don't* add doc strings to individual test methods!\r
-In verbose mode, printing of the module, class and method name is much\r
-more helpful than printing of (the first line of) the docstring,\r
-especially when debugging a test.\r
-"""\r
-\r
-from __future__ import with_statement\r
-\r
-import sys\r
-import warnings\r
-\r
-# Testing imports\r
-from . import support\r
-\r
-from lib2to3 import pytree\r
-\r
-try:\r
- sorted\r
-except NameError:\r
- def sorted(lst):\r
- l = list(lst)\r
- l.sort()\r
- return l\r
-\r
-class TestNodes(support.TestCase):\r
-\r
- """Unit tests for nodes (Base, Leaf, Node)."""\r
-\r
- if sys.version_info >= (2,6):\r
- # warnings.catch_warnings is new in 2.6.\r
- def test_deprecated_prefix_methods(self):\r
- l = pytree.Leaf(100, "foo")\r
- with warnings.catch_warnings(record=True) as w:\r
- warnings.simplefilter("always", DeprecationWarning)\r
- self.assertEqual(l.get_prefix(), "")\r
- l.set_prefix("hi")\r
- self.assertEqual(l.prefix, "hi")\r
- self.assertEqual(len(w), 2)\r
- for warning in w:\r
- self.assertTrue(warning.category is DeprecationWarning)\r
- self.assertEqual(str(w[0].message), "get_prefix() is deprecated; " \\r
- "use the prefix property")\r
- self.assertEqual(str(w[1].message), "set_prefix() is deprecated; " \\r
- "use the prefix property")\r
-\r
- def test_instantiate_base(self):\r
- if __debug__:\r
- # Test that instantiating Base() raises an AssertionError\r
- self.assertRaises(AssertionError, pytree.Base)\r
-\r
- def test_leaf(self):\r
- l1 = pytree.Leaf(100, "foo")\r
- self.assertEqual(l1.type, 100)\r
- self.assertEqual(l1.value, "foo")\r
-\r
- def test_leaf_repr(self):\r
- l1 = pytree.Leaf(100, "foo")\r
- self.assertEqual(repr(l1), "Leaf(100, 'foo')")\r
-\r
- def test_leaf_str(self):\r
- l1 = pytree.Leaf(100, "foo")\r
- self.assertEqual(str(l1), "foo")\r
- l2 = pytree.Leaf(100, "foo", context=(" ", (10, 1)))\r
- self.assertEqual(str(l2), " foo")\r
-\r
- def test_leaf_str_numeric_value(self):\r
- # Make sure that the Leaf's value is stringified. Failing to\r
- # do this can cause a TypeError in certain situations.\r
- l1 = pytree.Leaf(2, 5)\r
- l1.prefix = "foo_"\r
- self.assertEqual(str(l1), "foo_5")\r
-\r
- def test_leaf_equality(self):\r
- l1 = pytree.Leaf(100, "foo")\r
- l2 = pytree.Leaf(100, "foo", context=(" ", (1, 0)))\r
- self.assertEqual(l1, l2)\r
- l3 = pytree.Leaf(101, "foo")\r
- l4 = pytree.Leaf(100, "bar")\r
- self.assertNotEqual(l1, l3)\r
- self.assertNotEqual(l1, l4)\r
-\r
- def test_leaf_prefix(self):\r
- l1 = pytree.Leaf(100, "foo")\r
- self.assertEqual(l1.prefix, "")\r
- self.assertFalse(l1.was_changed)\r
- l1.prefix = " ##\n\n"\r
- self.assertEqual(l1.prefix, " ##\n\n")\r
- self.assertTrue(l1.was_changed)\r
-\r
- def test_node(self):\r
- l1 = pytree.Leaf(100, "foo")\r
- l2 = pytree.Leaf(200, "bar")\r
- n1 = pytree.Node(1000, [l1, l2])\r
- self.assertEqual(n1.type, 1000)\r
- self.assertEqual(n1.children, [l1, l2])\r
-\r
- def test_node_repr(self):\r
- l1 = pytree.Leaf(100, "foo")\r
- l2 = pytree.Leaf(100, "bar", context=(" ", (1, 0)))\r
- n1 = pytree.Node(1000, [l1, l2])\r
- self.assertEqual(repr(n1),\r
- "Node(1000, [%s, %s])" % (repr(l1), repr(l2)))\r
-\r
- def test_node_str(self):\r
- l1 = pytree.Leaf(100, "foo")\r
- l2 = pytree.Leaf(100, "bar", context=(" ", (1, 0)))\r
- n1 = pytree.Node(1000, [l1, l2])\r
- self.assertEqual(str(n1), "foo bar")\r
-\r
- def test_node_prefix(self):\r
- l1 = pytree.Leaf(100, "foo")\r
- self.assertEqual(l1.prefix, "")\r
- n1 = pytree.Node(1000, [l1])\r
- self.assertEqual(n1.prefix, "")\r
- n1.prefix = " "\r
- self.assertEqual(n1.prefix, " ")\r
- self.assertEqual(l1.prefix, " ")\r
-\r
- def test_get_suffix(self):\r
- l1 = pytree.Leaf(100, "foo", prefix="a")\r
- l2 = pytree.Leaf(100, "bar", prefix="b")\r
- n1 = pytree.Node(1000, [l1, l2])\r
-\r
- self.assertEqual(l1.get_suffix(), l2.prefix)\r
- self.assertEqual(l2.get_suffix(), "")\r
- self.assertEqual(n1.get_suffix(), "")\r
-\r
- l3 = pytree.Leaf(100, "bar", prefix="c")\r
- n2 = pytree.Node(1000, [n1, l3])\r
-\r
- self.assertEqual(n1.get_suffix(), l3.prefix)\r
- self.assertEqual(l3.get_suffix(), "")\r
- self.assertEqual(n2.get_suffix(), "")\r
-\r
- def test_node_equality(self):\r
- n1 = pytree.Node(1000, ())\r
- n2 = pytree.Node(1000, [], context=(" ", (1, 0)))\r
- self.assertEqual(n1, n2)\r
- n3 = pytree.Node(1001, ())\r
- self.assertNotEqual(n1, n3)\r
-\r
- def test_node_recursive_equality(self):\r
- l1 = pytree.Leaf(100, "foo")\r
- l2 = pytree.Leaf(100, "foo")\r
- n1 = pytree.Node(1000, [l1])\r
- n2 = pytree.Node(1000, [l2])\r
- self.assertEqual(n1, n2)\r
- l3 = pytree.Leaf(100, "bar")\r
- n3 = pytree.Node(1000, [l3])\r
- self.assertNotEqual(n1, n3)\r
-\r
- def test_replace(self):\r
- l1 = pytree.Leaf(100, "foo")\r
- l2 = pytree.Leaf(100, "+")\r
- l3 = pytree.Leaf(100, "bar")\r
- n1 = pytree.Node(1000, [l1, l2, l3])\r
- self.assertEqual(n1.children, [l1, l2, l3])\r
- self.assertTrue(isinstance(n1.children, list))\r
- self.assertFalse(n1.was_changed)\r
- l2new = pytree.Leaf(100, "-")\r
- l2.replace(l2new)\r
- self.assertEqual(n1.children, [l1, l2new, l3])\r
- self.assertTrue(isinstance(n1.children, list))\r
- self.assertTrue(n1.was_changed)\r
-\r
- def test_replace_with_list(self):\r
- l1 = pytree.Leaf(100, "foo")\r
- l2 = pytree.Leaf(100, "+")\r
- l3 = pytree.Leaf(100, "bar")\r
- n1 = pytree.Node(1000, [l1, l2, l3])\r
-\r
- l2.replace([pytree.Leaf(100, "*"), pytree.Leaf(100, "*")])\r
- self.assertEqual(str(n1), "foo**bar")\r
- self.assertTrue(isinstance(n1.children, list))\r
-\r
- def test_leaves(self):\r
- l1 = pytree.Leaf(100, "foo")\r
- l2 = pytree.Leaf(100, "bar")\r
- l3 = pytree.Leaf(100, "fooey")\r
- n2 = pytree.Node(1000, [l1, l2])\r
- n3 = pytree.Node(1000, [l3])\r
- n1 = pytree.Node(1000, [n2, n3])\r
-\r
- self.assertEqual(list(n1.leaves()), [l1, l2, l3])\r
-\r
- def test_depth(self):\r
- l1 = pytree.Leaf(100, "foo")\r
- l2 = pytree.Leaf(100, "bar")\r
- n2 = pytree.Node(1000, [l1, l2])\r
- n3 = pytree.Node(1000, [])\r
- n1 = pytree.Node(1000, [n2, n3])\r
-\r
- self.assertEqual(l1.depth(), 2)\r
- self.assertEqual(n3.depth(), 1)\r
- self.assertEqual(n1.depth(), 0)\r
-\r
- def test_post_order(self):\r
- l1 = pytree.Leaf(100, "foo")\r
- l2 = pytree.Leaf(100, "bar")\r
- l3 = pytree.Leaf(100, "fooey")\r
- c1 = pytree.Node(1000, [l1, l2])\r
- n1 = pytree.Node(1000, [c1, l3])\r
- self.assertEqual(list(n1.post_order()), [l1, l2, c1, l3, n1])\r
-\r
- def test_pre_order(self):\r
- l1 = pytree.Leaf(100, "foo")\r
- l2 = pytree.Leaf(100, "bar")\r
- l3 = pytree.Leaf(100, "fooey")\r
- c1 = pytree.Node(1000, [l1, l2])\r
- n1 = pytree.Node(1000, [c1, l3])\r
- self.assertEqual(list(n1.pre_order()), [n1, c1, l1, l2, l3])\r
-\r
- def test_changed(self):\r
- l1 = pytree.Leaf(100, "f")\r
- self.assertFalse(l1.was_changed)\r
- l1.changed()\r
- self.assertTrue(l1.was_changed)\r
-\r
- l1 = pytree.Leaf(100, "f")\r
- n1 = pytree.Node(1000, [l1])\r
- self.assertFalse(n1.was_changed)\r
- n1.changed()\r
- self.assertTrue(n1.was_changed)\r
-\r
- l1 = pytree.Leaf(100, "foo")\r
- l2 = pytree.Leaf(100, "+")\r
- l3 = pytree.Leaf(100, "bar")\r
- n1 = pytree.Node(1000, [l1, l2, l3])\r
- n2 = pytree.Node(1000, [n1])\r
- self.assertFalse(l1.was_changed)\r
- self.assertFalse(n1.was_changed)\r
- self.assertFalse(n2.was_changed)\r
-\r
- n1.changed()\r
- self.assertTrue(n1.was_changed)\r
- self.assertTrue(n2.was_changed)\r
- self.assertFalse(l1.was_changed)\r
-\r
- def test_leaf_constructor_prefix(self):\r
- for prefix in ("xyz_", ""):\r
- l1 = pytree.Leaf(100, "self", prefix=prefix)\r
- self.assertTrue(str(l1), prefix + "self")\r
- self.assertEqual(l1.prefix, prefix)\r
-\r
- def test_node_constructor_prefix(self):\r
- for prefix in ("xyz_", ""):\r
- l1 = pytree.Leaf(100, "self")\r
- l2 = pytree.Leaf(100, "foo", prefix="_")\r
- n1 = pytree.Node(1000, [l1, l2], prefix=prefix)\r
- self.assertTrue(str(n1), prefix + "self_foo")\r
- self.assertEqual(n1.prefix, prefix)\r
- self.assertEqual(l1.prefix, prefix)\r
- self.assertEqual(l2.prefix, "_")\r
-\r
- def test_remove(self):\r
- l1 = pytree.Leaf(100, "foo")\r
- l2 = pytree.Leaf(100, "foo")\r
- n1 = pytree.Node(1000, [l1, l2])\r
- n2 = pytree.Node(1000, [n1])\r
-\r
- self.assertEqual(n1.remove(), 0)\r
- self.assertEqual(n2.children, [])\r
- self.assertEqual(l1.parent, n1)\r
- self.assertEqual(n1.parent, None)\r
- self.assertEqual(n2.parent, None)\r
- self.assertFalse(n1.was_changed)\r
- self.assertTrue(n2.was_changed)\r
-\r
- self.assertEqual(l2.remove(), 1)\r
- self.assertEqual(l1.remove(), 0)\r
- self.assertEqual(n1.children, [])\r
- self.assertEqual(l1.parent, None)\r
- self.assertEqual(n1.parent, None)\r
- self.assertEqual(n2.parent, None)\r
- self.assertTrue(n1.was_changed)\r
- self.assertTrue(n2.was_changed)\r
-\r
- def test_remove_parentless(self):\r
- n1 = pytree.Node(1000, [])\r
- n1.remove()\r
- self.assertEqual(n1.parent, None)\r
-\r
- l1 = pytree.Leaf(100, "foo")\r
- l1.remove()\r
- self.assertEqual(l1.parent, None)\r
-\r
- def test_node_set_child(self):\r
- l1 = pytree.Leaf(100, "foo")\r
- n1 = pytree.Node(1000, [l1])\r
-\r
- l2 = pytree.Leaf(100, "bar")\r
- n1.set_child(0, l2)\r
- self.assertEqual(l1.parent, None)\r
- self.assertEqual(l2.parent, n1)\r
- self.assertEqual(n1.children, [l2])\r
-\r
- n2 = pytree.Node(1000, [l1])\r
- n2.set_child(0, n1)\r
- self.assertEqual(l1.parent, None)\r
- self.assertEqual(n1.parent, n2)\r
- self.assertEqual(n2.parent, None)\r
- self.assertEqual(n2.children, [n1])\r
-\r
- self.assertRaises(IndexError, n1.set_child, 4, l2)\r
- # I don't care what it raises, so long as it's an exception\r
- self.assertRaises(Exception, n1.set_child, 0, list)\r
-\r
- def test_node_insert_child(self):\r
- l1 = pytree.Leaf(100, "foo")\r
- n1 = pytree.Node(1000, [l1])\r
-\r
- l2 = pytree.Leaf(100, "bar")\r
- n1.insert_child(0, l2)\r
- self.assertEqual(l2.parent, n1)\r
- self.assertEqual(n1.children, [l2, l1])\r
-\r
- l3 = pytree.Leaf(100, "abc")\r
- n1.insert_child(2, l3)\r
- self.assertEqual(n1.children, [l2, l1, l3])\r
-\r
- # I don't care what it raises, so long as it's an exception\r
- self.assertRaises(Exception, n1.insert_child, 0, list)\r
-\r
- def test_node_append_child(self):\r
- n1 = pytree.Node(1000, [])\r
-\r
- l1 = pytree.Leaf(100, "foo")\r
- n1.append_child(l1)\r
- self.assertEqual(l1.parent, n1)\r
- self.assertEqual(n1.children, [l1])\r
-\r
- l2 = pytree.Leaf(100, "bar")\r
- n1.append_child(l2)\r
- self.assertEqual(l2.parent, n1)\r
- self.assertEqual(n1.children, [l1, l2])\r
-\r
- # I don't care what it raises, so long as it's an exception\r
- self.assertRaises(Exception, n1.append_child, list)\r
-\r
- def test_node_next_sibling(self):\r
- n1 = pytree.Node(1000, [])\r
- n2 = pytree.Node(1000, [])\r
- p1 = pytree.Node(1000, [n1, n2])\r
-\r
- self.assertTrue(n1.next_sibling is n2)\r
- self.assertEqual(n2.next_sibling, None)\r
- self.assertEqual(p1.next_sibling, None)\r
-\r
- def test_leaf_next_sibling(self):\r
- l1 = pytree.Leaf(100, "a")\r
- l2 = pytree.Leaf(100, "b")\r
- p1 = pytree.Node(1000, [l1, l2])\r
-\r
- self.assertTrue(l1.next_sibling is l2)\r
- self.assertEqual(l2.next_sibling, None)\r
- self.assertEqual(p1.next_sibling, None)\r
-\r
- def test_node_prev_sibling(self):\r
- n1 = pytree.Node(1000, [])\r
- n2 = pytree.Node(1000, [])\r
- p1 = pytree.Node(1000, [n1, n2])\r
-\r
- self.assertTrue(n2.prev_sibling is n1)\r
- self.assertEqual(n1.prev_sibling, None)\r
- self.assertEqual(p1.prev_sibling, None)\r
-\r
- def test_leaf_prev_sibling(self):\r
- l1 = pytree.Leaf(100, "a")\r
- l2 = pytree.Leaf(100, "b")\r
- p1 = pytree.Node(1000, [l1, l2])\r
-\r
- self.assertTrue(l2.prev_sibling is l1)\r
- self.assertEqual(l1.prev_sibling, None)\r
- self.assertEqual(p1.prev_sibling, None)\r
-\r
-\r
-class TestPatterns(support.TestCase):\r
-\r
- """Unit tests for tree matching patterns."""\r
-\r
- def test_basic_patterns(self):\r
- # Build a tree\r
- l1 = pytree.Leaf(100, "foo")\r
- l2 = pytree.Leaf(100, "bar")\r
- l3 = pytree.Leaf(100, "foo")\r
- n1 = pytree.Node(1000, [l1, l2])\r
- n2 = pytree.Node(1000, [l3])\r
- root = pytree.Node(1000, [n1, n2])\r
- # Build a pattern matching a leaf\r
- pl = pytree.LeafPattern(100, "foo", name="pl")\r
- r = {}\r
- self.assertFalse(pl.match(root, results=r))\r
- self.assertEqual(r, {})\r
- self.assertFalse(pl.match(n1, results=r))\r
- self.assertEqual(r, {})\r
- self.assertFalse(pl.match(n2, results=r))\r
- self.assertEqual(r, {})\r
- self.assertTrue(pl.match(l1, results=r))\r
- self.assertEqual(r, {"pl": l1})\r
- r = {}\r
- self.assertFalse(pl.match(l2, results=r))\r
- self.assertEqual(r, {})\r
- # Build a pattern matching a node\r
- pn = pytree.NodePattern(1000, [pl], name="pn")\r
- self.assertFalse(pn.match(root, results=r))\r
- self.assertEqual(r, {})\r
- self.assertFalse(pn.match(n1, results=r))\r
- self.assertEqual(r, {})\r
- self.assertTrue(pn.match(n2, results=r))\r
- self.assertEqual(r, {"pn": n2, "pl": l3})\r
- r = {}\r
- self.assertFalse(pn.match(l1, results=r))\r
- self.assertEqual(r, {})\r
- self.assertFalse(pn.match(l2, results=r))\r
- self.assertEqual(r, {})\r
-\r
- def test_wildcard(self):\r
- # Build a tree for testing\r
- l1 = pytree.Leaf(100, "foo")\r
- l2 = pytree.Leaf(100, "bar")\r
- l3 = pytree.Leaf(100, "foo")\r
- n1 = pytree.Node(1000, [l1, l2])\r
- n2 = pytree.Node(1000, [l3])\r
- root = pytree.Node(1000, [n1, n2])\r
- # Build a pattern\r
- pl = pytree.LeafPattern(100, "foo", name="pl")\r
- pn = pytree.NodePattern(1000, [pl], name="pn")\r
- pw = pytree.WildcardPattern([[pn], [pl, pl]], name="pw")\r
- r = {}\r
- self.assertFalse(pw.match_seq([root], r))\r
- self.assertEqual(r, {})\r
- self.assertFalse(pw.match_seq([n1], r))\r
- self.assertEqual(r, {})\r
- self.assertTrue(pw.match_seq([n2], r))\r
- # These are easier to debug\r
- self.assertEqual(sorted(r.keys()), ["pl", "pn", "pw"])\r
- self.assertEqual(r["pl"], l1)\r
- self.assertEqual(r["pn"], n2)\r
- self.assertEqual(r["pw"], [n2])\r
- # But this is equivalent\r
- self.assertEqual(r, {"pl": l1, "pn": n2, "pw": [n2]})\r
- r = {}\r
- self.assertTrue(pw.match_seq([l1, l3], r))\r
- self.assertEqual(r, {"pl": l3, "pw": [l1, l3]})\r
- self.assertTrue(r["pl"] is l3)\r
- r = {}\r
-\r
- def test_generate_matches(self):\r
- la = pytree.Leaf(1, "a")\r
- lb = pytree.Leaf(1, "b")\r
- lc = pytree.Leaf(1, "c")\r
- ld = pytree.Leaf(1, "d")\r
- le = pytree.Leaf(1, "e")\r
- lf = pytree.Leaf(1, "f")\r
- leaves = [la, lb, lc, ld, le, lf]\r
- root = pytree.Node(1000, leaves)\r
- pa = pytree.LeafPattern(1, "a", "pa")\r
- pb = pytree.LeafPattern(1, "b", "pb")\r
- pc = pytree.LeafPattern(1, "c", "pc")\r
- pd = pytree.LeafPattern(1, "d", "pd")\r
- pe = pytree.LeafPattern(1, "e", "pe")\r
- pf = pytree.LeafPattern(1, "f", "pf")\r
- pw = pytree.WildcardPattern([[pa, pb, pc], [pd, pe],\r
- [pa, pb], [pc, pd], [pe, pf]],\r
- min=1, max=4, name="pw")\r
- self.assertEqual([x[0] for x in pw.generate_matches(leaves)],\r
- [3, 5, 2, 4, 6])\r
- pr = pytree.NodePattern(type=1000, content=[pw], name="pr")\r
- matches = list(pytree.generate_matches([pr], [root]))\r
- self.assertEqual(len(matches), 1)\r
- c, r = matches[0]\r
- self.assertEqual(c, 1)\r
- self.assertEqual(str(r["pr"]), "abcdef")\r
- self.assertEqual(r["pw"], [la, lb, lc, ld, le, lf])\r
- for c in "abcdef":\r
- self.assertEqual(r["p" + c], pytree.Leaf(1, c))\r
-\r
- def test_has_key_example(self):\r
- pattern = pytree.NodePattern(331,\r
- (pytree.LeafPattern(7),\r
- pytree.WildcardPattern(name="args"),\r
- pytree.LeafPattern(8)))\r
- l1 = pytree.Leaf(7, "(")\r
- l2 = pytree.Leaf(3, "x")\r
- l3 = pytree.Leaf(8, ")")\r
- node = pytree.Node(331, [l1, l2, l3])\r
- r = {}\r
- self.assertTrue(pattern.match(node, r))\r
- self.assertEqual(r["args"], [l2])\r
projects / mirror_edk2.git / blobdiff