public void TestCtors()
{
var empty = new RedBlackSetTester<char>();
Assert.That(empty.Empty, Is.True);
Assert.That(empty.Count(), Is.EqualTo(0));
Assert.That(empty.ToList(), Is.Empty);
empty.Add('1');
Assert.That(empty.Empty, Is.False);
Assert.That(empty.Count(), Is.EqualTo(1));
WithRandomNumbers(list =>
{
var range = Enumerable.Range(42, list.Count);
var two = new RedBlackMapTester<int, int>(list, range);
var prs = new RedBlackMapTester<int, int>(list.Zip<int, int, KeyValuePair<int, int>>(range, RedBlackMap<int, int>.KeyValuePair.Create));
var tup = new RedBlackMapTester<int, int>(list.Zip<int, int, Tuple<int, int>>(range, Tuple.Create));
Assert.That(two.ToArray(), Is.EqualTo(prs.ToList()));
Assert.That(two.ToArray(), Is.EqualTo(tup.ToList()));
});
Assert.That(() =>
{
new RedBlackMapTester<int, int>(Enumerable.Range(1, 3), Enumerable.Range(1, 4));
}, Throws.ArgumentException);
}
public void TestExceptWith()
{
var a = new RedBlackSetTester<int>(_numbers);
Assert.That(() => a.ExceptWith(null), Throws.InstanceOf<ArgumentNullException>());
a.ExceptWith(_odd);
Assert.That(a, Is.EqualTo(_even.Where(x => x <= _numbers.Max())));
a.ExceptWith(_primes);
Assert.That(a, Is.EqualTo(_even.Where(x => x > 2 && x <= _numbers.Max())));
}
public void TestIntersectWith()
{
var a = new RedBlackSetTester<int>(_even);
Assert.That(() => a.IntersectWith(null), Throws.InstanceOf<ArgumentNullException>());
a.IntersectWith(_primes);
Assert.That(a, Has.Count.EqualTo(1));
Assert.That(a.Contains(2));
a.IntersectWith(_odd);
Assert.That(a, Is.Empty);
}
public void TestBalancedness()
{
var perfect = new RedBlackSetTester<int>();
perfect.Add(4);
perfect.Add(2);
perfect.Add(1);
perfect.Add(3);
perfect.Add(6);
perfect.Add(5);
perfect.Add(7);
Assert.That(perfect.MaxDepth(), Is.EqualTo(3));
}
public void TestIsProperSubsetOf()
{
var a = new RedBlackSetTester<int>();
Assert.That(() => a.IsProperSubsetOf(null), Throws.InstanceOf<ArgumentNullException>());
Assert.That(a.IsProperSubsetOf(Enumerable.Range(1, 1)));
Assert.That(a.IsProperSubsetOf(Enumerable.Empty<int>()), Is.False);
a.AddRange(_primes);
Assert.That(a.IsProperSubsetOf(_numbers));
a.AddRange(_even.Where(UpTo100));
Assert.That(a.IsProperSubsetOf(_numbers));
a.AddRange(_odd.Where(UpTo100));
Assert.That(a.IsProperSubsetOf(_numbers), Is.False);
}
public void TestCacheWorks()
{
var init = new int[] { 2, 3, 4, 5 };
var t = new RedBlackSetTester<int>(init);
Assert.That(t.Cache, Is.EqualTo(init));
Assert.That(t.Remove(4), Is.True);
var remove = init.Where(i => i != 4);
Assert.That(t.Add(2), Is.False);
Assert.That(t.Cache, Is.EquivalentTo(remove));
Assert.That(t.Add(7), Is.True);
var add = remove.Concat(Enumerable.Repeat(7, 1));
Assert.That(t.Cache, Is.EquivalentTo(add));
t.Clear();
Assert.That(t.Cache, Is.Empty);
}
public void TestDepthOfLinearInsertion()
{
const int up2 = 9999;
var rbt = new RedBlackSetTester<int>(Enumerable.Range(1, 7));
double max = 0.0;
for (int i = 8; i <= up2; ++i)
{
rbt.Add(i);
double actual = rbt.MaxDepth();
double perfect = Math.Log(i, 2.0);
double ratio = actual / perfect;
max = Math.Max(max, ratio);
}
Assert.That(rbt.Count, Is.EqualTo(up2));
Assert.That(max, Is.LessThanOrEqualTo(2.0));
}
public void TestOrderedness()
{
WithRandomNumbers(list =>
{
var rbt = new RedBlackSetTester<int>(list);
Assert.That(rbt.AreNodesOrdered(), Is.True);
});
}
public void TestDepthWithRandomNumbers()
{
WithRandomNumbers(list =>
{
if (list.Count <= 1)
{
return;
}
var rbt = new RedBlackSetTester<int>(list);
var depth = rbt.MaxDepth();
var theory = Math.Log(list.Count, 2.0) * 2.0;
Assert.That(depth, Is.LessThanOrEqualTo(theory),
"The tree is not well balanced.");
}, new int[] { 255, 256, 257, 9999, 99999 });
}
public void TestUnionWith()
{
var a = new RedBlackSetTester<int>(_odd.Where(UpTo100));
Assert.That(() => a.SymmetricExceptWith(null), Throws.InstanceOf<ArgumentNullException>());
int count = a.Count;
a.UnionWith(_primes);
Assert.That(a.Count, Is.EqualTo(count + 1));
Assert.That(a.Contains(2));
a.UnionWith(_even.Where(UpTo100));
Assert.That(a.SetEquals(_numbers));
}
public void TestSymmetricExceptWith()
{
var a = new RedBlackSetTester<int>(_odd.Where(UpTo100));
Assert.That(() => a.SymmetricExceptWith(null), Throws.InstanceOf<ArgumentNullException>());
a.SymmetricExceptWith(_even.Where(UpTo100));
Assert.That(a.SetEquals(_numbers));
a.Clear();
a.AddRange(_primes);
a.SymmetricExceptWith(_odd.Where(UpTo100).Concat(Enumerable.Repeat(2, 2)));
Assert.That(a.Contains(_primes.First()), Is.False);
Assert.That(_primes.Skip(1).All(p => !a.Contains(p)));
}
public void TestSetEquals()
{
var a = new RedBlackSetTester<int>(_odd.Where(UpTo100));
Assert.That(() => a.SetEquals(null), Throws.InstanceOf<ArgumentNullException>());
Assert.That(a.SetEquals(_numbers), Is.False);
a.AddRange(_primes);
Assert.That(a.SetEquals(_numbers), Is.False);
a.AddRange(_even.Where(UpTo100));
Assert.That(a.SetEquals(_numbers));
}
public void TestOverlap()
{
var a = new RedBlackSetTester<int>(_odd);
Assert.That(() => a.Overlaps(null), Throws.InstanceOf<ArgumentNullException>());
Assert.That(a.Overlaps(_even), Is.False);
a.AddRange(_primes);
Assert.That(a.Overlaps(_even));
}
public void TestIsSupersetOf()
{
var a = new RedBlackSetTester<int>();
Assert.That(() => a.IsSupersetOf(null), Throws.InstanceOf<ArgumentNullException>());
Assert.That(a.IsSupersetOf(Enumerable.Empty<int>()));
Assert.That(a.IsSupersetOf(Enumerable.Range(1, 1)), Is.False);
a.AddRange(_odd);
Assert.That(a.IsSupersetOf(_primes), Is.False);
a.Add(2);
Assert.That(a.IsSupersetOf(_primes));
}
