} //end-do-test
/// <summary>
/// Testing helper to assert that all items at every level of the tree has the same color and each level has different color than the other levels
/// </summary>
private static void AssetLevelsDifferentColors <TKey, TValue>(RedBlackTreeMap <TKey, TValue> redBlackTree)
where TKey : IComparable <TKey>
{
var root = redBlackTree.Root;
var height = GetMaxHeight(root);
var levels = new List <List <RedBlackTreeMapNode <TKey, TValue> > >();
// Initialize the list
for (var i = 0; i < height; ++i)
{
levels.Add(new List <RedBlackTreeMapNode <TKey, TValue> >());
}
var levelsIndex = 0;
var nodesInNextLevel = 0;
var nodesInCurrentLevel = 1;
var queue = new Queue <RedBlackTreeMapNode <TKey, TValue> >();
queue.Enqueue(root);
while (queue.Count > 0)
{
var curr = queue.Dequeue();
nodesInCurrentLevel--;
if (curr != null)
{
levels[levelsIndex].Add(curr);
queue.Enqueue(curr.LeftChild);
queue.Enqueue(curr.RightChild);
nodesInNextLevel += 2;
}
if (nodesInCurrentLevel == 0)
{
levelsIndex++;
nodesInCurrentLevel = nodesInNextLevel;
nodesInNextLevel = 0;
}
}
// [*] Assert that levels have different alternating colors:
var color = RedBlackTreeColors.Black;
for (var i = 0; i < levels.Count; ++i)
{
for (var j = 0; j < levels[i].Count; ++j)
{
Assert.True(levels[i][j].Color == color);
//if (levels[i][j].Color != color)
//Console.WriteLine(" [-] Level: {0}. Node Value: {1}. Node color: {2}. Expected color: {3}.", i, levels[i][j].Value, levels[i][j].Color, color.ToString());
}
color = color == RedBlackTreeColors.Black ? RedBlackTreeColors.Red : RedBlackTreeColors.Black;
}
} //end-test-case
private void BasicMap()
{
const int Count = 1000;
IOrderedMap <int, float> map;
switch (args[0])
{
default:
throw new ArgumentException();
case "avl":
map = new AVLTreeMap <int, float>();
break;
case "redblack":
map = new RedBlackTreeMap <int, float>();
break;
case "splay":
map = new SplayTreeMap <int, float>();
break;
}
BasicMapCore(map, Count);
}
public void ContatinsValueBeforeAndAfterUpdatingValue()
{
var tree = new RedBlackTreeMap <int, int>();
int elementsCount = 1000;
//Adding every seventh number, then every fifth number,
//every third and at last all numbers
for (int i = 7; i > 0; i -= 2)
{
int el = 0;
while (el < elementsCount)
{
if (!tree.ContainsKey(el))
{
tree.Add(el, el);
}
el += i;
}
}
// Check if values are contained, make them negative and check again. Skip zero...
for (int i = 1; i < elementsCount; i++)
{
if (!tree.ContainsValue(i))
{
Assert.Fail();
}
tree[i] = -i;
if (tree.ContainsValue(i))
{
Assert.Fail();
}
if (!tree.ContainsValue(-i))
{
Assert.Fail();
}
}
int last = -1;
int count = 0;
bool elementsAreSorted = true;
foreach (var item in tree)
{
if (last > item.Key)
{
elementsAreSorted = false;
}
last = item.Key;
count++;
}
Trace.WriteLine(tree.Count);
Assert.IsTrue(tree.Count == elementsCount &&
elementsAreSorted &&
count == elementsCount);
}
public RedBlackUniqueNonClusteredIndex(Expression <Func <TRow, TIndexKey> > keySelector,
IComparer <TIndexKey>?comparer, bool allowNullKeys)
{
var selector = keySelector.Compile();
_keySelector = allowNullKeys ? selector : KeySelector.ThrowOnNullKey(selector);
_map = new RedBlackTreeMap <TIndexKey, DataPage <TPrimaryKey, TRow> >(comparer);
}
public void AddingOneMillionInts()
{
var tree = new RedBlackTreeMap <int, int>();
for (int i = 0; i < 1000000; i++)
{
tree.Add(i, i);
}
Assert.IsTrue(tree.Count == 1000000);
}
public RedBlackNonUniqueNonClusteredIndex(Expression <Func <TRow, TIndexKey> > keySelector,
IComparer <TIndexKey>?comparer,
bool allowNullKeys,
IComparer <TPrimaryKey> primaryKeyComparer)
{
_primaryKeyComparer = new AnonymousComparer <DataPage <TPrimaryKey, TRow>, TPrimaryKey>(k => k.PrimaryKey, primaryKeyComparer);
var selector = keySelector.Compile();
_keySelector = allowNullKeys ? selector : KeySelector.ThrowOnNullKey(selector);
_map = new RedBlackTreeMap <TIndexKey, Set <DataPage <TPrimaryKey, TRow> > >(comparer);
}
public void CheckIfNodeIsInvalidatedAfterClearingAndAfterRemoval()
{
var tree = new RedBlackTreeMap <int, int>();
tree.Add(2, 2);
tree.Add(1, 1);
tree.Add(3, 3);
// Tree looks like this:
// 2
// / \
// 1 3
var node1 = tree.Root.Left;
var node2 = tree.Root;
var node3 = tree.Root.Right;
tree.Remove(2);
if (node2.Left != null || node2.Right != null)
{
Assert.Fail("2");
}
tree.Remove(3);
if (node3.Left != null || node3.Right != null)
{
Assert.Fail("3");
}
tree.Remove(1);
if (node1.Left != null || node1.Right != null)
{
Assert.Fail("1");
}
tree.Add(2, 2);
tree.Add(1, 1);
tree.Add(3, 3);
node1 = tree.Root.Left;
node2 = tree.Root;
node3 = tree.Root.Right;
tree.Clear();
Assert.IsTrue(node1.Left == null && node1.Right == null &&
node2.Left == null && node2.Right == null &&
node3.Left == null && node3.Right == null &&
tree.Root == null &&
tree.Count == 0);
}
public void SortedElementsAfterAddingAndRemoving()
{
var tree = new RedBlackTreeMap <int, int>();
int elementsCount = 100000;
//Adding every seventh number, then every fifth number,
//every third and at last all numbers
for (int i = 7; i > 0; i -= 2)
{
int el = 0;
while (el < elementsCount)
{
if (!tree.ContainsKey(el))
{
tree.Add(el, el);
}
el += i;
}
}
bool removedEverything = true;
//Removing every second number
for (int i = 0; i < elementsCount; i += 2)
{
if (!tree.Remove(i))
{
removedEverything = false;
}
}
int last = -1;
int count = 0;
bool elementsAreSorted = true;
foreach (var item in tree)
{
if (last > item.Key)
{
elementsAreSorted = false;
}
last = item.Key;
count++;
}
Assert.IsTrue(tree.Count == count &&
elementsAreSorted &&
removedEverything);
}
public void RemoveRootEveryTimeUntilTreeElementsAreHalfed()
{
var tree = new RedBlackTreeMap <int, int>();
int elementsCount = 100000;
//Adding every seventh number, then every fifth number,
//every third and at last all numbers
for (int i = 7; i > 0; i -= 2)
{
int el = 0;
while (el < elementsCount)
{
if (!tree.ContainsKey(el))
{
tree.Add(el, el);
}
el += i;
}
}
bool removedEverything = true;
while (tree.Count > elementsCount / 2)
{
if (!tree.Remove(tree.Root.Value))
{
removedEverything = false;
}
}
int last = -1;
int count = 0;
bool elementsAreSorted = true;
foreach (var item in tree)
{
if (last > item.Key)
{
elementsAreSorted = false;
}
last = item.Key;
count++;
}
Assert.IsTrue(tree.Count == count &&
elementsAreSorted &&
count == elementsCount / 2 &&
removedEverything);
}
public void BalancingCheckWithRootRotation()
{
var tree = new RedBlackTreeMap <int, int>();
tree.Add(1, 1);
tree.Add(2, 2);
tree.Add(3, 3);
/*
* After balance the tree should look like this:
* 2
* / \
* 1 3
*/
Assert.IsTrue(tree.Root.Value == 2 &&
tree.Root.Left.Value == 1 &&
tree.Root.Right.Value == 3);
}
private void EnumerateMap()
{
const int Count = 1000;
IOrderedMap <int, float> map;
switch (args[0])
{
default:
throw new ArgumentException();
case "avl":
map = new AVLTreeMap <int, float>();
break;
case "redblack":
map = new RedBlackTreeMap <int, float>();
break;
case "splay":
map = new SplayTreeMap <int, float>();
break;
}
bool fast;
switch (args[1])
{
default:
throw new ArgumentException();
case "fast":
fast = true;
break;
case "robust":
fast = false;
break;
}
EnumerateCore(map, Count, fast);
}
public void AddingElementsWithIndexer()
{
var tree = new RedBlackTreeMap <int, int>();
int elementsCount = 100000;
//Adding every seventh number, then every fifth number,
//every third and at last all numbers
for (int i = 7; i > 0; i -= 2)
{
int el = 0;
while (el < elementsCount)
{
if (!tree.ContainsKey(el))
{
tree[el] = el;
}
el += i;
}
}
int last = -1;
int count = 0;
bool elementsAreSorted = true;
foreach (var item in tree)
{
if (last > item.Key)
{
elementsAreSorted = false;
}
last = item.Key;
count++;
}
Assert.IsTrue(tree.Count == elementsCount &&
elementsAreSorted &&
count == elementsCount);
}
public void RemoveAllExceptOne()
{
var tree = new RedBlackTreeMap <int, int>();
int elementsCount = 100000;
//Adding every seventh number, then every fifth number,
//every third and at last all numbers
for (int i = 7; i > 0; i -= 2)
{
int el = 0;
while (el < elementsCount)
{
if (!tree.ContainsKey(el))
{
tree.Add(el, el);
}
el += i;
}
}
bool removedEverything = true;
for (int i = 0; i < elementsCount - 1; i++)
{
if (!tree.Remove(i))
{
removedEverything = false;
}
}
Assert.IsTrue(tree.Count == 1 &&
removedEverything &&
tree.Root.Value == elementsCount - 1 &&
tree.Root.Left == null &&
tree.Root.Right == null);
}
/// <summary>
/// Clears this instance.
/// </summary>
public void Clear()
{
_collection = new RedBlackTreeMap <TKey, TValue>(false);
}
/// <summary>
/// Constructor.
/// </summary>
public SortedDictionary()
{
_collection = new RedBlackTreeMap <TKey, TValue>(false);
}
/// <summary>
/// Constructor.
/// </summary>
public SortedDictionary()
{
_collection = new RedBlackTreeMap <TKey, TValue>(allowDuplicates: false);
}
public static void DoTest()
{
// Red-Black Tree Map collection
var redBlackTree = new RedBlackTreeMap <int, string>(allowDuplicates: false);
// Testing data
KeyValuePair <int, string>[] values = new KeyValuePair <int, string> [10];
// Prepare the values array
for (int i = 1; i <= 10; ++i)
{
var keyValPair = new KeyValuePair <int, string>(i, String.Format("Integer: {0}", i));
values[i - 1] = keyValPair;
}
// Test singular insert
for (int i = 0; i < 10; ++i)
{
redBlackTree.Insert(values[i].Key, values[i].Value);
}
Assert.True(redBlackTree.Count == values.Length, "Expected the same number of items.");
Assert.True(redBlackTree.Height < redBlackTree.Count, "Fail! Tree doesn't rebalance against sorted elements!");
redBlackTree.Clear();
// Test collection insert
redBlackTree.Insert(values);
Assert.True(redBlackTree.Height < redBlackTree.Count, "Fail! Tree doesn't rebalance against sorted elements!");
// Test enumeration of key-value pairs is still in oreder
var enumerator = redBlackTree.GetInOrderEnumerator();
for (int i = 0; i < 10; ++i)
{
if (enumerator.MoveNext())
{
var curr = enumerator.Current;
if (curr.Key != values[i].Key || curr.Value != values[i].Value)
{
throw new Exception();
}
}
}
// Test against re-shuffled insertions (not like above order)
redBlackTree = new RedBlackTreeMap <int, string>(allowDuplicates: false);
redBlackTree.Insert(4, "int4");
redBlackTree.Insert(5, "int5");
redBlackTree.Insert(7, "int7");
redBlackTree.Insert(2, "int2");
redBlackTree.Insert(1, "int1");
redBlackTree.Insert(3, "int3");
redBlackTree.Insert(6, "int6");
//redBlackTree.Insert(0, "int0");
redBlackTree.Insert(8, "int8");
redBlackTree.Insert(10, "int10");
redBlackTree.Insert(9, "int9");
Assert.True(redBlackTree.Count == values.Length, "Expected the same number of items.");
Assert.True(redBlackTree.Height < redBlackTree.Count, "Fail! Tree doesn't rebalance against sorted elements!");
// ASSERT INSERTING DUPLICATES WOULD BREAK
var insert_duplicate_passed = true;
try
{
// 2 already exists in tree
redBlackTree.Insert(2, "int2");
insert_duplicate_passed = true;
}
catch
{
insert_duplicate_passed = false;
}
Assert.True(insert_duplicate_passed == false, "Fail! The tree doesn't allow duplicates");
// Test find
Assert.True(redBlackTree.Find(5).Key == 5, "Wrong find result!");
Assert.True(redBlackTree.FindMin().Key == 1, "Wrong min!");
Assert.True(redBlackTree.FindMax().Key == 10, "Wrong max!");
// Assert find raises exception on non-existing elements
bool threwKeyNotFoundError = false;
try
{
redBlackTree.Find(999999999);
threwKeyNotFoundError = false;
}
catch (KeyNotFoundException)
{
threwKeyNotFoundError = true;
}
Assert.True(true == threwKeyNotFoundError, "Expected to catch KeyNotFoundException.");
// PRINT TREE
//Console.WriteLine("********************");
//Console.WriteLine(" [*] RED-BLACK TREE:\r\n");
//Console.WriteLine("********************");
//Console.WriteLine(redBlackTree.DrawTree());
//Console.WriteLine("\r\n");
// Assert count
Assert.True(redBlackTree.Count == 10);
// Assert existence and nonexistence of some items
Assert.True(redBlackTree.Contains(1) == true);
Assert.True(redBlackTree.Contains(3) == true);
Assert.True(redBlackTree.Contains(999) == false);
// ASSERT THAT EACH LEVEL HAS A DIFFERENT COLOR
// TODO: Wrong color element "int4"
// AssetLevelsDifferentColors(redBlackTree);
// Do some deletions
redBlackTree.Remove(7);
redBlackTree.Remove(1);
redBlackTree.Remove(3);
// Assert count
Assert.True(redBlackTree.Count == 7);
// Assert nonexistence of previously existing items
Assert.True(redBlackTree.Contains(1) == false);
Assert.True(redBlackTree.Contains(3) == false);
// Remove root value
var oldRootKey = redBlackTree.Root.Key;
redBlackTree.Remove(redBlackTree.Root.Key);
// Assert count
Assert.True(redBlackTree.Count == 6);
// Assert nonexistence of old root's key
Assert.True(redBlackTree.Contains(oldRootKey) == false);
//// PRINT TREE
//Console.WriteLine("********************");
//Console.WriteLine(" [*] RED-BLACK TREE:\r\n");
//Console.WriteLine("********************");
//Console.WriteLine(redBlackTree.DrawTree(includeValues: true));
//Console.WriteLine("\r\n");
//Console.ReadLine();
}//end-do-test
public static IEnumerable <(TKey Key, TItem Value)> SeekMany <TKey, TItem>(this RedBlackTreeMap <TKey, TItem> source, IEnumerable <TKey> keys)
{
foreach (var key in keys)
/// <summary>
/// Clears this instance.
/// </summary>
public void Clear()
{
_collection = new RedBlackTreeMap <TKey, TValue>(allowDuplicates: false);
}
public void UpdatingElementsWithIndexerUsingTryGetValueMethodToGetValue()
{
var tree = new RedBlackTreeMap <int, int>();
int elementsCount = 100000;
//Adding every seventh number, then every fifth number,
//every third and at last all numbers
for (int i = 7; i > 0; i -= 2)
{
int el = 0;
while (el < elementsCount)
{
if (!tree.ContainsKey(el))
{
tree.Add(el, el);
}
el += i;
}
}
bool removedEverything = true;
//Removing every second number
for (int i = 0; i < elementsCount; i += 2)
{
if (!tree.Remove(i))
{
removedEverything = false;
}
}
// Make all values negative
for (int i = 0; i < elementsCount; i++)
{
int value;
if (tree.TryGetValue(i, out value))
{
tree[value] = -value;
}
}
int last = -1;
int count = 0;
bool elementsAreSorted = true;
foreach (var item in tree)
{
if (item.Value > 0)
{
Assert.Fail();
}
if (last > item.Key)
{
elementsAreSorted = false;
}
last = item.Key;
count++;
}
Trace.WriteLine(tree.Count);
Assert.IsTrue(tree.Count == count &&
elementsAreSorted &&
removedEverything);
}
public RedBlackClusteredIndex(Expression <Func <TRow, TPrimaryKey> > keySelector, IComparer <TPrimaryKey>?comparer)
{
_keySelector = KeySelector.ThrowOnNullKey(keySelector.Compile());
_map = new RedBlackTreeMap <TPrimaryKey, DataPage <TPrimaryKey, TRow> >(comparer);
}
