private static void TestHeight(RedBlackNULLTree <int, int> tree)
{
var max = 2 * Math.Log(tree.Count + 1, 2);
var height = tree.Height();
Assert.IsTrue(height <= max);
}
private static void TestNodes(RedBlackNULLTree <int, int> tree)
{
var node = tree.Tree;
Assert.IsFalse(node.Red);
TestNode(node);
}
private static RedBlackNULLTree <int, int> Create()
{
var tree = new RedBlackNULLTree <int, int>((x, y) => x - y);
Assert.IsNull(tree.Tree);
Assert.AreEqual(0, tree.Count);
Assert.AreEqual(0, tree.Height());
return(tree);
}
private static void TestCopyKeysDescending(RedBlackNULLTree <int, int> tree)
{
var keys = tree.CopyKeysDescending();
Assert.AreEqual(tree.Count, keys.Length);
for (var i = keys.Length - 1; i > 0; --i)
{
Assert.IsTrue(keys[i - 1] > keys[i]);
}
}
private static void TestNode(RedBlackNULLTree <int, int> .Node node)
{
if (node.Red)
{
Assert.IsTrue((node.Less == null) == (node.More == null));
if (node.Less != null)
{
Assert.IsFalse(node.Less.Red);
}
if (node.More != null)
{
Assert.IsFalse(node.More.Red);
}
}
else
{
if (node.Less == null && node.More != null)
{
Assert.IsTrue(node.More.Red);
}
if (node.More == null && node.Less != null)
{
Assert.IsTrue(node.Less.Red);
}
if (node.Parent != null)
{
Assert.IsNotNull(node.Parent.Less);
Assert.IsNotNull(node.Parent.More);
}
}
if (node.Parent != null)
{
Assert.IsFalse(object.ReferenceEquals(node.Parent, node));
Assert.IsFalse(object.ReferenceEquals(node.Parent, node.Less));
Assert.IsFalse(object.ReferenceEquals(node.Parent, node.More));
}
if (node.Less != null)
{
Assert.IsFalse(object.ReferenceEquals(node.Less, node));
Assert.IsTrue(object.ReferenceEquals(node.Less.Parent, node));
TestNode(node.Less);
}
if (node.More != null)
{
Assert.IsFalse(object.ReferenceEquals(node.More, node));
Assert.IsTrue(object.ReferenceEquals(node.More.Parent, node));
TestNode(node.More);
}
if (node.Less != null && node.More != null)
{
Assert.IsFalse(object.ReferenceEquals(node.Less, node.More));
}
}
private static void Tests(RedBlackNULLTree <int, int> tree)
{
TestNodes(tree);
TestBlackCount(tree);
TestHeight(tree);
TestMinMaxKey(tree);
TestNext(tree);
TestTryNext(tree);
TestPrev(tree);
TestTryPrev(tree);
TestCopyKeysAscending(tree);
TestCopyKeysDescending(tree);
}
private static void TestMinMaxKey(RedBlackNULLTree <int, int> tree)
{
var minKey = tree.GetMinKey();
var maxKey = tree.GetMaxKey();
if (tree.Count > 1)
{
Assert.IsTrue(minKey < maxKey);
}
else
{
Assert.IsTrue(minKey == maxKey);
}
}
private static int GetBlackCount(RedBlackNULLTree <int, int> .Node node)
{
var count = 0;
while (true)
{
if (!node.Red)
{
++count;
}
node = node.Parent;
if (node == null)
{
return(count);
}
}
}
private static void TestBlackCount(RedBlackNULLTree <int, int> tree)
{
var node = tree.GetMinNode();
var blacks = GetBlackCount(node);
while (true)
{
node = node.Next();
if (node == null)
{
break;
}
if (node.Less == null || node.More == null)
{
Assert.AreEqual(blacks, GetBlackCount(node));
}
}
}
private static void TestPrev(RedBlackNULLTree <int, int> tree)
{
var node = tree.GetMaxNode();
Assert.IsNotNull(node);
var count = 1;
while (true)
{
var prev = node.Prev();
if (prev == null)
{
break;
}
++count;
Assert.IsNotNull(prev);
Assert.IsTrue(node.Key > prev.Key);
node = prev;
}
Assert.AreEqual(tree.Count, count);
}
private static void TestNext(RedBlackNULLTree <int, int> tree)
{
var node = tree.GetMinNode();
Assert.IsNotNull(node);
var count = 1;
while (true)
{
var next = node.Next();
if (next == null)
{
break;
}
++count;
Assert.IsNotNull(next);
Assert.IsTrue(node.Key < next.Key);
node = next;
}
Assert.AreEqual(tree.Count, count);
}
private static void TestTryPrev(RedBlackNULLTree <int, int> tree)
{
if (!tree.TryGetMaxNode(out var node))
{
Assert.Fail();
}
Assert.IsNotNull(node);
var count = 1;
while (true)
{
if (!node.TryPrev(out var prev))
{
break;
}
++count;
Assert.IsNotNull(prev);
Assert.IsTrue(node.Key > prev.Key);
node = prev;
}
Assert.AreEqual(tree.Count, count);
}
private static void TestTryNext(RedBlackNULLTree <int, int> tree)
{
if (!tree.TryGetMinNode(out var node))
{
Assert.Fail();
}
Assert.IsNotNull(node);
var count = 1;
while (true)
{
if (!node.TryNext(out var next))
{
break;
}
++count;
Assert.IsNotNull(next);
Assert.IsTrue(node.Key < next.Key);
node = next;
}
Assert.AreEqual(tree.Count, count);
}
private static void TestsAdd(RedBlackNULLTree <int, int> tree, int add)
{
tree.Add(add, add);
Tests(tree);
}
