| # -*- coding: utf-8 -*- |
| |
| import os |
| import unittest |
| from StringIO import StringIO |
| |
| from antlr3.tree import CommonTreeAdaptor, CommonTree, INVALID_TOKEN_TYPE |
| from antlr3.treewizard import TreeWizard, computeTokenTypes, \ |
| TreePatternLexer, EOF, ID, BEGIN, END, PERCENT, COLON, DOT, ARG, \ |
| TreePatternParser, \ |
| TreePattern, WildcardTreePattern, TreePatternTreeAdaptor |
| |
| |
| class TestComputeTokenTypes(unittest.TestCase): |
| """Test case for the computeTokenTypes function.""" |
| |
| def testNone(self): |
| """computeTokenTypes(None) -> {}""" |
| |
| typeMap = computeTokenTypes(None) |
| self.failUnless(isinstance(typeMap, dict)) |
| self.failUnlessEqual(typeMap, {}) |
| |
| |
| def testList(self): |
| """computeTokenTypes(['a', 'b']) -> { 'a': 0, 'b': 1 }""" |
| |
| typeMap = computeTokenTypes(['a', 'b']) |
| self.failUnless(isinstance(typeMap, dict)) |
| self.failUnlessEqual(typeMap, { 'a': 0, 'b': 1 }) |
| |
| |
| class TestTreePatternLexer(unittest.TestCase): |
| """Test case for the TreePatternLexer class.""" |
| |
| def testBegin(self): |
| """TreePatternLexer(): '('""" |
| |
| lexer = TreePatternLexer('(') |
| type = lexer.nextToken() |
| self.failUnlessEqual(type, BEGIN) |
| self.failUnlessEqual(lexer.sval, '') |
| self.failUnlessEqual(lexer.error, False) |
| |
| |
| def testEnd(self): |
| """TreePatternLexer(): ')'""" |
| |
| lexer = TreePatternLexer(')') |
| type = lexer.nextToken() |
| self.failUnlessEqual(type, END) |
| self.failUnlessEqual(lexer.sval, '') |
| self.failUnlessEqual(lexer.error, False) |
| |
| |
| def testPercent(self): |
| """TreePatternLexer(): '%'""" |
| |
| lexer = TreePatternLexer('%') |
| type = lexer.nextToken() |
| self.failUnlessEqual(type, PERCENT) |
| self.failUnlessEqual(lexer.sval, '') |
| self.failUnlessEqual(lexer.error, False) |
| |
| |
| def testDot(self): |
| """TreePatternLexer(): '.'""" |
| |
| lexer = TreePatternLexer('.') |
| type = lexer.nextToken() |
| self.failUnlessEqual(type, DOT) |
| self.failUnlessEqual(lexer.sval, '') |
| self.failUnlessEqual(lexer.error, False) |
| |
| |
| def testColon(self): |
| """TreePatternLexer(): ':'""" |
| |
| lexer = TreePatternLexer(':') |
| type = lexer.nextToken() |
| self.failUnlessEqual(type, COLON) |
| self.failUnlessEqual(lexer.sval, '') |
| self.failUnlessEqual(lexer.error, False) |
| |
| |
| def testEOF(self): |
| """TreePatternLexer(): EOF""" |
| |
| lexer = TreePatternLexer(' \n \r \t ') |
| type = lexer.nextToken() |
| self.failUnlessEqual(type, EOF) |
| self.failUnlessEqual(lexer.sval, '') |
| self.failUnlessEqual(lexer.error, False) |
| |
| |
| def testID(self): |
| """TreePatternLexer(): ID""" |
| |
| lexer = TreePatternLexer('_foo12_bar') |
| type = lexer.nextToken() |
| self.failUnlessEqual(type, ID) |
| self.failUnlessEqual(lexer.sval, '_foo12_bar') |
| self.failUnlessEqual(lexer.error, False) |
| |
| |
| def testARG(self): |
| """TreePatternLexer(): ARG""" |
| |
| lexer = TreePatternLexer('[ \\]bla\\n]') |
| type = lexer.nextToken() |
| self.failUnlessEqual(type, ARG) |
| self.failUnlessEqual(lexer.sval, ' ]bla\\n') |
| self.failUnlessEqual(lexer.error, False) |
| |
| |
| def testError(self): |
| """TreePatternLexer(): error""" |
| |
| lexer = TreePatternLexer('1') |
| type = lexer.nextToken() |
| self.failUnlessEqual(type, EOF) |
| self.failUnlessEqual(lexer.sval, '') |
| self.failUnlessEqual(lexer.error, True) |
| |
| |
| class TestTreePatternParser(unittest.TestCase): |
| """Test case for the TreePatternParser class.""" |
| |
| def setUp(self): |
| """Setup text fixure |
| |
| We need a tree adaptor, use CommonTreeAdaptor. |
| And a constant list of token names. |
| |
| """ |
| |
| self.adaptor = CommonTreeAdaptor() |
| self.tokens = [ |
| "", "", "", "", "", "A", "B", "C", "D", "E", "ID", "VAR" |
| ] |
| self.wizard = TreeWizard(self.adaptor, tokenNames=self.tokens) |
| |
| |
| def testSingleNode(self): |
| """TreePatternParser: 'ID'""" |
| lexer = TreePatternLexer('ID') |
| parser = TreePatternParser(lexer, self.wizard, self.adaptor) |
| tree = parser.pattern() |
| self.failUnless(isinstance(tree, CommonTree)) |
| self.failUnlessEqual(tree.getType(), 10) |
| self.failUnlessEqual(tree.getText(), 'ID') |
| |
| |
| def testSingleNodeWithArg(self): |
| """TreePatternParser: 'ID[foo]'""" |
| lexer = TreePatternLexer('ID[foo]') |
| parser = TreePatternParser(lexer, self.wizard, self.adaptor) |
| tree = parser.pattern() |
| self.failUnless(isinstance(tree, CommonTree)) |
| self.failUnlessEqual(tree.getType(), 10) |
| self.failUnlessEqual(tree.getText(), 'foo') |
| |
| |
| def testSingleLevelTree(self): |
| """TreePatternParser: '(A B)'""" |
| lexer = TreePatternLexer('(A B)') |
| parser = TreePatternParser(lexer, self.wizard, self.adaptor) |
| tree = parser.pattern() |
| self.failUnless(isinstance(tree, CommonTree)) |
| self.failUnlessEqual(tree.getType(), 5) |
| self.failUnlessEqual(tree.getText(), 'A') |
| self.failUnlessEqual(tree.getChildCount(), 1) |
| self.failUnlessEqual(tree.getChild(0).getType(), 6) |
| self.failUnlessEqual(tree.getChild(0).getText(), 'B') |
| |
| |
| def testNil(self): |
| """TreePatternParser: 'nil'""" |
| lexer = TreePatternLexer('nil') |
| parser = TreePatternParser(lexer, self.wizard, self.adaptor) |
| tree = parser.pattern() |
| self.failUnless(isinstance(tree, CommonTree)) |
| self.failUnlessEqual(tree.getType(), 0) |
| self.failUnlessEqual(tree.getText(), None) |
| |
| |
| def testWildcard(self): |
| """TreePatternParser: '(.)'""" |
| lexer = TreePatternLexer('(.)') |
| parser = TreePatternParser(lexer, self.wizard, self.adaptor) |
| tree = parser.pattern() |
| self.failUnless(isinstance(tree, WildcardTreePattern)) |
| |
| |
| def testLabel(self): |
| """TreePatternParser: '(%a:A)'""" |
| lexer = TreePatternLexer('(%a:A)') |
| parser = TreePatternParser(lexer, self.wizard, TreePatternTreeAdaptor()) |
| tree = parser.pattern() |
| self.failUnless(isinstance(tree, TreePattern)) |
| self.failUnlessEqual(tree.label, 'a') |
| |
| |
| def testError1(self): |
| """TreePatternParser: ')'""" |
| lexer = TreePatternLexer(')') |
| parser = TreePatternParser(lexer, self.wizard, self.adaptor) |
| tree = parser.pattern() |
| self.failUnless(tree is None) |
| |
| |
| def testError2(self): |
| """TreePatternParser: '()'""" |
| lexer = TreePatternLexer('()') |
| parser = TreePatternParser(lexer, self.wizard, self.adaptor) |
| tree = parser.pattern() |
| self.failUnless(tree is None) |
| |
| |
| def testError3(self): |
| """TreePatternParser: '(A ])'""" |
| lexer = TreePatternLexer('(A ])') |
| parser = TreePatternParser(lexer, self.wizard, self.adaptor) |
| tree = parser.pattern() |
| self.failUnless(tree is None) |
| |
| |
| class TestTreeWizard(unittest.TestCase): |
| """Test case for the TreeWizard class.""" |
| |
| def setUp(self): |
| """Setup text fixure |
| |
| We need a tree adaptor, use CommonTreeAdaptor. |
| And a constant list of token names. |
| |
| """ |
| |
| self.adaptor = CommonTreeAdaptor() |
| self.tokens = [ |
| "", "", "", "", "", "A", "B", "C", "D", "E", "ID", "VAR" |
| ] |
| |
| |
| def testInit(self): |
| """TreeWizard.__init__()""" |
| |
| wiz = TreeWizard( |
| self.adaptor, |
| tokenNames=['a', 'b'] |
| ) |
| |
| self.failUnless(wiz.adaptor is self.adaptor) |
| self.failUnlessEqual( |
| wiz.tokenNameToTypeMap, |
| { 'a': 0, 'b': 1 } |
| ) |
| |
| |
| def testGetTokenType(self): |
| """TreeWizard.getTokenType()""" |
| |
| wiz = TreeWizard( |
| self.adaptor, |
| tokenNames=self.tokens |
| ) |
| |
| self.failUnlessEqual( |
| wiz.getTokenType('A'), |
| 5 |
| ) |
| |
| self.failUnlessEqual( |
| wiz.getTokenType('VAR'), |
| 11 |
| ) |
| |
| self.failUnlessEqual( |
| wiz.getTokenType('invalid'), |
| INVALID_TOKEN_TYPE |
| ) |
| |
| def testSingleNode(self): |
| wiz = TreeWizard(self.adaptor, self.tokens) |
| t = wiz.create("ID") |
| found = t.toStringTree() |
| expecting = "ID" |
| self.failUnlessEqual(expecting, found) |
| |
| |
| def testSingleNodeWithArg(self): |
| wiz = TreeWizard(self.adaptor, self.tokens) |
| t = wiz.create("ID[foo]") |
| found = t.toStringTree() |
| expecting = "foo" |
| self.failUnlessEqual(expecting, found) |
| |
| |
| def testSingleNodeTree(self): |
| wiz = TreeWizard(self.adaptor, self.tokens) |
| t = wiz.create("(A)") |
| found = t.toStringTree() |
| expecting = "A" |
| self.failUnlessEqual(expecting, found) |
| |
| |
| def testSingleLevelTree(self): |
| wiz = TreeWizard(self.adaptor, self.tokens) |
| t = wiz.create("(A B C D)") |
| found = t.toStringTree() |
| expecting = "(A B C D)" |
| self.failUnlessEqual(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.failUnlessEqual(expecting, found) |
| |
| |
| def testInvalidListTree(self): |
| wiz = TreeWizard(self.adaptor, self.tokens) |
| t = wiz.create("A B C") |
| self.failUnless(t is None) |
| |
| |
| 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.failUnlessEqual(expecting, found) |
| |
| |
| def __simplifyIndexMap(self, indexMap): |
| return dict( # stringify nodes for easy comparing |
| (ttype, [str(node) for node in nodes]) |
| for ttype, nodes in indexMap.items() |
| ) |
| |
| 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 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.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 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.failUnlessEqual(expecting, elements) |
| |
| |
| def testNoRepeatsVisit2(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("C"), visitor) |
| |
| expecting = ['C'] |
| self.failUnlessEqual(expecting, elements) |
| |
| |
| def testRepeatsVisit(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("B"), visitor) |
| |
| expecting = ['B', 'B', 'B'] |
| self.failUnlessEqual(expecting, elements) |
| |
| |
| 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 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 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 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 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 testVisitPatternMultipleWithLabels(self): |
| wiz = TreeWizard(self.adaptor, self.tokens) |
| tree = wiz.create("(A B C (A[foo] B[bar]) (D (A[big] B[dog])))") |
| |
| elements = [] |
| def visitor(node, parent, childIndex, labels): |
| elements.append( |
| '%s@%s[%d]%s&%s' |
| % (node, |
| ['nil', parent][parent is not None], |
| childIndex, |
| labels['a'], |
| labels['b'], |
| ) |
| ) |
| |
| wiz.visit(tree, '(%a:A %b:B)', visitor) |
| |
| expecting = ['foo@A[2]foo&bar', 'big@D[0]big&dog'] |
| self.failUnlessEqual(expecting, elements) |
| |
| |
| def testParse(self): |
| wiz = TreeWizard(self.adaptor, self.tokens) |
| t = wiz.create("(A B C)") |
| valid = wiz.parse(t, "(A B C)") |
| self.failUnless(valid) |
| |
| |
| def testParseSingleNode(self): |
| wiz = TreeWizard(self.adaptor, self.tokens) |
| t = wiz.create("A") |
| valid = wiz.parse(t, "A") |
| self.failUnless(valid) |
| |
| |
| def testParseSingleNodeFails(self): |
| wiz = TreeWizard(self.adaptor, self.tokens) |
| t = wiz.create("A") |
| valid = wiz.parse(t, "B") |
| self.failUnless(not valid) |
| |
| |
| def testParseFlatTree(self): |
| wiz = TreeWizard(self.adaptor, self.tokens) |
| t = wiz.create("(nil A B C)") |
| valid = wiz.parse(t, "(nil A B C)") |
| self.failUnless(valid) |
| |
| |
| def testParseFlatTreeFails(self): |
| wiz = TreeWizard(self.adaptor, self.tokens) |
| t = wiz.create("(nil A B C)") |
| valid = wiz.parse(t, "(nil A B)") |
| self.failUnless(not valid) |
| |
| |
| def testParseFlatTreeFails2(self): |
| wiz = TreeWizard(self.adaptor, self.tokens) |
| t = wiz.create("(nil A B C)") |
| valid = wiz.parse(t, "(nil A B A)") |
| self.failUnless(not valid) |
| |
| |
| def testWildcard(self): |
| wiz = TreeWizard(self.adaptor, self.tokens) |
| t = wiz.create("(A B C)") |
| valid = wiz.parse(t, "(A . .)") |
| self.failUnless(valid) |
| |
| |
| 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 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 testParseWithTextFails(self): |
| wiz = TreeWizard(self.adaptor, self.tokens) |
| t = wiz.create("(A B C)") |
| valid = wiz.parse(t, "(A[foo] B C)") |
| self.failUnless(not valid) # fails |
| |
| |
| 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.failUnless(valid) |
| self.failUnlessEqual("A", str(labels["a"])) |
| self.failUnlessEqual("B", str(labels["b"])) |
| self.failUnlessEqual("C", str(labels["c"])) |
| |
| |
| 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 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 testEquals(self): |
| wiz = TreeWizard(self.adaptor, self.tokens) |
| t1 = wiz.create("(A B C)") |
| t2 = wiz.create("(A B C)") |
| same = wiz.equals(t1, t2) |
| self.failUnless(same) |
| |
| |
| def testEqualsWithText(self): |
| wiz = TreeWizard(self.adaptor, self.tokens) |
| t1 = wiz.create("(A B[foo] C)") |
| t2 = wiz.create("(A B[foo] C)") |
| same = wiz.equals(t1, t2) |
| self.failUnless(same) |
| |
| |
| def testEqualsWithMismatchedText(self): |
| wiz = TreeWizard(self.adaptor, self.tokens) |
| t1 = wiz.create("(A B[foo] C)") |
| t2 = wiz.create("(A B C)") |
| same = wiz.equals(t1, t2) |
| self.failUnless(not same) |
| |
| |
| def testEqualsWithMismatchedList(self): |
| wiz = TreeWizard(self.adaptor, self.tokens) |
| t1 = wiz.create("(A B C)") |
| t2 = wiz.create("(A B A)") |
| same = wiz.equals(t1, t2) |
| self.failUnless(not same) |
| |
| |
| def testEqualsWithMismatchedListLength(self): |
| wiz = TreeWizard(self.adaptor, self.tokens) |
| t1 = wiz.create("(A B C)") |
| t2 = wiz.create("(A B)") |
| same = wiz.equals(t1, t2) |
| self.failUnless(not same) |
| |
| |
| 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.failUnlessEqual(expecting, found) |
| |
| |
| 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) |
| |
| |
| |
| if __name__ == "__main__": |
| unittest.main(testRunner=unittest.TextTestRunner(verbosity=2)) |
