public void Simple()
{
var root = new GeneralTree<int>(5);
var child1 = new GeneralTree<int>(2);
var child2 = new GeneralTree<int>(3);
var child3 = new GeneralTree<int>(1);
root.Add(child1);
root.Add(child2);
root.Add(child3);
var child4 = new GeneralTree<int>(9);
var child5 = new GeneralTree<int>(12);
var child6 = new GeneralTree<int>(13);
child1.Add(child4);
child1.Add(child5);
child2.Add(child6);
Assert.AreEqual(root.FindNode(target => target == 13), child6);
Assert.AreEqual(root.FindNode(target => target == 2), child1);
Assert.AreEqual(root.FindNode(target => target == 9), child4);
Assert.AreEqual(root.FindNode(target => target == 57), null);
}
public void Interface()
{
var root = new GeneralTree <int>(5);
var child1 = new GeneralTree <int>(2);
var child2 = new GeneralTree <int>(3);
var child3 = new GeneralTree <int>(1);
root.Add(child1);
root.Add(child2);
root.Add(child3);
var child4 = new GeneralTree <int>(9);
var child5 = new GeneralTree <int>(12);
var child6 = new GeneralTree <int>(13);
child1.Add(child4);
child1.Add(child5);
child2.Add(child6);
ITree <int> tree = root;
Assert.AreEqual(tree.FindNode(target => target == 13), child6);
Assert.AreEqual(tree.FindNode(target => target == 2), child1);
Assert.AreEqual(tree.FindNode(target => target == 9), child4);
Assert.AreEqual(tree.FindNode(target => target == 57), null);
}
private GeneralTree<IDirectoryTreeNode> Crawl(DirectoryInfo directory, IDirectoryTreeNode rootNode)
{
IDirectoryTreeNode currentNode =
featureNodeFactory.Create(rootNode != null ? rootNode.OriginalLocation : null, directory);
if (rootNode == null)
{
rootNode = currentNode;
}
var tree = new GeneralTree<IDirectoryTreeNode>(currentNode);
bool isRelevantFileFound = false;
foreach (FileInfo file in directory.GetFiles().Where(file => relevantFileDetector.IsRelevant(file)))
{
isRelevantFileFound = true;
IDirectoryTreeNode node = featureNodeFactory.Create(rootNode.OriginalLocation, file);
tree.Add(node);
}
bool isRelevantDirectoryFound = false;
foreach (DirectoryInfo subDirectory in directory.GetDirectories())
{
GeneralTree<IDirectoryTreeNode> subTree = Crawl(subDirectory, rootNode);
if (subTree != null)
{
isRelevantDirectoryFound = true;
tree.Add(subTree);
}
}
if (!isRelevantFileFound && !isRelevantDirectoryFound) return null;
return tree;
}
public void TestRemove()
{
GeneralTree <int> root = new GeneralTree <int>(5);
GeneralTree <int> child1 = new GeneralTree <int>(2);
GeneralTree <int> child2 = new GeneralTree <int>(3);
GeneralTree <int> child3 = new GeneralTree <int>(5);
GeneralTree <int> child4 = new GeneralTree <int>(7);
root.Add(child1);
root.Add(child2);
Assert.AreEqual(root.Count, 2);
Assert.AreEqual(root.Degree, 2);
root.RemoveAt(0);
Assert.AreEqual(child1.Parent, null);
Assert.AreEqual(root.Count, 1);
Assert.AreEqual(root.Degree, 1);
Assert.AreEqual(root.GetChild(0), child2);
Assert.AreEqual(root.GetChild(0).Data, 3);
root.Add(child1);
Assert.AreEqual(child1.Parent, root);
Assert.AreEqual(root.Count, 2);
Assert.AreEqual(root.Degree, 2);
Assert.AreEqual(root.Remove(child1), true);
Assert.AreEqual(child1.Parent, null);
Assert.AreEqual(root.Count, 1);
Assert.AreEqual(root.Degree, 1);
Assert.AreEqual(root.GetChild(0), child2);
Assert.AreEqual(root.GetChild(0).Data, 3);
Assert.AreEqual(root.Remove(child3), false);
root.Add(child3);
root.Add(child4);
Assert.AreEqual(root.Count, 3);
Assert.AreEqual(root.Degree, 3);
GeneralTree <int> fiveNode = root.FindNode(delegate(int target) { return(target == 5); });
Assert.AreEqual(root.Remove(5), true);
Assert.AreEqual(fiveNode.Parent, null);
Assert.AreEqual(root.Count, 2);
Assert.AreEqual(root.Degree, 2);
Assert.AreEqual(root.GetChild(1).Data, 7);
Assert.AreEqual(root.Remove(13), false);
}
public void Simple()
{
var root = new GeneralTree <int>(5);
var child1 = new GeneralTree <int>(2);
var child2 = new GeneralTree <int>(3);
var child3 = new GeneralTree <int>(5);
var child4 = new GeneralTree <int>(7);
root.Add(child1);
root.Add(child2);
Assert.AreEqual(root.Count, 2);
Assert.AreEqual(root.Degree, 2);
root.RemoveAt(0);
Assert.IsNull(child1.Parent);
Assert.AreEqual(root.Count, 1);
Assert.AreEqual(root.Degree, 1);
Assert.AreEqual(root.GetChild(0), child2);
Assert.AreEqual(root.GetChild(0).Data, 3);
root.Add(child1);
Assert.AreEqual(child1.Parent, root);
Assert.AreEqual(root.Count, 2);
Assert.AreEqual(root.Degree, 2);
Assert.IsTrue(root.Remove(child1));
Assert.IsNull(child1.Parent);
Assert.AreEqual(root.Count, 1);
Assert.AreEqual(root.Degree, 1);
Assert.AreEqual(root.GetChild(0), child2);
Assert.AreEqual(root.GetChild(0).Data, 3);
Assert.IsFalse(root.Remove(child3));
root.Add(child3);
root.Add(child4);
Assert.AreEqual(root.Count, 3);
Assert.AreEqual(root.Degree, 3);
var fiveNode = root.FindNode(target => target == 5);
Assert.IsTrue(root.Remove(5));
Assert.IsNull(fiveNode.Parent);
Assert.AreEqual(root.Count, 2);
Assert.AreEqual(root.Degree, 2);
Assert.AreEqual(root.GetChild(1).Data, 7);
Assert.IsFalse(root.Remove(13));
}
public void Simple()
{
var root = new GeneralTree<int>(5);
var child1 = new GeneralTree<int>(2);
var child2 = new GeneralTree<int>(3);
var child3 = new GeneralTree<int>(5);
var child4 = new GeneralTree<int>(7);
root.Add(child1);
root.Add(child2);
Assert.AreEqual(root.Count, 2);
Assert.AreEqual(root.Degree, 2);
root.RemoveAt(0);
Assert.IsNull(child1.Parent);
Assert.AreEqual(root.Count, 1);
Assert.AreEqual(root.Degree, 1);
Assert.AreEqual(root.GetChild(0), child2);
Assert.AreEqual(root.GetChild(0).Data, 3);
root.Add(child1);
Assert.AreEqual(child1.Parent, root);
Assert.AreEqual(root.Count, 2);
Assert.AreEqual(root.Degree, 2);
Assert.IsTrue(root.Remove(child1));
Assert.IsNull(child1.Parent);
Assert.AreEqual(root.Count, 1);
Assert.AreEqual(root.Degree, 1);
Assert.AreEqual(root.GetChild(0), child2);
Assert.AreEqual(root.GetChild(0).Data, 3);
Assert.IsFalse(root.Remove(child3));
root.Add(child3);
root.Add(child4);
Assert.AreEqual(root.Count, 3);
Assert.AreEqual(root.Degree, 3);
var fiveNode = root.FindNode(target => target == 5);
Assert.IsTrue(root.Remove(5));
Assert.IsNull(fiveNode.Parent);
Assert.AreEqual(root.Count, 2);
Assert.AreEqual(root.Degree, 2);
Assert.AreEqual(root.GetChild(1).Data, 7);
Assert.IsFalse(root.Remove(13));
}
private GeneralTree <IDirectoryTreeNode> Crawl(DirectoryInfo directory, IDirectoryTreeNode rootNode)
{
IDirectoryTreeNode currentNode =
featureNodeFactory.Create(rootNode != null ? rootNode.OriginalLocation : null, directory);
if (rootNode == null)
{
rootNode = currentNode;
}
var tree = new GeneralTree <IDirectoryTreeNode>(currentNode);
bool isRelevantFileFound = false;
foreach (FileInfo file in directory.GetFiles().Where(file => relevantFileDetector.IsRelevant(file)))
{
isRelevantFileFound = true;
IDirectoryTreeNode node = null;
try
{
node = featureNodeFactory.Create(rootNode.OriginalLocation, file);
}
catch (Exception)
{
if (log.IsWarnEnabled)
{
log.WarnFormat("The file, {0}, will be ignored because it could not be read in properly", file.FullName);
}
}
if (node != null)
{
tree.Add(node);
}
}
bool isRelevantDirectoryFound = false;
foreach (DirectoryInfo subDirectory in directory.GetDirectories())
{
GeneralTree <IDirectoryTreeNode> subTree = Crawl(subDirectory, rootNode);
if (subTree != null)
{
isRelevantDirectoryFound = true;
tree.Add(subTree);
}
}
if (!isRelevantFileFound && !isRelevantDirectoryFound)
{
return(null);
}
return(tree);
}
public void TestInterfaceFind()
{
GeneralTree <int> root = new GeneralTree <int>(5);
GeneralTree <int> child1 = new GeneralTree <int>(2);
GeneralTree <int> child2 = new GeneralTree <int>(3);
GeneralTree <int> child3 = new GeneralTree <int>(1);
root.Add(child1);
root.Add(child2);
root.Add(child3);
GeneralTree <int> child4 = new GeneralTree <int>(9);
GeneralTree <int> child5 = new GeneralTree <int>(12);
GeneralTree <int> child6 = new GeneralTree <int>(13);
child1.Add(child4);
child1.Add(child5);
child2.Add(child6);
Assert.AreEqual(((ITree <int>) root).FindNode(
delegate(int target)
{
return(target == 13);
})
,
child6
);
Assert.AreEqual(((ITree <int>) root).FindNode(
delegate(int target)
{
return(target == 2);
})
,
child1
);
Assert.AreEqual(((ITree <int>) root).FindNode(
delegate(int target)
{
return(target == 9);
})
,
child4
);
Assert.AreEqual(((ITree <int>) root).FindNode(
delegate(int target)
{
return(target == 57);
})
,
null
);
}
public void ExceptionInvalidSubTree()
{
var root = new GeneralTree <int>(5);
var child1 = new GeneralTree <int>(2);
var child2 = new GeneralTree <int>(3);
root.Add(child1);
root.Add(child2);
Assert.Throws <ArgumentOutOfRangeException>(() => root.GetChild(3));
}
public void TestInvalidIndex1()
{
GeneralTree <int> root = new GeneralTree <int>(5);
GeneralTree <int> child1 = new GeneralTree <int>(2);
GeneralTree <int> child2 = new GeneralTree <int>(3);
root.Add(child1);
root.Add(child2);
int i = root[3].Data;
}
public void ExceptionInvalidIndex1()
{
var root = new GeneralTree <int>(5);
var child1 = new GeneralTree <int>(2);
var child2 = new GeneralTree <int>(3);
root.Add(child1);
root.Add(child2);
var i = root[3].Data;
}
public void TestInvalidSubTree()
{
GeneralTree <int> root = new GeneralTree <int>(5);
GeneralTree <int> child1 = new GeneralTree <int>(2);
GeneralTree <int> child2 = new GeneralTree <int>(3);
root.Add(child1);
root.Add(child2);
root.GetChild(3);
}
public void ExceptionInvalidSubTree()
{
var root = new GeneralTree <int>(5);
var child1 = new GeneralTree <int>(2);
var child2 = new GeneralTree <int>(3);
root.Add(child1);
root.Add(child2);
root.GetChild(3);
}
public void ExceptionInvalidSubTree()
{
var root = new GeneralTree<int>(5);
var child1 = new GeneralTree<int>(2);
var child2 = new GeneralTree<int>(3);
root.Add(child1);
root.Add(child2);
root.GetChild(3);
}
public void ExceptionInvalidIndex1()
{
var root = new GeneralTree<int>(5);
var child1 = new GeneralTree<int>(2);
var child2 = new GeneralTree<int>(3);
root.Add(child1);
root.Add(child2);
var i = root[3].Data;
}
public void ExceptionInvalidIndex1()
{
var root = new GeneralTree <int>(5);
var child1 = new GeneralTree <int>(2);
var child2 = new GeneralTree <int>(3);
root.Add(child1);
root.Add(child2);
int i;
Assert.Throws <ArgumentOutOfRangeException>(() => i = root[3].Data);
}
private bool CollectFiles(DirectoryInfoBase directory, INode rootNode, GeneralTree <INode> tree)
{
List <INode> collectedNodes = new List <INode>();
foreach (FileInfoBase file in directory.GetFiles().Where(file => this.relevantFileDetector.IsRelevant(file)))
{
INode node = null;
try
{
node = this.featureNodeFactory.Create(rootNode.OriginalLocation, file);
}
catch (Exception)
{
if (log.IsWarnEnabled)
{
log.Warn("The file, {0}, will be ignored because it could not be read in properly", file.FullName);
}
}
if (node != null)
{
collectedNodes.Add(node);
}
}
foreach (var node in OrderFileNodes(collectedNodes))
{
tree.Add(node);
}
return(collectedNodes.Count > 0);
}
public void Interface()
{
ITree <int> tree = new GeneralTree <int>(5);
var child1 = new GeneralTree <int>(4);
var child2 = new GeneralTree <int>(6);
var child3 = new GeneralTree <int>(7);
tree.Add(child1);
tree.Add(child2);
Assert.AreEqual(tree.Degree, 2);
Assert.IsTrue(tree.Remove(child1));
Assert.AreEqual(tree.Degree, 1);
Assert.IsFalse(tree.Remove(child3));
Assert.AreEqual(tree.Degree, 1);
Assert.IsTrue(tree.Remove(child2));
Assert.AreEqual(tree.Degree, 0);
}
public void Interface()
{
ITree<int> tree = new GeneralTree<int>(5);
var child1 = new GeneralTree<int>(4);
var child2 = new GeneralTree<int>(6);
var child3 = new GeneralTree<int>(7);
tree.Add(child1);
tree.Add(child2);
Assert.AreEqual(tree.Degree, 2);
Assert.IsTrue(tree.Remove(child1));
Assert.AreEqual(tree.Degree, 1);
Assert.IsFalse(tree.Remove(child3));
Assert.AreEqual(tree.Degree, 1);
Assert.IsTrue(tree.Remove(child2));
Assert.AreEqual(tree.Degree, 0);
}
public void TestInterfaceRemove()
{
ITree <int> tree = new GeneralTree <int>(5);
GeneralTree <int> child1 = new GeneralTree <int>(4);
GeneralTree <int> child2 = new GeneralTree <int>(6);
GeneralTree <int> child3 = new GeneralTree <int>(7);
tree.Add(child1);
tree.Add(child2);
Assert.AreEqual(tree.Degree, 2);
Assert.AreEqual(tree.Remove(child1), true);
Assert.AreEqual(tree.Degree, 1);
Assert.AreEqual(tree.Remove(child3), false);
Assert.AreEqual(tree.Degree, 1);
Assert.AreEqual(tree.Remove(child2), true);
Assert.AreEqual(tree.Degree, 0);
}
public void Simple()
{
var root = new GeneralTree <int>(5);
var child1 = new GeneralTree <int>(2);
var child2 = new GeneralTree <int>(3);
root.Add(child1);
root.Add(child2);
Assert.AreEqual(child1.Parent, root);
Assert.AreEqual(child2.Parent, root);
Assert.AreEqual(root.Count, 2);
Assert.AreEqual(root.Degree, 2);
Assert.AreEqual(root.GetChild(0), child1);
Assert.AreEqual(root.GetChild(0).Data, child1.Data);
Assert.AreEqual(root.GetChild(1).Data, child2.Data);
Assert.AreEqual(root.GetChild(1), child2);
root = new GeneralTree <int>(5)
{
2,
3
};
Assert.AreEqual(root.GetChild(0).Data, child1.Data);
Assert.AreEqual(root.GetChild(1).Data, child2.Data);
Assert.AreEqual(root.GetChild(0).Parent, root);
Assert.AreEqual(root.GetChild(1).Parent, root);
var anotherRoot = new GeneralTree <int>(2);
var movedChild = root.GetChild(0);
anotherRoot.Add(movedChild);
Assert.AreEqual(movedChild.Parent, anotherRoot);
Assert.AreEqual(root.Degree, 1);
Assert.AreEqual(root.GetChild(0).Parent, root);
}
public void Simple()
{
var root = new GeneralTree<int>(5);
var child1 = new GeneralTree<int>(2);
var child2 = new GeneralTree<int>(3);
root.Add(child1);
root.Add(child2);
Assert.AreEqual(child1.Parent, root);
Assert.AreEqual(child2.Parent, root);
Assert.AreEqual(root.Count, 2);
Assert.AreEqual(root.Degree, 2);
Assert.AreEqual(root.GetChild(0), child1);
Assert.AreEqual(root.GetChild(0).Data, child1.Data);
Assert.AreEqual(root.GetChild(1).Data, child2.Data);
Assert.AreEqual(root.GetChild(1), child2);
root = new GeneralTree<int>(5)
{
2,
3
};
Assert.AreEqual(root.GetChild(0).Data, child1.Data);
Assert.AreEqual(root.GetChild(1).Data, child2.Data);
Assert.AreEqual(root.GetChild(0).Parent, root);
Assert.AreEqual(root.GetChild(1).Parent, root);
var anotherRoot = new GeneralTree<int>(2);
var movedChild = root.GetChild(0);
anotherRoot.Add(movedChild);
Assert.AreEqual(movedChild.Parent, anotherRoot);
Assert.AreEqual(root.Degree, 1);
Assert.AreEqual(root.GetChild(0).Parent, root);
}
public void TestAdd()
{
GeneralTree <int> root = new GeneralTree <int>(5);
GeneralTree <int> child1 = new GeneralTree <int>(2);
GeneralTree <int> child2 = new GeneralTree <int>(3);
root.Add(child1);
root.Add(child2);
Assert.AreEqual(child1.Parent, root);
Assert.AreEqual(child2.Parent, root);
Assert.AreEqual(root.Count, 2);
Assert.AreEqual(root.Degree, 2);
Assert.AreEqual(root.GetChild(0), child1);
Assert.AreEqual(root.GetChild(0).Data, child1.Data);
Assert.AreEqual(root.GetChild(1).Data, child2.Data);
Assert.AreEqual(root.GetChild(1), child2);
root = new GeneralTree <int>(5);
root.Add(2);
root.Add(3);
Assert.AreEqual(root.GetChild(0).Data, child1.Data);
Assert.AreEqual(root.GetChild(1).Data, child2.Data);
Assert.AreEqual(root.GetChild(0).Parent, root);
Assert.AreEqual(root.GetChild(1).Parent, root);
GeneralTree <int> anotherRoot = new GeneralTree <int>(2);
GeneralTree <int> movedChild = root.GetChild(0);
anotherRoot.Add(movedChild);
Assert.AreEqual(movedChild.Parent, anotherRoot);
Assert.AreEqual(root.Degree, 1);
Assert.AreEqual(root.GetChild(0).Parent, root);
}
private GeneralTree <int> GetMixedTestTree()
{
GeneralTree <int> root = new GeneralTree <int>(5);
GeneralTree <int> child1 = new GeneralTree <int>(2);
GeneralTree <int> child2 = new GeneralTree <int>(3);
GeneralTree <int> child3 = new GeneralTree <int>(1);
root.Add(child1);
root.Add(child2);
root.Add(child3);
GeneralTree <int> child4 = new GeneralTree <int>(15);
GeneralTree <int> child5 = new GeneralTree <int>(11);
GeneralTree <int> child6 = new GeneralTree <int>(13);
child1.Add(child4);
child1.Add(child5);
child2.Add(child6);
return(root);
}
internal static GeneralTree<int> GetTestTree()
{
var root = new GeneralTree<int>(5);
var child1 = new GeneralTree<int>(2);
var child2 = new GeneralTree<int>(3);
var child3 = new GeneralTree<int>(1);
root.Add(child1);
root.Add(child2);
root.Add(child3);
var child4 = new GeneralTree<int>(9);
var child5 = new GeneralTree<int>(12);
var child6 = new GeneralTree<int>(13);
child1.Add(child4);
child1.Add(child5);
child2.Add(child6);
return root;
}
internal static GeneralTree <int> GetMixedTestTree()
{
var root = new GeneralTree <int>(5);
var child1 = new GeneralTree <int>(2);
var child2 = new GeneralTree <int>(3);
var child3 = new GeneralTree <int>(1);
root.Add(child1);
root.Add(child2);
root.Add(child3);
var child4 = new GeneralTree <int>(15);
var child5 = new GeneralTree <int>(11);
var child6 = new GeneralTree <int>(13);
child1.Add(child4);
child1.Add(child5);
child2.Add(child6);
return(root);
}
public void Simple()
{
var tree = GetTestTree();
var ancestors = tree.GetChild(0).GetChild(0).Ancestors;
Assert.AreEqual(ancestors.Count, 2);
Assert.AreEqual(ancestors[1], tree.GetChild(0));
Assert.AreEqual(ancestors[0], tree);
var root = new GeneralTree<int>(5);
var child1 = new GeneralTree<int>(2);
var child2 = new GeneralTree<int>(3);
var child3 = new GeneralTree<int>(1);
root.Add(child1);
root.Add(child2);
root.Add(child3);
var child4 = new GeneralTree<int>(9);
var child5 = new GeneralTree<int>(12);
var child6 = new GeneralTree<int>(13);
var child7 = new GeneralTree<int>(15);
child1.Add(child4);
child1.Add(child5);
child2.Add(child6);
child4.Add(child7);
ancestors = child7.Ancestors;
Assert.AreEqual(ancestors.Count, 3);
Assert.AreEqual(ancestors[0], root);
Assert.AreEqual(ancestors[1], child1);
Assert.AreEqual(ancestors[2], child4);
}
public void TestAncestors()
{
GeneralTree <int> tree = GetTestTree();
GeneralTree <int>[] ancestors = tree.GetChild(0).GetChild(0).Ancestors;
Assert.AreEqual(ancestors.Length, 2);
Assert.AreEqual(ancestors[0], tree.GetChild(0));
Assert.AreEqual(ancestors[1], tree);
GeneralTree <int> root = new GeneralTree <int>(5);
GeneralTree <int> child1 = new GeneralTree <int>(2);
GeneralTree <int> child2 = new GeneralTree <int>(3);
GeneralTree <int> child3 = new GeneralTree <int>(1);
root.Add(child1);
root.Add(child2);
root.Add(child3);
GeneralTree <int> child4 = new GeneralTree <int>(9);
GeneralTree <int> child5 = new GeneralTree <int>(12);
GeneralTree <int> child6 = new GeneralTree <int>(13);
GeneralTree <int> child7 = new GeneralTree <int>(15);
child1.Add(child4);
child1.Add(child5);
child2.Add(child6);
child4.Add(child7);
ancestors = child7.Ancestors;
Assert.AreEqual(ancestors.Length, 3);
Assert.AreEqual(ancestors[0], child4);
Assert.AreEqual(ancestors[1], child1);
Assert.AreEqual(ancestors[2], root);
}
public void Simple()
{
var tree = GetTestTree();
var ancestors = tree.GetChild(0).GetChild(0).Ancestors;
Assert.AreEqual(ancestors.Count, 2);
Assert.AreEqual(ancestors[1], tree.GetChild(0));
Assert.AreEqual(ancestors[0], tree);
var root = new GeneralTree <int>(5);
var child1 = new GeneralTree <int>(2);
var child2 = new GeneralTree <int>(3);
var child3 = new GeneralTree <int>(1);
root.Add(child1);
root.Add(child2);
root.Add(child3);
var child4 = new GeneralTree <int>(9);
var child5 = new GeneralTree <int>(12);
var child6 = new GeneralTree <int>(13);
var child7 = new GeneralTree <int>(15);
child1.Add(child4);
child1.Add(child5);
child2.Add(child6);
child4.Add(child7);
ancestors = child7.Ancestors;
Assert.AreEqual(ancestors.Count, 3);
Assert.AreEqual(ancestors[0], root);
Assert.AreEqual(ancestors[1], child1);
Assert.AreEqual(ancestors[2], child4);
}
public void Simple()
{
var generalTree = new GeneralTree <int>(5);
Assert.AreEqual(generalTree.Height, 0);
var s1 = new GeneralTree <int>(3);
generalTree.Add(s1);
Assert.AreEqual(generalTree.Height, 1);
s1.Add(new GeneralTree <int>(6));
Assert.AreEqual(generalTree.Height, 2);
generalTree.Add(new GeneralTree <int>(4));
Assert.AreEqual(generalTree.Height, 2);
generalTree = GetTestTree();
Assert.AreEqual(generalTree.Height, 2);
}
public void TestHeight()
{
GeneralTree <int> t = new GeneralTree <int>(5);
Assert.AreEqual(t.Height, 0);
GeneralTree <int> s1 = new GeneralTree <int>(3);
t.Add(s1);
Assert.AreEqual(t.Height, 1);
s1.Add(new GeneralTree <int>(6));
Assert.AreEqual(t.Height, 2);
t.Add(new GeneralTree <int>(4));
Assert.AreEqual(t.Height, 2);
t = GetTestTree();
Assert.AreEqual(t.Height, 2);
}
public void Simple()
{
var generalTree = new GeneralTree<int>(5);
Assert.AreEqual(generalTree.Height, 0);
var s1 = new GeneralTree<int>(3);
generalTree.Add(s1);
Assert.AreEqual(generalTree.Height, 1);
s1.Add(new GeneralTree<int>(6));
Assert.AreEqual(generalTree.Height, 2);
generalTree.Add(new GeneralTree<int>(4));
Assert.AreEqual(generalTree.Height, 2);
generalTree = GetTestTree();
Assert.AreEqual(generalTree.Height, 2);
}
private GeneralTree<IDirectoryTreeNode> Crawl(DirectoryInfo directory, IDirectoryTreeNode rootNode)
{
IDirectoryTreeNode currentNode =
featureNodeFactory.Create(rootNode != null ? rootNode.OriginalLocation : null, directory);
if (rootNode == null)
{
rootNode = currentNode;
}
var tree = new GeneralTree<IDirectoryTreeNode>(currentNode);
bool isRelevantFileFound = false;
foreach (FileInfo file in directory.GetFiles().Where(file => relevantFileDetector.IsRelevant(file)))
{
isRelevantFileFound = true;
IDirectoryTreeNode node = null;
try
{
node = featureNodeFactory.Create(rootNode.OriginalLocation, file);
}
catch (Exception)
{
if (log.IsWarnEnabled) log.WarnFormat("The file, {0}, will be ignored because it could not be read in properly", file.FullName);
}
if (node != null) tree.Add(node);
}
bool isRelevantDirectoryFound = false;
foreach (DirectoryInfo subDirectory in directory.GetDirectories())
{
GeneralTree<IDirectoryTreeNode> subTree = Crawl(subDirectory, rootNode);
if (subTree != null)
{
isRelevantDirectoryFound = true;
tree.Add(subTree);
}
}
if (!isRelevantFileFound && !isRelevantDirectoryFound) return null;
return tree;
}
public void TestCompareTo()
{
GeneralTree <int> t = GetTestTree();
GeneralTree <int> biggerTree = GetTestTree();
biggerTree.Add(new GeneralTree <int>(4));
GeneralTree <int> smallerTree = new GeneralTree <int>(3);
smallerTree.Add(new GeneralTree <int>(2));
Assert.AreEqual(biggerTree.CompareTo(t), 1);
Assert.AreEqual(t.CompareTo(biggerTree), -1);
Assert.AreEqual(t.CompareTo(t), 0);
object o = new object();
Assert.AreEqual(t.CompareTo(o), -1);
}
private bool CollectDirectories(DirectoryInfoBase directory, INode rootNode, GeneralTree <INode> tree)
{
List <GeneralTree <INode> > collectedNodes = new List <GeneralTree <INode> >();
foreach (DirectoryInfoBase subDirectory in directory.GetDirectories().OrderBy(di => di.Name))
{
GeneralTree <INode> subTree = this.Crawl(subDirectory, rootNode);
if (subTree != null)
{
collectedNodes.Add(subTree);
}
}
foreach (var node in collectedNodes)
{
tree.Add(node);
}
return(collectedNodes.Count > 0);
}
private bool CollectFiles(DirectoryInfoBase directory, INode rootNode, GeneralTree <INode> tree)
{
List <INode> collectedNodes = new List <INode>();
foreach (FileInfoBase file in directory.GetFiles().Where(file => this.relevantFileDetector.IsRelevant(file)))
{
INode node = null;
try
{
node = this.featureNodeFactory.Create(rootNode.OriginalLocation, file);
}
catch (Exception ex)
{
if (Log.IsWarnEnabled)
{
// retrieving the name as file.FullName may trigger an exception if the FullName is too long
// so we retreive Name and DirectoryName separately
// https://github.com/picklesdoc/pickles/issues/199
var fullName = file.Name + " in directory " + file.DirectoryName;
Log.Warn("The file {0} will be ignored because it could not be read in properly", fullName);
}
if (Log.IsDebugEnabled)
{
Log.Debug(ex, "Exception received");
}
}
if (node != null)
{
collectedNodes.Add(node);
}
}
foreach (var node in OrderFileNodes(collectedNodes))
{
tree.Add(node);
}
return(collectedNodes.Count > 0);
}
public void Simple()
{
var tree = new GeneralTree <int>(5);
var originalNodes = new GeneralTree <int> [10];
for (var i = 10; i < 20; i++)
{
originalNodes[i - 10] = new GeneralTree <int>(i);
tree.Add(originalNodes[i - 10]);
}
var childNodes = tree.ChildNodes;
Assert.AreEqual(childNodes.Count, 10);
for (var i = 0; i < 10; i++)
{
Assert.IsTrue(childNodes.Contains(originalNodes[i]));
}
}
public void Simple()
{
var tree = new GeneralTree<int>(5);
var originalNodes = new GeneralTree<int>[10];
for (var i = 10; i < 20; i++)
{
originalNodes[i - 10] = new GeneralTree<int>(i);
tree.Add(originalNodes[i - 10]);
}
var childNodes = tree.ChildNodes;
Assert.AreEqual(childNodes.Count, 10);
for (var i = 0; i < 10; i++)
{
Assert.IsTrue(childNodes.Contains(originalNodes[i]));
}
}
public void TestNodes()
{
GeneralTree <int> tree = new GeneralTree <int>(5);
GeneralTree <int>[] originalNodes = new GeneralTree <int> [10];
for (int i = 10; i < 20; i++)
{
originalNodes[i - 10] = new GeneralTree <int>(i);
tree.Add(originalNodes[i - 10]);
}
IList <GeneralTree <int> > childNodes = tree.ChildNodes;
Assert.AreEqual(childNodes.Count, 10);
for (int i = 0; i < 10; i++)
{
Assert.AreEqual(childNodes.Contains(originalNodes[i]), true);
}
}
private GeneralTree<FeatureNode> Crawl(DirectoryInfo directory, FeatureNode rootNode)
{
var currentNode = new FeatureNode
{
Location = directory,
Url = new Uri(directory.FullName),
RelativePathFromRoot = rootNode == null ? @".\" : PathExtensions.MakeRelativePath(rootNode.Location, directory)
};
if (rootNode == null)
{
rootNode = currentNode;
}
var tree = new GeneralTree<FeatureNode>(currentNode);
bool isRelevantFileFound = false;
foreach (var file in directory.GetFiles().Where(file => this.relevantFileDetector.IsRelevant(file)))
{
isRelevantFileFound = true;
var node = new FeatureNode
{
Location = file,
Url = new Uri(file.FullName),
RelativePathFromRoot = PathExtensions.MakeRelativePath(rootNode.Location, file)
};
if (node.Type == FeatureNodeType.Feature) node.Feature = this.featureParser.Parse(file.FullName);
tree.Add(node);
}
bool isRelevantDirectoryFound = false;
foreach (var subDirectory in directory.GetDirectories())
{
var subTree = Crawl(subDirectory, rootNode);
if (subTree != null)
{
isRelevantDirectoryFound = true;
tree.Add(subTree);
}
}
if (!isRelevantFileFound && !isRelevantDirectoryFound) return null;
return tree;
}
private bool CollectFiles(DirectoryInfoBase directory, INode rootNode, GeneralTree<INode> tree)
{
List<INode> collectedNodes = new List<INode>();
foreach (FileInfoBase file in directory.GetFiles().Where(file => this.relevantFileDetector.IsRelevant(file)))
{
INode node = null;
try
{
node = this.featureNodeFactory.Create(rootNode.OriginalLocation, file);
}
catch (Exception)
{
if (log.IsWarnEnabled)
{
log.WarnFormat("The file, {0}, will be ignored because it could not be read in properly", file.FullName);
}
}
if (node != null)
{
collectedNodes.Add(node);
}
}
foreach (var node in OrderFileNodes(collectedNodes))
{
tree.Add(node);
}
return collectedNodes.Count > 0;
}
private bool CollectFiles(DirectoryInfoBase directory, INode rootNode, GeneralTree<INode> tree)
{
List<INode> collectedNodes = new List<INode>();
foreach (FileInfoBase file in directory.GetFiles().Where(file => this.relevantFileDetector.IsRelevant(file)))
{
INode node = null;
try
{
node = this.featureNodeFactory.Create(rootNode.OriginalLocation, file);
}
catch (Exception)
{
if (Log.IsWarnEnabled)
{
// retrieving the name as file.FullName may trigger an exception if the FullName is too long
// so we retreive Name and DirectoryName separately
// https://github.com/picklesdoc/pickles/issues/199
var fullName = file.Name + " in directory " + file.DirectoryName;
Log.Warn("The file {0} will be ignored because it could not be read in properly", fullName);
}
}
if (node != null)
{
collectedNodes.Add(node);
}
}
foreach (var node in OrderFileNodes(collectedNodes))
{
tree.Add(node);
}
return collectedNodes.Count > 0;
}
private bool CollectDirectories(DirectoryInfoBase directory, INode rootNode, GeneralTree<INode> tree)
{
List<GeneralTree<INode>> collectedNodes = new List<GeneralTree<INode>>();
foreach (DirectoryInfoBase subDirectory in directory.GetDirectories().OrderBy(di => di.Name))
{
GeneralTree<INode> subTree = this.Crawl(subDirectory, rootNode);
if (subTree != null)
{
collectedNodes.Add(subTree);
}
}
foreach (var node in collectedNodes)
{
tree.Add(node);
}
return collectedNodes.Count > 0;
}
