[TestMethod] public void Add_Testing()
{
// adding duplicate values should throw exceptions
{
IAvlTree <int> tree = new AvlTreeLinked <int>()
{
1,
};
Assert.ThrowsException <ArgumentException>(() => tree.Add(1));
}
// normal add checking
{
IAvlTree <int> tree = new AvlTreeLinked <int>()
{
1, 2, 3,
};
Assert.IsTrue(tree.Count == 3);
Assert.IsTrue(tree.Contains(1));
Assert.IsTrue(tree.Contains(2));
Assert.IsTrue(tree.Contains(3));
}
{
IAvlTree <int> tree = new AvlTreeLinked <int>();
Stepper.Iterate(100, i => tree.Add(i));
Assert.IsTrue(tree.Count == 100);
Stepper.Iterate(100, i => Assert.IsTrue(tree.Contains(i)));
}
}
[TestMethod] public void TryRemove_Testing()
{
// removing a non-existing value should return false
{
IAvlTree <int> tree = new AvlTreeLinked <int>()
{
1, 3,
};
Assert.IsFalse(tree.TryRemove(2));
}
// normal remove checking
{
IAvlTree <int> tree = new AvlTreeLinked <int>()
{
1, 2, 3,
};
Assert.IsTrue(tree.Count == 3);
Assert.IsTrue(tree.TryRemove(1));
Assert.IsFalse(tree.Contains(1));
Assert.IsTrue(tree.Count == 2);
Assert.IsTrue(tree.TryRemove(2));
Assert.IsFalse(tree.Contains(2));
Assert.IsTrue(tree.Count == 1);
Assert.IsTrue(tree.TryRemove(3));
Assert.IsFalse(tree.Contains(3));
Assert.IsTrue(tree.Count == 0);
}
{
IAvlTree <int> tree = new AvlTreeLinked <int>();
Stepper.Iterate(100, i => tree.Add(i));
Assert.IsTrue(tree.Count == 100);
Stepper.Iterate(100, i => tree.TryRemove(i));
Assert.IsTrue(tree.Count == 0);
}
}
public static void TestAlgorithm(
Action <int[], Compare <int> > algorithm,
Action <int[], int, int, Compare <int> > algorithmPartial,
int?sizeOverride = null)
{
void Test(int sizeAdjusted)
{
Random random = new Random(randomSeed);
int[] array = new int[sizeAdjusted];
Stepper.Iterate(sizeAdjusted, i => array[i] = i);
Sort.Shuffle(array, random);
Assert.IsFalse(IsLeastToGreatest(array), "Test failed (invalid randomization).");
algorithm(array, Compare.Default);
Assert.IsTrue(IsLeastToGreatest(array), "Sorting algorithm failed.");
}
Test(sizeOverride ?? size); // Even Data Set
Test((sizeOverride ?? size) + 1); // Odd Data Set
if (sizeOverride is null)
{
Test(1000); // Large(er) Data Set
}
{ // Partial Array Sort
int[] array = new int[] { 9, 8, 7, 6, 5, 4, 3, 2, 1, 0, };
watchArray = array;
algorithmPartial(array, 3, 7, Compare.Default);
int[] expected = new int[] { 9, 8, 7, /*|*/ 2, 3, 4, 5, 6, /*|*/ 1, 0, };
for (int i = 0; i < size; i++)
{
Assert.IsTrue(array[i] == expected[i]);
}
}
}
[TestMethod] public void TryAdd_Testing()
{
// adding duplicate values should return false
{
IAvlTree <int> tree = new AvlTreeLinked <int>();
Assert.IsTrue(tree.TryAdd(1));
Assert.IsFalse(tree.TryAdd(1));
}
// normal add checking
{
IAvlTree <int> tree = new AvlTreeLinked <int>();
Assert.IsTrue(tree.TryAdd(1));
Assert.IsTrue(tree.TryAdd(2));
Assert.IsTrue(tree.TryAdd(3));
Assert.IsTrue(tree.Count == 3);
Assert.IsTrue(tree.Contains(1));
Assert.IsTrue(tree.Contains(2));
Assert.IsTrue(tree.Contains(3));
}
{
IAvlTree <int> tree = new AvlTreeLinked <int>();
Stepper.Iterate(100, i => tree.TryAdd(i));
Assert.IsTrue(tree.Count == 100);
Stepper.Iterate(100, i => Assert.IsTrue(tree.Contains(i)));
}
}
[TestMethod] public void Remove_Testing()
{
// removing a non-existing value should throw exceptions
{
IRedBlackTree <int> tree = new RedBlackTreeLinked <int>()
{
1, 3,
};
Assert.ThrowsException <ArgumentException>(() => tree.Remove(2));
}
// normal remove checking
{
IRedBlackTree <int> tree = new RedBlackTreeLinked <int>()
{
1, 2, 3,
};
Assert.IsTrue(tree.Count == 3);
tree.Remove(1);
Assert.IsFalse(tree.Contains(1));
Assert.IsTrue(tree.Count == 2);
tree.Remove(2);
Assert.IsFalse(tree.Contains(2));
Assert.IsTrue(tree.Count == 1);
tree.Remove(3);
Assert.IsFalse(tree.Contains(3));
Assert.IsTrue(tree.Count == 0);
}
{
IRedBlackTree <int> tree = new RedBlackTreeLinked <int>();
Stepper.Iterate(100, i => tree.Add(i));
Assert.IsTrue(tree.Count == 100);
Stepper.Iterate(100, i => tree.Remove(i));
Assert.IsTrue(tree.Count == 0);
}
}
public void Iterate_2()
{
var evaluator = new Mock <INodeEvaluator>();
var analyser = new Mock <IBitAnalyser>();
var stepper = new Stepper(evaluator.Object, analyser.Object);
ushort[] BRANCH_KEYS = new ushort[] {
// first branch key
1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1,
};
const int FIRST_MASK = 0x1;
const int SECOND_MASK = 0xfe;
var rowTree = new RowTree
{
Branches = BRANCH_KEYS,
Instructions = new Instruction[] {
new Instruction
{
Chunk = 0,
Mask = FIRST_MASK,
},
new Instruction
{
Chunk = 0,
Mask = SECOND_MASK,
},
},
Leaves = new int[] {
0,
},
TestChunks = new TestChunk[] {
new TestChunk
{
KeyOffset = 0,
LeafOffset = 0,
LeafLength = 16,
}
},
};
ushort value = 100;
evaluator.Setup(ev => ev.Evaluate(It.IsAny <TestChunk>(), It.IsAny <ushort[]>(), value))
.Returns(0xfe);
analyser.Setup(a => a.GetRightmostBit(It.IsAny <uint>()))
.Returns(0);
var actual = stepper.Iterate(rowTree, value);
Assert.AreEqual(0, actual);
evaluator.Verify(ev => ev.Evaluate(It.IsAny <TestChunk>(), BRANCH_KEYS, value), Times.Once());
analyser.Verify(a => a.GetRightmostBit(It.IsAny <uint>()), Times.Once());
analyser.Verify(a => a.GetRightmostBit(SECOND_MASK), Times.Once());
evaluator.VerifyNoOtherCalls();
analyser.VerifyNoOtherCalls();
}
[IterationSetup] public void IterationSetup()
{
Values = new int[N];
Stepper.Iterate(N, i => Values[i] = i);
Random random = new Random(7);
random.Shuffle(Values);
}
[TestMethod] public void Shuffle_Testing()
{
Random random = new Random(randomSeed);
int[] array = new int[size];
Stepper.Iterate(size, i => array[i] = i);
Sort.Shuffle(random, array);
Assert.IsFalse(IsLeastToGreatest(array));
}
public static void Enqueue_Dequeue_Int32_Testing <Queue>()
where Queue : IQueue <int>, new()
{
const int count = 100000;
int[] values = new int[count];
Stepper.Iterate(count, i => values[i] = i);
Enqueue_Dequeue_Testing <int, Queue>(values);
}
public static void Push_Pop_String_Testing <Stack>()
where Stack : IStack <string>, new()
{
const int count = 10000;
string[] values = new string[count];
Stepper.Iterate(count, i => values[i] = i.ToString());
Push_Pop_Testing <string, Stack>(values);
}
public static void Push_Pop_Int32_Testing <Stack>()
where Stack : IStack <int>, new()
{
const int count = 10000;
int[] values = new int[count];
Stepper.Iterate(count, i => values[i] = i);
Push_Pop_Testing <int, Stack>(values);
}
public static void Enqueue_Dequeue_String_Testing <Queue>()
where Queue : IQueue <string>, new()
{
const int count = 100000;
string[] values = new string[count];
Stepper.Iterate(count, i => values[i] = i.ToString());
Enqueue_Dequeue_Testing <string, Queue>(values);
}
public static void TestAlgorithm(Action <int[]> algorithm)
{
Random random = new Random(randomSeed);
int[] array = new int[size];
Stepper.Iterate(size, i => array[i] = i);
Sort.Shuffle(random, array);
Assert.IsFalse(IsLeastToGreatest(array)); // make sure the data is randomized before algorithm
algorithm(array);
Assert.IsTrue(IsLeastToGreatest(array));
}
[TestMethod] public void Add_Testing()
{
{ // string, int
const int count = 100000;
IMap <string, int> map = new MapHashLinked <string, int>();
Stepper.Iterate(count, i => map.Add(i, i.ToString()));
map.Add(int.MinValue, int.MinValue.ToString());
map.Add(int.MaxValue, int.MaxValue.ToString());
// contains
Stepper.Iterate(count, i => Assert.IsTrue(map.Contains(i)));
Assert.IsTrue(map.Contains(int.MinValue));
Assert.IsTrue(map.Contains(int.MaxValue));
Assert.IsFalse(map.Contains(-1));
Assert.IsFalse(map.Contains(count));
// get
Stepper.Iterate(count, i => Assert.IsTrue(map[i] == i.ToString()));
Assert.IsTrue(map[int.MinValue] == int.MinValue.ToString());
Assert.IsTrue(map[int.MaxValue] == int.MaxValue.ToString());
Assert.ThrowsException <ArgumentException>(() => map.Add(0, 0.ToString()));
Assert.ThrowsException <ArgumentException>(() => map.Add(int.MinValue, int.MinValue.ToString()));
Assert.ThrowsException <ArgumentException>(() => map.Add(int.MaxValue, int.MaxValue.ToString()));
}
{ // int, string
const int count = 100000;
IMap <int, string> map = new MapHashLinked <int, string>();
Stepper.Iterate(count, i => map.Add(i.ToString(), i));
map.Add(int.MinValue.ToString(), int.MinValue);
map.Add(int.MaxValue.ToString(), int.MaxValue);
// contains
Stepper.Iterate(count, i => Assert.IsTrue(map.Contains(i.ToString())));
Assert.IsTrue(map.Contains(int.MinValue.ToString()));
Assert.IsTrue(map.Contains(int.MaxValue.ToString()));
Assert.IsFalse(map.Contains((-1).ToString()));
Assert.IsFalse(map.Contains(count.ToString()));
// get
Stepper.Iterate(count, i => Assert.IsTrue(map[i.ToString()] == i));
Assert.IsTrue(map[int.MinValue.ToString()] == int.MinValue);
Assert.IsTrue(map[int.MaxValue.ToString()] == int.MaxValue);
Assert.ThrowsException <ArgumentException>(() => map.Add(0.ToString(), 0));
Assert.ThrowsException <ArgumentException>(() => map.Add(int.MinValue.ToString(), int.MinValue));
Assert.ThrowsException <ArgumentException>(() => map.Add(int.MaxValue.ToString(), int.MaxValue));
}
}
[TestMethod] public void Add_Testing()
{
const int count = 100000;
IList <int> list = new ListArray <int>();
Stepper.Iterate(count, i => list.Add(i));
// check count
Assert.IsTrue(list.Count == count);
// check for all values
bool[] values = new bool[count];
list.Stepper(i => values[i] = true);
values.Stepper(b => Assert.IsTrue(b));
}
[TestMethod] public void Remove_Testing()
{
{ // string, int
const int count = 100000;
IMap <string, int> map = new MapHashLinked <string, int>();
Stepper.Iterate(count, i => map.Add(i, i.ToString()));
for (int i = 0; i < count; i += 3)
{
map.Remove(i);
}
for (int i = 0; i < count; i++)
{
if (i % 3 == 0)
{
Assert.IsFalse(map.Contains(i));
}
else
{
Assert.IsTrue(map.Contains(i));
}
}
Assert.IsFalse(map.Contains(-1));
Assert.IsFalse(map.Contains(count));
}
{ // int, string
const int count = 100000;
IMap <int, string> map = new MapHashLinked <int, string>();
Stepper.Iterate(count, i => map.Add(i.ToString(), i));
for (int i = 0; i < count; i += 3)
{
map.Remove(i.ToString());
}
for (int i = 0; i < count; i++)
{
if (i % 3 == 0)
{
Assert.IsFalse(map.Contains(i.ToString()));
}
else
{
Assert.IsTrue(map.Contains(i.ToString()));
}
}
Assert.IsFalse(map.Contains((-1).ToString()));
Assert.IsFalse(map.Contains(count.ToString()));
}
}
[TestMethod] public void Remove_Testing()
{
{ // int
const int count = 100000;
ISet <int> set = new SetHashLinked <int>();
Stepper.Iterate(count, i => set.Add(i));
for (int i = 0; i < count; i += 3)
{
set.Remove(i);
}
for (int i = 0; i < count; i++)
{
if (i % 3 == 0)
{
Assert.IsFalse(set.Contains(i));
}
else
{
Assert.IsTrue(set.Contains(i));
}
}
Assert.IsFalse(set.Contains(-1));
Assert.IsFalse(set.Contains(count));
}
{ // string
const int count = 100000;
ISet <string> set = new SetHashLinked <string>();
Stepper.Iterate(count, i => set.Add(i.ToString()));
for (int i = 0; i < count; i += 3)
{
set.Remove(i.ToString());
}
for (int i = 0; i < count; i++)
{
if (i % 3 == 0)
{
Assert.IsFalse(set.Contains(i.ToString()));
}
else
{
Assert.IsTrue(set.Contains(i.ToString()));
}
}
Assert.IsFalse(set.Contains((-1).ToString()));
Assert.IsFalse(set.Contains(count.ToString()));
}
}
[TestMethod] public void Remove_Testing()
{
const int count = 1000;
IList <int> list = new ListArray <int>();
Stepper.Iterate(count, i => list.Add(i));
// check count
Assert.IsTrue(list.Count == count);
// check for all values
bool[] values = new bool[count];
list.Stepper(i => values[i] = true);
values.Stepper(b => Assert.IsTrue(b));
// remove every 3rd value
Stepper.Iterate(count / 3 + 1, i => list.RemoveFirst(i * 3));
Array.Fill(values, false);
list.Stepper(i => values[i] = true);
for (int i = 0; i < count; i++)
{
Assert.IsTrue(i % 3 == 0 ? !values[i] : values[i]);
}
// check count
Assert.IsTrue(list.Count == count / 3 * 2);
// remove the remaining values
for (int i = 0; i < count; i++)
{
if (values[i])
{
list.RemoveFirst(i);
}
}
Array.Fill(values, false);
list.Stepper(i => values[i] = true);
values.Stepper(b => Assert.IsFalse(b));
// check count
Assert.IsTrue(list.Count == 0);
// exception
Assert.ThrowsException <ArgumentException>(() => list.RemoveFirst(0));
}
[TestMethod] public void Dequeue_Testing()
{
void Test <T>(T[] values, Compare <T> compare)
{
T[] clonedValues = (T[])values.Clone();
Towel.Sort.Shuffle(clonedValues);
IHeap <T> heap = new HeapArray <T>(compare);
clonedValues.Stepper(x => heap.Enqueue(x));
foreach (T value in values)
{
T dequeue = heap.Dequeue();
Assert.IsTrue(value.Equals(dequeue));
}
}
{ // int compare
const int count = 100;
int[] values = new int[count];
Stepper.Iterate(count, i => values[i] = i);
Array.Sort(values, (a, b) => - a.CompareTo(b));
Test(values, (a, b) => Compare.Wrap(a.CompareTo(b)));
}
{ // string compare
const int count = 100;
string[] values = new string[count];
Stepper.Iterate(count, i => values[i] = i.ToString());
Array.Sort(values, (a, b) => - a.CompareTo(b));
Test(values, (a, b) => Compare.Wrap(a.CompareTo(b)));
}
{ // int reverse compare
const int count = 100;
int[] values = new int[count];
Stepper.Iterate(count, i => values[i] = i);
Array.Sort(values);
Test(values, (a, b) => Compare.Wrap(-a.CompareTo(b)));
}
{ // string reverse compare
const int count = 100;
string[] values = new string[count];
Stepper.Iterate(count, i => values[i] = i.ToString());
Array.Sort(values);
Test(values, (a, b) => Compare.Wrap(-a.CompareTo(b)));
}
}
[TestMethod] public void Set_Testing()
{
{ // string, int
const int count = 100000;
IMap <string, int> map = new MapHashLinked <string, int>();
Stepper.Iterate(count, i => map[i] = i.ToString());
map[int.MinValue] = int.MinValue.ToString();
map[int.MaxValue] = int.MaxValue.ToString();
// contains
Stepper.Iterate(count, i => Assert.IsTrue(map.Contains(i)));
Assert.IsTrue(map.Contains(int.MinValue));
Assert.IsTrue(map.Contains(int.MaxValue));
Assert.IsFalse(map.Contains(-1));
Assert.IsFalse(map.Contains(count));
// get
Stepper.Iterate(count, i => Assert.IsTrue(map[i] == i.ToString()));
Assert.IsTrue(map[int.MinValue] == int.MinValue.ToString());
Assert.IsTrue(map[int.MaxValue] == int.MaxValue.ToString());
}
{ // int, string
const int count = 100000;
IMap <int, string> map = new MapHashLinked <int, string>();
Stepper.Iterate(count, i => map[i.ToString()] = i);
map[int.MinValue.ToString()] = int.MinValue;
map[int.MaxValue.ToString()] = int.MaxValue;
// contains
Stepper.Iterate(count, i => Assert.IsTrue(map.Contains(i.ToString())));
Assert.IsTrue(map.Contains(int.MinValue.ToString()));
Assert.IsTrue(map.Contains(int.MaxValue.ToString()));
Assert.IsFalse(map.Contains((-1).ToString()));
Assert.IsFalse(map.Contains(count.ToString()));
// get
Stepper.Iterate(count, i => Assert.IsTrue(map[i.ToString()] == i));
Assert.IsTrue(map[int.MinValue.ToString()] == int.MinValue);
Assert.IsTrue(map[int.MaxValue.ToString()] == int.MaxValue);
}
}
[TestMethod] public void Add_Testing()
{
{ // int
const int count = 100000;
ISet <int> set = new SetHashLinked <int>();
Stepper.Iterate(count, i => set.Add(i));
set.Add(int.MinValue);
set.Add(int.MaxValue);
Stepper.Iterate(count, i => Assert.IsTrue(set.Contains(i)));
Assert.IsTrue(set.Contains(int.MinValue));
Assert.IsTrue(set.Contains(int.MaxValue));
Assert.IsFalse(set.Contains(-1));
Assert.IsFalse(set.Contains(count));
Assert.ThrowsException <ArgumentException>(() => set.Add(0));
Assert.ThrowsException <ArgumentException>(() => set.Add(int.MinValue));
Assert.ThrowsException <ArgumentException>(() => set.Add(int.MaxValue));
}
{ // string
const int count = 100000;
ISet <string> set = new SetHashLinked <string>();
Stepper.Iterate(count, i => set.Add(i.ToString()));
set.Add(int.MinValue.ToString());
set.Add(int.MaxValue.ToString());
Stepper.Iterate(count, i => Assert.IsTrue(set.Contains(i.ToString())));
Assert.IsTrue(set.Contains(int.MinValue.ToString()));
Assert.IsTrue(set.Contains(int.MaxValue.ToString()));
Assert.IsFalse(set.Contains((-1).ToString()));
Assert.IsFalse(set.Contains(count.ToString()));
Assert.ThrowsException <ArgumentException>(() => set.Add(0.ToString()));
Assert.ThrowsException <ArgumentException>(() => set.Add(int.MinValue.ToString()));
Assert.ThrowsException <ArgumentException>(() => set.Add(int.MaxValue.ToString()));
}
}
public void Iterate_0()
{
var evaluator = new Mock <INodeEvaluator>();
var analyser = new Mock <IBitAnalyser>();
var stepper = new Stepper(evaluator.Object, analyser.Object);
var rowTree = new RowTree {
Branches = new ushort[] { },
Instructions = new Instruction[] { },
Leaves = new int[] { },
TestChunks = new TestChunk[] { },
};
ushort value = 100;
var actual = stepper.Iterate(rowTree, value);
Assert.AreEqual(-1, actual);
evaluator.Verify(ev => ev.Evaluate(It.IsAny <TestChunk>(), It.IsAny <ushort[]>(), value), Times.Never());
analyser.Verify(a => a.GetRightmostBit(It.IsAny <uint>()), Times.Never());
evaluator.VerifyNoOtherCalls();
analyser.VerifyNoOtherCalls();
}
[TestMethod] public void Remove_Testing()
{
// removing a non-existing value should throw exceptions
{
IAvlTree <int> tree = new AvlTreeLinked <int>()
{
1, 3,
};
Assert.ThrowsException <ArgumentException>(() => tree.Remove(2));
}
// normal remove checking
{
IAvlTree <int> tree = new AvlTreeLinked <int>()
{
1, 2, 3,
};
Assert.IsTrue(tree.Count == 3);
tree.Remove(1);
Assert.IsFalse(tree.Contains(1));
Assert.IsTrue(tree.Count == 2);
tree.Remove(2);
Assert.IsFalse(tree.Contains(2));
Assert.IsTrue(tree.Count == 1);
tree.Remove(3);
Assert.IsFalse(tree.Contains(3));
Assert.IsTrue(tree.Count == 0);
}
{
IAvlTree <int> tree = new AvlTreeLinked <int>();
Stepper.Iterate(100, i => tree.Add(i));
Assert.IsTrue(tree.Count == 100);
Stepper.Iterate(100, i => tree.Remove(i));
Assert.IsTrue(tree.Count == 0);
}
// large randomized data set
{
const int count = 1000;
IAvlTree <int> tree = new AvlTreeLinked <int>();
for (int i = 0; i < count; i++)
{
Assert.IsTrue(tree.Count == i);
tree.Add(i);
Assert.IsTrue(tree.Count == i + 1);
Assert.IsTrue(tree.Contains(i));
int stepperCount = 0;
tree.Stepper(x => stepperCount++);
Assert.IsTrue(stepperCount == tree.Count);
}
int[] values = new int[count];
for (int i = 0; i < count; i++)
{
values[i] = i;
}
Random random = new Random(7);
random.Shuffle(values);
for (int i = 0; i < count; i++)
{
Assert.IsTrue(tree.Count == count - i);
tree.Remove(values[i]);
Assert.IsTrue(tree.Count == count - i - 1);
Assert.IsFalse(tree.Contains(values[i]));
int stepperCount = 0;
tree.Stepper(x => stepperCount++);
Assert.IsTrue(stepperCount == tree.Count);
}
}
}