[Boost-commit] svn:boost r73710 - sandbox/bloom_filter/trunk/libs/bloom_filter/test

Subject: [Boost-commit] svn:boost r73710 - sandbox/bloom_filter/trunk/libs/bloom_filter/test
From: cpp.cabrera_at_[hidden]
Date: 2011-08-13 01:10:26

Author: alejandro
Date: 2011-08-13 01:10:24 EDT (Sat, 13 Aug 2011)
New Revision: 73710
URL: http://svn.boost.org/trac/boost/changeset/73710

Log:
New test:
  - twohash_dynamic_counting_bloom_filter-pass.cpp

Updates:
  - Removed intersect/union exception tests
    from dynamic_counting_bloom_filter.
  - Removed union/intersect tests for counting_bloom_filter.
  - Split regression into two suites - twohash and original.

Renaming:
  - bloom-pass.cpp -> basic_bloom_filter-pass.cpp
  - counting_bloom-pass.cpp -> counting_bloom_filter-pass.cpp
  - dynamic_bloom-pass.cpp -> dynamic_bloom_filter-pass.cpp
  - dynamic_counting_bloom-pass.cpp
    -> dynamic_counting_bloom_filter-pass.cpp
Added:
   sandbox/bloom_filter/trunk/libs/bloom_filter/test/basic_bloom_filter-pass.cpp   (contents, props changed)
      - copied, changed from r73661, /sandbox/bloom_filter/trunk/libs/bloom_filter/test/bloom-pass.cpp
   sandbox/bloom_filter/trunk/libs/bloom_filter/test/counting_bloom_filter-pass.cpp   (contents, props changed)
      - copied, changed from r73661, /sandbox/bloom_filter/trunk/libs/bloom_filter/test/counting_bloom-pass.cpp
   sandbox/bloom_filter/trunk/libs/bloom_filter/test/dynamic_bloom_filter-pass.cpp   (contents, props changed)
      - copied, changed from r73661, /sandbox/bloom_filter/trunk/libs/bloom_filter/test/dynamic_bloom-pass.cpp
   sandbox/bloom_filter/trunk/libs/bloom_filter/test/dynamic_counting_bloom_filter-pass.cpp   (contents, props changed)
      - copied, changed from r73661, /sandbox/bloom_filter/trunk/libs/bloom_filter/test/dynamic_counting_bloom-pass.cpp
   sandbox/bloom_filter/trunk/libs/bloom_filter/test/twohash_dynamic_counting_bloom_filter-pass.cpp   (contents, props changed)
Removed:
   sandbox/bloom_filter/trunk/libs/bloom_filter/test/bloom-pass.cpp
   sandbox/bloom_filter/trunk/libs/bloom_filter/test/counting_bloom-pass.cpp
   sandbox/bloom_filter/trunk/libs/bloom_filter/test/dynamic_bloom-pass.cpp
   sandbox/bloom_filter/trunk/libs/bloom_filter/test/dynamic_counting_bloom-pass.cpp
Text files modified: 
   sandbox/bloom_filter/trunk/libs/bloom_filter/test/Jamfile.v2                             |    14 ++-                                     
   sandbox/bloom_filter/trunk/libs/bloom_filter/test/counting_bloom_filter-pass.cpp         |   101 -----------------------                 
   sandbox/bloom_filter/trunk/libs/bloom_filter/test/dynamic_counting_bloom_filter-pass.cpp |   171 ----------------------------------------
   3 files changed, 9 insertions(+), 277 deletions(-)

Modified: sandbox/bloom_filter/trunk/libs/bloom_filter/test/Jamfile.v2
==============================================================================
--- sandbox/bloom_filter/trunk/libs/bloom_filter/test/Jamfile.v2	(original)
+++ sandbox/bloom_filter/trunk/libs/bloom_filter/test/Jamfile.v2	2011-08-13 01:10:24 EDT (Sat, 13 Aug 2011)
@@ -22,12 +22,16 @@
 
     test-suite "regression"
         :
-	[ run bloom-pass.cpp ]
-	[ run dynamic_bloom-pass.cpp ]
-	[ run counting_bloom-pass.cpp ]
-	[ run dynamic_counting_bloom-pass.cpp ]
+	[ run basic_bloom_filter-pass.cpp ]
+	[ run dynamic_bloom_filter-pass.cpp ]
+	[ run counting_bloom_filter-pass.cpp ]
+	[ run dynamic_counting_bloom_filter-pass.cpp ]
+        ;
+
+    test-suite "twohash_regression"
+        :
         [ run twohash_basic_bloom_filter-pass.cpp ]
         [ run twohash_dynamic_basic_bloom_filter-pass.cpp ]
         [ run twohash_counting_bloom_filter-pass.cpp ]
+	[ run twohash_dynamic_counting_bloom_filter-pass.cpp ]
         ;
-

Copied: sandbox/bloom_filter/trunk/libs/bloom_filter/test/basic_bloom_filter-pass.cpp (from r73661, /sandbox/bloom_filter/trunk/libs/bloom_filter/test/bloom-pass.cpp)
==============================================================================

Deleted: sandbox/bloom_filter/trunk/libs/bloom_filter/test/bloom-pass.cpp
==============================================================================
--- sandbox/bloom_filter/trunk/libs/bloom_filter/test/bloom-pass.cpp	2011-08-13 01:10:24 EDT (Sat, 13 Aug 2011)
+++ (empty file)
@@ -1,293 +0,0 @@
-//////////////////////////////////////////////////////////////////////////////
-//
-// (C) Copyright Alejandro Cabrera 2011.
-// Distributed under the Boost
-// Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or
-// copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-// See http://www.boost.org/libs/bloom_filter for documentation.
-//
-//////////////////////////////////////////////////////////////////////////////
-
-#define BOOST_TEST_DYN_LINK 1
-#define BOOST_TEST_MODULE "Boost Bloom Filter" 1
-#include <iostream>
-
-#include <boost/bloom_filter/basic_bloom_filter.hpp>
-#include <boost/test/unit_test.hpp>
-#include <boost/test/floating_point_comparison.hpp>
-
-using boost::bloom_filters::basic_bloom_filter;
-using boost::bloom_filters::boost_hash;
-
-BOOST_AUTO_TEST_CASE(defaultConstructor) {
-  typedef boost::mpl::vector<
-    boost_hash<int, 13>,
-    boost_hash<int, 17>,
-    boost_hash<int, 19> > BoostHashFunctions;
-  
-  basic_bloom_filter<int, 8> bloom1;
-  basic_bloom_filter<int, 8, BoostHashFunctions> bloom2;
-}
-
-BOOST_AUTO_TEST_CASE(rangeConstructor) {
-  int elems[5] = {1,2,3,4,5};
-  basic_bloom_filter<int, 8> bloom(elems, elems+5);
-
-  BOOST_CHECK_EQUAL(bloom.count(), 5ul);
-}
-
-#ifndef BOOST_NO_0X_HDR_INITIALIZER_LIST
-BOOST_AUTO_TEST_CASE(initListConstructor) {
-  basic_bloom_filter<int, 8> bloom = {1,2,3,4,5};
-
-  BOOST_CHECK_EQUAL(bloom.count(), 5ul);
-}
-#endif
-
-BOOST_AUTO_TEST_CASE(copyConstructor) {
-  int elems[5] = {1,2,3,4,5};
-  basic_bloom_filter<int, 8> bloom1(elems, elems+5);
-  basic_bloom_filter<int, 8> bloom2(bloom1);
-
-  BOOST_CHECK_EQUAL(bloom1.count(), bloom2.count());
-}
-
-BOOST_AUTO_TEST_CASE(assignment)
-{
-  basic_bloom_filter<int, 8> bloom1;
-  basic_bloom_filter<int, 8> bloom2;
-
-  for (size_t i = 0; i < 200; ++i) {
-    bloom1.insert(i);
-    BOOST_CHECK_EQUAL(bloom1.probably_contains(i), true);
-  }
-
-  bloom2 = bloom1;
-
-  for (size_t i = 0; i < 200; ++i) {
-    BOOST_CHECK_EQUAL(bloom2.probably_contains(i), true);
-  }
-}
-
-BOOST_AUTO_TEST_CASE(bit_capacity) {
-  basic_bloom_filter<size_t, 8> bloom_8;
-  basic_bloom_filter<size_t, 256> bloom_256;
-  basic_bloom_filter<size_t, 2048> bloom_2048;
-  
-  BOOST_CHECK_EQUAL(bloom_8.bit_capacity(), 8ul);
-  BOOST_CHECK_EQUAL(bloom_256.bit_capacity(), 256ul);
-  BOOST_CHECK_EQUAL(bloom_2048.bit_capacity(), 2048ul);
-}
-
-BOOST_AUTO_TEST_CASE(empty) {
-  basic_bloom_filter<size_t, 8> bloom;
-  
-  BOOST_CHECK_EQUAL(bloom.empty(), true);
-  bloom.insert(1);
-  BOOST_CHECK_EQUAL(bloom.empty(), false);
-  bloom.clear();
-  BOOST_CHECK_EQUAL(bloom.empty(), true);
-}
-
-BOOST_AUTO_TEST_CASE(numHashFunctions) {
-  basic_bloom_filter<size_t, 8> bloom_3;
-  basic_bloom_filter<size_t, 8, boost::mpl::vector<
-    boost_hash<size_t, 1>,
-    boost_hash<size_t, 2> > > bloom_2;
-  basic_bloom_filter<size_t, 8, boost::mpl::vector<
-    boost_hash<size_t, 1>,
-    boost_hash<size_t, 2>,
-    boost_hash<size_t, 3>,
-    boost_hash<size_t, 4>,
-    boost_hash<size_t, 5>,
-    boost_hash<size_t, 6>,
-    boost_hash<size_t, 7> > > bloom_7;
-
-  BOOST_CHECK_EQUAL(bloom_3.num_hash_functions(), 1ul);
-  BOOST_CHECK_EQUAL(bloom_2.num_hash_functions(), 2ul);
-  BOOST_CHECK_EQUAL(bloom_7.num_hash_functions(), 7ul);
-}
-
-BOOST_AUTO_TEST_CASE(falsePositiveRate) {
-  basic_bloom_filter<size_t, 64> bloom;
-
-  BOOST_CHECK_EQUAL(bloom.false_positive_rate(), 0.0);
-
-  bloom.insert(1);
-  BOOST_CHECK_CLOSE(bloom.false_positive_rate(), 0.015504, .01);
-
-  bloom.insert(2);
-  BOOST_CHECK_CLOSE(bloom.false_positive_rate(), 0.030768, .01);
-
-  bloom.insert(3);
-  BOOST_CHECK_CLOSE(bloom.false_positive_rate(), 0.045794, .01);
-
-  bloom.insert(4);
-  BOOST_CHECK_CLOSE(bloom.false_positive_rate(), 0.060588, .01);
-
-  bloom.insert(5);
-  BOOST_CHECK_CLOSE(bloom.false_positive_rate(), 0.075151, .01);
-
-  bloom.insert(6);
-  BOOST_CHECK_CLOSE(bloom.false_positive_rate(), 0.089491, .01);
-
-  for (size_t i = 7; i < 5000; ++i)
-    bloom.insert(i);
-  
-  BOOST_CHECK_GE(bloom.false_positive_rate(), 0.6);
-  BOOST_CHECK_LE(bloom.false_positive_rate(), 1.0);
-}
-
-BOOST_AUTO_TEST_CASE(probably_contains) {
-  basic_bloom_filter<size_t, 8> bloom;
-
-  bloom.insert(1);
-  BOOST_CHECK_EQUAL(bloom.probably_contains(1), true);
-  BOOST_CHECK_LE(bloom.count(), 3ul);
-  BOOST_CHECK_GE(bloom.count(), 1ul);
-}
-
-BOOST_AUTO_TEST_CASE(doesNotContain) {
-  basic_bloom_filter<size_t, 8> bloom;
-
-  BOOST_CHECK_EQUAL(bloom.probably_contains(1), false);
-}
-
-BOOST_AUTO_TEST_CASE(insertNoFalseNegatives) {
-  basic_bloom_filter<size_t, 2048> bloom;
-
-  for (size_t i = 0; i < 100; ++i) {
-    bloom.insert(i);
-    BOOST_CHECK_EQUAL(bloom.probably_contains(i), true);
-  }
-}
-
-BOOST_AUTO_TEST_CASE(rangeInsert) {
-  int elems[5] = {1,2,3,4,5};
-  basic_bloom_filter<size_t, 8> bloom;
-
-  bloom.insert(elems, elems+5);
-  BOOST_CHECK_EQUAL(bloom.count(), 5ul);
-}
-
-BOOST_AUTO_TEST_CASE(clear) {
-  basic_bloom_filter<size_t, 8> bloom;
-
-  for (size_t i = 0; i < 1000; ++i)
-    bloom.insert(i);
-
-  bloom.clear();
-  BOOST_CHECK_EQUAL(bloom.probably_contains(1), false);
-  BOOST_CHECK_EQUAL(bloom.count(), 0ul);
-}
-
-BOOST_AUTO_TEST_CASE(memberSwap) {
-  size_t elems[5] = {1,2,3,4,5};
-  basic_bloom_filter<size_t, 8> bloom1(elems, elems+2);
-  basic_bloom_filter<size_t, 8> bloom2(elems+2, elems+5);
-
-  bloom1.swap(bloom2);
-
-  BOOST_CHECK_EQUAL(bloom1.count(), 3ul);
-  BOOST_CHECK_EQUAL(bloom2.count(), 2ul);
-}
-
-BOOST_AUTO_TEST_CASE(testUnion) {
-  basic_bloom_filter<size_t, 300> bloom_1;
-  basic_bloom_filter<size_t, 300> bloom_2;
-  basic_bloom_filter<size_t, 300> bloom_union;
-
-  for (size_t i = 0; i < 100; ++i)
-    bloom_1.insert(i);
-
-  for (size_t i = 100; i < 200; ++i)
-    bloom_2.insert(i);
-
-  bloom_union = bloom_1 | bloom_2;
-
-  for (size_t i = 0; i < 200; ++i)
-    BOOST_CHECK_EQUAL(bloom_union.probably_contains(i), true);
-  BOOST_CHECK_GE(bloom_union.count(), bloom_1.count());
-  BOOST_CHECK_GE(bloom_union.count(), bloom_2.count());
-}
-
-BOOST_AUTO_TEST_CASE(testUnionAssign) {
-  basic_bloom_filter<size_t, 300> bloom_1;
-  basic_bloom_filter<size_t, 300> bloom_union;
-
-  for (size_t i = 0; i < 100; ++i) 
-    bloom_1.insert(i);
-
-  bloom_union |= bloom_1;
-
-  for (size_t i = 0; i < 100; ++i)
-    BOOST_CHECK_EQUAL(bloom_union.probably_contains(i), true);
-  BOOST_CHECK_EQUAL(bloom_union.count(), bloom_1.count());
-}
-
-BOOST_AUTO_TEST_CASE(testIntersect) {
-  basic_bloom_filter<size_t, 300> bloom_1;
-  basic_bloom_filter<size_t, 300> bloom_2;
-  basic_bloom_filter<size_t, 300> bloom_intersect;
-
-  // overlap at 100
-  for (size_t i = 0; i < 101; ++i) 
-    bloom_1.insert(i);
-  
-  for (size_t i = 100; i < 200; ++i) 
-    bloom_2.insert(i);
-
-  bloom_intersect = bloom_1 & bloom_2;
-
-  BOOST_CHECK_LE(bloom_intersect.count(), bloom_1.count());
-  BOOST_CHECK_LE(bloom_intersect.count(), bloom_2.count());
-  BOOST_CHECK_EQUAL(bloom_intersect.probably_contains(100), true);
-}
-
-BOOST_AUTO_TEST_CASE(testIntersectAssign) {
-  basic_bloom_filter<size_t, 300> bloom_1;
-  basic_bloom_filter<size_t, 300> bloom_intersect;
-
-  for (size_t i = 0; i < 100; ++i) 
-    bloom_1.insert(i);
-  
-  bloom_intersect &= bloom_1;
-
-  for (size_t i = 0; i < 100; ++i)
-    BOOST_CHECK_EQUAL(bloom_intersect.probably_contains(i), false);
-}
-
-BOOST_AUTO_TEST_CASE(globalSwap) {
-  size_t elems[5] = {1,2,3,4,5};
-  basic_bloom_filter<size_t, 8> bloom1(elems, elems+2);
-  basic_bloom_filter<size_t, 8> bloom2(elems+2, elems+5);
-
-  swap(bloom1, bloom2);
-
-  BOOST_CHECK_EQUAL(bloom1.count(), 3ul);
-  BOOST_CHECK_EQUAL(bloom2.count(), 2ul);
-}
-
-BOOST_AUTO_TEST_CASE(equalityOperator) {
-  basic_bloom_filter<int, 8> bloom1;
-  basic_bloom_filter<int, 8> bloom2;
-
-  BOOST_CHECK_EQUAL(bloom1 == bloom2, true);
-  bloom1.insert(1);
-  BOOST_CHECK_EQUAL(bloom1 == bloom2, false);
-  bloom2.insert(1);
-  BOOST_CHECK_EQUAL(bloom1 == bloom2, true);
-}
-
-BOOST_AUTO_TEST_CASE(inequalityOperator) {
-  basic_bloom_filter<int, 8> bloom1;
-  basic_bloom_filter<int, 8> bloom2;
-
-  BOOST_CHECK_EQUAL(bloom1 != bloom2, false);
-  bloom1.insert(1);
-  BOOST_CHECK_EQUAL(bloom1 != bloom2, true);
-  bloom2.insert(1);
-  BOOST_CHECK_EQUAL(bloom1 != bloom2, false);
-}

