public void TestScalableBloomReset() { var f = new ScalableBloomFilter(10, 0.1, 0.8); for (int i = 0; i < 1000; i++) { f.Add(Encoding.ASCII.GetBytes(i.ToString())); } var count = f.Filters.Count; Assert.IsTrue(count > 1, string.Format("Expected more than 1 filter, got {0}", count)); var resetF = f.Reset(); Assert.AreSame(f, resetF, "Returned ScalableBloomFilter should be the same instance"); count = f.Filters.Count; Assert.IsTrue(count == 1, string.Format("Expected 1 filter, got {0}", count)); foreach (var partition in f.Filters[0].Partitions) { for (uint i = 0; i < partition.count; i++) { if (partition.Get(i) != 0) { Assert.Fail("Expected all bits to be unset"); } } } }
public void Contains_WhenItemHasBeenAdded_ShouldReturnTrue() { var filter = new ScalableBloomFilter <int>(0.02); filter.Add(42); Assert.True(filter.Contains(42)); }
public void Initialize() { DataClashFilter = new ScalableBloomFilter <string>(0.02); Assert.IsNotNull(Execution.Everything); Assert.IsNotNull(BuiltWholeFeatureSetEvaluationTestProcessor); }
public void TestNewDefaultScalableBloomFilter() { var f = ScalableBloomFilter.NewDefaultScalableBloomFilter(0.1); Assert.AreEqual(0.1, f.FP); Assert.AreEqual(10000u, f.Hint); Assert.AreEqual(0.8, f.R); }
private void GeneralSetup(IByteConverter <ComplexType> byteConverter) { _bloomFilter = new ScalableBloomFilter <ComplexType>(0.02, byteConverter); foreach (var complexType in CreateComplexTypes()) { _bloomFilter.Add(complexType); } }
public void TestScalableBloomK() { var f = new ScalableBloomFilter(10, 0.1, 0.8); var k = f.K(); Assert.AreEqual(4u, k); }
private void GeneralSetup(IByteConverter <string> byteConverter, int itemsToInsert) { _bloomFilter = new ScalableBloomFilter <string>(MaximumErrorRate, byteConverter); for (var i = 0; i < itemsToInsert; i++) { var s = $"string-{i + 1}"; _bloomFilter.Add(s); } }
public static byte[] SerializeBloom(this ScalableBloomFilter bloom, ScalableBloomSerializer serializer) { using (var stream = new MemoryStream()) { serializer.Serialize(stream, bloom); return(stream.ToArray()); } }
public void NumberFilters_WithThreeTimesFirstCapacity_ShouldBeTwo() { var filter = new ScalableBloomFilter <int>(0.02); for (var i = 0; i < 3 * ScalableBloomFilter <int> .MinimumCapacity; i++) { filter.Add(i); } Assert.Equal(2, filter.NumberFilters); }
public void Setup_ScalableBloomFilter() { _regularScalableBloomFilter = new ScalableBloomFilter <string>(MaximumErrorRate, ByteConverter); for (var i = 0; i < ItemsToInsert; i++) { var s = $"string-{i + 1}"; _regularScalableBloomFilter.Add(s); } }
public void TestScalableBloomCapacity() { var f = new ScalableBloomFilter(1, 0.1, 1); f.AddFilter(); f.AddFilter(); var capacity = f.Capacity(); Assert.AreEqual(15u, capacity); }
public void Contains_WhenItemHasBeenAdded_AndFilterHasBeenSerializedAndUnserialized_ShouldReturnTrue() { using (var stream = new MemoryStream()) { var filterOld = new ScalableBloomFilter <int>(0.02, ByteConverter); filterOld.Add(42); IFormatter formatter = new BinaryFormatter(); formatter.Serialize(stream, filterOld); stream.Flush(); stream.Position = 0; ScalableBloomFilter <int> filterNew = (ScalableBloomFilter <int>)formatter.Deserialize(stream); Assert.True(filterNew.Contains(42)); } }
public void BenchmarkScalableBloomTestAndAdd() { var n = 100000; var f = new ScalableBloomFilter(100000, 0.1, 0.8); 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.TestAndAdd(data[i]); } }
public void TestScalableFillRatio() { var f = new ScalableBloomFilter(100, 0.1, 0.8); f.SetHash(ProbabilisticDataStructures.Defaults.GetDefaultHashAlgorithm()); for (int i = 0; i < 200; i++) { f.Add(Encoding.ASCII.GetBytes(i.ToString())); } var fillRatio = f.FillRatio(); if (fillRatio > 0.5) { Assert.Fail(string.Format("Expected less than or equal to 0.5, got {0}", fillRatio)); } }
public void ScalableBloomFilterCorrectlyActsAsASet() { IBloomFilter<int> filter = new ScalableBloomFilter<int>(0.9, 10, 0.001); //10 cannot already be in the collection, so inserting it must succeed Assert.IsFalse(filter.Add(10)); //10 is in the collection Assert.IsTrue(filter.Contains(10)); //check a load more numbers for (int i = 0; i < 100; i++) { filter.Add(i); Assert.IsTrue(filter.Contains(i)); } }
public void ScalableBloomFilterCorrectlyActsAsASet() { IBloomFilter <int> filter = new ScalableBloomFilter <int>(0.9, 10, 0.001); //10 cannot already be in the collection, so inserting it must succeed Assert.IsFalse(filter.Add(10)); //10 is in the collection Assert.IsTrue(filter.Contains(10)); //check a load more numbers for (int i = 0; i < 100; i++) { filter.Add(i); Assert.IsTrue(filter.Contains(i)); } }
public void ClearingScalabeBloomFilterResetsEverything() { ScalableBloomFilter <int> filter = new ScalableBloomFilter <int>(0.9, 1000, 0.001); //Add a load of numbers for (int i = 0; i < 100; i++) { filter.Add(i); Assert.IsTrue(filter.Contains(i)); } Assert.AreEqual(100, filter.Count); filter.Clear(); Assert.AreEqual(0, filter.Count); //Add them again for (int i = 0; i < 100; i++) { filter.Add(i); Assert.IsTrue(filter.Contains(i)); } Assert.AreEqual(100, filter.Count); }
public void Serialize(Stream stream, ScalableBloomFilter filter) { using (var bw = new BinaryWriter(stream)) { bw.Write(DataFormatMajorVersion); bw.Write(DataFormatMinorVersion); ScalableBloomState data = filter.GetState(); bw.Write(data.R); bw.Write(data.Fp); bw.Write(data.P); bw.Write(data.Hint); bw.Write(data.Partitions.Length); foreach (var partition in data.Partitions) ParitionedBloomSerializer.Serialize(bw, partition); bw.Flush(); } }
public ScalableBloomFilter Deserialize(Stream stream) { using (var br = new BinaryReader(stream)) { int dataFormatMajorVersion = br.ReadUInt16(); int dataFormatMinorVersion = br.ReadUInt16(); AssertDataVersionCanBeRead(dataFormatMajorVersion, dataFormatMinorVersion); double r = br.ReadDouble(); double fp = br.ReadDouble(); double p = br.ReadDouble(); uint hint = br.ReadUInt32(); int count = br.ReadInt32(); var stored = new List<PartitionedBloomState>(); for (var i = 0; i < count; i++) { stored.Add(ParitionedBloomSerializer.Deserialize(br)); } var data = new ScalableBloomState { Partitions = stored.ToArray(), R = r, Fp = fp, P = p, Hint = hint }; var result = new ScalableBloomFilter(data); return result; } }
public void ClearingScalabeBloomFilterResetsEverything() { ScalableBloomFilter<int> filter = new ScalableBloomFilter<int>(0.9, 1000, 0.001); //Add a load of numbers for (int i = 0; i < 100; i++) { filter.Add(i); Assert.IsTrue(filter.Contains(i)); } Assert.AreEqual(100, filter.Count); filter.Clear(); Assert.AreEqual(0, filter.Count); //Add them again for (int i = 0; i < 100; i++) { filter.Add(i); Assert.IsTrue(filter.Contains(i)); } Assert.AreEqual(100, filter.Count); }
public void Contains_WithFreshFilter_ShouldReturnFalse() { var filter = new ScalableBloomFilter <int>(0.02); Assert.False(filter.Contains(42)); }
public void TestScalableBloomTestAndAdd() { var f = new ScalableBloomFilter(1000, 0.01, 0.8); // '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 ScalableBloomFilter 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 < 10000; i++) { f.TestAndAdd(Encoding.ASCII.GetBytes(i.ToString())); } // 'x' should not be a false positive. if (f.Test(X_BYTES)) { Assert.Fail("'x' should be a member"); } }
public void Setup_ScalableBloomFilter() { var byteConverter = new ByteConverterStringMarshal(); _scalableBloomFilter = new ScalableBloomFilter <string>(MaximumErrorRate, byteConverter); }