public void benchmark()
{
const int HeapSize = 5000;
int[] randomValues = Enumerable.Range(0, 100000).Select(_ => _random.Next()).ToArray();
BenchmarkResult r1 = MicroBenchmark.MeasureTime(() =>
{
BestKeeper <int> sut = new BestKeeper <int>(HeapSize, (n1, n2) => n1 - n2);
for (int i = 0; i < randomValues.Length; i++)
{
sut.Add(randomValues[i]);
}
}, 100);
BenchmarkResult r2 = MicroBenchmark.MeasureTime(() =>
{
OrderedArrayBestKeeper <int> sut = new OrderedArrayBestKeeper <int>(HeapSize, (n1, n2) => n1 - n2);
for (int i = 0; i < randomValues.Length; i++)
{
sut.Add(randomValues[i]);
}
}, 100);
r1.IsSignificantlyBetterThan(r2).Should().BeTrue();
}
public void collect_eliminated_items()
{
const int HeapSize = 32;
int[] randomValues = Enumerable.Range(0, 1000).Select(_ => _random.Next()).ToArray();
List <int> eliminated = new List <int>();
BestKeeper <int> sut = new BestKeeper <int>(HeapSize, (n1, n2) => n1 - n2);
for (int i = 0; i < HeapSize; i++)
{
sut.Add(randomValues[i], e => eliminated.Add(e));
Assert.That(sut.Count, Is.EqualTo(Math.Min(i + 1, HeapSize)));
}
List <int> expected = new List <int>();
for (int i = HeapSize; i < randomValues.Length; i++)
{
int top = sut.First();
if (top < randomValues[i])
{
expected.Add(top);
}
sut.Add(randomValues[i], e => eliminated.Add(e));
Assert.That(sut.Count, Is.EqualTo(HeapSize));
}
IEnumerable <int> best = randomValues.OrderByDescending(x => x).Take(HeapSize);
Assert.That(sut, Is.EquivalentTo(best));
Assert.That(eliminated, Is.EqualTo(expected));
}
public void BestKeeper_add_and_indexer()
{
//arrange
var sut = new BestKeeper <Algorithm>(8);
//act and assert
sut.Count.Should().Be(0);
sut.Add(algo1);
sut.Count.Should().Be(1);
}
public void test_BestKeeper()
{
BestKeeper <int> b = new BestKeeper <int>(5, (x, y) => y - x);
Assert.That(b.Count, Is.EqualTo(0));
Assert.That(b.Add(5));
Assert.That(b.Add(3));
Assert.That(b.Add(4));
CollectionAssert.AreEqual(new int[] { 5, 4, 3 }, b);
Assert.That(b.Add(2));
Assert.That(b.Add(1));
Assert.That(b.Add(0), Is.False);
Assert.That(b.Add(6));
CollectionAssert.AreEqual(new int[] { 6, 5, 4, 3, 2 }, b);
}
public void add_some_candidates()
{
const int HeapSize = 16;
int[] randomValues = Enumerable.Range(0, 1000).Select(_ => _random.Next()).ToArray();
BestKeeper <int> sut = new BestKeeper <int>(HeapSize, (n1, n2) => n1 - n2);
for (int i = 0; i < randomValues.Length; i++)
{
sut.Add(randomValues[i]);
Assert.That(sut.Count, Is.EqualTo(Math.Min(i + 1, HeapSize)));
}
IEnumerable <int> best = randomValues.OrderByDescending(x => x).Take(HeapSize);
Assert.That(sut, Is.EquivalentTo(best));
}
public void testing_best_keeper()
{
{
var all = new[] { 10, 3, 5, 7, 9, 78, 12 };
BestKeeper <int> k = new BestKeeper <int>(1, (a, b) => b - a);
foreach (var i in all)
{
k.AddCandidate(i);
}
Assert.That(k.Count, Is.EqualTo(1));
CollectionAssert.AreEqual(new[] { 78 }, k);
}
{
var all = new[] { 10, 3, 5, 7, 9, 78, 12 };
BestKeeper <int> k = new BestKeeper <int>(4, (a, b) => b - a);
foreach (var i in all)
{
k.AddCandidate(i);
}
Assert.That(k.Count, Is.EqualTo(4));
CollectionAssert.AreEqual(new[] { 78, 12, 10, 9 }, k);
}
{
var all = new[] { 10, 3, 52 };
BestKeeper <int> k = new BestKeeper <int>(4, (a, b) => b - a);
foreach (var i in all)
{
k.AddCandidate(i);
}
Assert.That(k.Count, Is.EqualTo(3));
CollectionAssert.AreEqual(new[] { 52, 10, 3 }, k);
}
{
var all = new[] { 10, 3, 52, 100, 6, 1 };
BestKeeper <int> k = new BestKeeper <int>(4, (a, b) => b - a);
foreach (var i in all)
{
k.AddCandidate(i);
}
Assert.That(k.Count, Is.EqualTo(4));
CollectionAssert.AreEqual(new[] { 100, 52, 10, 6 }, k);
}
}
public void bestkeeper_peekbest()
{
//arrange
var sut = new BestKeeper <Algorithm>(5);
//act
sut.Add(algo1);
sut.Add(algo2);
sut.Add(algo3);
sut.Add(algo4);
sut.Add(algo5);
sut.Add(algo6);
sut.Count.Should().Be(5);
//assert
sut.PeekBest.Delta.Should().Be(1);
sut.Count.Should().Be(5);
}
public void bestkeeper_supports_foreach()
{
//arrange
var d = new BestKeeper <int>(8);
for (int i = 0; i < 8; ++i)
{
d.Add(i);
}
//act assert
int c = 0;
bool[] seen = new bool[8];
foreach (var j in d)
{
j.Should().BeInRange(0, 7);
c++;
seen[j].Should().BeFalse();
seen[j] = true;
}
c.Should().Be(8);
}
public void simple_scenario()
{
var bestKeeper = new BestKeeper <int>(3);
bestKeeper.Submit(2);
bestKeeper.Submit(3);
bestKeeper.Submit(1);
bestKeeper.Count.Should().Be(3);
bestKeeper.Should().BeEquivalentTo(new[] { 1, 2, 3 });
bestKeeper.Submit(1);
bestKeeper.Submit(4);
bestKeeper.Submit(5);
bestKeeper.Count.Should().Be(3);
bestKeeper.Should().BeEquivalentTo(new[] { 3, 4, 5 });
bestKeeper.Submit(5);
bestKeeper.Submit(5);
bestKeeper.Submit(6);
bestKeeper.Count.Should().Be(3);
bestKeeper.Should().BeEquivalentTo(new[] { 5, 5, 6 });
}
public void bestkeeper_add_comparable()
{
//arrange
var sut = new BestKeeper <Algorithm>(8, (a, b) => a.CompareTo(b));
//act
sut.Add(algo1);
sut.Add(algo2);
sut.Add(algo3);
sut.Add(algo4);
sut.Add(algo5);
sut.Count.Should().Be(5);
//assert
sut.RemoveMax().Delta.Should().Be(algo1.Delta);
sut.RemoveMax().Delta.Should().Be(algo2.Delta);
sut.RemoveMax().Delta.Should().Be(algo3.Delta);
sut.RemoveMax().Delta.Should().Be(algo4.Delta);
sut.RemoveMax().Delta.Should().Be(algo5.Delta);
sut.Count.Should().Be(0);
}
public void bestkeeper_with_limit()
{
//arrange
var sut = new BestKeeper <Algorithm>(5);
//act
sut.Add(algo1);
sut.Add(algo2);
sut.Add(algo3);
sut.Add(algo4);
sut.Add(algo5);
sut.Add(algo6);
sut.Count.Should().Be(5);
//assert
sut.RemoveMax().Delta.Should().Be(algo6.Delta);
sut.RemoveMax().Delta.Should().Be(algo1.Delta);
sut.RemoveMax().Delta.Should().Be(algo2.Delta);
sut.RemoveMax().Delta.Should().Be(algo3.Delta);
sut.RemoveMax().Delta.Should().Be(algo4.Delta);
}
