public void TestCountingK()
{
var f = CountingBloomFilter.NewDefaultCountingBloomFilter(100, 0.1);
var k = f.K();
Assert.AreEqual(4u, k);
}
public void AddAndCheck_WhenItemHasBeenAddedBefore_ShouldReturnTrue()
{
var filter = new CountingBloomFilter <int>(50, 0.02);
filter.Add(42);
Assert.True(filter.AddAndCheck(42));
}
public void Contains_WhenItemHasBeenAdded_ShouldReturnTrue()
{
var filter = new CountingBloomFilter <int>(50, 0.02);
filter.Add(42);
Assert.True(filter.Contains(42));
}
public void Remove_WithItemInCollection_ShouldReturnTrue()
{
var filter = new CountingBloomFilter <int>(100, 0.2);
filter.Add(27);
Assert.True(filter.Remove(27));
}
public void TestCountingCapacity()
{
var f = CountingBloomFilter.NewDefaultCountingBloomFilter(100, 0.1);
var capacity = f.Capacity();
Assert.AreEqual(480u, capacity);
}
public Property AddAndCheck_WhenItemHasntBeenAddedBefore_ShouldReturnFalse()
{
return(Prop.ForAll(Arb.Default.Int32(), testData =>
{
var filter = new CountingBloomFilter <int>(50, 0.02, ByteConverter);
(filter.AddAndCheck(testData)).ToProperty();
}));
}
public Property Contains_WithFreshFilter_ShouldReturnFalse()
{
return(Prop.ForAll(Arb.Default.Int32(), testData =>
{
var filter = new CountingBloomFilter <int>(50, 0.02, ByteConverter);
return (!filter.Contains(testData)).ToProperty();
}));
}
public Property Remove_WithItemNotInCollection_ShouldReturnFalse()
{
return(Prop.ForAll(Arb.Default.Int32(), testData =>
{
var filter = new CountingBloomFilter <int>(100, 0.2, ByteConverter);
(!filter.Remove(testData)).ToProperty();
}));
}
public void Remove_WithItemInCollection_ShouldRemoveItemFromCollection()
{
var filter = new CountingBloomFilter <int>(100, 0.2);
filter.Add(27);
filter.Remove(27);
Assert.False(filter.Contains(27));
}
public void Positive()
{
var sut = new CountingBloomFilter(FilterSize, HashfunctionsSetSize);
const string input = "test";
sut.Insert(input);
Assert.True(sut.IsInBloomFilter(input));
}
public Property Remove_WithItemInCollection_ShouldReturnTrue()
{
return(Prop.ForAll(Arb.Default.Int32(), testData =>
{
var filter = new CountingBloomFilter <int>(100, 0.2);
filter.Add(testData);
return filter.Remove(testData).ToProperty();
}));
}
public void CountingBloomFilter()
{
CountingBloomFilter <int> filter = new CountingBloomFilter <int>(10, 2);
Assert.IsFalse(filter.Add(10));
Assert.IsTrue(filter.Contains(10));
Assert.IsTrue(filter.Remove(10));
Assert.IsFalse(filter.Contains(10));
}
public Property Contains_WhenItemHasBeenAdded_ShouldReturnTrue()
{
return(Prop.ForAll(Arb.Default.Int32(), testData =>
{
var filter = new CountingBloomFilter <int>(50, 0.02, ByteConverter);
filter.Add(testData);
return filter.Contains(testData).ToProperty();
}));
}
public void Negative()
{
var sut = new CountingBloomFilter(FilterSize, HashfunctionsSetSize);
const string input = "test";
const string notinfilter = "nifi";
sut.Insert(input);
Assert.False(sut.IsInBloomFilter(notinfilter));
}
public void CountingBloomFilter()
{
CountingBloomFilter<int> filter = new CountingBloomFilter<int>(10, 2);
Assert.IsFalse(filter.Add(10));
Assert.IsTrue(filter.Contains(10));
Assert.IsTrue(filter.Remove(10));
Assert.IsFalse(filter.Contains(10));
}
public void CanDeleteFromFilter()
{
var sut = new CountingBloomFilter(FilterSize, HashfunctionsSetSize);
const string input = "test";
sut.Insert(input);
Assert.True(sut.IsInBloomFilter(input));
sut.RemoveFromFilter(input);
Assert.False(sut.IsInBloomFilter(input));
}
public void Add_WithCounterAtMaxValue_ShouldRemainConstant()
{
var filter = new CountingBloomFilter <int>(50, 0.01);
while (filter.CounterAt(42) < byte.MaxValue)
{
filter.Add(42);
}
filter.Add(42); // one additional add to attempt to roll over byte.maxvalue
Assert.True(filter.Contains(42));
}
public void Contains_With5PercentFalsePositives_ShouldHaveLessThan5PercentErrors(int stepRange, double errorRate)
{
var filter = new CountingBloomFilter <int>(stepRange, errorRate);
foreach (var num in Enumerable.Range(1, stepRange))
{
filter.Add(num);
}
var errorCount = Enumerable.Range(stepRange + 1, stepRange * 2).Count(num => filter.Contains(num));
Assert.InRange(errorCount, 0d, errorRate * stepRange);
}
public void Remove_RemovedItemIsNotPresent()
{
CountingBloomFilter bf = new CountingBloomFilter(10, 0.001);
bf.Add("a");
bf.Add("a");
Assert.IsTrue(bf.IsPresent("a"));
bf.Remove("a");
Assert.IsFalse(bf.IsPresent("a"));
}
public Property Contains_With5PercentFalsePositives_ShouldHaveLessThan5PercentErrors()
{
return(Prop.ForAll(Arb.From(Gen.Choose(1, 5000)), Arb.From(Gen.Choose(1, 99)), (stepRange, errorRate) =>
{
var filter = new CountingBloomFilter <int>(stepRange, errorRate / 100d, ByteConverter);
foreach (var num in Enumerable.Range(1, stepRange))
{
filter.Add(num);
}
var errorCount = Enumerable.Range(stepRange + 1, stepRange * 2).Count(num => filter.Contains(num));
var highError = errorRate * stepRange;
(0 <= errorCount && errorCount <= highError).ToProperty();
}));
}
public void Contains_WhenItemHasBeenAdded_AndFilterHasBeenSerializedAndUnserialized_ShouldReturnTrue()
{
using (var stream = new MemoryStream())
{
var filterOld = new CountingBloomFilter <int>(50, 0.02);
filterOld.Add(42);
IFormatter formatter = new BinaryFormatter();
formatter.Serialize(stream, filterOld);
stream.Flush();
stream.Position = 0;
CountingBloomFilter <int> filterNew = (CountingBloomFilter <int>)formatter.Deserialize(stream);
Assert.True(filterNew.Contains(42));
}
}
public void BenchmarkCountingTestAndRemove()
{
var n = 100000;
var f = CountingBloomFilter.NewDefaultCountingBloomFilter(100000, 0.1);
var data = new byte[n][];
for (int i = 0; i < n; i++)
{
data[i] = Encoding.ASCII.GetBytes(i.ToString());
}
for (int i = 0; i < n; i++)
{
f.TestAndRemove(data[i]);
}
}
public void RollbackWhenRemovingANonExistantItem()
{
var a = new CountingBloomFilter <int>(1000, 0.01f);
for (var i = 0; i < 1000; i++)
{
a.Add(i);
}
byte[] copy = (byte[])a.Array.Clone();
Assert.IsFalse(a.Remove(1001));
for (int i = 0; i < a.Array.Length; i++)
{
Assert.AreEqual(a.Array[i], copy[i]);
}
}
public void TestCountingCount()
{
var f = CountingBloomFilter.NewDefaultCountingBloomFilter(100, 0.1);
for (uint i = 0; i < 10; i++)
{
f.Add(Encoding.ASCII.GetBytes(i.ToString()));
}
for (int i = 0; i < 5; i++)
{
f.TestAndRemove(Encoding.ASCII.GetBytes(i.ToString()));
}
var count = f.Count();
Assert.AreEqual(5u, count);
}
public void TestCountingReset()
{
var f = CountingBloomFilter.NewDefaultCountingBloomFilter(100, 0.1);
for (int i = 0; i < 1000; i++)
{
f.Add(Encoding.ASCII.GetBytes(i.ToString()));
}
var resetF = f.Reset();
Assert.AreSame(f, resetF, "Returned CountingBloomFilter should be the same instance");
for (uint i = 0; i < f.Buckets.count; i++)
{
if (f.Buckets.Get(i) != 0)
{
Assert.Fail("Expected all bits to be unset");
}
}
Assert.AreEqual(0u, f.Count());
}
public void TestCountingTestAndRemove()
{
var f = CountingBloomFilter.NewDefaultCountingBloomFilter(100, 0.01);
// 'a' is not in the filter.
if (f.TestAndRemove(A_BYTES))
{
Assert.Fail("'a' should not be a member");
}
f.Add(Encoding.ASCII.GetBytes("a"));
// 'a' is now in the filter.
if (!f.TestAndRemove(A_BYTES))
{
Assert.Fail("'a' should be a member");
}
// 'a' is no longer in the filter.
if (f.TestAndRemove(A_BYTES))
{
Assert.Fail("'a' should not be a member");
}
}
public void Add_EmptyString_Throws()
{
CountingBloomFilter bf = new CountingBloomFilter(10, 0.01d);
CommonBloomFilterTests.Add_EmptyString_Throws(bf);
}
public void Remove_NullData_Throws()
{
CountingBloomFilter bf = new CountingBloomFilter(10, 0.01d);
bf.Remove((byte[])null);
}
public void Remove_EmptyData_Throws()
{
CountingBloomFilter bf = new CountingBloomFilter(10, 0.01d);
bf.Remove(new byte[0]);
}
public void Constructor_ErrorRateGreaterThanOne_Throws()
{
CountingBloomFilter bf = new CountingBloomFilter(1, 2.0d);
}
public void Remove_NullString_Throws()
{
CountingBloomFilter bf = new CountingBloomFilter(10, 0.01d);
bf.Remove((string)null);
}
public void Constructor_ExpectedNumberOfItemsLessThanZero_Throws()
{
CountingBloomFilter bf = new CountingBloomFilter(-1, 0.5d);
}
public void Constructor_ErrorRateIsValid_DoesNotThrow()
{
CountingBloomFilter bf = new CountingBloomFilter(1, 0.5d);
}
public void Remove_RemovedItemIsNotPresent()
{
CountingBloomFilter bf = new CountingBloomFilter(10, 0.001);
bf.Add("a");
bf.Add("a");
Assert.IsTrue(bf.IsPresent("a"));
bf.Remove("a");
Assert.IsFalse(bf.IsPresent("a"));
}
public void Add_NonAddedItemIsNotPresent()
{
CountingBloomFilter bf = new CountingBloomFilter(10, 0.001);
CommonBloomFilterTests.Add_NonAddedItemIsNotPresent(bf);
}
public void Add_NullData_Throws()
{
CountingBloomFilter bf = new CountingBloomFilter(10, 0.01d);
CommonBloomFilterTests.Add_NullData_Throws(bf);
}
public void Constructor_ErrorRateLessThanZero_Throws()
{
CountingBloomFilter bf = new CountingBloomFilter(1, -1.0d);
}
public void Add_NonAddedItemIsNotPresent()
{
CountingBloomFilter bf = new CountingBloomFilter(10, 0.001);
CommonBloomFilterTests.Add_NonAddedItemIsNotPresent(bf);
}
public void Remove_WithItemNotInCollection_ShouldReturnFalse()
{
var filter = new CountingBloomFilter <int>(100, 0.2);
Assert.False(filter.Remove(27));
}
public void Contains_WithFreshFilter_ShouldReturnFalse()
{
var filter = new CountingBloomFilter <int>(50, 0.02);
Assert.False(filter.Contains(42));
}
public void ErrorRateWithinExpectedBounds()
{
CountingBloomFilter bf = new CountingBloomFilter(10000, 0.01d);
CommonBloomFilterTests.ErrorRateWithinExpectedBounds(bf);
}
public void Remove_EmptyString_Throws()
{
CountingBloomFilter bf = new CountingBloomFilter(10, 0.01d);
bf.Remove(string.Empty);
}
public void Clear_AddedItemNoLongerPresent()
{
CountingBloomFilter bf = new CountingBloomFilter(10, 0.001);
CommonBloomFilterTests.Clear_AddedItemNoLongerPresent(bf);
}
public void TestCountingTestAndAdd()
{
var f = CountingBloomFilter.NewDefaultCountingBloomFilter(100, 0.01);
// 'a' is not in the filter.
if (f.Test(A_BYTES))
{
Assert.Fail("'a' should not be a member");
}
var addedF = f.Add(A_BYTES);
Assert.AreSame(f, addedF, "Returned BloomFilter should be the same instance");
// 'a' is now in the filter.
if (!f.Test(A_BYTES))
{
Assert.Fail("'a' should be a member");
}
// 'a' is still in the filter.
if (!f.TestAndAdd(A_BYTES))
{
Assert.Fail("'a' should be a member");
}
// 'b' is not in the filter.
if (f.TestAndAdd(B_BYTES))
{
Assert.Fail("'b' should not be a member");
}
// 'a' is still in the filter.
if (!f.Test(A_BYTES))
{
Assert.Fail("'a' should be a member");
}
// 'b' is now in the filter.
if (!f.Test(B_BYTES))
{
Assert.Fail("'b' should be a member");
}
// 'c' is not in the filter.
if (f.Test(C_BYTES))
{
Assert.Fail("'c' should not be a member");
}
for (int i = 0; i < 1000000; i++)
{
f.TestAndAdd(Encoding.ASCII.GetBytes(i.ToString()));
}
// 'x' should be a false positive.
if (!f.Test(X_BYTES))
{
Assert.Fail("'x' should be a member");
}
}
public void FillRatio_WithNewFilter_ShouldBeZero()
{
var filter = new CountingBloomFilter <int>(1000, 0.05);
Assert.Equal(0d, filter.FillRatio);
}
public void Constructor_ExpectedNumberOfItemsGreaterThanZero_DoesNotThrow()
{
CountingBloomFilter bf = new CountingBloomFilter(1, 0.5d);
}