Deleted: sandbox/bloom_filter/trunk/libs/bloom_filter/test/counting_bloom-pass.cpp
==============================================================================
--- sandbox/bloom_filter/trunk/libs/bloom_filter/test/counting_bloom-pass.cpp	2011-08-13 01:10:24 EDT (Sat, 13 Aug 2011)
+++ (empty file)
@@ -1,537 +0,0 @@
-//////////////////////////////////////////////////////////////////////////////
-//
-// (C) Copyright Alejandro Cabrera 2011.
-// Distributed under the Boost
-// Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or
-// copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-// See http://www.boost.org/libs/bloom_filter for documentation.
-//
-//////////////////////////////////////////////////////////////////////////////
-
-#define BOOST_TEST_DYN_LINK 1
-#define BOOST_TEST_MODULE "Boost Bloom Filter" 1
-
-#include <boost/bloom_filter/counting_bloom_filter.hpp>
-#include <boost/test/unit_test.hpp>
-#include <boost/test/floating_point_comparison.hpp>
-
-#include <boost/bloom_filter/detail/exceptions.hpp>
-
-#include <boost/cstdint.hpp>
-
-using boost::bloom_filters::counting_bloom_filter;
-using boost::bloom_filters::detail::bin_underflow_exception;
-using boost::bloom_filters::detail::bin_overflow_exception;
-using boost::bloom_filters::boost_hash;
-
-BOOST_AUTO_TEST_CASE(allBitsPerBinCompile)
-{
-  counting_bloom_filter<size_t, 2, 1> bloom1;
-  counting_bloom_filter<size_t, 2, 2> bloom2;
-  counting_bloom_filter<size_t, 2, 4> bloom4;
-  counting_bloom_filter<size_t, 2, 8> bloom8;
-  counting_bloom_filter<size_t, 2, 16> bloom16;
-  counting_bloom_filter<size_t, 2, 32> bloom32;
-}
-
-BOOST_AUTO_TEST_CASE(allReasonableBlockTypesCompile)
-{
-  typedef boost::mpl::vector<boost_hash<int, 0> > default_hash;
-
-  counting_bloom_filter<int, 2, 2, default_hash, unsigned char> a;
-  counting_bloom_filter<int, 2, 2, default_hash, unsigned short> b;
-  counting_bloom_filter<int, 2, 2, default_hash, unsigned int> c;
-  counting_bloom_filter<int, 2, 2, default_hash, unsigned long> d;
-  counting_bloom_filter<int, 2, 2, default_hash, size_t> e;
-
-  counting_bloom_filter<int, 2, 2, default_hash, uint8_t> aa;
-  counting_bloom_filter<int, 2, 2, default_hash, uint16_t> ab;
-  counting_bloom_filter<int, 2, 2, default_hash, uint32_t> ac;
-  counting_bloom_filter<int, 2, 2, default_hash, uintmax_t> ad;
-}
-
-BOOST_AUTO_TEST_CASE(defaultConstructor) {
-  typedef boost::mpl::vector<
-    boost_hash<int, 13>,
-    boost_hash<int, 17>,
-    boost_hash<int, 19> > BoostHashFunctions;
-  
-  counting_bloom_filter<int, 2> bloom1;
-  counting_bloom_filter<int, 2, 1> bloom2;
-  counting_bloom_filter<int, 2, 2, BoostHashFunctions> bloom3;
-  counting_bloom_filter<int, 2, 4,
-			BoostHashFunctions, unsigned char> bloom4;
-}
-
-BOOST_AUTO_TEST_CASE(countSingle)
-{
-  counting_bloom_filter<int, 2> bloom;
-  
-  bloom.insert(1);
-  BOOST_CHECK_EQUAL(bloom.count(), 1ul);
-  bloom.remove(1);
-  BOOST_CHECK_EQUAL(bloom.count(), 0ul);
-}
-
-#include <iostream>
-
-BOOST_AUTO_TEST_CASE(countMulti)
-{
-  counting_bloom_filter<int, 100> bloom_default;
-  counting_bloom_filter<int, 100, 1> bloom1;
-  counting_bloom_filter<int, 100, 2> bloom2;
-  counting_bloom_filter<int, 100, 8> bloom8;
-  counting_bloom_filter<int, 100, 16> bloom16;
-  counting_bloom_filter<int, 100, 32> bloom32;
-
-  for (size_t i = 0; i < 100; ++i) {
-    bloom_default.insert(i);
-    bloom1.insert(i);
-    bloom2.insert(i);
-    bloom8.insert(i);
-    bloom16.insert(i);
-    bloom32.insert(i);
-  }
-
-  BOOST_CHECK_EQUAL(bloom_default.count(), 100ul);
-  BOOST_CHECK_EQUAL(bloom1.count(), 100ul);
-  BOOST_CHECK_EQUAL(bloom2.count(), 100ul);
-  BOOST_CHECK_EQUAL(bloom8.count(), 100ul);
-  BOOST_CHECK_EQUAL(bloom16.count(), 100ul);
-  BOOST_CHECK_EQUAL(bloom32.count(), 100ul);
-
-  for (size_t i = 0; i < 100; ++i) {
-    bloom_default.insert(i);
-    bloom2.insert(i);
-    bloom8.insert(i);
-    bloom16.insert(i);
-    bloom32.insert(i);
-  }
-
-  BOOST_CHECK_EQUAL(bloom_default.count(), 100ul);
-  BOOST_CHECK_EQUAL(bloom2.count(), 100ul);
-  BOOST_CHECK_EQUAL(bloom8.count(), 100ul);
-  BOOST_CHECK_EQUAL(bloom16.count(), 100ul);
-  BOOST_CHECK_EQUAL(bloom32.count(), 100ul);
-
-  for (size_t i = 0; i < 100; ++i) {
-    bloom_default.remove(i);
-    bloom2.remove(i);
-    bloom8.remove(i);
-    bloom16.remove(i);
-    bloom32.remove(i);
-  }
-
-  BOOST_CHECK_EQUAL(bloom_default.count(), 100ul);
-  BOOST_CHECK_EQUAL(bloom2.count(), 100ul);
-  BOOST_CHECK_EQUAL(bloom8.count(), 100ul);
-  BOOST_CHECK_EQUAL(bloom16.count(), 100ul);
-  BOOST_CHECK_EQUAL(bloom32.count(), 100ul);
-
-  for (size_t i = 0; i < 100; ++i) {
-    bloom_default.remove(i);
-    bloom1.remove(i);
-    bloom2.remove(i);
-    bloom8.remove(i);
-    bloom16.remove(i);
-    bloom32.remove(i);
-  }
-
-  BOOST_CHECK_EQUAL(bloom_default.count(), 0ul);
-  BOOST_CHECK_EQUAL(bloom1.count(), 0ul);
-  BOOST_CHECK_EQUAL(bloom2.count(), 0ul);
-  BOOST_CHECK_EQUAL(bloom8.count(), 0ul);
-  BOOST_CHECK_EQUAL(bloom16.count(), 0ul);
-  BOOST_CHECK_EQUAL(bloom32.count(), 0ul);
-}
-
-BOOST_AUTO_TEST_CASE(rangeConstructor) {
-  int elems[5] = {1,2,3,4,5};
-  counting_bloom_filter<int, 5> bloom(elems, elems+5);
-
-  BOOST_CHECK_EQUAL(bloom.count(), 5ul);
-}
-
-#ifndef BOOST_NO_0X_HDR_INITIALIZER_LIST
-BOOST_AUTO_TEST_CASE(initListConstructor) {
-  counting_bloom_filter<int, 5> bloom = {1,2,3,4,5};
-
-  BOOST_CHECK_EQUAL(bloom.count(), 5ul);
-}
-#endif
-
-BOOST_AUTO_TEST_CASE(copyConstructor) {
-  int elems[5] = {1,2,3,4,5};
-  counting_bloom_filter<int, 5> bloom1(elems, elems+5);
-  counting_bloom_filter<int, 5> bloom2(bloom1);
-
-  BOOST_CHECK_EQUAL(bloom1.count(), bloom2.count());
-}
-
-BOOST_AUTO_TEST_CASE(assignment)
-{
-  counting_bloom_filter<int, 200> bloom1;
-  counting_bloom_filter<int, 200> bloom2;
-
-  for (size_t i = 0; i < 200; ++i) {
-    bloom1.insert(i);
-    BOOST_CHECK_EQUAL(bloom1.probably_contains(i), true);
-  }
-
-  bloom2 = bloom1;
-
-  for (size_t i = 0; i < 200; ++i) {
-    BOOST_CHECK_EQUAL(bloom2.probably_contains(i), true);
-  }
-}
-
-BOOST_AUTO_TEST_CASE(bit_capacity) {
-  counting_bloom_filter<size_t, 8> bloom_8;
-  counting_bloom_filter<size_t, 256> bloom_256;
-  counting_bloom_filter<size_t, 2048> bloom_2048;
-  
-  BOOST_CHECK_EQUAL(bloom_8.bit_capacity(), 
-		    8ul * bloom_8.bits_per_bin());
-  BOOST_CHECK_EQUAL(bloom_256.bit_capacity(), 
-		    256ul * bloom_256.bits_per_bin());
-  BOOST_CHECK_EQUAL(bloom_2048.bit_capacity(), 
-		    2048ul * bloom_2048.bits_per_bin());
-}
-
-BOOST_AUTO_TEST_CASE(empty) {
-  counting_bloom_filter<size_t, 2> bloom;
-  
-  BOOST_CHECK_EQUAL(bloom.empty(), true);
-  bloom.insert(1);
-  BOOST_CHECK_EQUAL(bloom.empty(), false);
-  bloom.clear();
-  BOOST_CHECK_EQUAL(bloom.empty(), true);
-}
-
-BOOST_AUTO_TEST_CASE(numHashFunctions) {
-  counting_bloom_filter<size_t, 1> bloom_1;
-  counting_bloom_filter<size_t, 1, 1, boost::mpl::vector<
-    boost_hash<size_t, 1>,
-    boost_hash<size_t, 2> > > bloom_2;
-  counting_bloom_filter<size_t, 1, 1, boost::mpl::vector<
-    boost_hash<size_t, 1>,
-    boost_hash<size_t, 2>,
-    boost_hash<size_t, 3>,
-    boost_hash<size_t, 4>,
-    boost_hash<size_t, 5>,
-    boost_hash<size_t, 6>,
-    boost_hash<size_t, 7> > > bloom_7;
-
-  BOOST_CHECK_EQUAL(bloom_1.num_hash_functions(), 1ul);
-  BOOST_CHECK_EQUAL(bloom_2.num_hash_functions(), 2ul);
-  BOOST_CHECK_EQUAL(bloom_7.num_hash_functions(), 7ul);
-}
-
-BOOST_AUTO_TEST_CASE(falsePositiveRate) {
-  counting_bloom_filter<size_t, 64> bloom;
-
-  BOOST_CHECK_EQUAL(bloom.false_positive_rate(), 0.0);
-
-  bloom.insert(1);
-  BOOST_CHECK_CLOSE(bloom.false_positive_rate(), 0.015504, .01);
-
-  bloom.insert(2);
-  BOOST_CHECK_CLOSE(bloom.false_positive_rate(), 0.030768, .01);
-
-  bloom.insert(3);
-  BOOST_CHECK_CLOSE(bloom.false_positive_rate(), 0.045794, .01);
-
-  bloom.insert(4);
-  BOOST_CHECK_CLOSE(bloom.false_positive_rate(), 0.060588, .01);
-
-  bloom.insert(5);
-  BOOST_CHECK_CLOSE(bloom.false_positive_rate(), 0.075151, .01);
-
-  bloom.insert(6);
-  BOOST_CHECK_CLOSE(bloom.false_positive_rate(), 0.089491, .01);
-
-  for (size_t i = 7; i < 128; ++i)
-    bloom.insert(i);
-  
-  BOOST_CHECK_GE(bloom.false_positive_rate(), 0.6);
-  BOOST_CHECK_LE(bloom.false_positive_rate(), 1.0);
-}
-
-BOOST_AUTO_TEST_CASE(probably_contains) {
-  counting_bloom_filter<size_t, 2> bloom;
-
-  bloom.insert(1);
-  BOOST_CHECK_EQUAL(bloom.probably_contains(1), true);
-  BOOST_CHECK_EQUAL(bloom.count(), 1ul);
-}
-
-BOOST_AUTO_TEST_CASE(doesNotContain) {
-  counting_bloom_filter<size_t, 2> bloom;
-
-  BOOST_CHECK_EQUAL(bloom.probably_contains(1), false);
-}
-
-BOOST_AUTO_TEST_CASE(insertNoFalseNegatives) {
-  counting_bloom_filter<size_t, 100> bloom;
-
-  for (size_t i = 0; i < 100; ++i) {
-    bloom.insert(i);
-    BOOST_CHECK_EQUAL(bloom.probably_contains(i), true);
-  }
-}
-
-BOOST_AUTO_TEST_CASE(insertOverflowExceptionThrown) {
-  counting_bloom_filter<size_t, 2, 1> bloom;
-  bool exception_occurred = false;
-
-  bloom.insert(1);
-  BOOST_CHECK_EQUAL(bloom.probably_contains(1), true);
-
-  try {
-    bloom.insert(1);
-  }
-
-  catch (bin_overflow_exception e) {
-    exception_occurred = true;
-  }
-
-  BOOST_CHECK_EQUAL(exception_occurred, true);
-  BOOST_CHECK_EQUAL(bloom.probably_contains(1), true);
-}
-
-BOOST_AUTO_TEST_CASE(removeUnderflowExceptionThrown) {
-  counting_bloom_filter<size_t, 2, 1> bloom;
-  bool exception_occurred = false;
-
-  try {
-    bloom.remove(1);
-  }
-
-  catch (bin_underflow_exception e) {
-    exception_occurred = true;
-  }
-
-  BOOST_CHECK_EQUAL(exception_occurred, true);
-  BOOST_CHECK_EQUAL(bloom.probably_contains(1), false);
-}
-
-BOOST_AUTO_TEST_CASE(insertOverflowException4bit)
-{
-  counting_bloom_filter<size_t, 2> bloom;
-  bool exception_occurred = false;
-
-  try {
-    for (size_t i = 0; i < (1ul << bloom.bits_per_bin()); ++i)
-      bloom.insert(1);
-  }
-
-  catch (bin_overflow_exception e) {
-    exception_occurred = true;
-  }
-
-  BOOST_CHECK_EQUAL(exception_occurred, true);
-  BOOST_CHECK_EQUAL(bloom.probably_contains(1), true);
-}
-
-BOOST_AUTO_TEST_CASE(rangeInsert) {
-  int elems[5] = {1,2,3,4,5};
-  counting_bloom_filter<size_t, 5> bloom;
-
-  bloom.insert(elems, elems+5);
-  BOOST_CHECK_EQUAL(bloom.count(), 5ul);
-}
-
-BOOST_AUTO_TEST_CASE(_remove) {
-  counting_bloom_filter<size_t, 1> bloom;
-  
-  bloom.insert(1);
-  bloom.remove(1);
-  BOOST_CHECK_EQUAL(bloom.count(), 0ul);
-}
-
-BOOST_AUTO_TEST_CASE(removeMulti) {
-  counting_bloom_filter<size_t, 100> bloom;
-
-  for (size_t i = 0; i < 100; ++i) {
-    bloom.insert(i);
-    bloom.remove(i);
-    BOOST_CHECK_EQUAL(bloom.count(), 0ul);
-  }
-}
-
-BOOST_AUTO_TEST_CASE(rangeRemove) {
-  size_t arr[] = {1,2,3,4,5};
-  counting_bloom_filter<size_t, 5> bloom;
-
-  bloom.insert(arr, arr+5);
-  bloom.remove(arr, arr+5);
-  BOOST_CHECK_EQUAL(bloom.count(), 0ul);
-}
-
-BOOST_AUTO_TEST_CASE(clear) {
-  counting_bloom_filter<size_t, 1000> bloom;
-
-  for (size_t i = 0; i < 1000; ++i)
-    bloom.insert(i);
-
-  bloom.clear();
-  BOOST_CHECK_EQUAL(bloom.probably_contains(1), false);
-  BOOST_CHECK_EQUAL(bloom.count(), 0ul);
-}
-
-struct SwapFixture {
-  SwapFixture() 
-  {
-    for (size_t i = 0; i < 5; ++i)
-      elems[i] = i+1;
-    
-    bloom1.insert(elems, elems+2);
-    bloom2.insert(elems+2, elems+5);
-  }
-
-  size_t elems[5];
-  counting_bloom_filter<size_t, 5> bloom1;
-  counting_bloom_filter<size_t, 5> bloom2;
-};
-
-BOOST_FIXTURE_TEST_CASE(memberSwap, SwapFixture) {
-  bloom1.swap(bloom2);
-
-  BOOST_CHECK_EQUAL(bloom1.count(), 3ul);
-  BOOST_CHECK_EQUAL(bloom2.count(), 2ul);
-}
-
-BOOST_FIXTURE_TEST_CASE(globalSwap, SwapFixture) {
-  swap(bloom1, bloom2);
-
-  BOOST_CHECK_EQUAL(bloom1.count(), 3ul);
-  BOOST_CHECK_EQUAL(bloom2.count(), 2ul);
-}
-
-struct PairwiseOpsFixture {
-
-  PairwiseOpsFixture() {}    
-
-  counting_bloom_filter<size_t, 300> bloom1;
-  counting_bloom_filter<size_t, 300> bloom2;
-  counting_bloom_filter<size_t, 300> bloom_result;
-};
-
-BOOST_AUTO_TEST_CASE(testUnion) {
-  counting_bloom_filter<size_t, 4, 2> bloom1;
-  counting_bloom_filter<size_t, 4, 2> bloom2;
-  counting_bloom_filter<size_t, 4, 2> bloom_union;
-
-  bloom1.insert(0);
-  bloom1.insert(1);
-  bloom1.insert(1);
-  bloom1.insert(3);
-  bloom1.insert(3);
-
-  bloom2.insert(0);
-  bloom2.insert(0);
-  bloom2.insert(1);
-  bloom2.insert(1);
-  bloom2.insert(1);
-  bloom2.insert(3);
-  bloom2.insert(3);
-
-  bloom_union = experimental_union(bloom1, bloom2);
-
-  BOOST_CHECK_EQUAL(bloom_union.probably_contains(0), true);
-  BOOST_CHECK_EQUAL(bloom_union.probably_contains(1), true);
-  BOOST_CHECK_EQUAL(bloom_union.probably_contains(2), false);
-  BOOST_CHECK_EQUAL(bloom_union.probably_contains(3), true);
-  BOOST_CHECK_GE(bloom_union.count(), bloom1.count());
-  BOOST_CHECK_GE(bloom_union.count(), bloom2.count());
-}
-
-BOOST_AUTO_TEST_CASE(testUnionAssign) {
-  counting_bloom_filter<size_t, 4, 2> bloom1;
-  counting_bloom_filter<size_t, 4, 2> bloom_union;
-
-  bloom1.insert(0);
-  bloom1.insert(1);
-  bloom1.insert(1);
-
-  bloom_union.insert(1);
-  bloom_union.insert(3);
-  bloom_union.insert(3);
-
-  bloom_union.experimental_union_assign(bloom1);
-
-  BOOST_CHECK_EQUAL(bloom_union.probably_contains(0), true);
-  BOOST_CHECK_EQUAL(bloom_union.probably_contains(1), true);
-  BOOST_CHECK_EQUAL(bloom_union.probably_contains(2), false);
-  BOOST_CHECK_EQUAL(bloom_union.probably_contains(3), true);
-  BOOST_CHECK_EQUAL(bloom_union.count(), 3ul);
-}
-
-BOOST_AUTO_TEST_CASE(testIntersect) {
-  counting_bloom_filter<size_t, 4, 2> bloom1;
-  counting_bloom_filter<size_t, 4, 2> bloom2;
-  counting_bloom_filter<size_t, 4, 2> bloom_intersect;
-
-  bloom1.insert(0);
-  bloom1.insert(1);
-  bloom1.insert(3);
-  bloom1.insert(3);
-
-  bloom2.insert(0);
-  bloom2.insert(0);
-  bloom2.insert(1);
-  bloom2.insert(1);
-  bloom2.insert(3);
-  bloom2.insert(3);
-
-  bloom_intersect = experimental_intersect(bloom1, bloom2);
-
-  BOOST_CHECK_EQUAL(bloom_intersect.probably_contains(0), false);
-  BOOST_CHECK_EQUAL(bloom_intersect.probably_contains(1), false);
-  BOOST_CHECK_EQUAL(bloom_intersect.probably_contains(2), false);
-  BOOST_CHECK_EQUAL(bloom_intersect.probably_contains(3), true);
-  BOOST_CHECK_LE(bloom_intersect.count(), bloom1.count());
-  BOOST_CHECK_LE(bloom_intersect.count(), bloom2.count());
-}
-
-BOOST_AUTO_TEST_CASE(testIntersectAssign) {
-  counting_bloom_filter<size_t, 4, 2> bloom1;
-  counting_bloom_filter<size_t, 4, 2> bloom_intersect;
-
-  bloom1.insert(0);
-  bloom1.insert(1);
-  bloom1.insert(3);
-
-  bloom1.insert(0);
-  bloom1.insert(0);
-  bloom_intersect.insert(1);
-  bloom_intersect.insert(3);
-  bloom_intersect.insert(3);
-  bloom_intersect.insert(3);
-
-  bloom_intersect.experimental_intersect_assign(bloom1);
-
-  BOOST_CHECK_EQUAL(bloom_intersect.probably_contains(0), false);
-  BOOST_CHECK_EQUAL(bloom_intersect.probably_contains(1), true);
-  BOOST_CHECK_EQUAL(bloom_intersect.probably_contains(2), false);
-  BOOST_CHECK_EQUAL(bloom_intersect.probably_contains(3), true);
-  BOOST_CHECK_EQUAL(bloom_intersect.count(), 2ul);
-}
-
-BOOST_FIXTURE_TEST_CASE(equalityOperator, PairwiseOpsFixture) {
-  BOOST_CHECK_EQUAL(bloom1 == bloom2, true);
-  bloom1.insert(1);
-  BOOST_CHECK_EQUAL(bloom1 == bloom2, false);
-  bloom2.insert(1);
-  BOOST_CHECK_EQUAL(bloom1 == bloom2, true);
-}
-
-BOOST_FIXTURE_TEST_CASE(inequalityOperator, PairwiseOpsFixture) {
-  BOOST_CHECK_EQUAL(bloom1 != bloom2, false);
-  bloom1.insert(1);
-  BOOST_CHECK_EQUAL(bloom1 != bloom2, true);
-  bloom2.insert(1);
-  BOOST_CHECK_EQUAL(bloom1 != bloom2, false);
-}

