public void NextKeyTest()
{
var tree = new VanEmdeBoasTree <int>(111);
tree.Insert(100, 1100);
tree.Insert(77, 1077);
tree.Insert(33, 1033);
tree.Insert(55, 1055);
Assert.Null(tree.NextKey(100));
Assert.Equal(100, tree.NextKey(77));
Assert.Equal(33, tree.NextKey(10));
Assert.Equal(55, tree.NextKey(33));
Assert.Equal(100, tree.NextKey(77));
Assert.True(tree.Delete(33));
Assert.Equal(55, tree.NextKey(10));
for (int i = 0; i < tree.Capacity; ++i)
{
tree.Insert(i, i * 100);
}
for (int i = 0; i < tree.Capacity - 1; ++i)
{
Assert.Equal(i + 1, tree.NextKey(i));
}
Assert.Null(tree.NextKey(tree.Capacity - 1));
}
public void PreviousKeyTest()
{
var tree = new VanEmdeBoasTree <int>(111);
tree.Insert(100, 1100);
tree.Insert(77, 1077);
tree.Insert(33, 1033);
tree.Insert(55, 1055);
Assert.Null(tree.PreviousKey(33));
Assert.Equal(77, tree.PreviousKey(100));
Assert.Equal(33, tree.PreviousKey(55));
Assert.Equal(100, tree.PreviousKey(110));
for (int i = 0; i < tree.Capacity; ++i)
{
tree.Insert(i, i * 100);
}
for (int i = 1; i < tree.Capacity; ++i)
{
Assert.Equal(i - 1, tree.PreviousKey(i));
}
Assert.Null(tree.PreviousKey(0));
}
public void VanEmdeBoasNodeTest(int universeSize)
{
var tree = new VanEmdeBoasTree <string>(universeSize);
Assert.Equal(universeSize, tree.Capacity);
for (int i = 0; i < universeSize; ++i)
{
Assert.False(tree.Contains(i));
}
for (int i = 0; i < universeSize; ++i)
{
tree.Insert(i, i.ToString());
}
Assert.Equal(universeSize, tree.Count);
for (int i = universeSize - 1; i > 0; i -= 3)
{
Assert.True(tree.Contains(i));
Assert.Equal(i.ToString(), tree.GetValue(i));
}
for (int i = 0; i < universeSize; ++i)
{
Assert.True(tree.Contains(i));
Assert.Equal(i.ToString(), tree.GetValue(i));
}
}
public void VanEmdeBoasTree_CLRS_Book_SuccessorTest()
{
// Arrange.
IReadOnlyList <int> values = TestData.Get_CLRS_Figure20_6_Values();
const int universe = 16;
int expectedMinimum = values.Min();
int expectedMaximum = values.Max();
IVanEmdeBoasTree tree;
// Act.
tree = new VanEmdeBoasTree(universe, values);
// Assert.
int?successorFound = tree.Successor(expectedMaximum);
int expectedSuccessor;
Assert.IsNull(
successorFound,
$"The van Emde Boas tree claims to have found a successor to the largest value ({successorFound}).");
for (int i = 0; i < values.Count - 1; i++)
{
successorFound = tree.Successor(values[i]);
Assert.IsNotNull(
successorFound,
$"The van Emde Boas tree could not find a successor to value {values[i]}.");
expectedSuccessor = values[i + 1];
Assert.AreEqual(
expectedSuccessor,
successorFound,
$"The successor the van Emde Boas tree found for value {values[i]} was {successorFound}, not {expectedSuccessor}.");
}
}
public void VanEmdeBoasTree_CLRS_Book_MembershipTest()
{
// Arrange.
IReadOnlyList <int> values = TestData.Get_CLRS_Figure20_6_Values();
const int universe = 16;
int expectedMinimum = values.Min();
int expectedMaximum = values.Max();
IVanEmdeBoasTree tree;
// Act.
tree = new VanEmdeBoasTree(universe, values);
// Assert.
for (int i = 0; i <= universe; i++)
{
if (values.Contains(i))
{
Assert.IsTrue(
tree.Member(i),
$"The van Emde Boas tree claims not to contain a value it should ({i}).");
}
else
{
Assert.IsFalse(
tree.Member(i),
$"The van Emde Boas tree claims to contain a value it should not ({i}).");
}
}
}
public void OutOfRanngeKeyTest()
{
var tree = new VanEmdeBoasTree <int>(64);
Assert.Throws <ArgumentOutOfRangeException>(() => tree.GetValue(-1));
Assert.Throws <ArgumentOutOfRangeException>(() => tree.GetValue(100));
Assert.Throws <ArgumentOutOfRangeException>(() => tree.Contains(-1));
Assert.Throws <ArgumentOutOfRangeException>(() => tree.Contains(100));
Assert.Throws <ArgumentOutOfRangeException>(() => tree.Delete(-1));
Assert.Throws <ArgumentOutOfRangeException>(() => tree.Delete(100));
Assert.Throws <ArgumentOutOfRangeException>(() => tree.Insert(-1, 1));
Assert.Throws <ArgumentOutOfRangeException>(() => tree.Insert(100, 1));
}
public void VanEmdeBoasTree_CLRS_Book_TreeStructureTest()
{
// Arrange.
IReadOnlyList <int> values = TestData.Get_CLRS_Figure20_6_Values();
const int universe = 16;
int expectedMinimum = values.Min();
int expectedMaximum = values.Max();
VanEmdeBoasTree tree;
IVanEmdeBoasTreeNode root;
// Act.
tree = new VanEmdeBoasTree(universe, values);
// Assert.
// Check the root node.
root = tree.Root;
Utility.CheckNode(root, "The van Emde Boas tree root", universe, expectedMinimum, expectedMaximum, false, 4);
// Check depth 1.
Utility.CheckNode(root.Summary, "vEB(4) node 1", 4, 0, 3, false, 2);
Utility.CheckNode(root.Cluster[0], "vEB(4) node 2", 4, 3, 3, false, 2);
Utility.CheckNode(root.Cluster[1], "vEB(4) node 3", 4, 0, 3, false, 2);
Utility.CheckNode(root.Cluster[2], "vEB(4) node 4", 4, null, null, false, 2);
Utility.CheckNode(root.Cluster[3], "vEB(4) node 5", 4, 2, 3, false, 2);
// Check depth 2.
Utility.CheckNode(root.Summary.Summary, "vEB(2) node 1", 2, 0, 1, true, 0);
Utility.CheckNode(root.Summary.Cluster[0], "vEB(2) node 2", 2, 1, 1, true, 0);
Utility.CheckNode(root.Summary.Cluster[1], "vEB(2) node 3", 2, 1, 1, true, 0);
Utility.CheckNode(root.Cluster[0].Summary, "vEB(2) node 4", 2, null, null, true, 0);
Utility.CheckNode(root.Cluster[0].Cluster[0], "vEB(2) node 5", 2, null, null, true, 0);
Utility.CheckNode(root.Cluster[0].Cluster[1], "vEB(2) node 6", 2, null, null, true, 0);
Utility.CheckNode(root.Cluster[1].Summary, "vEB(2) node 7", 2, 0, 1, true, 0);
Utility.CheckNode(root.Cluster[1].Cluster[0], "vEB(2) node 8", 2, 1, 1, true, 0);
Utility.CheckNode(root.Cluster[1].Cluster[1], "vEB(2) node 9", 2, 1, 1, true, 0);
Utility.CheckNode(root.Cluster[2].Summary, "vEB(2) node 10", 2, null, null, true, 0);
Utility.CheckNode(root.Cluster[2].Cluster[0], "vEB(2) node 11", 2, null, null, true, 0);
Utility.CheckNode(root.Cluster[2].Cluster[1], "vEB(2) node 12", 2, null, null, true, 0);
Utility.CheckNode(root.Cluster[3].Summary, "vEB(2) node 13", 2, 1, 1, true, 0);
Utility.CheckNode(root.Cluster[3].Cluster[0], "vEB(2) node 14", 2, null, null, true, 0);
Utility.CheckNode(root.Cluster[3].Cluster[1], "vEB(2) node 15", 2, 1, 1, true, 0);
}
public void VanEmdeBoasNodeDeleteTest(int capacity, int expectedCapacity)
{
var tree = new VanEmdeBoasTree <int>(capacity);
Assert.Equal(expectedCapacity, tree.Capacity);
for (int i = 0; i < tree.Capacity; ++i)
{
tree.Insert(i, 100 * i);
}
int numDeleted = 0;
for (int i = 0; i < tree.Capacity; i += 3)
{
++numDeleted;
Assert.True(tree.Delete(i));
Assert.Equal(tree.Capacity - numDeleted, tree.Count);
}
for (int i = tree.Capacity - 2; i >= 0; i -= 2)
{
bool toDelete = i % 3 != 0;
Assert.Equal(toDelete, tree.Delete(i));
if (toDelete)
{
++numDeleted;
}
}
Assert.Equal(tree.Capacity - numDeleted, tree.Count);
for (int i = 0; i < tree.Capacity; i += 2)
{
bool deleted = (i % 2 == 0) || (i % 3 == 0);
Assert.Equal(!deleted, tree.Contains(i));
Assert.Equal(deleted ? 0 : i * 100, tree.GetValue(i));
}
}
public void VanEmdeBoasNodeInsertTest()
{
var tree = new VanEmdeBoasTree <int>(64);
Assert.Equal(0, tree.Count);
Assert.False(tree.Contains(1));
Assert.True(tree.Insert(1, 11));
Assert.Equal(11, tree.GetValue(1));
Assert.True(tree.Contains(1));
Assert.False(tree.Insert(1, 10));
Assert.Equal(10, tree.GetValue(1));
Assert.True(tree.Contains(1));
Assert.False(tree.Contains(50));
Assert.True(tree.Insert(50, 101));
Assert.Equal(101, tree.GetValue(50));
Assert.True(tree.Contains(50));
Assert.Equal(2, tree.Count);
}
