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))