Copied: sandbox/bloom_filter/trunk/libs/bloom_filter/test/counting_bloom_filter-pass.cpp (from r73661, /sandbox/bloom_filter/trunk/libs/bloom_filter/test/counting_bloom-pass.cpp)
==============================================================================
--- /sandbox/bloom_filter/trunk/libs/bloom_filter/test/counting_bloom-pass.cpp	(original)
+++ sandbox/bloom_filter/trunk/libs/bloom_filter/test/counting_bloom_filter-pass.cpp	2011-08-13 01:10:24 EDT (Sat, 13 Aug 2011)
@@ -419,107 +419,6 @@
   counting_bloom_filter<size_t, 300> bloom_result;
 };
 
-BOOST_AUTO_TEST_CASE(testUnion) {
-  counting_bloom_filter<size_t, 4, 2> bloom1;
-  counting_bloom_filter<size_t, 4, 2> bloom2;
-  counting_bloom_filter<size_t, 4, 2> bloom_union;
-
-  bloom1.insert(0);
-  bloom1.insert(1);
-  bloom1.insert(1);
-  bloom1.insert(3);
-  bloom1.insert(3);
-
-  bloom2.insert(0);
-  bloom2.insert(0);
-  bloom2.insert(1);
-  bloom2.insert(1);
-  bloom2.insert(1);
-  bloom2.insert(3);
-  bloom2.insert(3);
-
-  bloom_union = experimental_union(bloom1, bloom2);
-
-  BOOST_CHECK_EQUAL(bloom_union.probably_contains(0), true);
-  BOOST_CHECK_EQUAL(bloom_union.probably_contains(1), true);
-  BOOST_CHECK_EQUAL(bloom_union.probably_contains(2), false);
-  BOOST_CHECK_EQUAL(bloom_union.probably_contains(3), true);
-  BOOST_CHECK_GE(bloom_union.count(), bloom1.count());
-  BOOST_CHECK_GE(bloom_union.count(), bloom2.count());
-}
-
-BOOST_AUTO_TEST_CASE(testUnionAssign) {
-  counting_bloom_filter<size_t, 4, 2> bloom1;
-  counting_bloom_filter<size_t, 4, 2> bloom_union;
-
-  bloom1.insert(0);
-  bloom1.insert(1);
-  bloom1.insert(1);
-
-  bloom_union.insert(1);
-  bloom_union.insert(3);
-  bloom_union.insert(3);
-
-  bloom_union.experimental_union_assign(bloom1);
-
-  BOOST_CHECK_EQUAL(bloom_union.probably_contains(0), true);
-  BOOST_CHECK_EQUAL(bloom_union.probably_contains(1), true);
-  BOOST_CHECK_EQUAL(bloom_union.probably_contains(2), false);
-  BOOST_CHECK_EQUAL(bloom_union.probably_contains(3), true);
-  BOOST_CHECK_EQUAL(bloom_union.count(), 3ul);
-}
-
-BOOST_AUTO_TEST_CASE(testIntersect) {
-  counting_bloom_filter<size_t, 4, 2> bloom1;
-  counting_bloom_filter<size_t, 4, 2> bloom2;
-  counting_bloom_filter<size_t, 4, 2> bloom_intersect;
-
-  bloom1.insert(0);
-  bloom1.insert(1);
-  bloom1.insert(3);
-  bloom1.insert(3);
-
-  bloom2.insert(0);
-  bloom2.insert(0);
-  bloom2.insert(1);
-  bloom2.insert(1);
-  bloom2.insert(3);
-  bloom2.insert(3);
-
-  bloom_intersect = experimental_intersect(bloom1, bloom2);
-
-  BOOST_CHECK_EQUAL(bloom_intersect.probably_contains(0), false);
-  BOOST_CHECK_EQUAL(bloom_intersect.probably_contains(1), false);
-  BOOST_CHECK_EQUAL(bloom_intersect.probably_contains(2), false);
-  BOOST_CHECK_EQUAL(bloom_intersect.probably_contains(3), true);
-  BOOST_CHECK_LE(bloom_intersect.count(), bloom1.count());
-  BOOST_CHECK_LE(bloom_intersect.count(), bloom2.count());
-}
-
-BOOST_AUTO_TEST_CASE(testIntersectAssign) {
-  counting_bloom_filter<size_t, 4, 2> bloom1;
-  counting_bloom_filter<size_t, 4, 2> bloom_intersect;
-
-  bloom1.insert(0);
-  bloom1.insert(1);
-  bloom1.insert(3);
-
-  bloom1.insert(0);
-  bloom1.insert(0);
-  bloom_intersect.insert(1);
-  bloom_intersect.insert(3);
-  bloom_intersect.insert(3);
-  bloom_intersect.insert(3);
-
-  bloom_intersect.experimental_intersect_assign(bloom1);
-
-  BOOST_CHECK_EQUAL(bloom_intersect.probably_contains(0), false);
-  BOOST_CHECK_EQUAL(bloom_intersect.probably_contains(1), true);
-  BOOST_CHECK_EQUAL(bloom_intersect.probably_contains(2), false);
-  BOOST_CHECK_EQUAL(bloom_intersect.probably_contains(3), true);
-  BOOST_CHECK_EQUAL(bloom_intersect.count(), 2ul);
-}
-
 BOOST_FIXTURE_TEST_CASE(equalityOperator, PairwiseOpsFixture) {
   BOOST_CHECK_EQUAL(bloom1 == bloom2, true);
   bloom1.insert(1);

Deleted: sandbox/bloom_filter/trunk/libs/bloom_filter/test/dynamic_bloom-pass.cpp
==============================================================================
--- sandbox/bloom_filter/trunk/libs/bloom_filter/test/dynamic_bloom-pass.cpp	2011-08-13 01:10:24 EDT (Sat, 13 Aug 2011)
+++ (empty file)
@@ -1,336 +0,0 @@
-//////////////////////////////////////////////////////////////////////////////
-//
-// (C) Copyright Alejandro Cabrera 2011.
-// Distributed under the Boost
-// Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or
-// copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-// See http://www.boost.org/libs/bloom_filter for documentation.
-//
-//////////////////////////////////////////////////////////////////////////////
-
-#define BOOST_TEST_DYN_LINK 1
-#define BOOST_TEST_MODULE "Boost Dynamic Bloom Filter" 1
-#include <iostream>
-
-#include <boost/bloom_filter/dynamic_bloom_filter.hpp>
-#include <boost/test/unit_test.hpp>
-#include <boost/test/floating_point_comparison.hpp>
-
-using boost::bloom_filters::dynamic_bloom_filter;
-using boost::bloom_filters::boost_hash;
-using boost::bloom_filters::detail::incompatible_size_exception;
-
-BOOST_AUTO_TEST_CASE(defaultConstructor) {
-  typedef boost::mpl::vector<
-    boost_hash<int, 13>,
-    boost_hash<int, 17>,
-    boost_hash<int, 19> > BoostHashFunctions;
-  
-  dynamic_bloom_filter<int> bloom1;
-  dynamic_bloom_filter<int, BoostHashFunctions> bloom2;
-}
-
-BOOST_AUTO_TEST_CASE(rangeConstructor) {
-  int elems[5] = {1,2,3,4,5};
-  dynamic_bloom_filter<int> bloom(elems, elems+5);
-
-  BOOST_CHECK_EQUAL(bloom.count(), 5ul);
-}
-
-BOOST_AUTO_TEST_CASE(copyConstructor) {
-  int elems[5] = {1,2,3,4,5};
-  dynamic_bloom_filter<int> bloom1(elems, elems+5);
-  dynamic_bloom_filter<int> bloom2(bloom1);
-
-  BOOST_CHECK_EQUAL(bloom1.count(), bloom2.count());
-}
-
-
-BOOST_AUTO_TEST_CASE(assignment)
-{
-  dynamic_bloom_filter<int> bloom1(200);
-  dynamic_bloom_filter<int> bloom2(200);
-
-  for (size_t i = 0; i < 200; ++i) {
-    bloom1.insert(i);
-    BOOST_CHECK_EQUAL(bloom1.probably_contains(i), true);
-  }
-
-  bloom2 = bloom1;
-
-  for (size_t i = 0; i < 200; ++i) {
-    BOOST_CHECK_EQUAL(bloom2.probably_contains(i), true);
-  }
-}
-
-BOOST_AUTO_TEST_CASE(bit_capacity) {
-  dynamic_bloom_filter<size_t> bloom_8(8);
-  dynamic_bloom_filter<size_t> bloom_256(256);
-  dynamic_bloom_filter<size_t> bloom_2048(2048);
-  
-  BOOST_CHECK_EQUAL(bloom_8.bit_capacity(), 8ul);
-  BOOST_CHECK_EQUAL(bloom_256.bit_capacity(), 256ul);
-  BOOST_CHECK_EQUAL(bloom_2048.bit_capacity(), 2048ul);
-}
-
-BOOST_AUTO_TEST_CASE(empty) {
-  dynamic_bloom_filter<size_t> bloom(8);
-  
-  BOOST_CHECK_EQUAL(bloom.empty(), true);
-  bloom.insert(1);
-  BOOST_CHECK_EQUAL(bloom.empty(), false);
-  bloom.clear();
-  BOOST_CHECK_EQUAL(bloom.empty(), true);
-}
-
-BOOST_AUTO_TEST_CASE(numHashFunctions) {
-  dynamic_bloom_filter<size_t> bloom_1;
-  dynamic_bloom_filter<size_t, boost::mpl::vector<
-    boost_hash<size_t, 1>,
-    boost_hash<size_t, 2> > > bloom_2;
-  dynamic_bloom_filter<size_t, boost::mpl::vector<
-    boost_hash<size_t, 1>,
-    boost_hash<size_t, 2>,
-    boost_hash<size_t, 3>,
-    boost_hash<size_t, 4>,
-    boost_hash<size_t, 5>,
-    boost_hash<size_t, 6>,
-    boost_hash<size_t, 7> > > bloom_7;
-
-  BOOST_CHECK_EQUAL(bloom_1.num_hash_functions(), 1ul);
-  BOOST_CHECK_EQUAL(bloom_2.num_hash_functions(), 2ul);
-  BOOST_CHECK_EQUAL(bloom_7.num_hash_functions(), 7ul);
-}
-
-BOOST_AUTO_TEST_CASE(falsePositiveRate) {
-  dynamic_bloom_filter<size_t> bloom(64);
-
-  BOOST_CHECK_EQUAL(bloom.false_positive_rate(), 0.0);
-
-  bloom.insert(1);
-  BOOST_CHECK_CLOSE(bloom.false_positive_rate(), 0.015504, .01);
-
-  bloom.insert(2);
-  BOOST_CHECK_CLOSE(bloom.false_positive_rate(), 0.030768, .01);
-
-  bloom.insert(3);
-  BOOST_CHECK_CLOSE(bloom.false_positive_rate(), 0.045794, .01);
-
-  bloom.insert(4);
-  BOOST_CHECK_CLOSE(bloom.false_positive_rate(), 0.060588, .01);
-
-  bloom.insert(5);
-  BOOST_CHECK_CLOSE(bloom.false_positive_rate(), 0.075151, .01);
-
-  bloom.insert(6);
-  BOOST_CHECK_CLOSE(bloom.false_positive_rate(), 0.089491, .01);
-
-  for (size_t i = 7; i < 5000; ++i)
-    bloom.insert(i);
-  
-  BOOST_CHECK_GE(bloom.false_positive_rate(), 0.6);
-  BOOST_CHECK_LE(bloom.false_positive_rate(), 1.0);
-}
-
-BOOST_AUTO_TEST_CASE(probably_contains) {
-  dynamic_bloom_filter<size_t> bloom(8);
-
-  bloom.insert(1);
-  BOOST_CHECK_EQUAL(bloom.probably_contains(1), true);
-  BOOST_CHECK_LE(bloom.count(), 3ul);
-  BOOST_CHECK_GE(bloom.count(), 1ul);
-}
-
-BOOST_AUTO_TEST_CASE(doesNotContain) {
-  dynamic_bloom_filter<size_t> bloom(8);
-
-  BOOST_CHECK_EQUAL(bloom.probably_contains(1), false);
-}
-
-BOOST_AUTO_TEST_CASE(insertNoFalseNegatives) {
-  dynamic_bloom_filter<size_t> bloom(2048);
-
-  for (size_t i = 0; i < 100; ++i) {
-    bloom.insert(i);
-    BOOST_CHECK_EQUAL(bloom.probably_contains(i), true);
-  }
-}
-
-BOOST_AUTO_TEST_CASE(rangeInsert) {
-  int elems[5] = {1,2,3,4,5};
-  dynamic_bloom_filter<size_t> bloom(8);
-
-  bloom.insert(elems, elems+5);
-  BOOST_CHECK_EQUAL(bloom.count(), 5ul);
-}
-
-BOOST_AUTO_TEST_CASE(clear) {
-  dynamic_bloom_filter<size_t> bloom(8);
-
-  for (size_t i = 0; i < 1000; ++i)
-    bloom.insert(i);
-
-  bloom.clear();
-  BOOST_CHECK_EQUAL(bloom.probably_contains(1), false);
-  BOOST_CHECK_EQUAL(bloom.count(), 0ul);
-}
-
-struct SwapFixture {
-  SwapFixture() 
-    : bloom1(10), bloom2(20)
-  {
-    for (size_t i = 0; i < 5; ++i)
-      elems[i] = i+1;
-    
-    bloom1.insert(elems, elems+2);
-    bloom2.insert(elems+2, elems+5);
-  }
-
-  dynamic_bloom_filter<size_t> bloom1;
-  dynamic_bloom_filter<size_t> bloom2;  
-  size_t elems[5];
-};
-
-BOOST_FIXTURE_TEST_CASE(memberSwap, SwapFixture) {
-  bloom1.swap(bloom2);
-
-  BOOST_CHECK_EQUAL(bloom1.count(), 3ul);
-  BOOST_CHECK_EQUAL(bloom1.bit_capacity(), 20ul);
-  BOOST_CHECK_EQUAL(bloom2.count(), 2ul);
-  BOOST_CHECK_EQUAL(bloom2.bit_capacity(), 10ul);
-}
-
-BOOST_FIXTURE_TEST_CASE(globalSwap, SwapFixture) {
-  swap(bloom1, bloom2);
-
-  BOOST_CHECK_EQUAL(bloom1.count(), 3ul);
-  BOOST_CHECK_EQUAL(bloom2.count(), 2ul);
-}
-
-struct PairwiseOpsFixture {
-  PairwiseOpsFixture() :
-    bloom1(100), bloom2(100), bloom_result(100)
-  {
-  }
-
-  dynamic_bloom_filter<size_t> bloom1;
-  dynamic_bloom_filter<size_t> bloom2;
-  dynamic_bloom_filter<size_t> bloom_result;
-};
-
-BOOST_FIXTURE_TEST_CASE(testUnion, PairwiseOpsFixture) {
-  for (size_t i = 0; i < 50; ++i)
-    bloom1.insert(i);
-
-  for (size_t i = 50; i < 100; ++i)
-    bloom2.insert(i);
-
-  bloom_result = bloom1 | bloom2;
-
-  for (size_t i = 0; i < 100; ++i)
-    BOOST_CHECK_EQUAL(bloom_result.probably_contains(i), true);
-
-  BOOST_CHECK_GE(bloom_result.count(), bloom1.count());
-  BOOST_CHECK_GE(bloom_result.count(), bloom2.count());
-}
-
-BOOST_FIXTURE_TEST_CASE(testUnionAssign, PairwiseOpsFixture) {
-  for (size_t i = 0; i < 100; ++i) 
-    bloom1.insert(i);
-
-  bloom_result |= bloom1;
-
-  for (size_t i = 0; i < 100; ++i)
-    BOOST_CHECK_EQUAL(bloom_result.probably_contains(i), true);
-
-  BOOST_CHECK_EQUAL(bloom_result.count(), bloom1.count());
-}
-
-BOOST_FIXTURE_TEST_CASE(testIntersect, PairwiseOpsFixture) {
-  // overlap at 50
-  for (size_t i = 0; i < 51; ++i) 
-    bloom1.insert(i);
-  
-  for (size_t i = 50; i < 100; ++i) 
-    bloom2.insert(i);
-
-  bloom_result = bloom1 & bloom2;
-
-  BOOST_CHECK_LE(bloom_result.count(), bloom1.count());
-  BOOST_CHECK_LE(bloom_result.count(), bloom2.count());
-  BOOST_CHECK_LE(bloom_result.count(), 1ul);
-  BOOST_CHECK_EQUAL(bloom_result.probably_contains(50), true);
-}
-
-BOOST_FIXTURE_TEST_CASE(testIntersectAssign, PairwiseOpsFixture) {
-  for (size_t i = 0; i < 100; ++i) 
-    bloom1.insert(i);
-  
-  bloom_result &= bloom1;
-
-  for (size_t i = 0; i < 100; ++i)
-    BOOST_CHECK_EQUAL(bloom_result.probably_contains(i), false);
-}
-
-BOOST_FIXTURE_TEST_CASE(equalityOperator, PairwiseOpsFixture) {
-  BOOST_CHECK_EQUAL(bloom1 == bloom2, true);
-  bloom1.insert(1);
-  BOOST_CHECK_EQUAL(bloom1 == bloom2, false);
-  bloom2.insert(1);
-  BOOST_CHECK_EQUAL(bloom1 == bloom2, true);
-}
-
-BOOST_FIXTURE_TEST_CASE(inequalityOperator, PairwiseOpsFixture) {
-  BOOST_CHECK_EQUAL(bloom1 != bloom2, false);
-  bloom1.insert(1);
-  BOOST_CHECK_EQUAL(bloom1 != bloom2, true);
-  bloom2.insert(1);
-  BOOST_CHECK_EQUAL(bloom1 != bloom2, false);
-}
-
-struct IncompatibleSizeFixture {
-  IncompatibleSizeFixture() : 
-    bloom1(100), bloom2(101), exception_thrown(false)
-  {}
-
-  dynamic_bloom_filter<size_t> bloom1;
-  dynamic_bloom_filter<size_t> bloom2;
-  dynamic_bloom_filter<size_t> bloom3;  
-  bool exception_thrown;
-};
-
-BOOST_FIXTURE_TEST_CASE(_intersectException, IncompatibleSizeFixture) {
-  try {
-    bloom3 = bloom1 & bloom2;
-  }
-  catch (incompatible_size_exception e) {
-    exception_thrown = true;
-  }
-
-  BOOST_CHECK_EQUAL(exception_thrown, true);
-}
-
-BOOST_FIXTURE_TEST_CASE(_unionException, IncompatibleSizeFixture) {
-  try {
-    bloom3 = bloom1 | bloom2;
-  }
-  catch (incompatible_size_exception e) {
-    exception_thrown = true;
-  }
-
-  BOOST_CHECK_EQUAL(exception_thrown, true);
-}
-
-BOOST_FIXTURE_TEST_CASE(_equalityException, IncompatibleSizeFixture) {
-  try {
-    if (bloom1 == bloom2)
-      exception_thrown = false;
-  }
-  catch (incompatible_size_exception e) {
-    exception_thrown = true;
-  }
-
-  BOOST_CHECK_EQUAL(exception_thrown, true);
-}

Copied: sandbox/bloom_filter/trunk/libs/bloom_filter/test/dynamic_bloom_filter-pass.cpp (from r73661, /sandbox/bloom_filter/trunk/libs/bloom_filter/test/dynamic_bloom-pass.cpp)
==============================================================================

Deleted: sandbox/bloom_filter/trunk/libs/bloom_filter/test/dynamic_counting_bloom-pass.cpp
==============================================================================
--- sandbox/bloom_filter/trunk/libs/bloom_filter/test/dynamic_counting_bloom-pass.cpp	2011-08-13 01:10:24 EDT (Sat, 13 Aug 2011)
+++ (empty file)
@@ -1,641 +0,0 @@
-//////////////////////////////////////////////////////////////////////////////
-//
-// (C) Copyright Alejandro Cabrera 2011.
-// Distributed under the Boost
-// Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or
-// copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-// See http://www.boost.org/libs/bloom_filter for documentation.
-//
-//////////////////////////////////////////////////////////////////////////////
-
-#define BOOST_TEST_DYN_LINK 1
-#define BOOST_TEST_MODULE "Boost Bloom Filter" 1
-
-#include <boost/bloom_filter/dynamic_counting_bloom_filter.hpp>
-#include <boost/test/unit_test.hpp>
-#include <boost/test/floating_point_comparison.hpp>
-
-#include <boost/bloom_filter/detail/exceptions.hpp>
-
-#include <boost/cstdint.hpp>
-
-using boost::bloom_filters::dynamic_counting_bloom_filter;
-using boost::bloom_filters::detail::bin_underflow_exception;
-using boost::bloom_filters::detail::bin_overflow_exception;
-using boost::bloom_filters::detail::incompatible_size_exception;
-using boost::bloom_filters::boost_hash;
-
-BOOST_AUTO_TEST_CASE(allBitsPerBinCompile)
-{
-  dynamic_counting_bloom_filter<size_t, 1> bloom1;
-  dynamic_counting_bloom_filter<size_t, 2> bloom2;
-  dynamic_counting_bloom_filter<size_t, 4> bloom4;
-  dynamic_counting_bloom_filter<size_t, 8> bloom8;
-  dynamic_counting_bloom_filter<size_t, 16> bloom16;
-  dynamic_counting_bloom_filter<size_t, 32> bloom32;
-}
-
-BOOST_AUTO_TEST_CASE(allReasonableBlockTypesCompile)
-{
-  typedef boost::mpl::vector<boost_hash<int, 0> > default_hash;
-
-  dynamic_counting_bloom_filter<int, 2, default_hash, unsigned char> a;
-  dynamic_counting_bloom_filter<int, 2, default_hash, unsigned short> b;
-  dynamic_counting_bloom_filter<int, 2, default_hash, unsigned int> c;
-  dynamic_counting_bloom_filter<int, 2, default_hash, unsigned long> d;
-  dynamic_counting_bloom_filter<int, 2, default_hash, size_t> e;
-
-  dynamic_counting_bloom_filter<int, 2, default_hash, uint8_t> aa;
-  dynamic_counting_bloom_filter<int, 2, default_hash, uint16_t> ab;
-  dynamic_counting_bloom_filter<int, 2, default_hash, uint32_t> ac;
-  dynamic_counting_bloom_filter<int, 2, default_hash, uintmax_t> ad;
-}
-
-BOOST_AUTO_TEST_CASE(defaultConstructor) {
-  typedef boost::mpl::vector<
-    boost_hash<int, 13>,
-    boost_hash<int, 17>,
-    boost_hash<int, 19> > BoostHashFunctions;
-  
-  dynamic_counting_bloom_filter<int, 2> bloom1;
-  dynamic_counting_bloom_filter<int, 2, BoostHashFunctions> bloom2;
-  dynamic_counting_bloom_filter<int, 2, 
-				BoostHashFunctions, 
-				unsigned char> bloom3;
-  dynamic_counting_bloom_filter<int, 2, 
-				BoostHashFunctions, 
-				unsigned char,
-				std::allocator<unsigned char> > bloom4;
-}
-
-BOOST_AUTO_TEST_CASE(countSingle)
-{
-  dynamic_counting_bloom_filter<int> bloom(2);
-  
-  bloom.insert(1);
-  BOOST_CHECK_EQUAL(bloom.count(), 1ul);
-  bloom.remove(1);
-  BOOST_CHECK_EQUAL(bloom.count(), 0ul);
-}
-
-BOOST_AUTO_TEST_CASE(countMulti)
-{
-  dynamic_counting_bloom_filter<int> bloom_default(100);
-  dynamic_counting_bloom_filter<int, 1> bloom1(100);
-  dynamic_counting_bloom_filter<int, 2> bloom2(100);
-  dynamic_counting_bloom_filter<int, 8> bloom8(100);
-  dynamic_counting_bloom_filter<int, 16> bloom16(100);
-  dynamic_counting_bloom_filter<int, 32> bloom32(100);
-
-  for (size_t i = 0; i < 100; ++i) {
-    bloom_default.insert(i);
-    bloom1.insert(i);
-    bloom2.insert(i);
-    bloom8.insert(i);
-    bloom16.insert(i);
-    bloom32.insert(i);
-  }
-
-  BOOST_CHECK_EQUAL(bloom_default.count(), 100ul);
-  BOOST_CHECK_EQUAL(bloom1.count(), 100ul);
-  BOOST_CHECK_EQUAL(bloom2.count(), 100ul);
-  BOOST_CHECK_EQUAL(bloom8.count(), 100ul);
-  BOOST_CHECK_EQUAL(bloom16.count(), 100ul);
-  BOOST_CHECK_EQUAL(bloom32.count(), 100ul);
-
-  for (size_t i = 0; i < 100; ++i) {
-    bloom_default.insert(i);
-    bloom2.insert(i);
-    bloom8.insert(i);
-    bloom16.insert(i);
-    bloom32.insert(i);
-  }
-
-  BOOST_CHECK_EQUAL(bloom_default.count(), 100ul);
-  BOOST_CHECK_EQUAL(bloom2.count(), 100ul);
-  BOOST_CHECK_EQUAL(bloom8.count(), 100ul);
-  BOOST_CHECK_EQUAL(bloom16.count(), 100ul);
-  BOOST_CHECK_EQUAL(bloom32.count(), 100ul);
-
-  for (size_t i = 0; i < 100; ++i) {
-    bloom_default.remove(i);
-    bloom2.remove(i);
-    bloom8.remove(i);
-    bloom16.remove(i);
-    bloom32.remove(i);
-  }
-
-  BOOST_CHECK_EQUAL(bloom_default.count(), 100ul);
-  BOOST_CHECK_EQUAL(bloom2.count(), 100ul);
-  BOOST_CHECK_EQUAL(bloom8.count(), 100ul);
-  BOOST_CHECK_EQUAL(bloom16.count(), 100ul);
-  BOOST_CHECK_EQUAL(bloom32.count(), 100ul);
-
-  for (size_t i = 0; i < 100; ++i) {
-    bloom_default.remove(i);
-    bloom1.remove(i);
-    bloom2.remove(i);
-    bloom8.remove(i);
-    bloom16.remove(i);
-    bloom32.remove(i);
-  }
-
-  BOOST_CHECK_EQUAL(bloom_default.count(), 0ul);
-  BOOST_CHECK_EQUAL(bloom1.count(), 0ul);
-  BOOST_CHECK_EQUAL(bloom2.count(), 0ul);
-  BOOST_CHECK_EQUAL(bloom8.count(), 0ul);
-  BOOST_CHECK_EQUAL(bloom16.count(), 0ul);
-  BOOST_CHECK_EQUAL(bloom32.count(), 0ul);
-}
-
-BOOST_AUTO_TEST_CASE(rangeConstructor) {
-  int elems[5] = {1,2,3,4,5};
-  dynamic_counting_bloom_filter<int> bloom(elems, elems+5);
-
-  BOOST_CHECK_EQUAL(bloom.count(), 5ul);
-}
-
-BOOST_AUTO_TEST_CASE(copyConstructor) {
-  int elems[5] = {1,2,3,4,5};
-  dynamic_counting_bloom_filter<int, 2> bloom1(elems, elems+5);
-  dynamic_counting_bloom_filter<int, 2> bloom2(bloom1);
-
-  BOOST_CHECK_EQUAL(bloom1.count(), bloom2.count());
-}
-
-BOOST_AUTO_TEST_CASE(assignment)
-{
-  dynamic_counting_bloom_filter<int> bloom1(200);
-  dynamic_counting_bloom_filter<int> bloom2(200);
-
-  for (size_t i = 0; i < 200; ++i) {
-    bloom1.insert(i);
-    BOOST_CHECK_EQUAL(bloom1.probably_contains(i), true);
-  }
-
-  bloom2 = bloom1;
-
-  for (size_t i = 0; i < 200; ++i) {
-    BOOST_CHECK_EQUAL(bloom2.probably_contains(i), true);
-  }
-}
-
-BOOST_AUTO_TEST_CASE(bit_capacity) {
-  dynamic_counting_bloom_filter<size_t> bloom_8(8);
-  dynamic_counting_bloom_filter<size_t> bloom_256(256);
-  dynamic_counting_bloom_filter<size_t> bloom_2048(2048);
-  
-  BOOST_CHECK_EQUAL(bloom_8.bit_capacity(), 
-		    8ul * bloom_8.bits_per_bin());
-  BOOST_CHECK_EQUAL(bloom_256.bit_capacity(), 
-		    256ul * bloom_256.bits_per_bin());
-  BOOST_CHECK_EQUAL(bloom_2048.bit_capacity(), 
-		    2048ul * bloom_2048.bits_per_bin());
-}
-
-BOOST_AUTO_TEST_CASE(empty) {
-  dynamic_counting_bloom_filter<size_t> bloom(2);
-  
-  BOOST_CHECK_EQUAL(bloom.empty(), true);
-  bloom.insert(1);
-  BOOST_CHECK_EQUAL(bloom.empty(), false);
-  bloom.clear();
-  BOOST_CHECK_EQUAL(bloom.empty(), true);
-}
-
-BOOST_AUTO_TEST_CASE(numHashFunctions) {
-  dynamic_counting_bloom_filter<size_t> bloom_1;
-  dynamic_counting_bloom_filter<size_t, 1, boost::mpl::vector<
-    boost_hash<size_t, 1>,
-    boost_hash<size_t, 2> > > bloom_2;
-  dynamic_counting_bloom_filter<size_t, 1, boost::mpl::vector<
-    boost_hash<size_t, 1>,
-    boost_hash<size_t, 2>,
-    boost_hash<size_t, 3>,
-    boost_hash<size_t, 4>,
-    boost_hash<size_t, 5>,
-    boost_hash<size_t, 6>,
-    boost_hash<size_t, 7> > > bloom_7;
-
-  BOOST_CHECK_EQUAL(bloom_1.num_hash_functions(), 1ul);
-  BOOST_CHECK_EQUAL(bloom_2.num_hash_functions(), 2ul);
-  BOOST_CHECK_EQUAL(bloom_7.num_hash_functions(), 7ul);
-}
-
-BOOST_AUTO_TEST_CASE(falsePositiveRate) {
-  dynamic_counting_bloom_filter<size_t> bloom(64);
-
-  BOOST_CHECK_EQUAL(bloom.false_positive_rate(), 0.0);
-
-  bloom.insert(1);
-  BOOST_CHECK_CLOSE(bloom.false_positive_rate(), 0.015504, .01);
-
-  bloom.insert(2);
-  BOOST_CHECK_CLOSE(bloom.false_positive_rate(), 0.030768, .01);
-
-  bloom.insert(3);
-  BOOST_CHECK_CLOSE(bloom.false_positive_rate(), 0.045794, .01);
-
-  bloom.insert(4);
-  BOOST_CHECK_CLOSE(bloom.false_positive_rate(), 0.060588, .01);
-
-  bloom.insert(5);
-  BOOST_CHECK_CLOSE(bloom.false_positive_rate(), 0.075151, .01);
-
-  bloom.insert(6);
-  BOOST_CHECK_CLOSE(bloom.false_positive_rate(), 0.089491, .01);
-
-  for (size_t i = 7; i < 128; ++i)
-    bloom.insert(i);
-  
-  BOOST_CHECK_GE(bloom.false_positive_rate(), 0.6);
-  BOOST_CHECK_LE(bloom.false_positive_rate(), 1.0);
-}
-
-BOOST_AUTO_TEST_CASE(probably_contains) {
-  dynamic_counting_bloom_filter<size_t> bloom(2);
-
-  bloom.insert(1);
-  BOOST_CHECK_EQUAL(bloom.probably_contains(1), true);
-  BOOST_CHECK_EQUAL(bloom.count(), 1ul);
-}
-
-BOOST_AUTO_TEST_CASE(doesNotContain) {
-  dynamic_counting_bloom_filter<size_t> bloom(2);
-
-  BOOST_CHECK_EQUAL(bloom.probably_contains(1), false);
-}
-
-BOOST_AUTO_TEST_CASE(insertNoFalseNegatives) {
-  dynamic_counting_bloom_filter<size_t> bloom(100);
-
-  for (size_t i = 0; i < 100; ++i) {
-    bloom.insert(i);
-    BOOST_CHECK_EQUAL(bloom.probably_contains(i), true);
-  }
-}
-
-BOOST_AUTO_TEST_CASE(insertOverflowExceptionThrown) {
-  dynamic_counting_bloom_filter<size_t, 1> bloom(2);
-  bool exception_occurred = false;
-
-  bloom.insert(1);
-  BOOST_CHECK_EQUAL(bloom.probably_contains(1), true);
-
-  try {
-    bloom.insert(1);
-  }
-
-  catch (bin_overflow_exception e) {
-    exception_occurred = true;
-  }
-
-  BOOST_CHECK_EQUAL(exception_occurred, true);
-  BOOST_CHECK_EQUAL(bloom.probably_contains(1), true);
-}
-
-BOOST_AUTO_TEST_CASE(removeUnderflowExceptionThrown) {
-  dynamic_counting_bloom_filter<size_t, 1> bloom(2);
-  bool exception_occurred = false;
-
-  try {
-    bloom.remove(1);
-  }
-
-  catch (bin_underflow_exception e) {
-    exception_occurred = true;
-  }
-
-  BOOST_CHECK_EQUAL(exception_occurred, true);
-  BOOST_CHECK_EQUAL(bloom.probably_contains(1), false);
-}
-
-BOOST_AUTO_TEST_CASE(insertOverflowException4bit)
-{
-  dynamic_counting_bloom_filter<size_t> bloom(8);
-  bool exception_occurred = false;
-
-  try {
-    for (size_t i = 0; i < (1ul << bloom.bits_per_bin()); ++i)
-      bloom.insert(1);
-  }
-
-  catch (bin_overflow_exception e) {
-    exception_occurred = true;
-  }
-
-  BOOST_CHECK_EQUAL(exception_occurred, true);
-  BOOST_CHECK_EQUAL(bloom.probably_contains(1), true);
-}
-
-BOOST_AUTO_TEST_CASE(incompatibleSizeExceptionThrown_equality)
-{
-  dynamic_counting_bloom_filter<int> bloom1(1);
-  dynamic_counting_bloom_filter<int> bloom2(2);
-  bool exception_thrown = false;
-
-  try {
-    if (bloom1 == bloom2)
-      exception_thrown = false;
-  }
-
-  catch (incompatible_size_exception e) {
-    exception_thrown = true;
-  }
-
-  BOOST_CHECK_EQUAL(exception_thrown, true);
-}
-
-BOOST_AUTO_TEST_CASE(incompatibleSizeExceptionThrown_inequality)
-{
-  dynamic_counting_bloom_filter<int> bloom1(1);
-  dynamic_counting_bloom_filter<int> bloom2(2);
-  bool exception_thrown = false;
-
-  try {
-    if (bloom1 != bloom2)
-      exception_thrown = false;
-  }
-
-  catch (incompatible_size_exception e) {
-    exception_thrown = true;
-  }
-
-  BOOST_CHECK_EQUAL(exception_thrown, true);
-}
-
-BOOST_AUTO_TEST_CASE(incompatibleSizeExceptionThrown_union)
-{
-  dynamic_counting_bloom_filter<int> bloom1(1);
-  dynamic_counting_bloom_filter<int> bloom2(2);
-  dynamic_counting_bloom_filter<int> bloom_result;
-  bool exception_thrown = false;
-
-  try {
-    bloom_result = experimental_union(bloom1, bloom2);
-  }
-
-  catch (incompatible_size_exception e) {
-    exception_thrown = true;
-  }
-
-  BOOST_CHECK_EQUAL(exception_thrown, true);
-}
-
-BOOST_AUTO_TEST_CASE(incompatibleSizeExceptionThrown_intersect)
-{
-  dynamic_counting_bloom_filter<int> bloom1(1);
-  dynamic_counting_bloom_filter<int> bloom2(2);
-  dynamic_counting_bloom_filter<int> bloom_result;
-  bool exception_thrown = false;
-
-  try {
-    bloom_result = experimental_intersect(bloom1, bloom2);
-  }
-
-  catch (incompatible_size_exception e) {
-    exception_thrown = true;
-  }
-
-  BOOST_CHECK_EQUAL(exception_thrown, true);
-}
-
-BOOST_AUTO_TEST_CASE(incompatibleSizeExceptionThrown_unionAssign)
-{
-  dynamic_counting_bloom_filter<int> bloom1(1);
-  dynamic_counting_bloom_filter<int> bloom2(2);
-  bool exception_thrown = false;
-
-  try {
-    bloom1.experimental_union_assign(bloom2);
-  }
-
-  catch (incompatible_size_exception e) {
-    exception_thrown = true;
-  }
-
-  BOOST_CHECK_EQUAL(exception_thrown, true);
-}
-
-BOOST_AUTO_TEST_CASE(incompatibleSizeExceptionThrown_intersectAssign)
-{
-  dynamic_counting_bloom_filter<int> bloom1(1);
-  dynamic_counting_bloom_filter<int> bloom2(2);
-  bool exception_thrown = false;
-
-  try {
-    bloom1.experimental_intersect_assign(bloom2);
-  }
-
-  catch (incompatible_size_exception e) {
-    exception_thrown = true;
-  }
-
-  BOOST_CHECK_EQUAL(exception_thrown, true);
-}
-
-BOOST_AUTO_TEST_CASE(rangeInsert) {
-  int elems[5] = {1,2,3,4,5};
-  dynamic_counting_bloom_filter<size_t> bloom(5);
-
-  bloom.insert(elems, elems+5);
-  BOOST_CHECK_EQUAL(bloom.count(), 5ul);
-}
-
-BOOST_AUTO_TEST_CASE(_remove) {
-  dynamic_counting_bloom_filter<size_t> bloom(1);
-  
-  bloom.insert(1);
-  bloom.remove(1);
-  BOOST_CHECK_EQUAL(bloom.count(), 0ul);
-}
-
-BOOST_AUTO_TEST_CASE(removeMulti) {
-  dynamic_counting_bloom_filter<size_t> bloom(100);
-
-  for (size_t i = 0; i < 100; ++i) {
-    bloom.insert(i);
-    bloom.remove(i);
-    BOOST_CHECK_EQUAL(bloom.count(), 0ul);
-  }
-}
-
-BOOST_AUTO_TEST_CASE(rangeRemove) {
-  size_t arr[] = {1,2,3,4,5};
-  dynamic_counting_bloom_filter<size_t> bloom(5);
-
-  bloom.insert(arr, arr+5);
-  bloom.remove(arr, arr+5);
-  BOOST_CHECK_EQUAL(bloom.count(), 0ul);
-}
-
-BOOST_AUTO_TEST_CASE(clear) {
-  dynamic_counting_bloom_filter<size_t> bloom(100);
-
-  for (size_t i = 0; i < 100; ++i)
-    bloom.insert(i);
-
-  bloom.clear();
-  BOOST_CHECK_EQUAL(bloom.probably_contains(1), false);
-  BOOST_CHECK_EQUAL(bloom.count(), 0ul);
-}
-
-struct SwapFixture {
-  SwapFixture() 
-    : bloom1(5), bloom2(5)
-  {
-    for (size_t i = 0; i < 5; ++i)
-      elems[i] = i+1;
-    
-    bloom1.insert(elems, elems+2);
-    bloom2.insert(elems+2, elems+5);
-  }
-
-  size_t elems[5];
-  dynamic_counting_bloom_filter<size_t> bloom1;
-  dynamic_counting_bloom_filter<size_t> bloom2;
-};
-
-BOOST_FIXTURE_TEST_CASE(memberSwap, SwapFixture) {
-  bloom1.swap(bloom2);
-
-  BOOST_CHECK_EQUAL(bloom1.count(), 3ul);
-  BOOST_CHECK_EQUAL(bloom2.count(), 2ul);
-}
-
-BOOST_FIXTURE_TEST_CASE(globalSwap, SwapFixture) {
-  swap(bloom1, bloom2);
-
-  BOOST_CHECK_EQUAL(bloom1.count(), 3ul);
-  BOOST_CHECK_EQUAL(bloom2.count(), 2ul);
-}
-
-struct PairwiseOpsFixture {
-
-  PairwiseOpsFixture() 
-    : bloom1(300), bloom2(300), bloom_result(300)
-  {}
-
-  dynamic_counting_bloom_filter<size_t> bloom1;
-  dynamic_counting_bloom_filter<size_t> bloom2;
-  dynamic_counting_bloom_filter<size_t> bloom_result;
-};
-
-BOOST_AUTO_TEST_CASE(testUnion) {
-  dynamic_counting_bloom_filter<size_t, 2> bloom1(4);
-  dynamic_counting_bloom_filter<size_t, 2> bloom2(4);
-  dynamic_counting_bloom_filter<size_t, 2> bloom_union(4);
-
-  bloom1.insert(0);
-  bloom1.insert(1);
-  bloom1.insert(1);
-  bloom1.insert(3);
-  bloom1.insert(3);
-
-  bloom2.insert(0);
-  bloom2.insert(0);
-  bloom2.insert(1);
-  bloom2.insert(1);
-  bloom2.insert(1);
-  bloom2.insert(3);
-  bloom2.insert(3);
-
-  bloom_union = experimental_union(bloom1, bloom2);
-
-  BOOST_CHECK_EQUAL(bloom_union.probably_contains(0), true);
-  BOOST_CHECK_EQUAL(bloom_union.probably_contains(1), true);
-  BOOST_CHECK_EQUAL(bloom_union.probably_contains(2), false);
-  BOOST_CHECK_EQUAL(bloom_union.probably_contains(3), true);
-  BOOST_CHECK_GE(bloom_union.count(), bloom1.count());
-  BOOST_CHECK_GE(bloom_union.count(), bloom2.count());
-}
-
-BOOST_AUTO_TEST_CASE(testUnionAssign) {
-  dynamic_counting_bloom_filter<size_t, 2> bloom1(4);
-  dynamic_counting_bloom_filter<size_t, 2> bloom_union(4);
-
-  bloom1.insert(0);
-  bloom1.insert(1);
-  bloom1.insert(1);
-
-  bloom_union.insert(1);
-  bloom_union.insert(3);
-  bloom_union.insert(3);
-
-  bloom_union.experimental_union_assign(bloom1);
-
-  BOOST_CHECK_EQUAL(bloom_union.probably_contains(0), true);
-  BOOST_CHECK_EQUAL(bloom_union.probably_contains(1), true);
-  BOOST_CHECK_EQUAL(bloom_union.probably_contains(2), false);
-  BOOST_CHECK_EQUAL(bloom_union.probably_contains(3), true);
-  BOOST_CHECK_EQUAL(bloom_union.count(), 3ul);
-}
-
-BOOST_AUTO_TEST_CASE(testIntersect) {
-  dynamic_counting_bloom_filter<size_t, 2> bloom1(4);
-  dynamic_counting_bloom_filter<size_t, 2> bloom2(4);
-  dynamic_counting_bloom_filter<size_t, 2> bloom_intersect(4);
-
-  bloom1.insert(0);
-  bloom1.insert(1);
-  bloom1.insert(3);
-  bloom1.insert(3);
-
-  bloom2.insert(0);
-  bloom2.insert(0);
-  bloom2.insert(1);
-  bloom2.insert(1);
-  bloom2.insert(3);
-  bloom2.insert(3);
-
-  bloom_intersect = experimental_intersect(bloom1, bloom2);
-
-  BOOST_CHECK_EQUAL(bloom_intersect.probably_contains(0), false);
-  BOOST_CHECK_EQUAL(bloom_intersect.probably_contains(1), false);
-  BOOST_CHECK_EQUAL(bloom_intersect.probably_contains(2), false);
-  BOOST_CHECK_EQUAL(bloom_intersect.probably_contains(3), true);
-  BOOST_CHECK_LE(bloom_intersect.count(), bloom1.count());
-  BOOST_CHECK_LE(bloom_intersect.count(), bloom2.count());
-}
-
-BOOST_AUTO_TEST_CASE(testIntersectAssign) {
-  dynamic_counting_bloom_filter<size_t, 2> bloom1(4);
-  dynamic_counting_bloom_filter<size_t, 2> bloom_intersect(4);
-
-  bloom1.insert(0);
-  bloom1.insert(1);
-  bloom1.insert(3);
-
-  bloom1.insert(0);
-  bloom1.insert(0);
-  bloom_intersect.insert(1);
-  bloom_intersect.insert(3);
-  bloom_intersect.insert(3);
-  bloom_intersect.insert(3);
-
-  bloom_intersect.experimental_intersect_assign(bloom1);
-
-  BOOST_CHECK_EQUAL(bloom_intersect.probably_contains(0), false);
-  BOOST_CHECK_EQUAL(bloom_intersect.probably_contains(1), true);
-  BOOST_CHECK_EQUAL(bloom_intersect.probably_contains(2), false);
-  BOOST_CHECK_EQUAL(bloom_intersect.probably_contains(3), true);
-  BOOST_CHECK_EQUAL(bloom_intersect.count(), 2ul);
-}
-
-BOOST_FIXTURE_TEST_CASE(equalityOperator, PairwiseOpsFixture) {
-  BOOST_CHECK_EQUAL(bloom1 == bloom2, true);
-  bloom1.insert(1);
-  BOOST_CHECK_EQUAL(bloom1 == bloom2, false);
-  bloom2.insert(1);
-  BOOST_CHECK_EQUAL(bloom1 == bloom2, true);
-}
-
-BOOST_FIXTURE_TEST_CASE(inequalityOperator, PairwiseOpsFixture) {
-  BOOST_CHECK_EQUAL(bloom1 != bloom2, false);
-  bloom1.insert(1);
-  BOOST_CHECK_EQUAL(bloom1 != bloom2, true);
-  bloom2.insert(1);
-  BOOST_CHECK_EQUAL(bloom1 != bloom2, false);
-}

Copied: sandbox/bloom_filter/trunk/libs/bloom_filter/test/dynamic_counting_bloom_filter-pass.cpp (from r73661, /sandbox/bloom_filter/trunk/libs/bloom_filter/test/dynamic_counting_bloom-pass.cpp)
==============================================================================
--- /sandbox/bloom_filter/trunk/libs/bloom_filter/test/dynamic_counting_bloom-pass.cpp	(original)
+++ sandbox/bloom_filter/trunk/libs/bloom_filter/test/dynamic_counting_bloom_filter-pass.cpp	2011-08-13 01:10:24 EDT (Sat, 13 Aug 2011)
@@ -366,76 +366,6 @@
   BOOST_CHECK_EQUAL(exception_thrown, true);
 }
 
