def testFindTokenType(self):
wiz = TreeWizard(self.adaptor, self.tokens)
t = wiz.create("(A B C (A[foo] B[bar]) (D (A[big] B[dog])))")
subtrees = wiz.find(t, wiz.getTokenType('A'))
found = [str(node) for node in subtrees]
expecting = ['A', 'foo', 'big']
self.failUnlessEqual(expecting, found)
def testParseWithText2(self):
wiz = TreeWizard(self.adaptor, self.tokens)
t = wiz.create("(A B[T__32] (C (D E[a])))")
# C pattern has no text arg so despite [bar] in t, no need
# to match text--check structure only.
valid = wiz.parse(t, "(A B[foo] C)")
self.assertEquals("(A T__32 (C (D a)))", t.toStringTree())
def testParseWithText(self):
wiz = TreeWizard(self.adaptor, self.tokens)
t = wiz.create("(A B[foo] C[bar])")
# C pattern has no text arg so despite [bar] in t, no need
# to match text--check structure only.
valid = wiz.parse(t, "(A B[foo] C)")
self.failUnless(valid)
def testNoRepeatsIndex(self):
wiz = TreeWizard(self.adaptor, self.tokens)
tree = wiz.create("(A B C D)")
indexMap = wiz.index(tree)
found = self.__simplifyIndexMap(indexMap)
expecting = { 8:['D'], 6:['B'], 7:['C'], 5:['A'] }
self.assertEqual(expecting, found)
def testSingleNodeIndex(self):
wiz = TreeWizard(self.adaptor, self.tokens)
tree = wiz.create("ID")
indexMap = wiz.index(tree)
found = self.__simplifyIndexMap(indexMap)
expecting = { 10: ["ID"] }
self.failUnlessEqual(expecting, found)
def testRepeatsIndex(self):
wiz = TreeWizard(self.adaptor, self.tokens)
tree = wiz.create("(A B (A C B) B D D)")
indexMap = wiz.index(tree)
found = self.__simplifyIndexMap(indexMap)
expecting = { 8: ['D', 'D'], 6: ['B', 'B', 'B'], 7: ['C'], 5: ['A', 'A'] }
self.failUnlessEqual(expecting, found)
def testFindPattern(self):
wiz = TreeWizard(self.adaptor, self.tokens)
t = wiz.create("(A B C (A[foo] B[bar]) (D (A[big] B[dog])))")
subtrees = wiz.find(t, "(A B)")
found = [str(node) for node in subtrees]
expecting = ['foo', 'big']
self.assertEqual(expecting, found)
def testVerticalList(self):
adaptor = CommonTreeAdaptor()
wiz = TreeWizard(adaptor, self.tokens)
t = wiz.create("(A (B C))")
it = TreeIterator(t)
expecting = "A DOWN B DOWN C UP UP EOF"
found = self.toString(it)
self.assertEquals(expecting, found)
def testNode(self):
adaptor = CommonTreeAdaptor()
wiz = TreeWizard(adaptor, self.tokens)
t = wiz.create("A")
it = TreeIterator(t)
expecting = "A EOF"
found = self.toString(it)
self.assertEquals(expecting, found)
def testFlatAB(self):
adaptor = CommonTreeAdaptor()
wiz = TreeWizard(adaptor, self.tokens)
t = wiz.create("(nil A B)")
it = TreeIterator(t)
expecting = "nil DOWN A B UP EOF"
found = self.toString(it)
self.assertEquals(expecting, found)
def testABC(self):
adaptor = CommonTreeAdaptor()
wiz = TreeWizard(adaptor, self.tokens)
t = wiz.create("(A B C)")
it = TreeIterator(t)
expecting = "A DOWN B C UP EOF"
found = self.toString(it)
self.assertEqual(expecting, found)
def testComplex(self):
adaptor = CommonTreeAdaptor()
wiz = TreeWizard(adaptor, self.tokens)
t = wiz.create("(A (B (C D E) F) G)")
it = TreeIterator(t)
expecting = "A DOWN B DOWN C DOWN D E UP F UP G UP EOF"
found = self.toString(it)
self.assertEquals(expecting, found)
def testParseWithWildcardLabels(self):
wiz = TreeWizard(self.adaptor, self.tokens)
t = wiz.create("(A B C)")
labels = {}
valid = wiz.parse(t, "(A %b:. %c:.)", labels)
self.failUnless(valid)
self.failUnlessEqual("B", str(labels["b"]))
self.failUnlessEqual("C", str(labels["c"]))
def testParseLabelsAndTestText(self):
wiz = TreeWizard(self.adaptor, self.tokens)
t = wiz.create("(A B[foo] C)")
labels = {}
valid = wiz.parse(t, "(%a:A %b:B[foo] %c:C)", labels)
self.failUnless(valid)
self.failUnlessEqual("A", str(labels["a"]))
self.failUnlessEqual("foo", str(labels["b"]))
self.failUnlessEqual("C", str(labels["c"]))
def testParseLabels(self):
wiz = TreeWizard(self.adaptor, self.tokens)
t = wiz.create("(A B C)")
labels = {}
valid = wiz.parse(t, "(%a:A %b:B %c:C)", labels)
self.assertTrue(valid)
self.assertEqual("A", str(labels["a"]))
self.assertEqual("B", str(labels["b"]))
self.assertEqual("C", str(labels["c"]))
class TestToDOT(unittest.TestCase):
"""Test case for the toDOT function."""
def setUp(self):
self.adaptor = CommonTreeAdaptor()
self.tokens = [
"", "", "", "", "", "A", "B", "C", "D", "E", "ID", "VAR"
]
self.wiz = TreeWizard(self.adaptor, self.tokens)
def testNone(self):
"""toDOT()"""
treeST = stringtemplate3.StringTemplate(
template=(
"digraph {\n" +
" $nodes$\n" +
" $edges$\n" +
"}\n")
)
edgeST = stringtemplate3.StringTemplate(
template="$parent$ -> $child$\n"
)
tree = self.wiz.create("(A B (B C C) (B (C D D)))")
st = toDOT(tree, self.adaptor, treeST, edgeST)
result = st.toString()
expected = textwrap.dedent(
'''\
digraph {
n0 [label="A"];
n1 [label="B"];
n2 [label="B"];
n3 [label="C"];
n4 [label="C"];
n5 [label="B"];
n6 [label="C"];
n7 [label="D"];
n8 [label="D"];
n0 -> n1
n0 -> n2
n2 -> n3
n2 -> n4
n0 -> n5
n5 -> n6
n6 -> n7
n6 -> n8
}
'''
)
self.assertEqual(result, expected)
def testParseLabelsInNestedTree(self):
wiz = TreeWizard(self.adaptor, self.tokens)
t = wiz.create("(A (B C) (D E))")
labels = {}
valid = wiz.parse(t, "(%a:A (%b:B %c:C) (%d:D %e:E) )", labels)
self.failUnless(valid)
self.failUnlessEqual("A", str(labels["a"]))
self.failUnlessEqual("B", str(labels["b"]))
self.failUnlessEqual("C", str(labels["c"]))
self.failUnlessEqual("D", str(labels["d"]))
self.failUnlessEqual("E", str(labels["e"]))
def testRepeatsVisit2(self):
wiz = TreeWizard(self.adaptor, self.tokens)
tree = wiz.create("(A B (A C B) B D D)")
elements = []
def visitor(node, parent, childIndex, labels):
elements.append(str(node))
wiz.visit(tree, wiz.getTokenType("A"), visitor)
expecting = ['A', 'A']
self.failUnlessEqual(expecting, elements)
def testNoRepeatsVisit(self):
wiz = TreeWizard(self.adaptor, self.tokens)
tree = wiz.create("(A B C D)")
elements = []
def visitor(node, parent, childIndex, labels):
elements.append(str(node))
wiz.visit(tree, wiz.getTokenType("B"), visitor)
expecting = ['B']
self.assertEqual(expecting, elements)
def testRepeatsVisitWithContext(self):
wiz = TreeWizard(self.adaptor, self.tokens)
tree = wiz.create("(A B (A C B) B D D)")
elements = []
def visitor(node, parent, childIndex, labels):
elements.append('%s@%s[%d]' % (node, parent, childIndex))
wiz.visit(tree, wiz.getTokenType("B"), visitor)
expecting = ['B@A[0]', 'B@A[1]', 'B@A[2]']
self.failUnlessEqual(expecting, elements)
def testLotsOfWildcards(self):
tree = "(nil (ASSIGN ID[x] INT[3]) (PRINT (MULT ID[x] (VEC INT[1] INT[2] INT[3]))))"
adaptor = CommonTreeAdaptor()
wiz = TreeWizard(adaptor, self.tokenNames)
t = wiz.create(tree)
labels = {}
valid = wiz.parse(t, "(nil (ASSIGN ID[x] INT[3]) (PRINT (MULT ID (VEC INT %x:INT INT))))", labels)
self.assertTrue(valid)
node = labels.get("x")
expecting = True
found = TreeParser._inContext(adaptor, self.tokenNames, node, "... PRINT ... VEC ...")
self.assertEquals(expecting, found)
def testNotParent(self):
tree = "(PRINT (MULT ID[x] (VEC (MULT INT[9] INT[1]) INT[2] INT[3])))"
adaptor = CommonTreeAdaptor()
wiz = TreeWizard(adaptor, self.tokenNames)
t = wiz.create(tree)
labels = {}
valid = wiz.parse(t, "(PRINT (MULT ID (VEC (MULT INT %x:INT) INT INT)))", labels)
self.assertTrue(valid)
node = labels.get("x")
expecting = False
found = TreeParser._inContext(adaptor, self.tokenNames, node, "VEC")
self.assertEquals(expecting, found)
def testVisitPatternMultiple(self):
wiz = TreeWizard(self.adaptor, self.tokens)
tree = wiz.create("(A B C (A B) (D (A B)))")
elements = []
def visitor(node, parent, childIndex, labels):
elements.append(
'{}@{}[{}]'.format(node, parent or 'nil', childIndex)
)
wiz.visit(tree, '(A B)', visitor)
expecting = ['A@A[2]', 'A@D[0]']
self.assertEqual(expecting, elements)
def testVisitPattern(self):
wiz = TreeWizard(self.adaptor, self.tokens)
tree = wiz.create("(A B C (A B) D)")
elements = []
def visitor(node, parent, childIndex, labels):
elements.append(
str(node)
)
wiz.visit(tree, '(A B)', visitor)
expecting = ['A'] # shouldn't match overall root, just (A B)
self.failUnlessEqual(expecting, elements)
def testRepeatsVisitWithNullParentAndContext(self):
wiz = TreeWizard(self.adaptor, self.tokens)
tree = wiz.create("(A B (A C B) B D D)")
elements = []
def visitor(node, parent, childIndex, labels):
elements.append(
'{}@{}[{}]'.format(
node, parent or 'nil', childIndex)
)
wiz.visit(tree, wiz.getTokenType("A"), visitor)
expecting = ['A@nil[0]', 'A@A[1]']
self.assertEqual(expecting, elements)
def testRepeatsVisitWithNullParentAndContext(self):
wiz = TreeWizard(self.adaptor, self.tokens)
tree = wiz.create("(A B (A C B) B D D)")
elements = []
def visitor(node, parent, childIndex, labels):
elements.append(
'%s@%s[%d]'
% (node, ['nil', parent][parent is not None], childIndex)
)
wiz.visit(tree, wiz.getTokenType("A"), visitor)
expecting = ['A@nil[0]', 'A@A[1]']
self.failUnlessEqual(expecting, elements)
def testVisitPatternMultiple(self):
wiz = TreeWizard(self.adaptor, self.tokens)
tree = wiz.create("(A B C (A B) (D (A B)))")
elements = []
def visitor(node, parent, childIndex, labels):
elements.append(
'%s@%s[%d]'
% (node, ['nil', parent][parent is not None], childIndex)
)
wiz.visit(tree, '(A B)', visitor)
expecting = ['A@A[2]', 'A@D[0]']
self.failUnlessEqual(expecting, elements)
def testSingleNodeTree(self):
wiz = TreeWizard(self.adaptor, self.tokens)
t = wiz.create("(A)")
found = t.toStringTree()
expecting = "A"
self.assertEqual(expecting, found)
def testListTree(self):
wiz = TreeWizard(self.adaptor, self.tokens)
t = wiz.create("(nil A B C)")
found = t.toStringTree()
expecting = "A B C"
self.assertEqual(expecting, found)
def testInvalidListTree(self):
wiz = TreeWizard(self.adaptor, self.tokens)
t = wiz.create("A B C")
self.assertIsNone(t)
def testDoubleLevelTree(self):
wiz = TreeWizard(self.adaptor, self.tokens)
t = wiz.create("(A (B C) (B D) E)")
found = t.toStringTree()
expecting = "(A (B C) (B D) E)"
self.assertEqual(expecting, found)
def testParse(self):
wiz = TreeWizard(self.adaptor, self.tokens)
t = wiz.create("(A B C)")
valid = wiz.parse(t, "(A B C)")
self.assertTrue(valid)
def testSingleNodeWithArg(self):
wiz = TreeWizard(self.adaptor, self.tokens)
t = wiz.create("ID[foo]")
found = t.toStringTree()
expecting = "foo"
self.assertEqual(expecting, found)
