#!/usr/bin/env python2.5

# Copyright 2006 Google, Inc. All Rights Reserved.

# Licensed to PSF under a Contributor Agreement.

"""Unit tests for pytree.py.

NOTE: Please *don't* add doc strings to individual test methods!

In verbose mode, printing of the module, class and method name is much

more helpful than printing of (the first line of) the docstring,

especially when debugging a test.

"""

# Testing imports

from . import support

# Local imports (XXX should become a package)

from .. import pytree

try:

    sorted

except NameError:

    def sorted(lst):

        l = list(lst)

        l.sort()

        return l

class TestNodes(support.TestCase):

    """Unit tests for nodes (Base, Leaf, Node)."""

    def testBaseCantConstruct(self):

        if __debug__:

            # Test that instantiating Base() raises an AssertionError

            self.assertRaises(AssertionError, pytree.Base)

    def testLeaf(self):

        l1 = pytree.Leaf(100, "foo")

        self.assertEqual(l1.type, 100)

        self.assertEqual(l1.value, "foo")

    def testLeafRepr(self):

        l1 = pytree.Leaf(100, "foo")

        self.assertEqual(repr(l1), "Leaf(100, 'foo')")

    def testLeafStr(self):

        l1 = pytree.Leaf(100, "foo")

        self.assertEqual(str(l1), "foo")

        l2 = pytree.Leaf(100, "foo", context=(" ", (10, 1)))

        self.assertEqual(str(l2), " foo")

    def testLeafStrNumericValue(self):

        # Make sure that the Leaf's value is stringified. Failing to

        #  do this can cause a TypeError in certain situations.

        l1 = pytree.Leaf(2, 5)

        l1.set_prefix("foo_")

        self.assertEqual(str(l1), "foo_5")

    def testLeafEq(self):

        l1 = pytree.Leaf(100, "foo")

        l2 = pytree.Leaf(100, "foo", context=(" ", (1, 0)))

        self.assertEqual(l1, l2)

        l3 = pytree.Leaf(101, "foo")

        l4 = pytree.Leaf(100, "bar")

        self.assertNotEqual(l1, l3)

        self.assertNotEqual(l1, l4)

    def testLeafPrefix(self):

        l1 = pytree.Leaf(100, "foo")

        self.assertEqual(l1.get_prefix(), "")

        self.failIf(l1.was_changed)

        l1.set_prefix("  ##\n\n")

        self.assertEqual(l1.get_prefix(), "  ##\n\n")

        self.failUnless(l1.was_changed)

    def testNode(self):

        l1 = pytree.Leaf(100, "foo")

        l2 = pytree.Leaf(200, "bar")

        n1 = pytree.Node(1000, [l1, l2])

        self.assertEqual(n1.type, 1000)

        self.assertEqual(n1.children, [l1, l2])

    def testNodeRepr(self):

        l1 = pytree.Leaf(100, "foo")

        l2 = pytree.Leaf(100, "bar", context=(" ", (1, 0)))

        n1 = pytree.Node(1000, [l1, l2])

        self.assertEqual(repr(n1),

                         "Node(1000, [%s, %s])" % (repr(l1), repr(l2)))

    def testNodeStr(self):

        l1 = pytree.Leaf(100, "foo")

        l2 = pytree.Leaf(100, "bar", context=(" ", (1, 0)))

        n1 = pytree.Node(1000, [l1, l2])

        self.assertEqual(str(n1), "foo bar")

    def testNodePrefix(self):

        l1 = pytree.Leaf(100, "foo")

        self.assertEqual(l1.get_prefix(), "")

        n1 = pytree.Node(1000, [l1])

        self.assertEqual(n1.get_prefix(), "")

        n1.set_prefix(" ")

        self.assertEqual(n1.get_prefix(), " ")

        self.assertEqual(l1.get_prefix(), " ")

    def testGetSuffix(self):

        l1 = pytree.Leaf(100, "foo", prefix="a")

        l2 = pytree.Leaf(100, "bar", prefix="b")

        n1 = pytree.Node(1000, [l1, l2])

        self.assertEqual(l1.get_suffix(), l2.get_prefix())

        self.assertEqual(l2.get_suffix(), "")

        self.assertEqual(n1.get_suffix(), "")

        l3 = pytree.Leaf(100, "bar", prefix="c")

        n2 = pytree.Node(1000, [n1, l3])

        self.assertEqual(n1.get_suffix(), l3.get_prefix())

        self.assertEqual(l3.get_suffix(), "")

        self.assertEqual(n2.get_suffix(), "")

    def testNodeEq(self):

        n1 = pytree.Node(1000, ())

        n2 = pytree.Node(1000, [], context=(" ", (1, 0)))

        self.assertEqual(n1, n2)

        n3 = pytree.Node(1001, ())

        self.assertNotEqual(n1, n3)

    def testNodeEqRecursive(self):

        l1 = pytree.Leaf(100, "foo")

        l2 = pytree.Leaf(100, "foo")

        n1 = pytree.Node(1000, [l1])

        n2 = pytree.Node(1000, [l2])

        self.assertEqual(n1, n2)

        l3 = pytree.Leaf(100, "bar")

        n3 = pytree.Node(1000, [l3])

        self.assertNotEqual(n1, n3)

    def testReplace(self):

        l1 = pytree.Leaf(100, "foo")

        l2 = pytree.Leaf(100, "+")

        l3 = pytree.Leaf(100, "bar")

        n1 = pytree.Node(1000, [l1, l2, l3])

        self.assertEqual(n1.children, [l1, l2, l3])

        self.failUnless(isinstance(n1.children, list))

        self.failIf(n1.was_changed)

        l2new = pytree.Leaf(100, "-")

        l2.replace(l2new)

        self.assertEqual(n1.children, [l1, l2new, l3])

        self.failUnless(isinstance(n1.children, list))

        self.failUnless(n1.was_changed)

    def testReplaceWithList(self):

        l1 = pytree.Leaf(100, "foo")

        l2 = pytree.Leaf(100, "+")

        l3 = pytree.Leaf(100, "bar")

        n1 = pytree.Node(1000, [l1, l2, l3])

        l2.replace([pytree.Leaf(100, "*"), pytree.Leaf(100, "*")])

        self.assertEqual(str(n1), "foo**bar")

        self.failUnless(isinstance(n1.children, list))

    def testPostOrder(self):

        l1 = pytree.Leaf(100, "foo")

        l2 = pytree.Leaf(100, "bar")

        n1 = pytree.Node(1000, [l1, l2])

        self.assertEqual(list(n1.post_order()), [l1, l2, n1])

    def testPreOrder(self):

        l1 = pytree.Leaf(100, "foo")

        l2 = pytree.Leaf(100, "bar")

        n1 = pytree.Node(1000, [l1, l2])

        self.assertEqual(list(n1.pre_order()), [n1, l1, l2])

    def testChangedLeaf(self):

        l1 = pytree.Leaf(100, "f")

        self.failIf(l1.was_changed)

        l1.changed()

        self.failUnless(l1.was_changed)

    def testChangedNode(self):

        l1 = pytree.Leaf(100, "f")

        n1 = pytree.Node(1000, [l1])

        self.failIf(n1.was_changed)

        n1.changed()

        self.failUnless(n1.was_changed)

    def testChangedRecursive(self):

        l1 = pytree.Leaf(100, "foo")

        l2 = pytree.Leaf(100, "+")

        l3 = pytree.Leaf(100, "bar")

        n1 = pytree.Node(1000, [l1, l2, l3])

        n2 = pytree.Node(1000, [n1])

        self.failIf(l1.was_changed)

        self.failIf(n1.was_changed)

        self.failIf(n2.was_changed)

        n1.changed()

        self.failUnless(n1.was_changed)

        self.failUnless(n2.was_changed)

        self.failIf(l1.was_changed)

    def testLeafConstructorPrefix(self):

        for prefix in ("xyz_", ""):

            l1 = pytree.Leaf(100, "self", prefix=prefix)

            self.failUnless(str(l1), prefix + "self")

            self.assertEqual(l1.get_prefix(), prefix)

    def testNodeConstructorPrefix(self):

        for prefix in ("xyz_", ""):

            l1 = pytree.Leaf(100, "self")

            l2 = pytree.Leaf(100, "foo", prefix="_")

            n1 = pytree.Node(1000, [l1, l2], prefix=prefix)

            self.failUnless(str(n1), prefix + "self_foo")

            self.assertEqual(n1.get_prefix(), prefix)

            self.assertEqual(l1.get_prefix(), prefix)

            self.assertEqual(l2.get_prefix(), "_")

    def testRemove(self):

        l1 = pytree.Leaf(100, "foo")

        l2 = pytree.Leaf(100, "foo")

        n1 = pytree.Node(1000, [l1, l2])

        n2 = pytree.Node(1000, [n1])

        self.assertEqual(n1.remove(), 0)

        self.assertEqual(n2.children, [])

        self.assertEqual(l1.parent, n1)

        self.assertEqual(n1.parent, None)

        self.assertEqual(n2.parent, None)

        self.failIf(n1.was_changed)

        self.failUnless(n2.was_changed)

        self.assertEqual(l2.remove(), 1)

        self.assertEqual(l1.remove(), 0)

        self.assertEqual(n1.children, [])

        self.assertEqual(l1.parent, None)

        self.assertEqual(n1.parent, None)

        self.assertEqual(n2.parent, None)

        self.failUnless(n1.was_changed)

        self.failUnless(n2.was_changed)

    def testRemoveParentless(self):

        n1 = pytree.Node(1000, [])

        n1.remove()

        self.assertEqual(n1.parent, None)

        l1 = pytree.Leaf(100, "foo")

        l1.remove()

        self.assertEqual(l1.parent, None)

    def testNodeSetChild(self):

        l1 = pytree.Leaf(100, "foo")

        n1 = pytree.Node(1000, [l1])

        l2 = pytree.Leaf(100, "bar")

        n1.set_child(0, l2)

        self.assertEqual(l1.parent, None)

        self.assertEqual(l2.parent, n1)

        self.assertEqual(n1.children, [l2])

        n2 = pytree.Node(1000, [l1])

        n2.set_child(0, n1)

        self.assertEqual(l1.parent, None)

        self.assertEqual(n1.parent, n2)

        self.assertEqual(n2.parent, None)

        self.assertEqual(n2.children, [n1])

        self.assertRaises(IndexError, n1.set_child, 4, l2)

        # I don't care what it raises, so long as it's an exception

        self.assertRaises(Exception, n1.set_child, 0, list)

    def testNodeInsertChild(self):

        l1 = pytree.Leaf(100, "foo")

        n1 = pytree.Node(1000, [l1])

        l2 = pytree.Leaf(100, "bar")

        n1.insert_child(0, l2)

        self.assertEqual(l2.parent, n1)

        self.assertEqual(n1.children, [l2, l1])

        l3 = pytree.Leaf(100, "abc")

        n1.insert_child(2, l3)

        self.assertEqual(n1.children, [l2, l1, l3])

        # I don't care what it raises, so long as it's an exception

        self.assertRaises(Exception, n1.insert_child, 0, list)

    def testNodeAppendChild(self):

        n1 = pytree.Node(1000, [])

        l1 = pytree.Leaf(100, "foo")

        n1.append_child(l1)

        self.assertEqual(l1.parent, n1)

        self.assertEqual(n1.children, [l1])

        l2 = pytree.Leaf(100, "bar")

        n1.append_child(l2)

        self.assertEqual(l2.parent, n1)

        self.assertEqual(n1.children, [l1, l2])

        # I don't care what it raises, so long as it's an exception

        self.assertRaises(Exception, n1.append_child, list)

    def testNodeNextSibling(self):

        n1 = pytree.Node(1000, [])

        n2 = pytree.Node(1000, [])

        p1 = pytree.Node(1000, [n1, n2])

        self.failUnless(n1.get_next_sibling() is n2)

        self.assertEqual(n2.get_next_sibling(), None)

        self.assertEqual(p1.get_next_sibling(), None)

    def testLeafNextSibling(self):

        l1 = pytree.Leaf(100, "a")

        l2 = pytree.Leaf(100, "b")

        p1 = pytree.Node(1000, [l1, l2])

        self.failUnless(l1.get_next_sibling() is l2)

        self.assertEqual(l2.get_next_sibling(), None)

        self.assertEqual(p1.get_next_sibling(), None)

    def testNodePrevSibling(self):

        n1 = pytree.Node(1000, [])

        n2 = pytree.Node(1000, [])

        p1 = pytree.Node(1000, [n1, n2])

        self.failUnless(n2.get_prev_sibling() is n1)

        self.assertEqual(n1.get_prev_sibling(), None)

        self.assertEqual(p1.get_prev_sibling(), None)

    def testLeafPrevSibling(self):

        l1 = pytree.Leaf(100, "a")

        l2 = pytree.Leaf(100, "b")

        p1 = pytree.Node(1000, [l1, l2])

        self.failUnless(l2.get_prev_sibling() is l1)

        self.assertEqual(l1.get_prev_sibling(), None)

        self.assertEqual(p1.get_prev_sibling(), None)