-BOOST_AUTO_TEST_CASE(incompatibleSizeExceptionThrown_union)
-{
-  dynamic_counting_bloom_filter<int> bloom1(1);
-  dynamic_counting_bloom_filter<int> bloom2(2);
-  dynamic_counting_bloom_filter<int> bloom_result;
-  bool exception_thrown = false;
-
-  try {
-    bloom_result = experimental_union(bloom1, bloom2);
-  }
-
-  catch (incompatible_size_exception e) {
-    exception_thrown = true;
-  }
-
-  BOOST_CHECK_EQUAL(exception_thrown, true);
-}
-
-BOOST_AUTO_TEST_CASE(incompatibleSizeExceptionThrown_intersect)
-{
-  dynamic_counting_bloom_filter<int> bloom1(1);
-  dynamic_counting_bloom_filter<int> bloom2(2);
-  dynamic_counting_bloom_filter<int> bloom_result;
-  bool exception_thrown = false;
-
-  try {
-    bloom_result = experimental_intersect(bloom1, bloom2);
-  }
-
-  catch (incompatible_size_exception e) {
-    exception_thrown = true;
-  }
-
-  BOOST_CHECK_EQUAL(exception_thrown, true);
-}
-
-BOOST_AUTO_TEST_CASE(incompatibleSizeExceptionThrown_unionAssign)
-{
-  dynamic_counting_bloom_filter<int> bloom1(1);
-  dynamic_counting_bloom_filter<int> bloom2(2);
-  bool exception_thrown = false;
-
-  try {
-    bloom1.experimental_union_assign(bloom2);
-  }
-
-  catch (incompatible_size_exception e) {
-    exception_thrown = true;
-  }
-
-  BOOST_CHECK_EQUAL(exception_thrown, true);
-}
-
-BOOST_AUTO_TEST_CASE(incompatibleSizeExceptionThrown_intersectAssign)
-{
-  dynamic_counting_bloom_filter<int> bloom1(1);
-  dynamic_counting_bloom_filter<int> bloom2(2);
-  bool exception_thrown = false;
-
-  try {
-    bloom1.experimental_intersect_assign(bloom2);
-  }
-
-  catch (incompatible_size_exception e) {
-    exception_thrown = true;
-  }
-
-  BOOST_CHECK_EQUAL(exception_thrown, true);
-}
-
 BOOST_AUTO_TEST_CASE(rangeInsert) {
   int elems[5] = {1,2,3,4,5};
   dynamic_counting_bloom_filter<size_t> bloom(5);
@@ -523,107 +453,6 @@
   dynamic_counting_bloom_filter<size_t> bloom_result;
 };
 
