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