class TestPatterns(support.TestCase):

    """Unit tests for tree matching patterns."""

    def testBasicPatterns(self):

        # Build a tree

        l1 = pytree.Leaf(100, "foo")

        l2 = pytree.Leaf(100, "bar")

        l3 = pytree.Leaf(100, "foo")

        n1 = pytree.Node(1000, [l1, l2])

        n2 = pytree.Node(1000, [l3])

        root = pytree.Node(1000, [n1, n2])

        # Build a pattern matching a leaf

        pl = pytree.LeafPattern(100, "foo", name="pl")

        r = {}

        self.assertFalse(pl.match(root, results=r))

        self.assertEqual(r, {})

        self.assertFalse(pl.match(n1, results=r))

        self.assertEqual(r, {})

        self.assertFalse(pl.match(n2, results=r))

        self.assertEqual(r, {})

        self.assertTrue(pl.match(l1, results=r))

        self.assertEqual(r, {"pl": l1})

        r = {}

        self.assertFalse(pl.match(l2, results=r))

        self.assertEqual(r, {})

        # Build a pattern matching a node

        pn = pytree.NodePattern(1000, [pl], name="pn")

        self.assertFalse(pn.match(root, results=r))

        self.assertEqual(r, {})

        self.assertFalse(pn.match(n1, results=r))

        self.assertEqual(r, {})

        self.assertTrue(pn.match(n2, results=r))

        self.assertEqual(r, {"pn": n2, "pl": l3})

        r = {}

        self.assertFalse(pn.match(l1, results=r))

        self.assertEqual(r, {})

        self.assertFalse(pn.match(l2, results=r))

        self.assertEqual(r, {})

    def testWildcardPatterns(self):

        # Build a tree for testing

        l1 = pytree.Leaf(100, "foo")

        l2 = pytree.Leaf(100, "bar")

        l3 = pytree.Leaf(100, "foo")

        n1 = pytree.Node(1000, [l1, l2])

        n2 = pytree.Node(1000, [l3])

        root = pytree.Node(1000, [n1, n2])

        # Build a pattern

        pl = pytree.LeafPattern(100, "foo", name="pl")

        pn = pytree.NodePattern(1000, [pl], name="pn")

        pw = pytree.WildcardPattern([[pn], [pl, pl]], name="pw")

        r = {}

        self.assertFalse(pw.match_seq([root], r))

        self.assertEqual(r, {})

        self.assertFalse(pw.match_seq([n1], r))

        self.assertEqual(r, {})

        self.assertTrue(pw.match_seq([n2], r))

        # These are easier to debug

        self.assertEqual(sorted(r.keys()), ["pl", "pn", "pw"])

        self.assertEqual(r["pl"], l1)

        self.assertEqual(r["pn"], n2)

        self.assertEqual(r["pw"], [n2])

        # But this is equivalent

        self.assertEqual(r, {"pl": l1, "pn": n2, "pw": [n2]})

        r = {}

        self.assertTrue(pw.match_seq([l1, l3], r))

        self.assertEqual(r, {"pl": l3, "pw": [l1, l3]})

        self.assert_(r["pl"] is l3)

        r = {}

    def testGenerateMatches(self):

        la = pytree.Leaf(1, "a")

        lb = pytree.Leaf(1, "b")

        lc = pytree.Leaf(1, "c")

        ld = pytree.Leaf(1, "d")

        le = pytree.Leaf(1, "e")

        lf = pytree.Leaf(1, "f")

        leaves = [la, lb, lc, ld, le, lf]

        root = pytree.Node(1000, leaves)

        pa = pytree.LeafPattern(1, "a", "pa")

        pb = pytree.LeafPattern(1, "b", "pb")

        pc = pytree.LeafPattern(1, "c", "pc")

        pd = pytree.LeafPattern(1, "d", "pd")

        pe = pytree.LeafPattern(1, "e", "pe")

        pf = pytree.LeafPattern(1, "f", "pf")

        pw = pytree.WildcardPattern([[pa, pb, pc], [pd, pe],

                                     [pa, pb], [pc, pd], [pe, pf]],

                                    min=1, max=4, name="pw")

        self.assertEqual([x[0] for x in pw.generate_matches(leaves)],

                         [3, 5, 2, 4, 6])

        pr = pytree.NodePattern(type=1000, content=[pw], name="pr")

        matches = list(pytree.generate_matches([pr], [root]))

        self.assertEqual(len(matches), 1)

        c, r = matches[0]

        self.assertEqual(c, 1)

        self.assertEqual(str(r["pr"]), "abcdef")

        self.assertEqual(r["pw"], [la, lb, lc, ld, le, lf])

        for c in "abcdef":

            self.assertEqual(r["p" + c], pytree.Leaf(1, c))

    def testHasKeyExample(self):

        pattern = pytree.NodePattern(331,

                                     (pytree.LeafPattern(7),

                                      pytree.WildcardPattern(name="args"),

                                      pytree.LeafPattern(8)))

        l1 = pytree.Leaf(7, "(")

        l2 = pytree.Leaf(3, "x")

        l3 = pytree.Leaf(8, ")")

        node = pytree.Node(331, [l1, l2, l3])

        r = {}

        self.assert_(pattern.match(node, r))

        self.assertEqual(r["args"], [l2])

if __name__ == "__main__":

    import __main__

    support.run_all_tests(__main__)