-BOOST_AUTO_TEST_CASE(testUnion) {
-  dynamic_counting_bloom_filter<size_t, 2> bloom1(4);
-  dynamic_counting_bloom_filter<size_t, 2> bloom2(4);
-  dynamic_counting_bloom_filter<size_t, 2> bloom_union(4);
-
-  bloom1.insert(0);
-  bloom1.insert(1);
-  bloom1.insert(1);
-  bloom1.insert(3);
-  bloom1.insert(3);
-
-  bloom2.insert(0);
-  bloom2.insert(0);
-  bloom2.insert(1);
-  bloom2.insert(1);
-  bloom2.insert(1);
-  bloom2.insert(3);
-  bloom2.insert(3);
-
-  bloom_union = experimental_union(bloom1, bloom2);
-
-  BOOST_CHECK_EQUAL(bloom_union.probably_contains(0), true);
-  BOOST_CHECK_EQUAL(bloom_union.probably_contains(1), true);
-  BOOST_CHECK_EQUAL(bloom_union.probably_contains(2), false);
-  BOOST_CHECK_EQUAL(bloom_union.probably_contains(3), true);
-  BOOST_CHECK_GE(bloom_union.count(), bloom1.count());
-  BOOST_CHECK_GE(bloom_union.count(), bloom2.count());
-}
-
-BOOST_AUTO_TEST_CASE(testUnionAssign) {
-  dynamic_counting_bloom_filter<size_t, 2> bloom1(4);
-  dynamic_counting_bloom_filter<size_t, 2> bloom_union(4);
-
-  bloom1.insert(0);
-  bloom1.insert(1);
-  bloom1.insert(1);
-
-  bloom_union.insert(1);
-  bloom_union.insert(3);
-  bloom_union.insert(3);
-
-  bloom_union.experimental_union_assign(bloom1);
-
-  BOOST_CHECK_EQUAL(bloom_union.probably_contains(0), true);
-  BOOST_CHECK_EQUAL(bloom_union.probably_contains(1), true);
-  BOOST_CHECK_EQUAL(bloom_union.probably_contains(2), false);
-  BOOST_CHECK_EQUAL(bloom_union.probably_contains(3), true);
-  BOOST_CHECK_EQUAL(bloom_union.count(), 3ul);
-}
-
-BOOST_AUTO_TEST_CASE(testIntersect) {
-  dynamic_counting_bloom_filter<size_t, 2> bloom1(4);
-  dynamic_counting_bloom_filter<size_t, 2> bloom2(4);
-  dynamic_counting_bloom_filter<size_t, 2> bloom_intersect(4);
-
-  bloom1.insert(0);
-  bloom1.insert(1);
-  bloom1.insert(3);
-  bloom1.insert(3);
-
-  bloom2.insert(0);
-  bloom2.insert(0);
-  bloom2.insert(1);
-  bloom2.insert(1);
-  bloom2.insert(3);
-  bloom2.insert(3);
-
-  bloom_intersect = experimental_intersect(bloom1, bloom2);
-
-  BOOST_CHECK_EQUAL(bloom_intersect.probably_contains(0), false);
-  BOOST_CHECK_EQUAL(bloom_intersect.probably_contains(1), false);
-  BOOST_CHECK_EQUAL(bloom_intersect.probably_contains(2), false);
-  BOOST_CHECK_EQUAL(bloom_intersect.probably_contains(3), true);
-  BOOST_CHECK_LE(bloom_intersect.count(), bloom1.count());
-  BOOST_CHECK_LE(bloom_intersect.count(), bloom2.count());
-}
-
-BOOST_AUTO_TEST_CASE(testIntersectAssign) {
-  dynamic_counting_bloom_filter<size_t, 2> bloom1(4);
-  dynamic_counting_bloom_filter<size_t, 2> bloom_intersect(4);
-
-  bloom1.insert(0);
-  bloom1.insert(1);
-  bloom1.insert(3);
-
-  bloom1.insert(0);
-  bloom1.insert(0);
-  bloom_intersect.insert(1);
-  bloom_intersect.insert(3);
-  bloom_intersect.insert(3);
-  bloom_intersect.insert(3);
-
-  bloom_intersect.experimental_intersect_assign(bloom1);
-
-  BOOST_CHECK_EQUAL(bloom_intersect.probably_contains(0), false);
-  BOOST_CHECK_EQUAL(bloom_intersect.probably_contains(1), true);
-  BOOST_CHECK_EQUAL(bloom_intersect.probably_contains(2), false);
-  BOOST_CHECK_EQUAL(bloom_intersect.probably_contains(3), true);
-  BOOST_CHECK_EQUAL(bloom_intersect.count(), 2ul);
-}
-
 BOOST_FIXTURE_TEST_CASE(equalityOperator, PairwiseOpsFixture) {
   BOOST_CHECK_EQUAL(bloom1 == bloom2, true);
   bloom1.insert(1);

Added: sandbox/bloom_filter/trunk/libs/bloom_filter/test/twohash_dynamic_counting_bloom_filter-pass.cpp
==============================================================================
--- (empty file)
+++ sandbox/bloom_filter/trunk/libs/bloom_filter/test/twohash_dynamic_counting_bloom_filter-pass.cpp	2011-08-13 01:10:24 EDT (Sat, 13 Aug 2011)
@@ -0,0 +1,423 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Alejandro Cabrera 2011.
+// Distributed under the Boost
+// Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or
+// copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/bloom_filter for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#define BOOST_TEST_DYN_LINK 1
+#define BOOST_TEST_MODULE "Boost Bloom Filter" 1
+
+#include <boost/bloom_filter/twohash_dynamic_counting_bloom_filter.hpp>
+#include <boost/test/unit_test.hpp>
+#include <boost/test/floating_point_comparison.hpp>
+
+#include <boost/bloom_filter/detail/exceptions.hpp>
+
+#include <boost/cstdint.hpp>
+
+using boost::bloom_filters::twohash_dynamic_counting_bloom_filter;
+using boost::bloom_filters::detail::bin_underflow_exception;
+using boost::bloom_filters::detail::bin_overflow_exception;
+using boost::bloom_filters::detail::incompatible_size_exception;
+using boost::bloom_filters::boost_hash;
+using boost::bloom_filters::murmurhash3;
+using boost::bloom_filters::detail::zero;
+
+BOOST_AUTO_TEST_CASE(allBitsPerBinCompile)
+{
+  twohash_dynamic_counting_bloom_filter<size_t, 1> bloom1;
+  twohash_dynamic_counting_bloom_filter<size_t, 2> bloom2;
+  twohash_dynamic_counting_bloom_filter<size_t, 4> bloom4;
+  twohash_dynamic_counting_bloom_filter<size_t, 8> bloom8;
+  twohash_dynamic_counting_bloom_filter<size_t, 16> bloom16;
+  twohash_dynamic_counting_bloom_filter<size_t, 32> bloom32;
+}
+
+BOOST_AUTO_TEST_CASE(allReasonableBlockTypesCompile)
+{
+  twohash_dynamic_counting_bloom_filter<int, 2, 4, 0, 
+				boost_hash<int, 0>, murmurhash3<int>, 
+				zero, unsigned char> a;
+  twohash_dynamic_counting_bloom_filter<int, 2, 4, 0, 
+				boost_hash<int, 0>, murmurhash3<int>, 
+				zero, unsigned short> b;
+  twohash_dynamic_counting_bloom_filter<int, 2, 4, 0, 
+				boost_hash<int, 0>, murmurhash3<int>, 
+				zero, unsigned int> c;
+  twohash_dynamic_counting_bloom_filter<int, 2, 4, 0, 
+				boost_hash<int, 0>, murmurhash3<int>, 
+				zero, unsigned long> d;
+  twohash_dynamic_counting_bloom_filter<int, 2, 4, 0, 
+				boost_hash<int, 0>, murmurhash3<int>, 
+				zero, size_t> e;
+
+  twohash_dynamic_counting_bloom_filter<int, 2, 4, 0, 
+				boost_hash<int, 0>, murmurhash3<int>, 
+				zero, uint8_t> aa;
+  twohash_dynamic_counting_bloom_filter<int, 2, 4, 0, 
+				boost_hash<int, 0>, murmurhash3<int>, 
+				zero, uint16_t> ab;
+  twohash_dynamic_counting_bloom_filter<int, 2, 4, 0, 
+				boost_hash<int, 0>, murmurhash3<int>, 
+				zero, uint32_t> ac;
+  twohash_dynamic_counting_bloom_filter<int, 2, 4, 0, 
+				boost_hash<int, 0>, murmurhash3<int>, 
+				zero, uintmax_t> ad;
+}
+
+BOOST_AUTO_TEST_CASE(defaultConstructor) {
+  twohash_dynamic_counting_bloom_filter<int> bloom_default;
+  twohash_dynamic_counting_bloom_filter<int, 1> bloom_1bit_per_bin;
+  twohash_dynamic_counting_bloom_filter<int, 2, 1, 
+				9> bloom_9expected_insertions;
+  twohash_dynamic_counting_bloom_filter<int, 2, 1, 9,
+				boost_hash<int, 0> > bloom_remixed_hash;
+  twohash_dynamic_counting_bloom_filter<int, 2, 1, 9,
+				boost_hash<int, 0>, 
+				murmurhash3<int> > bloom_very_remixed_hash;
+  twohash_dynamic_counting_bloom_filter<int, 2, 1, 9,
+				boost_hash<int, 0>, 
+				murmurhash3<int>,
+				zero> bloom_very_reconfigured;  
+  twohash_dynamic_counting_bloom_filter<int, 2, 1, 9,
+				boost_hash<int, 0>, 
+				murmurhash3<int>,
+				zero, uint8_t> bloom_fully_reconfigured;  
+}
+
+BOOST_AUTO_TEST_CASE(countSingle)
+{
+  twohash_dynamic_counting_bloom_filter<int, 4, 1> bloom;
+  
+  bloom.insert(1);
+  BOOST_CHECK_EQUAL(bloom.count(), 1ul);
+  bloom.remove(1);
+  BOOST_CHECK_EQUAL(bloom.count(), 0ul);
+}
+
+BOOST_AUTO_TEST_CASE(countMulti)
+{
+  twohash_dynamic_counting_bloom_filter<int, 4, 1> bloom_default(400);
+  twohash_dynamic_counting_bloom_filter<int, 1, 1> bloom1(400);
+  twohash_dynamic_counting_bloom_filter<int, 2, 1> bloom2(400);
+  twohash_dynamic_counting_bloom_filter<int, 4, 1> bloom4(400);
+  twohash_dynamic_counting_bloom_filter<int, 8, 1> bloom8(400);
+  twohash_dynamic_counting_bloom_filter<int, 16, 1> bloom16(400);
+  twohash_dynamic_counting_bloom_filter<int, 32, 1> bloom32(400);
+
+  for (size_t i = 0; i < 100; ++i) {
+    bloom_default.insert(i);
+    bloom1.insert(i);
+    bloom2.insert(i);
+    bloom4.insert(i);
+    bloom8.insert(i);
+    bloom16.insert(i);
+    bloom32.insert(i);
+  }
+
+  BOOST_CHECK_EQUAL(bloom_default.count(), 100ul);
+  BOOST_CHECK_EQUAL(bloom1.count(), 100ul);
+  BOOST_CHECK_EQUAL(bloom2.count(), 100ul);
+  BOOST_CHECK_EQUAL(bloom4.count(), 100ul);
+  BOOST_CHECK_EQUAL(bloom8.count(), 100ul);
+  BOOST_CHECK_EQUAL(bloom16.count(), 100ul);
+  BOOST_CHECK_EQUAL(bloom32.count(), 100ul);
+
+  for (size_t i = 0; i < 100; ++i) {
+    bloom_default.insert(i);
+    bloom2.insert(i);
+    bloom4.insert(i);
+    bloom8.insert(i);
+    bloom16.insert(i);
+    bloom32.insert(i);
+  }
+
+  BOOST_CHECK_EQUAL(bloom_default.count(), 100ul);
+  BOOST_CHECK_EQUAL(bloom2.count(), 100ul);
+  BOOST_CHECK_EQUAL(bloom4.count(), 100ul);
+  BOOST_CHECK_EQUAL(bloom8.count(), 100ul);
+  BOOST_CHECK_EQUAL(bloom16.count(), 100ul);
+  BOOST_CHECK_EQUAL(bloom32.count(), 100ul);
+
+  for (size_t i = 0; i < 100; ++i) {
+    bloom_default.remove(i);
+    bloom2.remove(i);
+    bloom4.remove(i);
+    bloom8.remove(i);
+    bloom16.remove(i);
+    bloom32.remove(i);
+  }
+
+  BOOST_CHECK_EQUAL(bloom_default.count(), 100ul);
+  BOOST_CHECK_EQUAL(bloom2.count(), 100ul);
+  BOOST_CHECK_EQUAL(bloom4.count(), 100ul);
+  BOOST_CHECK_EQUAL(bloom8.count(), 100ul);
+  BOOST_CHECK_EQUAL(bloom16.count(), 100ul);
+  BOOST_CHECK_EQUAL(bloom32.count(), 100ul);
+
+  for (size_t i = 0; i < 100; ++i) {
+    bloom_default.remove(i);
+    bloom1.remove(i);
+    bloom2.remove(i);
+    bloom4.remove(i);
+    bloom8.remove(i);
+    bloom16.remove(i);
+    bloom32.remove(i);
+  }
+
+  BOOST_CHECK_EQUAL(bloom_default.count(), 0ul);
+  BOOST_CHECK_EQUAL(bloom1.count(), 0ul);
+  BOOST_CHECK_EQUAL(bloom2.count(), 0ul);
+  BOOST_CHECK_EQUAL(bloom4.count(), 0ul);
+  BOOST_CHECK_EQUAL(bloom8.count(), 0ul);
+  BOOST_CHECK_EQUAL(bloom16.count(), 0ul);
+  BOOST_CHECK_EQUAL(bloom32.count(), 0ul);
+}
+
+BOOST_AUTO_TEST_CASE(rangeConstructor) {
+  int elems[5] = {1,2,3,4,5};
+  twohash_dynamic_counting_bloom_filter<int, 4, 1> bloom(elems, elems+5);
+
+  BOOST_CHECK_EQUAL(bloom.count(), 5ul);
+}
+
+BOOST_AUTO_TEST_CASE(copyConstructor) {
+  int elems[5] = {1,2,3,4,5};
+  twohash_dynamic_counting_bloom_filter<int> bloom1(elems, elems+5);
+  twohash_dynamic_counting_bloom_filter<int> bloom2(bloom1);
+
+  BOOST_CHECK_EQUAL(bloom1.count(), bloom2.count());
+}
+
+BOOST_AUTO_TEST_CASE(assignment)
+{
+  twohash_dynamic_counting_bloom_filter<int> bloom1(200);
+  twohash_dynamic_counting_bloom_filter<int> bloom2(200);
+
+  for (size_t i = 0; i < 200; ++i) {
+    bloom1.insert(i);
+    BOOST_CHECK_EQUAL(bloom1.probably_contains(i), true);
+  }
+
+  bloom2 = bloom1;
+
+  for (size_t i = 0; i < 200; ++i) {
+    BOOST_CHECK_EQUAL(bloom2.probably_contains(i), true);
+  }
+}
+
+BOOST_AUTO_TEST_CASE(bit_capacity) {
+  twohash_dynamic_counting_bloom_filter<size_t> bloom_8(8);
+  twohash_dynamic_counting_bloom_filter<size_t> bloom_256(256);
+  twohash_dynamic_counting_bloom_filter<size_t> bloom_2048(2048);
+  
+  BOOST_CHECK_EQUAL(bloom_8.bit_capacity(), 
+		    8ul * bloom_8.bits_per_bin());
+  BOOST_CHECK_EQUAL(bloom_256.bit_capacity(), 
+		    256ul * bloom_256.bits_per_bin());
+  BOOST_CHECK_EQUAL(bloom_2048.bit_capacity(), 
+		    2048ul * bloom_2048.bits_per_bin());
+}
+
+BOOST_AUTO_TEST_CASE(empty) {
+  twohash_dynamic_counting_bloom_filter<size_t> bloom;
+  
+  BOOST_CHECK_EQUAL(bloom.empty(), true);
+  bloom.insert(1);
+  BOOST_CHECK_EQUAL(bloom.empty(), false);
+  bloom.clear();
+  BOOST_CHECK_EQUAL(bloom.empty(), true);
+}
+
+BOOST_AUTO_TEST_CASE(numHashFunctions) {
+  twohash_dynamic_counting_bloom_filter<int, 2> bloom_2h;
+  twohash_dynamic_counting_bloom_filter<int, 2, 1> bloom_1h;
+  twohash_dynamic_counting_bloom_filter<int, 2, 7> bloom_7h;
+
+  BOOST_CHECK_EQUAL(bloom_1h.num_hash_functions(), 1ul);
+  BOOST_CHECK_EQUAL(bloom_2h.num_hash_functions(), 2ul);
+  BOOST_CHECK_EQUAL(bloom_7h.num_hash_functions(), 7ul);
+}
+
+BOOST_AUTO_TEST_CASE(probably_contains) {
+  twohash_dynamic_counting_bloom_filter<size_t, 4, 1> bloom;
+
+  bloom.insert(1);
+  BOOST_CHECK_EQUAL(bloom.probably_contains(1), true);
+  BOOST_CHECK_EQUAL(bloom.count(), 1ul);
+}
+
+BOOST_AUTO_TEST_CASE(doesNotContain) {
+  twohash_dynamic_counting_bloom_filter<size_t> bloom;
+
+  BOOST_CHECK_EQUAL(bloom.probably_contains(1), false);
+}
+
+BOOST_AUTO_TEST_CASE(insertNoFalseNegatives) {
+  twohash_dynamic_counting_bloom_filter<size_t> bloom(100);
+
+  for (size_t i = 0; i < 100; ++i) {
+    bloom.insert(i);
+    BOOST_CHECK_EQUAL(bloom.probably_contains(i), true);
+  }
+}
+
+BOOST_AUTO_TEST_CASE(insertOverflowExceptionThrown) {
+  twohash_dynamic_counting_bloom_filter<size_t, 1> bloom;
+  bool exception_occurred = false;
+
+  bloom.insert(1);
+  BOOST_CHECK_EQUAL(bloom.probably_contains(1), true);
+
+  try {
+    bloom.insert(1);
+  }
+
+  catch (bin_overflow_exception e) {
+    exception_occurred = true;
+  }
+
+  BOOST_CHECK_EQUAL(exception_occurred, true);
+  BOOST_CHECK_EQUAL(bloom.probably_contains(1), true);
+}
+
+BOOST_AUTO_TEST_CASE(removeUnderflowExceptionThrown) {
+  twohash_dynamic_counting_bloom_filter<size_t, 1> bloom;
+  bool exception_occurred = false;
+
+  try {
+    bloom.remove(1);
+  }
+
+  catch (bin_underflow_exception e) {
+    exception_occurred = true;
+  }
+
+  BOOST_CHECK_EQUAL(exception_occurred, true);
+  BOOST_CHECK_EQUAL(bloom.probably_contains(1), false);
+}
+
+BOOST_AUTO_TEST_CASE(insertOverflowException4bit)
+{
+  twohash_dynamic_counting_bloom_filter<size_t, 4> bloom;
+  bool exception_occurred = false;
+
+  try {
+    for (size_t i = 0; i < (1ul << bloom.bits_per_bin()); ++i)
+      bloom.insert(1);
+  }
+
+  catch (bin_overflow_exception e) {
+    exception_occurred = true;
+  }
+
+  BOOST_CHECK_EQUAL(exception_occurred, true);
+  BOOST_CHECK_EQUAL(bloom.probably_contains(1), true);
+}
+
+BOOST_AUTO_TEST_CASE(rangeInsert) {
+  int elems[5] = {1,2,3,4,5};
+  twohash_dynamic_counting_bloom_filter<size_t> bloom(10);
+
+  bloom.insert(elems, elems+5);
+  BOOST_CHECK_EQUAL(bloom.count(), 5ul);
+}
+
+BOOST_AUTO_TEST_CASE(_remove) {
+  twohash_dynamic_counting_bloom_filter<size_t> bloom;
+  
+  bloom.insert(1);
+  bloom.remove(1);
+  BOOST_CHECK_EQUAL(bloom.count(), 0ul);
+}
+
+BOOST_AUTO_TEST_CASE(removeMulti) {
+  twohash_dynamic_counting_bloom_filter<size_t> bloom(100);
+
+  for (size_t i = 0; i < 100; ++i) {
+    bloom.insert(i);
+    bloom.remove(i);
+    BOOST_CHECK_EQUAL(bloom.count(), 0ul);
+  }
+}
+
+BOOST_AUTO_TEST_CASE(rangeRemove) {
+  size_t arr[] = {1,2,3,4,5};
+  twohash_dynamic_counting_bloom_filter<size_t> bloom;
+
+  bloom.insert(arr, arr+5);
+  bloom.remove(arr, arr+5);
+  BOOST_CHECK_EQUAL(bloom.count(), 0ul);
+}
+
+BOOST_AUTO_TEST_CASE(clear) {
+  twohash_dynamic_counting_bloom_filter<size_t> bloom(1000);
+
+  for (size_t i = 0; i < 1000; ++i)
+    bloom.insert(i);
+
+  bloom.clear();
+  BOOST_CHECK_EQUAL(bloom.probably_contains(1), false);
+  BOOST_CHECK_EQUAL(bloom.count(), 0ul);
+}
+
+struct SwapFixture {
+  SwapFixture() 
+    : bloom1(5), bloom2(5)
+  {
+    for (size_t i = 0; i < 5; ++i)
+      elems[i] = i+1;
+    
+    bloom1.insert(elems, elems+2);
+    bloom2.insert(elems+2, elems+5);
+  }
+
+  size_t elems[5];
+  twohash_dynamic_counting_bloom_filter<size_t, 4, 1> bloom1;
+  twohash_dynamic_counting_bloom_filter<size_t, 4, 1> bloom2;
+};
+
+BOOST_FIXTURE_TEST_CASE(memberSwap, SwapFixture) {
+  bloom1.swap(bloom2);
+
+  BOOST_CHECK_EQUAL(bloom1.count(), 3ul);
+  BOOST_CHECK_EQUAL(bloom2.count(), 2ul);
+}
+
+BOOST_FIXTURE_TEST_CASE(globalSwap, SwapFixture) {
+  swap(bloom1, bloom2);
+
+  BOOST_CHECK_EQUAL(bloom1.count(), 3ul);
+  BOOST_CHECK_EQUAL(bloom2.count(), 2ul);
+}
+
+struct PairwiseOpsFixture {
+
+  PairwiseOpsFixture() {}    
+
+  twohash_dynamic_counting_bloom_filter<size_t> bloom1;
+  twohash_dynamic_counting_bloom_filter<size_t> bloom2;
+  twohash_dynamic_counting_bloom_filter<size_t> bloom_result;
+};
+
+BOOST_FIXTURE_TEST_CASE(equalityOperator, PairwiseOpsFixture) {
+  BOOST_CHECK_EQUAL(bloom1 == bloom2, true);
+  bloom1.insert(1);
+  BOOST_CHECK_EQUAL(bloom1 == bloom2, false);
+  bloom2.insert(1);
+  BOOST_CHECK_EQUAL(bloom1 == bloom2, true);
+}
+
+BOOST_FIXTURE_TEST_CASE(inequalityOperator, PairwiseOpsFixture) {
+  BOOST_CHECK_EQUAL(bloom1 != bloom2, false);
+  bloom1.insert(1);
+  BOOST_CHECK_EQUAL(bloom1 != bloom2, true);
+  bloom2.insert(1);
+  BOOST_CHECK_EQUAL(bloom1 != bloom2, false);
+}