diff --git a/test/helpers/fwd.hpp b/test/helpers/fwd.hpp
index cc04ad85..0f56b80d 100644
--- a/test/helpers/fwd.hpp
+++ b/test/helpers/fwd.hpp
@@ -15,8 +15,6 @@ namespace test
     signed char generate(signed char const*);
     std::string generate(std::string*);
     float generate(float const*);
-    template <class T1, class T2>
-    std::pair<T1, T2> generate(std::pair<T1, T2>*);
 
     struct base_type {} base;
     struct derived_type : base_type {} derived;
diff --git a/test/helpers/generators.hpp b/test/helpers/generators.hpp
index a4442b4e..a85628b5 100644
--- a/test/helpers/generators.hpp
+++ b/test/helpers/generators.hpp
@@ -16,7 +16,6 @@
 #include <stdexcept>
 #include <cstdlib>
 #include <boost/type_traits/add_const.hpp>
-
 #include "./fwd.hpp"
 
 namespace test
@@ -27,29 +26,6 @@ namespace test
             srand(x);
         }
     };
-    
-    template <class T>
-    struct generator;
-
-    template <class T1, class T2> std::pair<T1, T2> generate(
-            std::pair<T1, T2> const*)
-    {
-        static generator<T1> g1;
-        static generator<T2> g2;
-
-        return std::pair<T1, T2>(g1(), g2());
-    }
-
-    template <class T>
-    struct generator
-    {
-        typedef T value_type;
-        typedef BOOST_DEDUCED_TYPENAME boost::add_const<T>::type const_value_type;
-        value_type operator()() const
-        {
-            return generate((const_value_type*) 0);
-        }
-    };
 
     inline int generate(int const*)
     {
@@ -73,13 +49,13 @@ namespace test
     {
         using namespace std;
 
-        static test::generator<char> char_gen;
+        char* char_ptr = 0;
 
         std::string result;
 
         int length = rand() % 10;
         for(int i = 0; i < length; ++i)
-            result += char_gen();
+            result += generate(char_ptr);
 
         return result;
     }
diff --git a/test/helpers/random_values.hpp b/test/helpers/random_values.hpp
index 62ac7f97..6f9b5d84 100644
--- a/test/helpers/random_values.hpp
+++ b/test/helpers/random_values.hpp
@@ -8,18 +8,102 @@
 
 #include <list>
 #include <algorithm>
+#include <boost/mpl/if.hpp>
 #include "./generators.hpp"
+#include "./metafunctions.hpp"
 
 namespace test
 {
+    typedef enum {
+        default_generator,
+        generate_collisions
+    } random_generator;
+
+    template <class X>
+    struct unordered_generator_set
+    {
+        typedef BOOST_DEDUCED_TYPENAME X::value_type value_type;
+
+        random_generator type_;
+
+        unordered_generator_set(random_generator type)
+            : type_(type) {}
+
+        template <class T>
+        void fill(T& x, std::size_t len) {
+            value_type* value_ptr = 0;
+            int* int_ptr = 0;
+
+            for(std::size_t i = 0; i < len; ++i) {
+                value_type value = generate(value_ptr);
+
+                for(int count =
+                    type_ == generate_collisions ?
+                    generate(int_ptr) % 10 : 1;
+                    count; --count) {
+                    x.push_back(value);
+                }
+            }
+        }
+    };
+
+    template <class X>
+    struct unordered_generator_map
+    {
+        typedef BOOST_DEDUCED_TYPENAME X::key_type key_type;
+        typedef BOOST_DEDUCED_TYPENAME X::mapped_type mapped_type;
+
+        random_generator type_;
+
+        unordered_generator_map(random_generator type)
+            : type_(type) {}
+
+        template <class T>
+        void fill(T& x, std::size_t len) {
+            key_type* key_ptr = 0;
+            mapped_type* mapped_ptr = 0;
+            int* int_ptr = 0;
+
+            for(std::size_t i = 0; i < len; ++i) {
+                key_type key = generate(key_ptr);
+
+                for(int count =
+                    type_ == generate_collisions ?
+                    generate(int_ptr) % 10 : 1;
+                    count; --count) {
+                    x.push_back(std::pair<key_type const, mapped_type>(key, generate(mapped_ptr)));
+                }
+            }
+        }
+    };
+
+    template <class X>
+    struct unordered_generator_base
+        : public boost::mpl::if_<
+            test::is_set<X>,
+            test::unordered_generator_set<X>,
+            test::unordered_generator_map<X> >
+    {
+    };
+
+    template <class X>
+    struct unordered_generator : public unordered_generator_base<X>::type
+    {
+        typedef BOOST_DEDUCED_TYPENAME unordered_generator_base<X>::type base;
+
+        unordered_generator(random_generator const& type = default_generator)
+            : base(type) {}
+    };
+
     template <class X>
     struct random_values
         : public std::list<BOOST_DEDUCED_TYPENAME X::value_type>
     {
-        random_values(int count) {
-            typedef BOOST_DEDUCED_TYPENAME X::value_type value_type;
-            static test::generator<value_type> gen;
-            std::generate_n(std::back_inserter(*this), count, gen);
+        random_values(int count, test::random_generator const& generator =
+			test::default_generator)
+        {
+            static test::unordered_generator<X> gen(generator);
+            gen.fill(*this, count);
         }
     };
 }
diff --git a/test/objects/exception.hpp b/test/objects/exception.hpp
index c9e4a030..803be4ae 100644
--- a/test/objects/exception.hpp
+++ b/test/objects/exception.hpp
@@ -32,6 +32,7 @@ namespace exception
     class hash;
     class equal_to;
     template <class T> class allocator;
+    object generate(object const*);
 
     class object
     {
diff --git a/test/objects/test.hpp b/test/objects/test.hpp
index 792d65a9..a81149d9 100644
--- a/test/objects/test.hpp
+++ b/test/objects/test.hpp
@@ -23,6 +23,7 @@ namespace test
     class less;
     class equal_to;
     template <class T> class allocator;
+    object generate(object const*);
 
     class object
     {
@@ -62,44 +63,6 @@ namespace test
         }
     };
 
-    // This object is usd to test how well the containers cope with equivalent keys.
-    class equivalent_object
-    {
-        friend class hash;
-        friend class equal_to;
-        friend class less;
-        int tag1_, tag2_;
-    public:
-        explicit equivalent_object(int t1 = 0, int t2 = 0) : tag1_(t1), tag2_(t2) {}
-
-        ~equivalent_object() {
-            tag1_ = -1;
-            tag2_ = -1;
-        }
-
-        friend bool operator==(equivalent_object const& x1, equivalent_object const& x2) {
-            return x1.tag1_ == x2.tag1_;
-        }
-
-        friend bool operator!=(equivalent_object const& x1, equivalent_object const& x2) {
-            return x1.tag1_ != x2.tag1_;
-        }
-
-        friend bool operator<(equivalent_object const& x1, equivalent_object const& x2) {
-            return x1.tag1_ < x2.tag1_;
-        }
-
-        friend equivalent_object generate(equivalent_object const*) {
-            signed char* x = 0;
-            return equivalent_object(generate(x), generate(x));
-        }
-
-        friend std::ostream& operator<<(std::ostream& out, equivalent_object const& o)
-        {
-            return out<<"("<<o.tag1_<<","<<o.tag2_<<")";
-        }
-    };
-
     class hash
     {
         int type_;
@@ -117,10 +80,6 @@ namespace test
             }
         }
 
-        std::size_t operator()(equivalent_object const& x) const {
-            return x.tag1_;
-        }
-
         std::size_t operator()(int x) const {
             return x;
         }
@@ -151,10 +110,6 @@ namespace test
             }
         }
 
