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 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 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); }