public void TestTreeAddChild()
{
// Arrange
var NAryTreeInt = new Tree <int>();
var NAryTreeStr = new Tree <string>();
// Act
var root_int = NAryTreeInt.AddChildNode(null, 1);
var child1_int = NAryTreeInt.AddChildNode(root_int, 2);
var root_str = NAryTreeStr.AddChildNode(null, "A");
var child1_str = NAryTreeStr.AddChildNode(root_str, "B");
// Assert
Assert.Multiple(() =>
{
// Check Count
Assert.That(NAryTreeInt.Count == 2);
Assert.That(NAryTreeStr.Count == 2);
// Check CountLeaf
Assert.That(NAryTreeInt.LeafCount == 1);
Assert.That(NAryTreeStr.LeafCount == 1);
// Check if it is added
Assert.Contains(child1_int, NAryTreeInt.TheTree);
// If root has a child
Assert.Contains(child1_int, root_int.Child);
});
}
public void AddChildNodeString()
{
// Arrange
string InitialValue = "Uien";
Tree <string> tree = new Tree <string>(InitialValue);
// Act
TreeNode <string> Child1 = tree.AddChildNode("hebben", tree.TopParent);
TreeNode <string> Child2 = tree.AddChildNode("laagjes", tree.TopParent);
TreeNode <string> Child1_1 = tree.AddChildNode("Knoflook", Child1);
TreeNode <string> Child1_1_1 = tree.AddChildNode("stinkt", Child1_1);
// Assert
Assert.Multiple(() =>
{
Assert.AreEqual("hebben", tree.TopParent.Children[0].Value);
Assert.AreEqual("laagjes", tree.TopParent.Children[1].Value);
Assert.AreEqual("Knoflook", tree.TopParent.Children[0].Children[0].Value);
Assert.AreEqual("stinkt", tree.TopParent.Children[0].Children[0].Children[0].Value);
Assert.That(tree.Count == 5);
Assert.That(tree.LeafCount == 2);
Assert.AreEqual(Child1_1.Parent, Child1);
Assert.IsNull(tree.TopParent.Parent);
});
}
public void TestTreeSumOfLeaves()
{
//Arrange
Tree <int> TreeInt = new Tree <int>();
Tree <string> TreeStr = new Tree <string>();
//Act
//int
var root = TreeInt.AddChildNode(null, 1);
var child1 = TreeInt.AddChildNode(root, 2);
var child2 = TreeInt.AddChildNode(root, 3);
var child11 = TreeInt.AddChildNode(child1, 4);
var sumleafs = TreeInt.SumToLeafs();
//str
var rootstr = TreeStr.AddChildNode(null, "A");
var child1str = TreeStr.AddChildNode(rootstr, "B");
var child2str = TreeStr.AddChildNode(rootstr, "C");
var child11str = TreeStr.AddChildNode(child1str, "D");
var sumleafsstr = TreeStr.SumToLeafs();
//Assert
Assert.Multiple(() =>
{
// controle of sumofleaves goed worden opgeteld
Assert.That(sumleafs[1] == 7);
Assert.That(sumleafsstr[0] == "CA");
});
}
public void AddChildNodeIntegers()
{
// Arrange
int InitialValue = 4;
Tree <int> tree = new Tree <int>(InitialValue);
// Act
TreeNode <int> Child1 = tree.AddChildNode(3, tree.TopParent);
TreeNode <int> Child2 = tree.AddChildNode(4, tree.TopParent);
TreeNode <int> Child1_1 = tree.AddChildNode(8, Child1);
TreeNode <int> Child1_1_1 = tree.AddChildNode(9, Child1_1);
// Assert
Assert.Multiple(() =>
{
Assert.AreEqual(3, tree.TopParent.Children[0].Value);
Assert.AreEqual(4, tree.TopParent.Children[1].Value);
Assert.AreEqual(8, tree.TopParent.Children[0].Children[0].Value);
Assert.AreEqual(9, tree.TopParent.Children[0].Children[0].Children[0].Value);
Assert.That(tree.Count == 5);
Assert.That(tree.LeafCount == 2);
Assert.AreEqual(Child1_1.Parent, Child1);
Assert.IsNull(tree.TopParent.Parent);
});
}
public void TestTree_AddChildNode()
{
// Arrange
Tree <string> Tree = new Tree <string>();
// Act
var Root = Tree.AddChildNode(null, "Root");
var Node1 = Tree.AddChildNode(Root, "Node1");
// Assert
Assert.True(Root.Value == "Root" && Root.Children[0] == Node1);
}
public void Test_Tree_Remove()
{
//Arrange
Tree <int> tree = new Tree <int>(2);
//Act
tree.AddChildNode(tree.ParentNode, 1);
tree.AddChildNode(tree.ParentNode, 2);
tree.RemoveNode(tree.children[1]);
//Assert
Assert.Contains(1, new System.Collections.Generic.List <int>(tree));
}
public void Testing_SumToLeaf()
{
// arrange
Tree <double> boom = new Tree <double>();
// act
TreeNode <double> root = boom.AddChildNode(2.0, null);
TreeNode <double> Hanneke = boom.AddChildNode(3.3, root);
List <double> somnaarleaf = boom.SumtoLeafs;
// Assert
Assert.That(somnaarleaf[0] == 5.3);
}
public void TestN_ARY_Remove()
{
//Test if the removal of parents and children is done right
Tree <string> beginningTree = new Tree <string>("Chaos");
beginningTree.AddChildNode(beginningTree.headOfTreeNode, "Erebus");
beginningTree.AddChildNode(beginningTree.headOfTreeNode, "Nyx");
TreeNode <string> Parent1 = beginningTree.headOfTreeNode.Child[1];
beginningTree.AddChildNode(Parent1, "Hemera");
beginningTree.AddChildNode(Parent1, "Aether");
beginningTree.AddChildNode(Parent1, "Gaia");
beginningTree.AddChildNode(Parent1, "Tartar");
TreeNode <string> Parent2 = Parent1.Child[2];
beginningTree.AddChildNode(Parent2, "Pontus");
beginningTree.AddChildNode(Parent2, "Ouranos");
beginningTree.RemoveNode(Parent2);
Assert.Multiple(() =>
{
Assert.That(beginningTree.treeTotal.Count == 6);
Assert.AreEqual(Parent1, beginningTree.headOfTreeNode.Child[1]);
Assert.Contains(Parent1, beginningTree.treeTotal);
});
}
public void Test_TreeConstructorSumLeafs()
{
//arange
var tree = new Tree <int>();
var root = tree.AddChildNode(null, 1);
var child1 = tree.AddChildNode(root, 2);
var child2 = tree.AddChildNode(child1, 3);
//act
List <int> sum = tree.SumToLeafs();
//assert
Assert.AreEqual(6, sum[0]); //Check if sum of first leave is 6
}
public void Test_TreeConstructorDeleteNode()
{
//arrange
var tree = new Tree <int>();
var root = tree.AddChildNode(null, 1);
var child1 = tree.AddChildNode(root, 2);
var child2 = tree.AddChildNode(child1, 3);
//act
tree.removeNode(child1); // Remove child1
//Assert
Assert.Contains(child2, tree.TheTree); //Check if child2 is in the tree
}
public void Testing_LeafCount()
{
// arrange
Tree <int> boom = new Tree <int>();
//act
TreeNode <int> root = boom.AddChildNode(2, null);
TreeNode <int> Hanneke = boom.AddChildNode(4, root);
TreeNode <int> Marieke = boom.AddChildNode(5, root);
int leafs = boom.LeafCount;
// Assert
Assert.That(leafs == 2);
}
public void Testing_Count()
{
// arrange
Tree <int> boom = new Tree <int>();
//act
TreeNode <int> root = boom.AddChildNode(2, null);
TreeNode <int> Hanneke = boom.AddChildNode(4, root);
TreeNode <int> Marieke = boom.AddChildNode(5, root);
int aantal = boom.Count;
// Assert
Assert.That(aantal == 3);
}
public void Test_SumToLeafs()
{
// Arrange
var TreeInt = new Tree<int>();
var root = new TreeNode<int>(0, null, new List<TreeNode<int>>());
var gen1c1 = TreeInt.AddChildNode(root, 10);
var gen2p1 = TreeInt.NextGen(gen1c1);
var gen2c1 = TreeInt.AddChildNode(gen2p1, 9);
var gen2c2 = TreeInt.AddChildNode(gen2p1, 8);
// Act
var sum = TreeInt.SumToLeafs();
// Assert
Assert.That(sum[0] == 19);
Assert.That(sum[1] == 18);
}
public void Test_Tree_TraverseNodes()
{
// Arrange
var NAryTree = new Tree <int>();
var root = new TreeNode <int>(3, null, new List <TreeNode <int> >());
var child1 = NAryTree.AddChildNode(root, 3);
var child2 = NAryTree.AddChildNode(child1, 2);
// Act
List <int> traversed = NAryTree.TraverseNodes();
// Assert
int[] validation = { 2, 3 };
Assert.That(traversed, Is.EquivalentTo(validation));
// weet niet goed wat ik nog meer moet testen
}
public void TraverseNodesTest()
{
// Arrange
int InitialValue = 1;
Tree <int> tree = new Tree <int>(InitialValue);
TreeNode <int> Child1 = tree.AddChildNode(2, tree.TopParent);
TreeNode <int> Child2 = tree.AddChildNode(3, tree.TopParent);
TreeNode <int> Child1_1 = tree.AddChildNode(4, Child1);
// Act
string TraverseTree = tree.TraverseNodes();
// Assert
Assert.AreEqual("1[ 2,[ 4,] 3,]", TraverseTree);
}
public void TestTreeRemoveNode()
{
// Arrange
Tree <int> Tree = new Tree <int>();
var Root = Tree.AddChildNode(null, 4);
var Node1 = Tree.AddChildNode(Root, 2);
var Node2 = Tree.AddChildNode(Root, 24);
var Node3 = Tree.AddChildNode(Node2, 8);
var Node4 = Tree.AddChildNode(Node2, 6);
// Act
Tree.RemoveNode(Node2);
// Assert
Assert.True(Root.Children.Count == 1);
}
public void Testing_AddChildNode()
{
// arrange
Tree <int> boom = new Tree <int>();
//act
TreeNode <int> root = boom.AddChildNode(2, null);
TreeNode <int> Hanneke = boom.AddChildNode(4, root);
// Assert
Assert.Multiple(() =>
{
Assert.That(Hanneke.parent.Value == 2);
Assert.Contains(Hanneke, boom.Root.children);
});
}
public void Test_Tree_SumLeafs()
{
//Arrange
Tree <int> tree_test = new Tree <int>(2);
tree_test.AddChildNode(tree_test.ParentNode, 3);
tree_test.AddChildNode(tree_test.ParentNode, 4);
tree_test.AddChildNode(tree_test.ParentNode, 5);
//Act
List <int> Som = tree_test.SumToLeafs();
//Assert
int[] antwoord = { 5, 6, 7 };
Assert.That(antwoord, Is.EquivalentTo(Som));
}
public void Test_TreeConstructorAddChild()
{
//arrange
var tree = new Tree <int>();
//act
var root = tree.AddChildNode(null, 1);
var child1 = tree.AddChildNode(root, 2);
//Assert
Assert.Multiple(() =>
{
Assert.That(child1.Parent.Value == 1); //Check if parent of child1 has value 1
Assert.Contains(child1, tree.TheTree); //Check if child1 is in the tree
});
}
public void Test_Traversenodes()
{
// Arrange
var TreeInt = new Tree<string>();
var root = new TreeNode<string>(null, null, new List<TreeNode<string>>());
var gen1c1 = TreeInt.AddChildNode(root, "Keeper");
var gen2p1 = TreeInt.NextGen(gen1c1);
var gen2c1 = TreeInt.AddChildNode(gen2p1, "Linker Centrale Verdediger");
var gen2c2 = TreeInt.AddChildNode(gen2p1, "Rechter Centrale Verdediger");
var gen3p1 = TreeInt.NextGen(gen2c1);
var gen3c1 = TreeInt.AddChildNode(gen3p1, "Linksback");
// Act
var traverseNodes = TreeInt.TraverseNodes();
// Assert
Assert.AreEqual(traverseNodes.Count, TreeInt.TotalChildren.Count);
}
public void Test_removeNode()
{
// Arrange
var TreeInt = new Tree<string>();
var root = new TreeNode<string>(null, null, new List<TreeNode<string>>());
var gen1c1 = TreeInt.AddChildNode(root, "Keeper");
var gen2p1 = TreeInt.NextGen(gen1c1);
var gen2c1 = TreeInt.AddChildNode(gen2p1, "Linker Centrale Verdediger");
var gen2c2 = TreeInt.AddChildNode(gen2p1, "Rechter Centrale Verdediger");
var gen3p1 = TreeInt.NextGen(gen2c1);
var gen3c1 = TreeInt.AddChildNode(gen3p1, "Linksback");
// Act
TreeInt.removeNode(gen2c1);
// Assert
Assert.That(TreeInt.TotalChildren.Count == 2);
}
public void Test_Tree_Traverse()
{
//Arrange
Tree <int> tree_test = new Tree <int>(2);
TreeNode <int> Parent;
tree_test.AddChildNode(tree_test.ParentNode, 3);
tree_test.AddChildNode(tree_test.ParentNode, 4);
tree_test.AddChildNode(tree_test.ParentNode, 5);
Parent = tree_test.ParentNode.Children[0];
tree_test.AddChildNode(Parent, 9);
tree_test.AddChildNode(tree_test.ParentNode, 6);
//Act
tree_test.TraverseNodes();
//Assert
Assert.IsNotEmpty(tree_test);
}
public void Testing_TraverseNodes()
{
// arrange
Tree <string> boom = new Tree <string>();
// act
TreeNode <string> root = boom.AddChildNode("Oma", null);
TreeNode <string> Hanneke = boom.AddChildNode("Hanneke", root);
TreeNode <string> Marieke = boom.AddChildNode("Marieke", root);
List <string> waardes = boom.TraverseNodes;
var checklist = new List <string> {
"Oma", "Hanneke", "Marieke"
};
// Assert
Assert.That(waardes.SequenceEqual(checklist));
}
static void Main(string[] args)
{
Tree <int> TreeInt = new Tree <int>();
var root = new TreeNode <int>(0, null, new List <TreeNode <int> >());
var gen1c1 = TreeInt.AddChildNode(root, 10);
var gen2p = TreeInt.NextGen(gen1c1);
var gen2c1 = TreeInt.AddChildNode(gen2p, 9);
var gen2c2 = TreeInt.AddChildNode(gen2p, 6);
var gen3p = TreeInt.NextGen(gen2c1);
var gen3c1 = TreeInt.AddChildNode(gen3p, 7);
var gen3p2 = TreeInt.NextGen(gen2c2);
var gen3c2 = TreeInt.AddChildNode(gen3p2, 7);
var sum1 = TreeInt.SumToLeafs();
foreach (var sum in sum1)
{
Console.WriteLine(sum);
}
Console.ReadLine();
TreeInt.removeNode(gen2c2);
var traversed = TreeInt.TraverseNodes();
foreach (var integer in traversed)
{
Console.WriteLine(integer);
}
Console.ReadLine();
var sum2 = TreeInt.SumToLeafs();
foreach (var sum in sum2)
{
Console.WriteLine(sum);
}
Console.ReadLine();
}
public void TestTreeRemoveNode()
{
//Arrange
Tree <int> TreeInt = new Tree <int>();
Tree <string> TreeStr = new Tree <string>();
//Act
//int
var root = TreeInt.AddChildNode(null, 1);
var child1 = TreeInt.AddChildNode(root, 2);
var child2 = TreeInt.AddChildNode(root, 3);
var child11 = TreeInt.AddChildNode(child1, 4);
TreeInt.removeNode(child1);
//str
var rootstr = TreeStr.AddChildNode(null, "A");
var child1str = TreeStr.AddChildNode(rootstr, "B");
var child2str = TreeStr.AddChildNode(rootstr, "C");
var child11str = TreeStr.AddChildNode(child1str, "D");
TreeStr.removeNode(child1str);
//Assert
Assert.Multiple(() =>
{
// controle lengte
Assert.That(TreeInt.count == 2);
Assert.That(TreeStr.count == 2);
// check aantal leafs
Assert.That(TreeInt.leafcount == 1);
Assert.That(TreeStr.leafcount == 1);
// controle of alle kinderen zijn verwijderd
for (int i = 0; i < TreeInt.count; i++)
{
Assert.AreNotSame(child11, TreeStr.TheTree[i]);
Assert.AreNotSame(child1, TreeInt.TheTree[i]);
}
for (int i = 0; i < TreeStr.count; i++)
{
Assert.AreNotSame(child11, TreeStr.TheTree[i]);
Assert.AreNotSame(child1str, TreeStr.TheTree[i]);
}
});
}
public void Test_Tree_SumToLeafs_int()
{
// Arrange
var NAryTree = new Tree <int>();
var root = new TreeNode <int>(3, null, new List <TreeNode <int> >());
var child1 = NAryTree.AddChildNode(root, 3);
var child2 = NAryTree.AddChildNode(child1, 2);
var child3 = NAryTree.AddChildNode(child1, 1);
// Act
var sum = NAryTree.SumToLeafs();
// Assert
Assert.Multiple(() =>
{
Assert.AreEqual(sum.Count, NAryTree.LeafCount);
Assert.Contains(4, sum);
Assert.Contains(5, sum);
});
}
public void TraverseNodesTest()
{
// Arrange
Tree <string> Groot = new Tree <string>("I ");
TreeNode <string> Gchild1_1 = Groot.AddChildNode("suck.");
TreeNode <string> Gchild1_2 = Groot.AddChildNode("am ");
TreeNode <string> Gchild2_1 = Groot.AddChildNode("Groot", Gchild1_2);
TreeNode <string> Gchild3_1 = Groot.AddChildNode("!!!", Gchild2_1);
// Act
List <TreeNode <string> > NodeList = Groot.TraverseNodes();
// Assert
Assert.Multiple(() =>
{
Assert.AreEqual(NodeList.Count, Groot.NrNodes);
Assert.That(NodeList.Contains(Gchild1_2));
});
}
public void TestTreeTraverseNode()
{
// Arrange
var NAryTreeInt = new Tree <int>();
var NAryTreeStr = new Tree <string>();
// Act
var root_int = NAryTreeInt.AddChildNode(null, 1);
var child1_int = NAryTreeInt.AddChildNode(root_int, 2);
var child2_int = NAryTreeInt.AddChildNode(root_int, 3);
var child3_int = NAryTreeInt.AddChildNode(child1_int, 4);
List <int> real = NAryTreeInt.TraverseNodes();
// Assert
// Check if values correspond with input
for (int i = 0; i < 4; i++)
{
Assert.That(i + 1 == real[i]);
}
}
public void Test_Tree_SumToLeafs_string()
{
// Arrange
var NAryTree = new Tree <string>();
var root = new TreeNode <string>("Oma", null, new List <TreeNode <string> >());
var child1 = NAryTree.AddChildNode(root, "Mama");
var child2 = NAryTree.AddChildNode(child1, "Ik");
var child3 = NAryTree.AddChildNode(child1, "Zus");
// Act
var sum = NAryTree.SumToLeafs();
// Assert
Assert.Multiple(() =>
{
Assert.AreEqual(sum.Count, NAryTree.LeafCount);
Assert.Contains("IkMama", sum);
Assert.Contains("ZusMama", sum);
});
}
public void SumToLeafsTestIntegers()
{
// Arrange
int InitialValue = 1;
Tree <int> tree = new Tree <int>(InitialValue);
TreeNode <int> Child1 = new TreeNode <int>(2, tree.TopParent);
TreeNode <int> Child2 = tree.AddChildNode(3, tree.TopParent);
TreeNode <int> Child1_1 = tree.AddChildNode(4, Child1);
// Act
List <int> SumLeafs = tree.SumToLeafs();
// Assert
Assert.Multiple(() =>
{
Assert.Contains(4, SumLeafs);
Assert.Contains(7, SumLeafs);
});
}