-        bool operator()(equivalent_object const& x1, equivalent_object const& x2) const {
-            return x1 < x2;
-        }
-
         std::size_t operator()(int x1, int x2) const {
             return x1 < x2;
         }
@@ -181,10 +136,6 @@ namespace test
             }
         }
 
-        bool operator()(equivalent_object const& x1, equivalent_object const& x2) const {
-            return x1 == x2;
-        }
-
         std::size_t operator()(int x1, int x2) const {
             return x1 == x2;
         }
@@ -294,13 +245,6 @@ namespace test
         y = tmp;
     }
 
-    void swap(test::equivalent_object& x, test::equivalent_object& y) {
-        test::equivalent_object tmp;
-        tmp = x;
-        x = y;
-        y = tmp;
-    }
-
     void swap(test::hash& x, test::hash& y) {
         test::hash tmp;
         tmp = x;
diff --git a/test/unordered/assign_tests.cpp b/test/unordered/assign_tests.cpp
index cf4eb7a8..13a0a09d 100644
--- a/test/unordered/assign_tests.cpp
+++ b/test/unordered/assign_tests.cpp
@@ -16,7 +16,7 @@
 test::seed_t seed(96785);
 
 template <class T>
-void assign_tests1(T* = 0)
+void assign_tests1(T*, test::random_generator generator = test::default_generator)
 {
     BOOST_DEDUCED_TYPENAME T::hasher hf;
     BOOST_DEDUCED_TYPENAME T::key_equal eq;
@@ -32,7 +32,7 @@ void assign_tests1(T* = 0)
 
     std::cerr<<"assign_tests1.2\n";
     {
-        test::random_values<T> v(1000);
+        test::random_values<T> v(1000, generator);
         T x(v.begin(), v.end());
 
         test::ordered<T> tracker = test::create_ordered(x);
@@ -50,7 +50,7 @@ void assign_tests1(T* = 0)
 }
 
 template <class T>
-void assign_tests2(T* = 0)
+void assign_tests2(T*, test::random_generator generator = test::default_generator)
 {
     BOOST_DEDUCED_TYPENAME T::hasher hf1(1);
     BOOST_DEDUCED_TYPENAME T::hasher hf2(2);
@@ -61,7 +61,7 @@ void assign_tests2(T* = 0)
 
     std::cerr<<"assign_tests2.1\n";
     {
-        test::random_values<T> v(1000);
+        test::random_values<T> v(1000, generator);
         T x1(v.begin(), v.end(), 0, hf1, eq1);
         T x2(0, hf2, eq2);
         x2 = x1;
@@ -72,7 +72,7 @@ void assign_tests2(T* = 0)
 
     std::cerr<<"assign_tests2.2\n";
     {
-        test::random_values<T> v1(100), v2(100);
+        test::random_values<T> v1(100, generator), v2(100, generator);
         T x1(v1.begin(), v1.end(), 0, hf1, eq1, al1);
         T x2(v2.begin(), v2.end(), 0, hf2, eq2, al2);
         x2 = x1;
@@ -85,25 +85,30 @@ void assign_tests2(T* = 0)
 
 int main()
 {
-    assign_tests1((boost::unordered_set<int>*) 0);
-    assign_tests1((boost::unordered_multiset<int>*) 0);
-    assign_tests1((boost::unordered_map<int, int>*) 0);
-    assign_tests1((boost::unordered_multimap<int, int>*) 0);
+    boost::unordered_set<test::object, test::hash, test::equal_to, test::allocator<test::object> >* test_set;
+    boost::unordered_multiset<test::object, test::hash, test::equal_to, test::allocator<test::object> >* test_multiset;
+    boost::unordered_map<test::object, test::object, test::hash, test::equal_to, test::allocator<test::object> >* test_map;
+    boost::unordered_multimap<test::object, test::object, test::hash, test::equal_to, test::allocator<test::object> >* test_multimap;
 
-    assign_tests1((boost::unordered_set<test::object, test::hash, test::equal_to, test::allocator<test::object> >*) 0);
-    assign_tests1((boost::unordered_multiset<test::object, test::hash, test::equal_to, test::allocator<test::object> >*) 0);
-    assign_tests1((boost::unordered_map<test::object, test::object, test::hash, test::equal_to, test::allocator<test::object> >*) 0);
-    assign_tests1((boost::unordered_multimap<test::object, test::object, test::hash, test::equal_to, test::allocator<test::object> >*) 0);
+    assign_tests1(test_set);
+    assign_tests1(test_multiset);
+    assign_tests1(test_map);
+    assign_tests1(test_multimap);
 
-    assign_tests1((boost::unordered_set<test::equivalent_object, test::hash, test::equal_to, test::allocator<test::equivalent_object> >*) 0);
-    assign_tests1((boost::unordered_multiset<test::equivalent_object, test::hash, test::equal_to, test::allocator<test::equivalent_object> >*) 0);
-    assign_tests1((boost::unordered_map<test::equivalent_object, test::equivalent_object, test::hash, test::equal_to, test::allocator<test::equivalent_object> >*) 0);
-    assign_tests1((boost::unordered_multimap<test::equivalent_object, test::equivalent_object, test::hash, test::equal_to, test::allocator<test::equivalent_object> >*) 0);
+    assign_tests1(test_set, test::generate_collisions);
+    assign_tests1(test_multiset, test::generate_collisions);
+    assign_tests1(test_map, test::generate_collisions);
+    assign_tests1(test_multimap, test::generate_collisions);
 
-    assign_tests2((boost::unordered_set<test::object, test::hash, test::equal_to, test::allocator<test::object> >*) 0);
-    assign_tests2((boost::unordered_multiset<test::equivalent_object, test::hash, test::equal_to, test::allocator<test::equivalent_object> >*) 0);
-    assign_tests2((boost::unordered_map<test::equivalent_object, test::equivalent_object, test::hash, test::equal_to, test::allocator<test::equivalent_object> >*) 0);
-    assign_tests2((boost::unordered_multimap<test::object, test::object, test::hash, test::equal_to, test::allocator<test::object> >*) 0);
+    assign_tests2(test_set);
+    assign_tests2(test_multiset);
+    assign_tests2(test_map);
+    assign_tests2(test_multimap);
+
+    assign_tests2(test_set, test::generate_collisions);
+    assign_tests2(test_multiset, test::generate_collisions);
+    assign_tests2(test_map, test::generate_collisions);
+    assign_tests2(test_multimap, test::generate_collisions);
 
     return boost::report_errors();
 }
diff --git a/test/unordered/bucket_tests.cpp b/test/unordered/bucket_tests.cpp
index 3b285405..68e6560b 100644
--- a/test/unordered/bucket_tests.cpp
+++ b/test/unordered/bucket_tests.cpp
@@ -50,11 +50,6 @@ void bucket_tests(X* = 0)
 
 int main()
 {
-    bucket_tests((boost::unordered_set<int>*) 0);
-    bucket_tests((boost::unordered_multiset<int>*) 0);
-    bucket_tests((boost::unordered_map<int, int>*) 0);
-    bucket_tests((boost::unordered_multimap<int, int>*) 0);
-
     bucket_tests((boost::unordered_set<test::object, test::hash, test::equal_to, test::allocator<test::object> >*) 0);
     bucket_tests((boost::unordered_multiset<test::object, test::hash, test::equal_to, test::allocator<test::object> >*) 0);
     bucket_tests((boost::unordered_map<test::object, test::object, test::hash, test::equal_to, test::allocator<test::object> >*) 0);
diff --git a/test/unordered/constructor_tests.cpp b/test/unordered/constructor_tests.cpp
index 16f0089d..3bd39aa6 100644
--- a/test/unordered/constructor_tests.cpp
+++ b/test/unordered/constructor_tests.cpp
@@ -18,7 +18,7 @@
 test::seed_t seed(356730);
 
 template <class T>
-void constructor_tests1(T* = 0)
+void constructor_tests1(T*, test::random_generator generator = test::default_generator)
 {
     BOOST_DEDUCED_TYPENAME T::hasher hf;
     BOOST_DEDUCED_TYPENAME T::key_equal eq;
@@ -68,7 +68,7 @@ void constructor_tests1(T* = 0)
 
     std::cerr<<"Construct 5\n";
     {
-        test::random_values<T> v(1000);
+        test::random_values<T> v(1000, generator);
         T x(v.begin(), v.end(), 10000, hf, eq);
         BOOST_TEST(x.bucket_count() >= 10000);
         BOOST_TEST(test::equivalent(x.hash_function(), hf));
@@ -80,7 +80,7 @@ void constructor_tests1(T* = 0)
 
     std::cerr<<"Construct 6\n";
     {
-        test::random_values<T> v(10);
+        test::random_values<T> v(10, generator);
         T x(v.begin(), v.end(), 10000, hf);
         BOOST_TEST(x.bucket_count() >= 10000);
         BOOST_TEST(test::equivalent(x.hash_function(), hf));
@@ -92,7 +92,7 @@ void constructor_tests1(T* = 0)
 
     std::cerr<<"Construct 7\n";
     {
-        test::random_values<T> v(100);
+        test::random_values<T> v(100, generator);
         T x(v.begin(), v.end(), 100);
         BOOST_TEST(x.bucket_count() >= 100);
         BOOST_TEST(test::equivalent(x.hash_function(), hf));
@@ -104,7 +104,7 @@ void constructor_tests1(T* = 0)
 
     std::cerr<<"Construct 8\n";
     {
-        test::random_values<T> v(1);
+        test::random_values<T> v(1, generator);
         T x(v.begin(), v.end());
         BOOST_TEST(test::equivalent(x.hash_function(), hf));
         BOOST_TEST(test::equivalent(x.key_eq(), eq));
@@ -125,7 +125,7 @@ void constructor_tests1(T* = 0)
 
     std::cerr<<"Construct 10\n";
     {
-        test::random_values<T> v(1000);
+        test::random_values<T> v(1000, generator);
         T x(v.begin(), v.end(), 10000, hf, eq, al);
         BOOST_TEST(x.bucket_count() >= 10000);
         BOOST_TEST(test::equivalent(x.hash_function(), hf));
@@ -137,7 +137,7 @@ void constructor_tests1(T* = 0)
 }
 
 template <class T>
-void constructor_tests2(T* = 0)
+void constructor_tests2(T*, test::random_generator const& generator = test::default_generator)
 {
     BOOST_DEDUCED_TYPENAME T::hasher hf;
     BOOST_DEDUCED_TYPENAME T::hasher hf1(1);
@@ -172,7 +172,7 @@ void constructor_tests2(T* = 0)
 
     std::cerr<<"Construct 3\n";
     {
-        test::random_values<T> v(100);
+        test::random_values<T> v(100, generator);
         T x(v.begin(), v.end(), 0, hf1, eq1);
         BOOST_TEST(test::equivalent(x.hash_function(), hf1));
         BOOST_TEST(test::equivalent(x.key_eq(), eq1));
@@ -183,7 +183,7 @@ void constructor_tests2(T* = 0)
 
     std::cerr<<"Construct 4\n";
     {
-        test::random_values<T> v(5);
+        test::random_values<T> v(5, generator);
         T x(v.begin(), v.end(), 1000, hf1);
         BOOST_TEST(x.bucket_count() >= 1000);
         BOOST_TEST(test::equivalent(x.hash_function(), hf1));
@@ -196,7 +196,7 @@ void constructor_tests2(T* = 0)
 
     std::cerr<<"Construct 5\n";
     {
-        test::random_values<T> v(100);
+        test::random_values<T> v(100, generator);
         T x(v.begin(), v.end(), 0, hf, eq, al1);
         T y(x.begin(), x.end(), 0, hf1, eq1, al2);
         test::check_container(x, v);
@@ -207,7 +207,7 @@ void constructor_tests2(T* = 0)
 
     std::cerr<<"Construct 6\n";
     {
-        test::random_values<T> v(100);
+        test::random_values<T> v(100, generator);
         T x(v.begin(), v.end(), 0, hf1, eq1);
         T y(x.begin(), x.end(), 0, hf, eq);
         test::check_container(x, v);
@@ -218,7 +218,7 @@ void constructor_tests2(T* = 0)
 
     std::cerr<<"Construct 7\n";
     {
-        test::random_values<T> v(100);
+        test::random_values<T> v(100, generator);
         T x(v.begin(), v.end(), 0, hf1, eq1);
         T y(x.begin(), x.end(), 0, hf2, eq2);
         test::check_container(x, v);
@@ -229,7 +229,7 @@ void constructor_tests2(T* = 0)
 
     std::cerr<<"Construct 8 - from input iterator\n";
     {
-        test::random_values<T> v(100);
+        test::random_values<T> v(100, generator);
         T x(test::input_iterator(v.begin()), test::input_iterator(v.end()), 0, hf1, eq1);
         T y(test::input_iterator(x.begin()), test::input_iterator(x.end()), 0, hf2, eq2);
         test::check_container(x, v);
@@ -257,55 +257,51 @@ void map_constructor_test(T* = 0)
 
 int main()
 {
-    std::cerr<<"Test1 unordered_set<int>\n";
-    constructor_tests1((boost::unordered_set<int>*) 0);
-    std::cerr<<"Test1 unordered_multiset<int>\n";
-    constructor_tests1((boost::unordered_multiset<int>*) 0);
-    std::cerr<<"Test1 unordered_map<int, int>\n";
-    constructor_tests1((boost::unordered_map<int, int>*) 0);
-    std::cerr<<"Test1 unordered_multimap<int, int>\n";
-    constructor_tests1((boost::unordered_multimap<int, int>*) 0);
+    boost::unordered_set<test::object, test::hash, test::equal_to, test::allocator<test::object> >* test_set;
+    boost::unordered_multiset<test::object, test::hash, test::equal_to, test::allocator<test::object> >* test_multiset;
+    boost::unordered_map<test::object, test::object, test::hash, test::equal_to, test::allocator<test::object> >* test_map;
+    boost::unordered_multimap<test::object, test::object, test::hash, test::equal_to, test::allocator<test::object> >* test_multimap;
 
-    std::cerr<<"Test1 unordered_set<test::object>\n";
-    constructor_tests1((boost::unordered_set<test::object, test::hash, test::equal_to, test::allocator<test::object> >*) 0);
-    std::cerr<<"Test1 unordered_multiset<test::object>\n";
-    constructor_tests1((boost::unordered_multiset<test::object, test::hash, test::equal_to, test::allocator<test::object> >*) 0);
-    std::cerr<<"Test1 unordered_map<test::object, test::object>\n";
-    constructor_tests1((boost::unordered_map<test::object, test::object, test::hash, test::equal_to, test::allocator<test::object> >*) 0);
-    std::cerr<<"Test1 unordered_multimap<test::object, test::object>\n";
-    constructor_tests1((boost::unordered_multimap<test::object, test::object, test::hash, test::equal_to, test::allocator<test::object> >*) 0);
+    std::cerr<<"Test1 test_set\n";
+    constructor_tests1(test_set);
+    std::cerr<<"Test1 test_multiset\n";
+    constructor_tests1(test_multiset);
+    std::cerr<<"Test1 test_map\n";
+    constructor_tests1(test_map);
+    std::cerr<<"Test1 test_multimap\n";
+    constructor_tests1(test_multimap);
 
-    std::cerr<<"Test1 unordered_set<test::equivalent_object>\n";
-    constructor_tests1((boost::unordered_set<test::equivalent_object, test::hash, test::equal_to, test::allocator<test::equivalent_object> >*) 0);
-    std::cerr<<"Test1 unordered_multiset<test::equivalent_object>\n";
-    constructor_tests1((boost::unordered_multiset<test::equivalent_object, test::hash, test::equal_to, test::allocator<test::equivalent_object> >*) 0);
-    std::cerr<<"Test1 unordered_map<test::equivalent_object, test::equivalent_object>\n";
-    constructor_tests1((boost::unordered_map<test::equivalent_object, test::equivalent_object, test::hash, test::equal_to, test::allocator<test::equivalent_object> >*) 0);
-    std::cerr<<"Test1 unordered_multimap<test::equivalent_object, test::equivalent_object>\n";
-    constructor_tests1((boost::unordered_multimap<test::equivalent_object, test::equivalent_object, test::hash, test::equal_to, test::allocator<test::equivalent_object> >*) 0);
+    std::cerr<<"Test1 test_set, collisions\n";
+    constructor_tests1(test_set, test::generate_collisions);
+    std::cerr<<"Test1 test_multiset, collisions\n";
+    constructor_tests1(test_multiset, test::generate_collisions);
+    std::cerr<<"Test1 test_map, collisions\n";
+    constructor_tests1(test_map, test::generate_collisions);
+    std::cerr<<"Test1 test_multimap, collisions\n";
+    constructor_tests1(test_multimap, test::generate_collisions);
 
-    std::cerr<<"Test2 unordered_set<test::object>\n";
-    constructor_tests2((boost::unordered_set<test::object, test::hash, test::equal_to, test::allocator<test::object> >*) 0);
-    std::cerr<<"Test2 unordered_multiset<test::object>\n";
-    constructor_tests2((boost::unordered_multiset<test::object, test::hash, test::equal_to, test::allocator<test::object> >*) 0);
-    std::cerr<<"Test2 unordered_map<test::object, test::object>\n";
-    constructor_tests2((boost::unordered_map<test::object, test::object, test::hash, test::equal_to, test::allocator<test::object> >*) 0);
-    std::cerr<<"Test2 unordered_multimap<test::object, test::object>\n";
-    constructor_tests2((boost::unordered_multimap<test::object, test::object, test::hash, test::equal_to, test::allocator<test::object> >*) 0);
+    std::cerr<<"Test2 test_set\n";
+    constructor_tests2(test_set);
+    std::cerr<<"Test2 test_multiset\n";
+    constructor_tests2(test_multiset);
+    std::cerr<<"Test2 test_map\n";
+    constructor_tests2(test_map);
+    std::cerr<<"Test2 test_multimap\n";
+    constructor_tests2(test_multimap);
 
-    std::cerr<<"Test2 unordered_set<test::equivalent_object>\n";
-    constructor_tests2((boost::unordered_set<test::equivalent_object, test::hash, test::equal_to, test::allocator<test::equivalent_object> >*) 0);
-    std::cerr<<"Test2 unordered_multiset<test::equivalent_object>\n";
-    constructor_tests2((boost::unordered_multiset<test::equivalent_object, test::hash, test::equal_to, test::allocator<test::equivalent_object> >*) 0);
-    std::cerr<<"Test2 unordered_map<test::equivalent_object, test::equivalent_object>\n";
-    constructor_tests2((boost::unordered_map<test::equivalent_object, test::equivalent_object, test::hash, test::equal_to, test::allocator<test::equivalent_object> >*) 0);
-    std::cerr<<"Test2 unordered_multimap<test::equivalent_object, test::equivalent_object>\n";
-    constructor_tests2((boost::unordered_multimap<test::equivalent_object, test::equivalent_object, test::hash, test::equal_to, test::allocator<test::equivalent_object> >*) 0);
+    std::cerr<<"Test2 test_set, collisions\n";
+    constructor_tests2(test_set, test::generate_collisions);
+    std::cerr<<"Test2 test_multiset, collisions\n";
+    constructor_tests2(test_multiset, test::generate_collisions);
+    std::cerr<<"Test2 test_map, collisions\n";
+    constructor_tests2(test_map, test::generate_collisions);
+    std::cerr<<"Test2 test_multimap, collisions\n";
+    constructor_tests2(test_multimap, test::generate_collisions);
 
     std::cerr<<"Map Test unordered_map<test::object, test::object>\n";
-    map_constructor_test((boost::unordered_map<test::object, test::object, test::hash, test::equal_to, test::allocator<test::object> >*) 0);
+    map_constructor_test(test_map);
     std::cerr<<"Map Test unordered_multimap<test::object, test::object>\n";
-    map_constructor_test((boost::unordered_multimap<test::object, test::object, test::hash, test::equal_to, test::allocator<test::object> >*) 0);
+    map_constructor_test(test_multimap);
 
     return boost::report_errors();
 }
diff --git a/test/unordered/copy_tests.cpp b/test/unordered/copy_tests.cpp
index 8dc6f350..853fc7a3 100644
--- a/test/unordered/copy_tests.cpp
+++ b/test/unordered/copy_tests.cpp
@@ -15,7 +15,7 @@
 test::seed_t seed(9063);
 
 template <class T>
-void copy_construct_tests1(T* = 0)
+void copy_construct_tests1(T*, test::random_generator const& generator = test::default_generator)
 {
     BOOST_DEDUCED_TYPENAME T::hasher hf;
     BOOST_DEDUCED_TYPENAME T::key_equal eq;
@@ -60,7 +60,7 @@ void copy_construct_tests1(T* = 0)
 }
 
 template <class T>
-void copy_construct_tests2(T* ptr = 0)
+void copy_construct_tests2(T* ptr, test::random_generator const& generator = test::default_generator)
 {
     copy_construct_tests1(ptr);
 
@@ -92,20 +92,25 @@ void copy_construct_tests2(T* ptr = 0)
 
 int main()
 {
-    copy_construct_tests1((boost::unordered_set<int>*) 0);
-    copy_construct_tests1((boost::unordered_multiset<int>*) 0);
-    copy_construct_tests1((boost::unordered_map<int, int>*) 0);
-    copy_construct_tests1((boost::unordered_multimap<int, int>*) 0);
+    boost::unordered_set<test::object, test::hash, test::equal_to, test::allocator<test::object> >* test_set;
+    boost::unordered_multiset<test::object, test::hash, test::equal_to, test::allocator<test::object> >* test_multiset;
+    boost::unordered_map<test::object, test::object, test::hash, test::equal_to, test::allocator<test::object> >* test_map;
+    boost::unordered_multimap<test::object, test::object, test::hash, test::equal_to, test::allocator<test::object> >* test_multimap;
 
-    copy_construct_tests2((boost::unordered_set<test::object, test::hash, test::equal_to, test::allocator<test::object> >*) 0);
-    copy_construct_tests2((boost::unordered_multiset<test::object, test::hash, test::equal_to, test::allocator<test::object> >*) 0);
-    copy_construct_tests2((boost::unordered_map<test::object, test::object, test::hash, test::equal_to, test::allocator<test::object> >*) 0);
-    copy_construct_tests2((boost::unordered_multimap<test::object, test::object, test::hash, test::equal_to, test::allocator<test::object> >*) 0);
+    copy_construct_tests1(test_set);
+    copy_construct_tests1(test_multiset);
+    copy_construct_tests1(test_map);
+    copy_construct_tests1(test_multimap);
 
-    copy_construct_tests2((boost::unordered_set<test::equivalent_object, test::hash, test::equal_to, test::allocator<test::equivalent_object> >*) 0);
-    copy_construct_tests2((boost::unordered_multiset<test::equivalent_object, test::hash, test::equal_to, test::allocator<test::equivalent_object> >*) 0);
-    copy_construct_tests2((boost::unordered_map<test::equivalent_object, test::equivalent_object, test::hash, test::equal_to, test::allocator<test::equivalent_object> >*) 0);
-    copy_construct_tests2((boost::unordered_multimap<test::equivalent_object, test::equivalent_object, test::hash, test::equal_to, test::allocator<test::equivalent_object> >*) 0);
+    copy_construct_tests2(test_set);
+    copy_construct_tests2(test_multiset);
+    copy_construct_tests2(test_map);
+    copy_construct_tests2(test_multimap);
+
+    copy_construct_tests2(test_set, test::generate_collisions);
+    copy_construct_tests2(test_multiset, test::generate_collisions);
+    copy_construct_tests2(test_map, test::generate_collisions);
+    copy_construct_tests2(test_multimap, test::generate_collisions);
 
     return boost::report_errors();
 }
diff --git a/test/unordered/erase_tests.cpp b/test/unordered/erase_tests.cpp
index 7848a01d..95979370 100644
--- a/test/unordered/erase_tests.cpp
+++ b/test/unordered/erase_tests.cpp
@@ -18,11 +18,11 @@
 test::seed_t seed(85638);
 
 template <class Container>
-void erase_tests1(Container* = 0)
+void erase_tests1(Container*, test::random_generator generator = test::default_generator)
 {
     std::cerr<<"Erase by key.\n";
     {
-        test::random_values<Container> v(1000);
+        test::random_values<Container> v(1000, generator);
         Container x(v.begin(), v.end());
         for(BOOST_DEDUCED_TYPENAME test::random_values<Container>::iterator it = v.begin();
             it != v.end(); ++it)
@@ -38,7 +38,7 @@ void erase_tests1(Container* = 0)
 
     std::cerr<<"erase(begin()).\n";
     {
-        test::random_values<Container> v(1000);
+        test::random_values<Container> v(1000, generator);
         Container x(v.begin(), v.end());
         std::size_t size = x.size();
         while(size > 0 && !x.empty())
@@ -56,7 +56,7 @@ void erase_tests1(Container* = 0)
 
     std::cerr<<"erase(random position).\n";
     {
-        test::random_values<Container> v(1000);
+        test::random_values<Container> v(1000, generator);
         Container x(v.begin(), v.end());
         std::size_t size = x.size();
         while(size > 0 && !x.empty())
@@ -87,7 +87,7 @@ void erase_tests1(Container* = 0)
 
     std::cerr<<"erase(ranges).\n";
     {
-        test::random_values<Container> v(500);
+        test::random_values<Container> v(500, generator);
         Container x(v.begin(), v.end());
 
         std::size_t size = x.size();
@@ -109,42 +109,40 @@ void erase_tests1(Container* = 0)
 
     std::cerr<<"clear().\n";
     {
-        test::random_values<Container> v(500);
+        test::random_values<Container> v(500, generator);
         Container x(v.begin(), v.end());
         x.clear();
         BOOST_TEST(x.empty());
         BOOST_TEST(x.begin() == x.end());
     }
+
+    std::cerr<<"\n";
 }
 
 int main()
 {
-    std::cerr<<"Erase unordered_set<int>.\n";
-    erase_tests1((boost::unordered_set<int>*) 0);
-    std::cerr<<"\nErase unordered_multiset<int>.\n";
-    erase_tests1((boost::unordered_multiset<int>*) 0);
-    std::cerr<<"\nErase unordered_map<int>.\n";
-    erase_tests1((boost::unordered_map<int, int>*) 0);
-    std::cerr<<"\nErase unordered_multimap<int>.\n";
-    erase_tests1((boost::unordered_multimap<int, int>*) 0);
+    boost::unordered_set<test::object, test::hash, test::equal_to, test::allocator<test::object> >* test_set;
+    boost::unordered_multiset<test::object, test::hash, test::equal_to, test::allocator<test::object> >* test_multiset;
+    boost::unordered_map<test::object, test::object, test::hash, test::equal_to, test::allocator<test::object> >* test_map;
+    boost::unordered_multimap<test::object, test::object, test::hash, test::equal_to, test::allocator<test::object> >* test_multimap;
 
-    std::cerr<<"\nErase unordered_set<test::object,..>.\n";
-    erase_tests1((boost::unordered_set<test::object, test::hash, test::equal_to, test::allocator<test::object> >*) 0);
-    std::cerr<<"\nErase unordered_multiset<test::object,..>.\n";
-    erase_tests1((boost::unordered_multiset<test::object, test::hash, test::equal_to, test::allocator<test::object> >*) 0);
-    std::cerr<<"\nErase unordered_map<test::object,..>.\n";
-    erase_tests1((boost::unordered_map<test::object, test::object, test::hash, test::equal_to, test::allocator<test::object> >*) 0);
-    std::cerr<<"\nErase unordered_multimap<test::object,..>.\n";
-    erase_tests1((boost::unordered_multimap<test::object, test::object, test::hash, test::equal_to, test::allocator<test::object> >*) 0);
+    std::cerr<<"Erase test_set.\n";
+    erase_tests1(test_set);
+    std::cerr<<"Erase test_multiset.\n";
+    erase_tests1(test_multiset);
+    std::cerr<<"Erase test_map.\n";
+    erase_tests1(test_map);
+    std::cerr<<"Erase test_multimap.\n";
+    erase_tests1(test_multimap);
 
-    std::cerr<<"\nErase unordered_set<test::equivalent_object,..>.\n";
-    erase_tests1((boost::unordered_set<test::equivalent_object, test::hash, test::equal_to, test::allocator<test::equivalent_object> >*) 0);
-    std::cerr<<"\nErase unordered_multiset<test::equivalent_object,..>.\n";
-    erase_tests1((boost::unordered_multiset<test::equivalent_object, test::hash, test::equal_to, test::allocator<test::equivalent_object> >*) 0);
-    std::cerr<<"\nErase unordered_map<test::equivalent_object,..>.\n";
-    erase_tests1((boost::unordered_map<test::equivalent_object, test::equivalent_object, test::hash, test::equal_to, test::allocator<test::equivalent_object> >*) 0);
-    std::cerr<<"\nErase unordered_multimap<test::equivalent_object,..>.\n";
-    erase_tests1((boost::unordered_multimap<test::equivalent_object, test::equivalent_object, test::hash, test::equal_to, test::allocator<test::equivalent_object> >*) 0);
+    std::cerr<<"Erase test_set, collisions.\n";
+    erase_tests1(test_set, test::generate_collisions);
+    std::cerr<<"Erase test_multiset, collisions.\n";
+    erase_tests1(test_multiset, test::generate_collisions);
+    std::cerr<<"Erase test_map, collisions.\n";
+    erase_tests1(test_map, test::generate_collisions);
+    std::cerr<<"Erase test_multimap, collisions.\n";
+    erase_tests1(test_multimap, test::generate_collisions);
 
     return boost::report_errors();
 }
diff --git a/test/unordered/find_tests.cpp b/test/unordered/find_tests.cpp
index 9c799e17..501b5d64 100644
--- a/test/unordered/find_tests.cpp
+++ b/test/unordered/find_tests.cpp
@@ -14,12 +14,12 @@
 test::seed_t seed(78937);
 
 template <class X>
-void find_tests1(X*)
+void find_tests1(X*, test::random_generator generator = test::default_generator)
 {
     typedef BOOST_DEDUCED_TYPENAME X::iterator iterator;
 
     {
-        test::random_values<X> v(500);
+        test::random_values<X> v(500, generator);
         X x(v.begin(), v.end());
         X const& x_const = x;
         test::ordered<X> tracker = test::create_ordered(x);
@@ -46,7 +46,7 @@ void find_tests1(X*)
                     (BOOST_DEDUCED_TYPENAME test::non_const_value_type<X>::type*) 0);
         }
 
-        test::random_values<X> v2(500);
+        test::random_values<X> v2(500, generator);
         for(BOOST_DEDUCED_TYPENAME test::random_values<X>::const_iterator it2 =
                 v2.begin(); it2 != v2.end(); ++it2)
         {
@@ -65,7 +65,7 @@ void find_tests1(X*)
     {
         X x;
 
-        test::random_values<X> v2(5);
+        test::random_values<X> v2(5, generator);
         for(BOOST_DEDUCED_TYPENAME test::random_values<X>::const_iterator it3 =
                 v2.begin(); it3 != v2.end(); ++it3)
         {
@@ -80,20 +80,20 @@ void find_tests1(X*)
 
 int main()
 {
-    find_tests1((boost::unordered_set<int>*) 0);
-    find_tests1((boost::unordered_multiset<int>*) 0);
-    find_tests1((boost::unordered_map<int, int>*) 0);
-    find_tests1((boost::unordered_multimap<int, int>*) 0);
+    boost::unordered_set<test::object, test::hash, test::equal_to, test::allocator<test::object> >* test_set;
+    boost::unordered_multiset<test::object, test::hash, test::equal_to, test::allocator<test::object> >* test_multiset;
+    boost::unordered_map<test::object, test::object, test::hash, test::equal_to, test::allocator<test::object> >* test_map;
+    boost::unordered_multimap<test::object, test::object, test::hash, test::equal_to, test::allocator<test::object> >* test_multimap;
 
-    find_tests1((boost::unordered_set<test::object, test::hash, test::equal_to, test::allocator<test::object> >*) 0);
-    find_tests1((boost::unordered_multiset<test::object, test::hash, test::equal_to, test::allocator<test::object> >*) 0);
-    find_tests1((boost::unordered_map<test::object, test::object, test::hash, test::equal_to, test::allocator<test::object> >*) 0);
-    find_tests1((boost::unordered_multimap<test::object, test::object, test::hash, test::equal_to, test::allocator<test::object> >*) 0);
+    find_tests1(test_set);
+    find_tests1(test_multiset);
+    find_tests1(test_map);
+    find_tests1(test_multimap);
 
-    find_tests1((boost::unordered_set<test::equivalent_object, test::hash, test::equal_to, test::allocator<test::equivalent_object> >*) 0);
-    find_tests1((boost::unordered_multiset<test::equivalent_object, test::hash, test::equal_to, test::allocator<test::equivalent_object> >*) 0);
-    find_tests1((boost::unordered_map<test::equivalent_object, test::equivalent_object, test::hash, test::equal_to, test::allocator<test::equivalent_object> >*) 0);
-    find_tests1((boost::unordered_multimap<test::equivalent_object, test::equivalent_object, test::hash, test::equal_to, test::allocator<test::equivalent_object> >*) 0);
+    find_tests1(test_set, test::generate_collisions);
+    find_tests1(test_multiset, test::generate_collisions);
+    find_tests1(test_map, test::generate_collisions);
+    find_tests1(test_multimap, test::generate_collisions);
 
     return 0;
 }
diff --git a/test/unordered/insert_tests.cpp b/test/unordered/insert_tests.cpp
index d24445c1..2520209b 100644
--- a/test/unordered/insert_tests.cpp
+++ b/test/unordered/insert_tests.cpp
@@ -19,7 +19,7 @@
 test::seed_t seed(243432);
 
 template <class X>
-void unique_insert_tests1(X* = 0)
+void unique_insert_tests1(X*, test::random_generator generator = test::default_generator)
 {
     typedef BOOST_DEDUCED_TYPENAME X::iterator iterator;
     typedef test::ordered<X> ordered;
@@ -29,7 +29,7 @@ void unique_insert_tests1(X* = 0)
     X x;
     test::ordered<X> tracker = test::create_ordered(x);
 
-    test::random_values<X> v(1000);
+    test::random_values<X> v(1000, generator);
 
     for(BOOST_DEDUCED_TYPENAME test::random_values<X>::iterator it = v.begin();
             it != v.end(); ++it)
@@ -54,14 +54,14 @@ void unique_insert_tests1(X* = 0)
 }
 
 template <class X>
-void equivalent_insert_tests1(X* = 0)
+void equivalent_insert_tests1(X*, test::random_generator generator = test::default_generator)
 {
     std::cerr<<"insert(value) tests for containers with equivalent keys.\n";
 
     X x;
     test::ordered<X> tracker = test::create_ordered(x);
 
-    test::random_values<X> v(1000);
+    test::random_values<X> v(1000, generator);
     for(BOOST_DEDUCED_TYPENAME test::random_values<X>::iterator it = v.begin();
             it != v.end(); ++it)
     {
@@ -83,7 +83,7 @@ void equivalent_insert_tests1(X* = 0)
 }
 
 template <class X>
-void insert_tests2(X* = 0)
+void insert_tests2(X*, test::random_generator generator = test::default_generator)
 {
     typedef BOOST_DEDUCED_TYPENAME test::ordered<X> tracker_type;
     typedef BOOST_DEDUCED_TYPENAME X::iterator iterator;
@@ -96,7 +96,7 @@ void insert_tests2(X* = 0)
         X x;
         tracker_type tracker = test::create_ordered(x);
 
-        test::random_values<X> v(1000);
+        test::random_values<X> v(1000, generator);
         for(BOOST_DEDUCED_TYPENAME test::random_values<X>::iterator it = v.begin();
                 it != v.end(); ++it)
         {
@@ -122,7 +122,7 @@ void insert_tests2(X* = 0)
         X const& x_const = x;
         tracker_type tracker = test::create_ordered(x);
 
-        test::random_values<X> v(100);
+        test::random_values<X> v(100, generator);
         for(BOOST_DEDUCED_TYPENAME test::random_values<X>::iterator it = v.begin();
                 it != v.end(); ++it)
         {
@@ -148,7 +148,7 @@ void insert_tests2(X* = 0)
         const_iterator pos = x.begin();
         tracker_type tracker = test::create_ordered(x);
 
-        test::random_values<X> v(1000);
+        test::random_values<X> v(1000, generator);
         for(BOOST_DEDUCED_TYPENAME test::random_values<X>::iterator it = v.begin();
                 it != v.end(); ++it)
         {
@@ -173,7 +173,7 @@ void insert_tests2(X* = 0)
         X x;
         tracker_type tracker = test::create_ordered(x);
 
-        test::random_values<X> v(1000);
+        test::random_values<X> v(1000, generator);
         for(BOOST_DEDUCED_TYPENAME test::random_values<X>::iterator it = v.begin();
                 it != v.end(); ++it)
         {
@@ -196,7 +196,7 @@ void insert_tests2(X* = 0)
     {
         X x;
 
-        test::random_values<X> v(1000);
+        test::random_values<X> v(1000, generator);
         x.insert(v.begin(), v.end());
 
         test::check_container(x, v);
@@ -208,7 +208,7 @@ void insert_tests2(X* = 0)
     {
         X x;
 
-        test::random_values<X> v(1000);
+        test::random_values<X> v(1000, generator);
         x.insert(test::input_iterator(v.begin()), test::input_iterator(v.end()));
         test::check_container(x, v);
 
@@ -217,14 +217,14 @@ void insert_tests2(X* = 0)
 }
 
 template <class X>
-void map_tests(X* = 0)
+void map_tests(X*, test::random_generator generator = test::default_generator)
 {
     std::cerr<<"map tests.\n";
 
     X x;
     test::ordered<X> tracker = test::create_ordered(x);
 
-    test::random_values<X> v(1000);
+    test::random_values<X> v(1000, generator);
     for(BOOST_DEDUCED_TYPENAME test::random_values<X>::iterator it = v.begin();
             it != v.end(); ++it)
     {
@@ -244,12 +244,12 @@ void map_tests(X* = 0)
 }
 
 template <class X>
-void associative_insert_range_test(X* = 0)
+void associative_insert_range_test(X*, test::random_generator generator = test::default_generator)
 {
     std::cerr<<"associative_insert_range_test\n";
 
     typedef std::list<std::pair<BOOST_DEDUCED_TYPENAME X::key_type, BOOST_DEDUCED_TYPENAME X::mapped_type> > list;
-    test::random_values<X> v(1000);
+    test::random_values<X> v(1000, generator);
     list l;
     std::copy(v.begin(), v.end(), std::back_inserter(l));
 
@@ -260,42 +260,38 @@ void associative_insert_range_test(X* = 0)
 
 int main()
 {
-    unique_insert_tests1((boost::unordered_set<int>*) 0);
-    equivalent_insert_tests1((boost::unordered_multiset<int>*) 0);
-    unique_insert_tests1((boost::unordered_map<int, int>*) 0);
-    equivalent_insert_tests1((boost::unordered_multimap<int, int>*) 0);
+    boost::unordered_set<test::object, test::hash, test::equal_to, test::allocator<test::object> >* test_set;
+    boost::unordered_multiset<test::object, test::hash, test::equal_to, test::allocator<test::object> >* test_multiset;
+    boost::unordered_map<test::object, test::object, test::hash, test::equal_to, test::allocator<test::object> >* test_map;
+    boost::unordered_multimap<test::object, test::object, test::hash, test::equal_to, test::allocator<test::object> >* test_multimap;
 
-    unique_insert_tests1((boost::unordered_set<test::object, test::hash, test::equal_to, test::allocator<test::object> >*) 0);
-    equivalent_insert_tests1((boost::unordered_multiset<test::object, test::hash, test::equal_to, test::allocator<test::object> >*) 0);
-    unique_insert_tests1((boost::unordered_map<test::object, test::object, test::hash, test::equal_to, test::allocator<test::object> >*) 0);
-    equivalent_insert_tests1((boost::unordered_multimap<test::object, test::object, test::hash, test::equal_to, test::allocator<test::object> >*) 0);
+    unique_insert_tests1(test_set);
+    equivalent_insert_tests1(test_multiset);
+    unique_insert_tests1(test_map);
+    equivalent_insert_tests1(test_multimap);
 
-    unique_insert_tests1((boost::unordered_set<test::equivalent_object, test::hash, test::equal_to, test::allocator<test::equivalent_object> >*) 0);
-    equivalent_insert_tests1((boost::unordered_multiset<test::equivalent_object, test::hash, test::equal_to, test::allocator<test::equivalent_object> >*) 0);
-    unique_insert_tests1((boost::unordered_map<test::equivalent_object, test::equivalent_object, test::hash, test::equal_to, test::allocator<test::equivalent_object> >*) 0);
-    equivalent_insert_tests1((boost::unordered_multimap<test::equivalent_object, test::equivalent_object, test::hash, test::equal_to, test::allocator<test::equivalent_object> >*) 0);
+    unique_insert_tests1(test_set, test::generate_collisions);
+    equivalent_insert_tests1(test_multiset, test::generate_collisions);
+    unique_insert_tests1(test_map, test::generate_collisions);
+    equivalent_insert_tests1(test_multimap, test::generate_collisions);
 
-    insert_tests2((boost::unordered_set<int>*) 0);
-    insert_tests2((boost::unordered_multiset<int>*) 0);
-    insert_tests2((boost::unordered_map<int, int>*) 0);
-    insert_tests2((boost::unordered_multimap<int, int>*) 0);
+    insert_tests2(test_set);
+    insert_tests2(test_multiset);
+    insert_tests2(test_map);
+    insert_tests2(test_multimap);
 
-    insert_tests2((boost::unordered_set<test::object, test::hash, test::equal_to, test::allocator<test::object> >*) 0);
-    insert_tests2((boost::unordered_multiset<test::object, test::hash, test::equal_to, test::allocator<test::object> >*) 0);
-    insert_tests2((boost::unordered_map<test::object, test::object, test::hash, test::equal_to, test::allocator<test::object> >*) 0);
-    insert_tests2((boost::unordered_multimap<test::object, test::object, test::hash, test::equal_to, test::allocator<test::object> >*) 0);
+    insert_tests2(test_set, test::generate_collisions);
+    insert_tests2(test_multiset, test::generate_collisions);
+    insert_tests2(test_map, test::generate_collisions);
+    insert_tests2(test_multimap, test::generate_collisions);
 
-    insert_tests2((boost::unordered_set<test::equivalent_object, test::hash, test::equal_to, test::allocator<test::equivalent_object> >*) 0);
-    insert_tests2((boost::unordered_multiset<test::equivalent_object, test::hash, test::equal_to, test::allocator<test::equivalent_object> >*) 0);
-    insert_tests2((boost::unordered_map<test::equivalent_object, test::equivalent_object, test::hash, test::equal_to, test::allocator<test::equivalent_object> >*) 0);
-    insert_tests2((boost::unordered_multimap<test::equivalent_object, test::equivalent_object, test::hash, test::equal_to, test::allocator<test::equivalent_object> >*) 0);
+    map_tests(test_map);
+    map_tests(test_map, test::generate_collisions);
 
-    map_tests((boost::unordered_map<int, int>*) 0);
-    map_tests((boost::unordered_map<test::object, test::object, test::hash, test::equal_to, test::allocator<test::object> >*) 0);
-    map_tests((boost::unordered_map<test::equivalent_object, test::equivalent_object, test::hash, test::equal_to, test::allocator<test::equivalent_object> >*) 0);
+    associative_insert_range_test(test_map);
+    associative_insert_range_test(test_map, test::generate_collisions);
+    associative_insert_range_test(test_multimap);
+    associative_insert_range_test(test_multimap, test::generate_collisions);
 
-    associative_insert_range_test((boost::unordered_map<test::object, test::object, test::hash, test::equal_to, test::allocator<test::object> >*) 0);
-    associative_insert_range_test((boost::unordered_multimap<test::object, test::object, test::hash, test::equal_to, test::allocator<test::object> >*) 0);
-    associative_insert_range_test((boost::unordered_multimap<test::equivalent_object, test::equivalent_object, test::hash, test::equal_to, test::allocator<test::equivalent_object> >*) 0);
     return boost::report_errors();
 }
diff --git a/test/unordered/swap_tests.cpp b/test/unordered/swap_tests.cpp
index 9e76cff8..2e27a6a3 100644
--- a/test/unordered/swap_tests.cpp
+++ b/test/unordered/swap_tests.cpp
@@ -116,23 +116,20 @@ void swap_tests2(X* ptr = 0)
 
 int main()
 {
-    std::cerr<<"Erase unordered_set<int>.\n";
-    swap_tests1((boost::unordered_set<int>*) 0);
-    std::cerr<<"\nErase unordered_multiset<int>.\n";
-    swap_tests1((boost::unordered_multiset<int>*) 0);
-    std::cerr<<"\nErase unordered_map<int>.\n";
-    swap_tests1((boost::unordered_map<int, int>*) 0);
-    std::cerr<<"\nErase unordered_multimap<int>.\n";
-    swap_tests1((boost::unordered_multimap<int, int>*) 0);
+    boost::unordered_set<test::object, test::hash, test::equal_to, test::allocator<test::object> >* test_set;
+    boost::unordered_multiset<test::object, test::hash, test::equal_to, test::allocator<test::object> >* test_multiset;
+    boost::unordered_map<test::object, test::object, test::hash, test::equal_to, test::allocator<test::object> >* test_map;
+    boost::unordered_multimap<test::object, test::object, test::hash, test::equal_to, test::allocator<test::object> >* test_multimap;
 
-    std::cerr<<"\nErase unordered_set<test::object,..>.\n";
-    swap_tests2((boost::unordered_set<test::object, test::hash, test::equal_to, test::allocator<test::object> >*) 0);
-    std::cerr<<"\nErase unordered_multiset<test::object,..>.\n";
-    swap_tests2((boost::unordered_multiset<test::object, test::hash, test::equal_to, test::allocator<test::object> >*) 0);
-    std::cerr<<"\nErase unordered_map<test::object,..>.\n";
-    swap_tests2((boost::unordered_map<test::object, test::object, test::hash, test::equal_to, test::allocator<test::object> >*) 0);
-    std::cerr<<"\nErase unordered_multimap<test::object,..>.\n";
-    swap_tests2((boost::unordered_multimap<test::object, test::object, test::hash, test::equal_to, test::allocator<test::object> >*) 0);
+    swap_tests1(test_set);
+    swap_tests1(test_multiset);
+    swap_tests1(test_map);
+    swap_tests1(test_multimap);
+
+    swap_tests2(test_set);
+    swap_tests2(test_multiset);
+    swap_tests2(test_map);
+    swap_tests2(test_multimap);
 
     return boost::report_errors();
 }