def getBody(tokenStack): body = Tree('Body') while True: nextToken = tokenStack.peek() if nextToken == '}': return body body.addChild(getBlock(tokenStack))
def convert(code): codeNoComments = removeComments(code) tokenStack = tokenParser.parse(codeNoComments) root = Tree('Program') root.addChild(Tree('WhenRun')) while not tokenStack.isEmpty(): root.addChild(getBlock(tokenStack)) return root
def antlrTree2Tree(antlrTree): t = Tree(antlrTree.type, antlrTree.text, antlrTree.line, antlrTree.charPositionInLine) for i in range(antlrTree.getChildCount()): subT = antlrTree2Tree(antlrTree.getChild(i)) t.addChild(subT) return t
def getInvocation(tokenStack): codeCmd = tokenStack.next() cmd, param1 = parseCommandName(codeCmd) tokenStack.checkNext('(') param2 = getExpression(tokenStack) tokenStack.checkNext(')') tree = Tree(cmd) tree.addChild(Tree(param1)) tree.addChild(param2) return tree
def getRepeat(tokenStack): tokenStack.checkNext('Repeat') tokenStack.checkNext('(') numTimes = getExpression(tokenStack) tokenStack.checkNext(')') tokenStack.checkNext('{') body = getBody(tokenStack) tokenStack.checkNext('}') repeatTree = Tree('Repeat') repeatTree.addChild(numTimes) repeatTree.addChild(body) return repeatTree
def getExpression(tokenStack): lhs = getUnary(tokenStack) # If you don't find a binary opp next, # you are done if not isBinaryOpperator(tokenStack.peek()): return lhs opp = tokenStack.next() oppName = getOppName(opp) rhs = getUnary(tokenStack) oppTree = Tree('Arithmetic') oppTree.addChild(Tree(oppName)) oppTree.addChild(lhs) oppTree.addChild(rhs) return oppTree
def getValue(tokenStack): singleton = tokenStack.next() if isNumber(singleton): return makeNumberValue(singleton) elif singleton == 'i' or singleton == 'x': tree = Tree('Value') var = tree.addChild(Tree('Variable')) var.addChild(Tree('Counter')) return tree else: raise Exception('???: ' + singleton)
def recursiveUnion(baseTree:Tree, updateTree:Tree, override=False): """recursively iterate over updateTree, adding all branches not found in baseTree if override, any branches of the same name will be overridden by updateTree this copies both trees and returns a new object """ baseTree = baseTree.copy() updateTree = updateTree.copy() for updateBranch in updateTree.branches: if not baseTree.getBranch(updateBranch.name): baseTree.addChild(updateBranch) continue recursiveUnion(baseTree(updateBranch.name), updateBranch, override=override)
def getFor(tokenStack): tokenStack.checkNext('For') tokenStack.checkNext('(') start = str(getExpression(tokenStack)) tokenStack.checkNext(',') end = str(getExpression(tokenStack)) tokenStack.checkNext(',') delta = str(getExpression(tokenStack)) tokenStack.checkNext(')') tokenStack.checkNext('{') body = getBody(tokenStack) tokenStack.checkNext('}') forTree = Tree('For') forTree.addChild(makeNumberValue(start)) forTree.addChild(makeNumberValue(end)) forTree.addChild(makeNumberValue(delta)) forTree.addChild(body) return forTree
def _build(self, df): if df.empty: # empty dataframe mode = self.df[self.target].mode()[0] return Tree(mode) if len(df[self.target].unique()) == 1: # entropy = 0 return Tree(df[self.target][0]) if df.shape[1] == 1: # empty attribute mode = df[self.target].mode()[0] return Tree(mode) attr = self.getMaxGainAttr(df) tree = Tree(attr) if self.isContinuous(attr) == True: treshold = self.getBestTreshold(df, attr) lowDf, highDf = self.splitHorizontalContinuous(df, attr, treshold) childLowDf = self.dropAttr(lowDf, attr) childLowTree = self._build(childLowDf) treshold = round(treshold, 2) tree.addChild('< ' + str(treshold), childLowTree) childHighDf = self.dropAttr(highDf, attr) childHighTree = self._build(childHighDf) tree.addChild('>= ' + str(treshold), childHighTree) return tree for value in self.attributes[attr]: splittedDf = self.splitHorizontalKeepValue(df, attr, value) if splittedDf.empty == True: # empty example originalDf = self.splitHorizontalKeepValue( self.df, attr, value) mode = originalDf[self.target].mode()[0] childTree = Tree(mode) else: childDf = self.dropAttr(splittedDf, attr) childTree = self._build(childDf) tree.addChild(value, childTree) return tree
def makeNumberValue(numStr): tree = Tree('Value') tree.addChild(Tree('Number')).addChild(Tree(numStr)) return tree
class TestMainTree(unittest.TestCase): """ test for main tree interface methods """ def setUp(self): """ construct a basic test tree """ self.tree = Tree(name="testRoot", val="tree root") # self.tree.debugOn = True self.tree("branchA", create=True).value = "first branch" self.tree("branchA", create=True)("leafA", create=True).value = "first leaf" self.tree("branchB", create=True).value = 2 self.serialisedTruth = { '?VALUE': 'tree root', '?CHILDREN': [{ '?VALUE': 'first branch', '?CHILDREN': [{ '?VALUE': 'first leaf', '?NAME': 'leafA' }], '?NAME': 'branchA' }, { '?VALUE': 2, '?NAME': 'branchB' }], '?NAME': 'testRoot', '?FORMAT_VERSION': 0, } def test_treeInternals(self): baseTree = Tree("basicRoot") self.assertEqual(baseTree._uidBranchMap(), {}) baseBranch = baseTree("basicBranch", create=True) self.assertTrue("basicBranch" in baseTree.keys()) self.assertTrue("basicBranch" in baseTree.branchMap) self.assertEqual({"basicBranch": baseBranch}, baseTree.branchMap) self.assertEqual([baseBranch], baseTree.branches) def test_treeRoot(self): """ test that tree objects find their root properly """ self.assertIs(self.tree.root, self.tree, msg="tree root is not itself") self.assertIs(self.tree("branchA").root, self.tree, msg="tree branch finds incorrect root of " "{}".format(self.tree)) self.assertIs(self.tree("branchA")("leafA").root, self.tree, msg="tree leaf finds incorrect root of " "{}".format(self.tree)) def test_treeRetrieval(self): """ test retrieving values and branches using different methods """ # token retrieval self.assertIs(self.tree("branchA", "leafA"), self.tree("branchA")("leafA"), msg="error in token retrieval") # sequence retrieval # self.assertIs(self.tree(["branchA", "leafA"]), # self.tree("branchA")("leafA"), # msg="error in list retrieval") # NOT USED YET # string retrieval self.assertEqual(self.tree(self.tree.sep.join(["branchA", "leafA"])), self.tree("branchA")("leafA"), msg="string address error") # parent retrieval self.assertEqual( self.tree("branchA", "leafA", "superleafA", create=True), self.tree("branchA", "leafA", "superleafA", "^", "^", "leafA", "superleafA")) def test_treeLookupCreate(self): self.assertRaises(LookupError, self.tree, "nonBranch") self.tree.lookupCreate = True self.assertEqual(self.tree.lookupCreate, True) self.assertIsInstance(self.tree("nonBranch"), Tree) newBranch = self.tree("nonBranch") self.assertEqual(newBranch.lookupCreate, True) self.assertIsNone(newBranch.getProperty(Tree.lookupCreateKey)) def test_treeAddresses(self): """ test address system check equivalence of list and string formats """ # sequence address self.assertEqual(self.tree("branchA")("leafA").address(), ["branchA", "leafA"], msg="address sequence error") # string address self.assertEqual(self.tree("branchA")("leafA").stringAddress(), self.tree.sep.join(["branchA", "leafA"]), msg="string address error") # uid address leafUidAddress = [ self.tree("branchA").uid, self.tree("branchA", "leafA").uid ] self.assertEqual(leafUidAddress, self.tree("branchA", "leafA").address(uid=True), msg="uid address error") def test_treeRemoval(self): self.assertIs(self.tree("branchA").parent, self.tree) self.assertIn(self.tree("branchA"), self.tree.branches) removedBranch = self.tree("branchA").remove() self.assertIs(removedBranch.parent, None) self.assertNotIn(removedBranch, self.tree.branches) def test_treeInsertion(self): """ test inserting new branch""" newBranch = Tree(name="newBranch", val=69) self.tree("branchA")("leafA").addChild(newBranch) self.assertIs(self.tree("branchA")("leafA")("newBranch"), newBranch) def test_treeEquality(self): """ testing distinction between identity and equality """ newBranch = self.tree("branchA", "new", create=True) self.assertTrue(newBranch in self.tree("branchA"), msg="Tree does not contain its branch") # newCopy = newBranch.__copy__() # self.assertEqual(newBranch, newCopy, # msg="branch and its shallow copy are not equal") """shallow copying unsupported for now as it invites more confusion over uniqueness and referencing""" newCopy = newBranch.__deepcopy__() self.assertEqual(newBranch, newCopy, msg="branch and its shallow copy are not equal") self.assertFalse(newBranch is newCopy, msg="branch IS its copy") # self.assertTrue(newBranch is self.tree("branchA"), # msg="tree does not contain its branch") self.assertFalse(newCopy is self.tree("branchA"), msg="tree contains copy of its branch") def test_treeRenaming(self): """test that branches can be renamed and update properly""" renameBranch = self.tree("branchA")("leafA") self.assertEqual("leafA", renameBranch.name) renameBranch.name = "leafNew" print("renameBranch", renameBranch) self.assertEqual("leafNew", renameBranch.name) self.assertTrue("leafNew" in renameBranch.parent.keys()) self.assertIs(renameBranch, self.tree("branchA")("leafNew")) def test_treeValues(self): self.tree("newName", create=True).value = "newValue" self.assertEqual(self.tree("newName", create=True).value, "newValue") def test_treeSerialisation(self): """ test serialising tree to dict should get more advanced testing here, serialisation needs to support more stuff """ self.assertEqual(self.tree.serialise(), self.serialisedTruth, msg="mismatch in serialised data") restoreTree = self.tree.fromDict(self.tree.serialise()) self.assertEqual(self.tree, restoreTree, msg="restored tree not equal to its source") def test_treeRegeneration(self): """ test regeneration from dict """ self.assertEqual(Tree.fromDict(self.tree.serialise()), self.tree) def test_treeTyping(self): """ test custom tree types in contiguous hierarchy """ self.tree.addChild(CustomTreeType("customBranch", val=34535)) restoreTree = self.tree.fromDict(self.tree.serialise()) self.assertEqual(self.tree, restoreTree, msg="restored custom tree not equal to its source") self.assertIs(type(restoreTree("customBranch")), CustomTreeType, msg="restored custom type not equal to its source") def test_treeBreakPoints(self): """test that breakpoints work properly""" breakBranch = self.tree("branchA") breakBranch.setBreakTags("testBreakPoint") self.assertEqual(breakBranch.breakTags, {"testBreakPoint"}) self.assertIs( self.tree("branchA", "leafA").getBreak("testBreakPoint"), breakBranch) # looking up a breakpoint on the breakpoint returns the breakpoint? sure self.assertIs(breakBranch.getBreak("testBreakPoint"), breakBranch) self.assertIs(self.tree("branchA", "leafA").root, self.tree) def test_treeSubRegions(self): """test that a "main" breakpoint creates a sub-region in the tree""" breakBranch = self.tree("branchA") breakBranch.setBreakTags("main") self.assertIs(self.tree("branchA", "leafA").root, breakBranch) self.assertIs(breakBranch.root, breakBranch) self.assertIs(self.tree("branchA", "leafA").absoluteRoot, self.tree)
class TestTree(unittest.TestCase): def setUp(self): self.root = Tree(NAME) self.tree2 = None self.tree3 = None self.tree4 = None def _AddChild(self, name): new_tree = Tree(name) self.root.addChild(new_tree) return new_tree def _createComplexTree(self, root_name=NAME): """ Creates the following tree NAME1 NAME2 NAME4 NAME3 :param str root_name: name of the root node """ self.tree2 = self._AddChild(NAME2) self.tree3 = self._AddChild(NAME3) self.tree4 = Tree(NAME4) self.tree2.addChild(self.tree4) self.root.setName(root_name) def testConstructor(self): if IGNORE_TEST: return self.assertEqual(self.root._name, NAME) self.assertEqual(len(self.root._children), 0) def testAddChild(self): if IGNORE_TEST: return new_tree = self._AddChild(NAME2) self.assertEqual(len(self.root._children), 1) self.assertEqual(self.root._children[0], new_tree) newer_tree = self._AddChild(NAME3) self.assertEqual(len(self.root._children), 2) self.assertEqual(self.root._children[1], newer_tree) def testAddChildComplex(self): if IGNORE_TEST: return self._createComplexTree() self.assertTrue(self.tree4 in self.tree2.getChildren()) def testGetAllNodes(self): """ NAME1->NAME2->NAME4 NAME1->NAME3 """ if IGNORE_TEST: return root = Tree(NEW_NAME) nodes = root.getAllNodes() self.assertEqual(len(nodes), 1) self.assertEqual(nodes[0]._name, NEW_NAME) self._createComplexTree() names = [n._name for n in self.root.getAllNodes()] _verifyComplexTreeDepthFirstList(names, root_name=NAME) def testRemoveChildSimple(self): if IGNORE_TEST: return new_tree = self._AddChild(NAME2) new_tree.removeTree() self.assertIsNone(new_tree._parent) self.assertEqual(len(self.root._children), 0) def testRemoveChildComplex(self): if IGNORE_TEST: return self._createComplexTree() self.tree4.removeTree() self.assertIsNone(self.tree4._parent) self.assertEqual(len(self.tree2._children), 0) self.assertEqual(len(self.root._children), 2) def testGetRoot(self): if IGNORE_TEST: return self._createComplexTree() self.assertEqual(self.tree2._children[0], self.tree4) root = self.tree4.getRoot() self.assertEqual(root, self.root) root = self.root.getRoot() self.assertEqual(root, self.root) root = self.tree3.getRoot() self.assertEqual(root, self.root) def testGetChildrenFromRoot(self): if IGNORE_TEST: return self._createComplexTree() children = self.tree2.getChildren(is_from_root=False) self.assertEqual(children, [self.tree4]) children = self.tree4.getChildren(is_from_root=True, is_recursive=True) self.assertEqual(len(children), 3) self.assertFalse(self.root in children) self.assertTrue(self.tree2 in children) self.assertTrue(self.tree4 in children) def testGetChildrenFromSelf(self): """ NAME1: NAME2 NAME4 NAME4.1 NAME4.2 NAME3 """ if IGNORE_TEST: return self._createComplexTree() self.tree4.addChild(Tree(NAME4 + ".1")) self.tree4.addChild(Tree(NAME4 + ".2")) children = self.tree2.getChildren(is_from_root=False, is_recursive=True) grandchildren = self.tree4.getChildren(is_from_root=False) self.assertEqual(len(children), 3) self.assertEqual(len(grandchildren), 2) self.assertTrue(self.tree4 in children) def testFindPathFromRoot(self): if IGNORE_TEST: return self._createComplexTree() path = self.tree2.findPathFromRoot() self.assertEqual(path, [NAME, NAME2]) path = self.tree4.findPathFromRoot() self.assertEqual(path, [NAME, NAME2, NAME4]) def testFindName(self): if IGNORE_TEST: return self._createComplexTree() trees = self.tree2.findChildrenWithName(NAME3, is_from_root=True) self.assertEqual(trees, [self.tree3]) trees = self.tree2.findChildrenWithName(NAME3, is_from_root=False) self.assertEqual(trees, []) def _checkNodeLists(self, list1, list2): names1 = [l.getName() for l in list1] names2 = [l.getName() for l in list2] return set(names1) == set(names2) def testGetLeaves(self): if IGNORE_TEST: return self._createComplexTree() leaves = self.tree2.getLeaves(is_from_root=True) self.assertTrue(self._checkNodeLists(leaves, [self.tree3, self.tree4])) leaves = self.tree2.getLeaves(is_from_root=False) self.assertTrue(self._checkNodeLists(leaves, [self.tree4])) def testToString(self): if IGNORE_TEST: return self._createComplexTree() self.root.setName(NEW_NAME) print_string = self.root.toString() _verifyComplexTreeDepthFirstList(print_string) def testIsAlwaysLeaf(self): if IGNORE_TEST: return self._createComplexTree() self.assertFalse(self.tree2.isAlwaysLeaf()) def testCopy(self): if IGNORE_TEST: return self._createComplexTree() new_tree = self.root.copy() self.assertTrue(self.root.isEquivalent(new_tree)) def testComplexCopy(self): if IGNORE_TEST: return tree = Tree.createRandomTree(100, 0.8) new_tree = tree.copy() self.assertTrue(tree.isEquivalent(new_tree)) def testGetReverseOrderListOfNodes(self): if IGNORE_TEST: return self._createComplexTree() reverse_nodes = self.root.getReverseOrderListOfNodes() forward_nodes = [n for n in self.root] forward_nodes.reverse() self.assertEqual(forward_nodes, reverse_nodes) def _testRandomTrees(self, leaf_cls=None, nonleaf_cls=None, tree_test=lambda x: True): num_nodes = [3, 100, 20, 1] branching_probabilities = [0.5, 0.2, 0.8] for nn in num_nodes: for pp in branching_probabilities: tree = Tree.createRandomTree(nn, pp, seed=0.3, leaf_cls=leaf_cls, nonleaf_cls=nonleaf_cls) nodes = [n for n in tree] diff = abs(len(nodes) - nn) if diff > 1: import pdb pdb.set_trace() self.assertTrue(diff < 2) if not tree_test(tree): import pdb pdb.set_trace() self.assertTrue(tree_test(tree)) def testRandomTrees(self): if IGNORE_TEST: return self._testRandomTrees() def testGetUniqueName(self): if IGNORE_TEST: return self._createComplexTree() unique_name = self.tree4.getUniqueName() self.assertEqual(unique_name, 'NAME1.NAME2.NAME4') def testGetChldrenAsDict(self): if IGNORE_TEST: return self._createComplexTree() children_dict = self.root.getChildrenBreadthFirst() self.assertEqual(children_dict["node"], self.root) self.assertEqual(len(children_dict["children"]), 2) # children_dict = self.root.getChildrenBreadthFirst( excludes=[self.tree2]) self.assertEqual(children_dict["node"], self.root) self.assertEqual(len(children_dict["children"]), 1) # children_dict = self.root.getChildrenBreadthFirst( includes=[self.root, self.tree2]) self.assertEqual(children_dict["node"], self.root) self.assertEqual(len(children_dict["children"]), 1) # children_dict = self.root.getChildrenBreadthFirst( includes=[self.tree2]) self.assertEqual(len(children_dict.keys()), 0) def testGetAttachedNodes(self): """ NAME1 NAME2 NAME4 NAME3 """ if IGNORE_TEST: return # All leaves self._createComplexTree() all_leaves = self.root.getLeaves() leaves = self.root.getAttachedNodes(all_leaves) self.assertEqual(set(leaves), set([self.tree4, self.tree3])) # Eliminate NAME4 self.tree2.setIsAttached(False) leaves = self.root.getAttachedNodes(all_leaves) self.assertEqual(leaves, [self.tree3]) # Detaching the root shouldn't matter self.root.setIsAttached(False) leaves = self.root.getAttachedNodes(all_leaves) self.assertEqual(leaves, [self.tree3])
class BrainDuck: def __init__(self): self.errorFlag = False self.alphabet = ['>', '<', '+', '-', '.', ',', '[', ']'] self.listOfPrefixes = [] self.tree = None def readFile(self, fileLocation): with open(fileLocation) as file: for line in file: for char in line: if char in self.alphabet: #ignore all other char not in alphabet self.listOfPrefixes.append(char) self.listOfPrefixes.append(None) def consume(self): val = self.listOfPrefixes[0] self.listOfPrefixes = self.listOfPrefixes[1:] return Tree(val) def loopParse(self): val = self.consume() while self.listOfPrefixes[0] != ']' and self.listOfPrefixes[0] != None: val.addChild(self.operation()) if self.listOfPrefixes[0] == ']': val.addChild(self.consume()) else: self.errorFlag = True return val def operation(self): if self.listOfPrefixes[0] == ']': self.errorFlag = True return None elif self.listOfPrefixes[0] == '[': return self.loopParse() elif self.listOfPrefixes[0] == None: return None else: return self.consume() def parse(self, fileLocation): self.errorFlag = False self.listOfPrefixes = [] self.tree = Tree() self.readFile(fileLocation) while self.listOfPrefixes[0] is not None: val = self.operation() if val != None: self.tree.addChild(val) elif self.errorFlag == True: break if self.errorFlag == True: print('Parsing Error') sys.exit(-1) def buildMap(self, operations): val = [] loopMap = {} for index, operation in enumerate(operations): if operation == '[': val.append(index) if operation == ']': beginning = val.pop() loopMap[beginning] = index loopMap[index] = beginning return loopMap def run(self, fileLocation): self.parse(fileLocation) tape = [0] cellPointer = 0 operations = self.tree.preOrderValues()[1:] loopMap = self.buildMap(operations) codePointer = 0 while (codePointer < len(operations)): if operations[codePointer] == '<': if cellPointer - 1 >= 0: cellPointer = cellPointer - 1 elif operations[codePointer] == '>': cellPointer = cellPointer + 1 if len(tape) == (cellPointer): tape.append(0) elif operations[codePointer] == '-': if tape[cellPointer] - 1 < 0: tape[cellPointer] = 255 else: tape[cellPointer] = tape[cellPointer] - 1 elif operations[codePointer] == '+': if tape[cellPointer] + 1 > 255: tape[cellPointer] = 0 else: tape[cellPointer] = tape[cellPointer] + 1 elif operations[codePointer] == '.': print(chr(tape[cellPointer]), end="") elif operations[codePointer] == ',': tape[cellPointer] = int(input()) elif operations[codePointer] == '[': if tape[cellPointer] == 0: codePointer = loopMap[codePointer] elif operations[codePointer] == ']': if tape[cellPointer] != 0: codePointer = loopMap[codePointer] codePointer = codePointer + 1 print("\n")
class TestTree(unittest.TestCase): def setUp(self): self.root = Tree(NAME) self.tree2 = None self.tree3 = None self.tree4 = None def _AddChild(self, name): new_tree = Tree(name) self.root.addChild(new_tree) return new_tree def _createComplexTree(self): """ Creates the following tree NAME1->NAME2->NAME4 NAME1->NAME3 """ self.tree2 = self._AddChild(NAME2) self.tree3 = self._AddChild(NAME3) self.tree4 = Tree(NAME4) self.tree2.addChild(self.tree4) def testConstructor(self): if IGNORE_TEST: return self.assertEqual(self.root._name, NAME) self.assertEqual(len(self.root._children), 0) def testAddChild(self): if IGNORE_TEST: return new_tree = self._AddChild(NAME2) self.assertEqual(len(self.root._children), 1) self.assertEqual(self.root._children[0], new_tree) newer_tree = self._AddChild(NAME3) self.assertEqual(len(self.root._children), 2) self.assertEqual(self.root._children[1], newer_tree) def testAddChildComplex(self): if IGNORE_TEST: return self._createComplexTree() self.assertTrue(self.tree4 in self.tree2.getChildren()) def testRemoveChildSimple(self): if IGNORE_TEST: return new_tree = self._AddChild(NAME2) new_tree.removeTree() self.assertIsNone(new_tree._parent) self.assertEqual(len(self.root._children), 0) def testRemoveChildComplex(self): if IGNORE_TEST: return self._createComplexTree() self.tree4.removeTree() self.assertIsNone(self.tree4._parent) self.assertEqual(len(self.tree2._children), 0) self.assertEqual(len(self.root._children), 2) def testGetRoot(self): if IGNORE_TEST: return self._createComplexTree() self.assertEqual(self.tree2._children[0], self.tree4) root = self.tree4.getRoot() self.assertEqual(root, self.root) root = self.root.getRoot() self.assertEqual(root, self.root) root = self.tree3.getRoot() self.assertEqual(root, self.root) def testGetChildrenFromRoot(self): if IGNORE_TEST: return self._createComplexTree() children = self.tree2.getChildren(is_from_root=False) self.assertEqual(children, [self.tree4]) children = self.tree4.getChildren(is_from_root=True, is_recursive=True) self.assertEqual(len(children), 3) self.assertFalse(self.root in children) self.assertTrue(self.tree2 in children) self.assertTrue(self.tree4 in children) def testGetChildrenFromSelf(self): if IGNORE_TEST: return self._createComplexTree() children = self.tree2.getChildren(is_from_root=False) grandchildren = self.tree4.getChildren(is_from_root=False) self.assertEqual(len(children), 1) self.assertEqual(len(grandchildren), 0) self.assertTrue(self.tree4 in children) def testFindPathFromRoot(self): if IGNORE_TEST: return self._createComplexTree() path = self.tree2.findPathFromRoot() self.assertEqual(path, [NAME, NAME2]) path = self.tree4.findPathFromRoot() self.assertEqual(path, [NAME, NAME2, NAME4]) def testFindName(self): if IGNORE_TEST: return self._createComplexTree() trees = self.tree2.findChildrenWithName(NAME3, is_from_root=True) self.assertEqual(trees, [self.tree3]) trees = self.tree2.findChildrenWithName(NAME3, is_from_root=False) self.assertEqual(trees, []) def _checkNodeLists(self, list1, list2): names1 = [l.getName() for l in list1] names2 = [l.getName() for l in list2] return set(names1) == set(names2) def testGetLeaves(self): if IGNORE_TEST: return self._createComplexTree() leaves = self.tree2.getLeaves(is_from_root=True) self.assertTrue(self._checkNodeLists(leaves, [self.tree3, self.tree4])) leaves = self.tree2.getLeaves(is_from_root=False) self.assertTrue(self._checkNodeLists(leaves, [self.tree4])) def testToString(self): if IGNORE_TEST: return self._createComplexTree() print_string = self.root.toString() self.assertTrue("%s->%s" % (NAME, NAME3) in print_string) self.assertTrue("%s->%s" % (NAME, NAME2) in print_string) self.assertTrue("%s->%s" % (NAME2, NAME4) in print_string) def testIsAlwaysLeaf(self): if IGNORE_TEST: return self._createComplexTree() self.assertFalse(self.tree2.isAlwaysLeaf()) def testCopy(self): if IGNORE_TEST: return new_tree = self.root.copy() self.assertTrue(self.root.isEquivalent(new_tree))