diff --git a/test/unordered/Jamfile.v2 b/test/unordered/Jamfile.v2
index 005a7787..5e02e281 100644
--- a/test/unordered/Jamfile.v2
+++ b/test/unordered/Jamfile.v2
@@ -16,9 +16,8 @@ test-suite unordered-tests
     :
         [ run set_compile.cpp ]
         [ run map_compile.cpp ]
-        [ run simple_tests.cpp ]
         [ run link_test_1.cpp link_test_2.cpp ]
-        [ run compile_tests.cpp ]
+        [ run simple_tests.cpp ]
         [ run equivalent_keys_tests.cpp ]
         [ run constructor_tests.cpp ]
         [ run copy_tests.cpp ]
diff --git a/test/unordered/compile_tests.cpp b/test/unordered/compile_tests.cpp
deleted file mode 100644
index 331bdad8..00000000
--- a/test/unordered/compile_tests.cpp
+++ /dev/null
@@ -1,328 +0,0 @@
-
-// Copyright 2006-2007 Daniel James.
-// 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)
-
-#include <boost/unordered_set.hpp>
-#include <boost/unordered_map.hpp>
-
-#if defined(BOOST_MSVC)
-#pragma warning(push)
-#pragma warning(disable:4100) // unreferenced formal parameter
-#endif
-
-#include <boost/concept_check.hpp>
-
-#if defined(BOOST_MSVC)
-#pragma warning(pop)
-#endif
-
-#include <boost/mpl/assert.hpp>
-#include <boost/iterator/iterator_traits.hpp>
-#include "../helpers/check_return_type.hpp"
-
-#include <iostream>
-#include <boost/detail/lightweight_test.hpp>
-#include "../objects/minimal.hpp"
-
-template <class T> void sink(T const&) {}
-
-template <class X, class Key>
-void unordered_set_test(X&, Key const&)
-{
-    typedef typename X::value_type value_type;
-    typedef typename X::key_type key_type;
-
-    BOOST_MPL_ASSERT((boost::is_same<value_type, key_type>));
-}
-
-template <class X, class Key, class T>
-void unordered_map_test(X&, Key const&, T const&)
-{
-    typedef typename X::value_type value_type;
-    typedef typename X::key_type key_type;
-    BOOST_MPL_ASSERT((boost::is_same<value_type, std::pair<key_type const, T> >));
-}
-
-template <class X, class T>
-void unordered_unique_test(X& r, T const& t)
-{
-    typedef typename X::iterator iterator;
-    test::check_return_type<std::pair<iterator, bool> >::equals(r.insert(t));
-}
-
-template <class X, class T>
-void unordered_equivalent_test(X& r, T const& t)
-{
-    typedef typename X::iterator iterator;
-    test::check_return_type<iterator>::equals(r.insert(t));
-}
-
-template <class X, class Key, class T>
-void unordered_map_functions(X&, Key const& k, T const&)
-{
-    typedef typename X::mapped_type mapped_type;
-
-    X a;
-    test::check_return_type<mapped_type>::equals_ref(a[k]);
-    test::check_return_type<mapped_type>::equals_ref(a.at(k));
-
-    X const b = a;
-    test::check_return_type<mapped_type const>::equals_ref(b.at(k));
-}
-
-template <class X, class Key, class T, class Hash, class Pred>
-void unordered_test(X&, Key& k, T& t, Hash& hf, Pred& eq)
-{
-    typedef typename X::key_type key_type;
-    typedef typename X::hasher hasher;
-    typedef typename X::key_equal key_equal;
-    typedef typename X::size_type size_type;
-
-    typedef typename X::iterator iterator;
-    typedef typename X::const_iterator const_iterator;
-    typedef typename X::local_iterator local_iterator;
-    typedef typename X::const_local_iterator const_local_iterator;
-
-    typedef typename boost::BOOST_ITERATOR_CATEGORY<iterator>::type iterator_category;
-    typedef typename boost::iterator_difference<iterator>::type iterator_difference;
-    typedef typename boost::iterator_pointer<iterator>::type iterator_pointer;
-    typedef typename boost::iterator_reference<iterator>::type iterator_reference;
-
-    typedef typename boost::BOOST_ITERATOR_CATEGORY<local_iterator>::type local_iterator_category;
-    typedef typename boost::iterator_difference<local_iterator>::type local_iterator_difference;
-    typedef typename boost::iterator_pointer<local_iterator>::type local_iterator_pointer;
-    typedef typename boost::iterator_reference<local_iterator>::type local_iterator_reference;
-
-    typedef typename boost::BOOST_ITERATOR_CATEGORY<const_iterator>::type const_iterator_category;
-    typedef typename boost::iterator_difference<const_iterator>::type const_iterator_difference;
-    typedef typename boost::iterator_pointer<const_iterator>::type const_iterator_pointer;
-    typedef typename boost::iterator_reference<const_iterator>::type const_iterator_reference;
-
-    typedef typename boost::BOOST_ITERATOR_CATEGORY<const_local_iterator>::type const_local_iterator_category;
-    typedef typename boost::iterator_difference<const_local_iterator>::type const_local_iterator_difference;
-    typedef typename boost::iterator_pointer<const_local_iterator>::type const_local_iterator_pointer;
-    typedef typename boost::iterator_reference<const_local_iterator>::type const_local_iterator_reference;
-
-    BOOST_MPL_ASSERT((boost::is_same<Key, key_type>));
-    boost::function_requires<boost::CopyConstructibleConcept<key_type> >();
-    boost::function_requires<boost::AssignableConcept<key_type> >();
-
-    BOOST_MPL_ASSERT((boost::is_same<Hash, hasher>));
-    test::check_return_type<std::size_t>::equals(hf(k));
-
-    BOOST_MPL_ASSERT((boost::is_same<Pred, key_equal>));
-    test::check_return_type<bool>::convertible(eq(k, k));
-
-    boost::function_requires<boost::InputIteratorConcept<local_iterator> >();
-    BOOST_MPL_ASSERT((boost::is_same<local_iterator_category, iterator_category>));
-    BOOST_MPL_ASSERT((boost::is_same<local_iterator_difference, iterator_difference>));
-    BOOST_MPL_ASSERT((boost::is_same<local_iterator_pointer, iterator_pointer>));
-    BOOST_MPL_ASSERT((boost::is_same<local_iterator_reference, iterator_reference>));
-
-    boost::function_requires<boost::InputIteratorConcept<const_local_iterator> >();
-    BOOST_MPL_ASSERT((boost::is_same<const_local_iterator_category, const_iterator_category>));
-    BOOST_MPL_ASSERT((boost::is_same<const_local_iterator_difference, const_iterator_difference>));
-    BOOST_MPL_ASSERT((boost::is_same<const_local_iterator_pointer, const_iterator_pointer>));
-    BOOST_MPL_ASSERT((boost::is_same<const_local_iterator_reference, const_iterator_reference>));
-
-    X(10, hf, eq);
-    X a(10, hf, eq);
-    X(10, hf);
-    X a2(10, hf);
-    X(10);
-    X a3(10);
-    X();
-    X a4;
-
-    typename X::value_type* i = 0;
-    typename X::value_type* j = 0;
-
-    X(i, j, 10, hf, eq);
-    X a5(i, j, 10, hf, eq);
-    X(i, j, 10, hf);
-    X a6(i, j, 10, hf);
-    X(i, j, 10);
-    X a7(i, j, 10);
-    X(i, j);
-    X a8(i, j);
-
-    X const b;
-    sink(X(b));
-    X a9(b);
-    a = b;
-
-    test::check_return_type<hasher>::equals(b.hash_function());
-    test::check_return_type<key_equal>::equals(b.key_eq());
-
-    const_iterator q = a.cbegin();
-    test::check_return_type<iterator>::equals(a.insert(q, t));
-
-    a.insert(i, j);
-    test::check_return_type<size_type>::equals(a.erase(k));
-
-    BOOST_TEST(a.empty());
-    if(a.empty()) {
-        a.insert(t);
-        q = a.cbegin();
-        test::check_return_type<iterator>::equals(a.erase(q));
-    }
-
-    const_iterator q1 = a.cbegin(), q2 = a.cend();
-    test::check_return_type<iterator>::equals(a.erase(q1, q2));
-
-    a.clear();
-
-    test::check_return_type<iterator>::equals(a.find(k));
-    test::check_return_type<const_iterator>::equals(b.find(k));
-    test::check_return_type<size_type>::equals(b.count(k));
-    test::check_return_type<std::pair<iterator, iterator> >::equals(
-            a.equal_range(k));
-    test::check_return_type<std::pair<const_iterator, const_iterator> >::equals(
-            b.equal_range(k));
-    test::check_return_type<size_type>::equals(b.bucket_count());
-    test::check_return_type<size_type>::equals(b.max_bucket_count());
-    test::check_return_type<size_type>::equals(b.bucket(k));
-    test::check_return_type<size_type>::equals(b.bucket_size(0));
-
-    test::check_return_type<local_iterator>::equals(a.begin(0));
-    test::check_return_type<const_local_iterator>::equals(b.begin(0));
-    test::check_return_type<local_iterator>::equals(a.end(0));
-    test::check_return_type<const_local_iterator>::equals(b.end(0));
-
-    test::check_return_type<const_local_iterator>::equals(a.cbegin(0));
-    test::check_return_type<const_local_iterator>::equals(b.cbegin(0));
-    test::check_return_type<const_local_iterator>::equals(a.cend(0));
-    test::check_return_type<const_local_iterator>::equals(b.cend(0));
-
-    test::check_return_type<float>::equals(b.load_factor());
-    test::check_return_type<float>::equals(b.max_load_factor());
-    a.max_load_factor((float) 2.0);
-    a.rehash(100);
-}
-
-void test1()
-{
-    boost::hash<int> hash;
-    std::equal_to<int> equal_to;
-    int value = 0;
-    std::pair<int const, int> map_value(0, 0);
-
-    std::cout<<"Test unordered_set.\n";
-
-    boost::unordered_set<int> set;
-    
-    unordered_unique_test(set, value);
-    unordered_set_test(set, value);
-    unordered_test(set, value, value, hash, equal_to);
-
-    std::cout<<"Test unordered_multiset.\n";
-
-    boost::unordered_multiset<int> multiset;
-    
-    unordered_equivalent_test(multiset, value);
-    unordered_set_test(multiset, value);
-    unordered_test(multiset, value, value, hash, equal_to);
-
-    std::cout<<"Test unordered_map.\n";
-
-    boost::unordered_map<int, int> map;
-
-    unordered_unique_test(map, map_value);
-    unordered_map_test(map, value, value);
-    unordered_test(map, value, map_value, hash, equal_to);
-    unordered_map_functions(map, value, value);
-
-    std::cout<<"Test unordered_multimap.\n";
-
-    boost::unordered_multimap<int, int> multimap;
-
-    unordered_equivalent_test(multimap, map_value);
-    unordered_map_test(multimap, value, value);
-    unordered_test(multimap, value, map_value, hash, equal_to);
-}
-
-void test2()
-{
-    test::minimal::assignable assignable
-        = test::minimal::assignable::create();
-    test::minimal::copy_constructible copy_constructible
-        = test::minimal::copy_constructible::create();
-    test::minimal::hash<test::minimal::assignable> hash
-        = test::minimal::hash<test::minimal::assignable>::create();
-    test::minimal::equal_to<test::minimal::assignable> equal_to
-        = test::minimal::equal_to<test::minimal::assignable>::create();
-
-    typedef std::pair<test::minimal::assignable const,
-            test::minimal::copy_constructible> map_value_type;
-    map_value_type map_value(assignable, copy_constructible);
-
-    std::cout<<"Test unordered_set.\n";
-
-    boost::unordered_set<
-        test::minimal::assignable,
-        test::minimal::hash<test::minimal::assignable>,
-        test::minimal::equal_to<test::minimal::assignable>,
-        test::minimal::allocator<test::minimal::assignable> > set;
-
-    unordered_unique_test(set, assignable);
-    unordered_set_test(set, assignable);
-    unordered_test(set, assignable, assignable, hash, equal_to);
-
-    std::cout<<"Test unordered_multiset.\n";
-
-    boost::unordered_multiset<
-        test::minimal::assignable,
-        test::minimal::hash<test::minimal::assignable>,
-        test::minimal::equal_to<test::minimal::assignable>,
-        test::minimal::allocator<test::minimal::assignable> > multiset;
-
-    unordered_equivalent_test(multiset, assignable);
-    unordered_set_test(multiset, assignable);
-    unordered_test(multiset, assignable, assignable, hash, equal_to);
-
-    std::cout<<"Test unordered_map.\n";
-
-    boost::unordered_map<
-        test::minimal::assignable,
-        test::minimal::copy_constructible,
-        test::minimal::hash<test::minimal::assignable>,
-        test::minimal::equal_to<test::minimal::assignable>,
-        test::minimal::allocator<map_value_type> > map;
-
-    unordered_unique_test(map, map_value);
-    unordered_map_test(map, assignable, copy_constructible);
-    unordered_test(map, assignable, map_value, hash, equal_to);
-
-
-    boost::unordered_map<
-        test::minimal::assignable,
-        test::minimal::default_copy_constructible,
-        test::minimal::hash<test::minimal::assignable>,
-        test::minimal::equal_to<test::minimal::assignable>,
-        test::minimal::allocator<map_value_type> > map2;
-
-    test::minimal::default_copy_constructible default_copy_constructible;
-
-    unordered_map_functions(map2, assignable, default_copy_constructible);
-
-    std::cout<<"Test unordered_multimap.\n";
-
-    boost::unordered_multimap<
-        test::minimal::assignable,
-        test::minimal::copy_constructible,
-        test::minimal::hash<test::minimal::assignable>,
-        test::minimal::equal_to<test::minimal::assignable>,
-        test::minimal::allocator<map_value_type> > multimap;
-
-    unordered_equivalent_test(multimap, map_value);
-    unordered_map_test(multimap, assignable, copy_constructible);
-    unordered_test(multimap, assignable, map_value, hash, equal_to);
-}
-
-int main() {
-    test1();
-    test2();
-
-    return boost::report_errors();
-}
diff --git a/test/unordered/compile_tests.hpp b/test/unordered/compile_tests.hpp
index b5fe1ab3..caa5acc1 100644
--- a/test/unordered/compile_tests.hpp
+++ b/test/unordered/compile_tests.hpp
@@ -128,3 +128,177 @@ void container_test(X& r, T&)
     test::check_return_type<size_type>::equals(a.max_size());
     test::check_return_type<bool>::convertible(a.empty());
 }
+
+template <class X, class Key>
+void unordered_set_test(X&, Key const&)
+{
+    typedef typename X::value_type value_type;
+    typedef typename X::key_type key_type;
+
+    BOOST_MPL_ASSERT((boost::is_same<value_type, key_type>));
+}
+
+template <class X, class Key, class T>
+void unordered_map_test(X&, Key const&, T const&)
+{
+    typedef typename X::value_type value_type;
+    typedef typename X::key_type key_type;
+    BOOST_MPL_ASSERT((boost::is_same<value_type, std::pair<key_type const, T> >));
+}
+
+template <class X, class T>
+void unordered_unique_test(X& r, T const& t)
+{
+    typedef typename X::iterator iterator;
+    test::check_return_type<std::pair<iterator, bool> >::equals(r.insert(t));
+}
+
+template <class X, class T>
+void unordered_equivalent_test(X& r, T const& t)
+{
+    typedef typename X::iterator iterator;
+    test::check_return_type<iterator>::equals(r.insert(t));
+}
+
+template <class X, class Key, class T>
+void unordered_map_functions(X&, Key const& k, T const&)
+{
+    typedef typename X::mapped_type mapped_type;
+
+    X a;
+    test::check_return_type<mapped_type>::equals_ref(a[k]);
+    test::check_return_type<mapped_type>::equals_ref(a.at(k));
+
+    X const b = a;
+    test::check_return_type<mapped_type const>::equals_ref(b.at(k));
+}
+
+template <class X, class Key, class T, class Hash, class Pred>
+void unordered_test(X&, Key& k, T& t, Hash& hf, Pred& eq)
+{
+    typedef typename X::key_type key_type;
+    typedef typename X::hasher hasher;
+    typedef typename X::key_equal key_equal;
+    typedef typename X::size_type size_type;
+
+    typedef typename X::iterator iterator;
+    typedef typename X::const_iterator const_iterator;
+    typedef typename X::local_iterator local_iterator;
+    typedef typename X::const_local_iterator const_local_iterator;
+
+    typedef typename boost::BOOST_ITERATOR_CATEGORY<iterator>::type iterator_category;
+    typedef typename boost::iterator_difference<iterator>::type iterator_difference;
+    typedef typename boost::iterator_pointer<iterator>::type iterator_pointer;
+    typedef typename boost::iterator_reference<iterator>::type iterator_reference;
+
+    typedef typename boost::BOOST_ITERATOR_CATEGORY<local_iterator>::type local_iterator_category;
+    typedef typename boost::iterator_difference<local_iterator>::type local_iterator_difference;
+    typedef typename boost::iterator_pointer<local_iterator>::type local_iterator_pointer;
+    typedef typename boost::iterator_reference<local_iterator>::type local_iterator_reference;
+
+    typedef typename boost::BOOST_ITERATOR_CATEGORY<const_iterator>::type const_iterator_category;
+    typedef typename boost::iterator_difference<const_iterator>::type const_iterator_difference;
+    typedef typename boost::iterator_pointer<const_iterator>::type const_iterator_pointer;
+    typedef typename boost::iterator_reference<const_iterator>::type const_iterator_reference;
+
+    typedef typename boost::BOOST_ITERATOR_CATEGORY<const_local_iterator>::type const_local_iterator_category;
+    typedef typename boost::iterator_difference<const_local_iterator>::type const_local_iterator_difference;
+    typedef typename boost::iterator_pointer<const_local_iterator>::type const_local_iterator_pointer;
+    typedef typename boost::iterator_reference<const_local_iterator>::type const_local_iterator_reference;
+
+    BOOST_MPL_ASSERT((boost::is_same<Key, key_type>));
+    boost::function_requires<boost::CopyConstructibleConcept<key_type> >();
+    boost::function_requires<boost::AssignableConcept<key_type> >();
+
+    BOOST_MPL_ASSERT((boost::is_same<Hash, hasher>));
+    test::check_return_type<std::size_t>::equals(hf(k));
+
+    BOOST_MPL_ASSERT((boost::is_same<Pred, key_equal>));
+    test::check_return_type<bool>::convertible(eq(k, k));
+
+    boost::function_requires<boost::InputIteratorConcept<local_iterator> >();
+    BOOST_MPL_ASSERT((boost::is_same<local_iterator_category, iterator_category>));
+    BOOST_MPL_ASSERT((boost::is_same<local_iterator_difference, iterator_difference>));
+    BOOST_MPL_ASSERT((boost::is_same<local_iterator_pointer, iterator_pointer>));
+    BOOST_MPL_ASSERT((boost::is_same<local_iterator_reference, iterator_reference>));
+
+    boost::function_requires<boost::InputIteratorConcept<const_local_iterator> >();
+    BOOST_MPL_ASSERT((boost::is_same<const_local_iterator_category, const_iterator_category>));
+    BOOST_MPL_ASSERT((boost::is_same<const_local_iterator_difference, const_iterator_difference>));
+    BOOST_MPL_ASSERT((boost::is_same<const_local_iterator_pointer, const_iterator_pointer>));
+    BOOST_MPL_ASSERT((boost::is_same<const_local_iterator_reference, const_iterator_reference>));
+
+    X(10, hf, eq);
+    X a(10, hf, eq);
+    X(10, hf);
+    X a2(10, hf);
+    X(10);
+    X a3(10);
+    X();
+    X a4;
+
+    typename X::value_type* i = 0;
+    typename X::value_type* j = 0;
+
+    X(i, j, 10, hf, eq);
+    X a5(i, j, 10, hf, eq);
+    X(i, j, 10, hf);
+    X a6(i, j, 10, hf);
+    X(i, j, 10);
+    X a7(i, j, 10);
+    X(i, j);
+    X a8(i, j);
+
+    X const b;
+    sink(X(b));
+    X a9(b);
+    a = b;
+
+    test::check_return_type<hasher>::equals(b.hash_function());
+    test::check_return_type<key_equal>::equals(b.key_eq());
+
+    const_iterator q = a.cbegin();
+    test::check_return_type<iterator>::equals(a.insert(q, t));
+
+    a.insert(i, j);
+    test::check_return_type<size_type>::equals(a.erase(k));
+
+    BOOST_TEST(a.empty());
+    if(a.empty()) {
+        a.insert(t);
+        q = a.cbegin();
+        test::check_return_type<iterator>::equals(a.erase(q));
+    }
+
+    const_iterator q1 = a.cbegin(), q2 = a.cend();
+    test::check_return_type<iterator>::equals(a.erase(q1, q2));
+
+    a.clear();
+
+    test::check_return_type<iterator>::equals(a.find(k));
+    test::check_return_type<const_iterator>::equals(b.find(k));
+    test::check_return_type<size_type>::equals(b.count(k));
+    test::check_return_type<std::pair<iterator, iterator> >::equals(
+            a.equal_range(k));
+    test::check_return_type<std::pair<const_iterator, const_iterator> >::equals(
+            b.equal_range(k));
+    test::check_return_type<size_type>::equals(b.bucket_count());
+    test::check_return_type<size_type>::equals(b.max_bucket_count());
+    test::check_return_type<size_type>::equals(b.bucket(k));
+    test::check_return_type<size_type>::equals(b.bucket_size(0));
+
+    test::check_return_type<local_iterator>::equals(a.begin(0));
+    test::check_return_type<const_local_iterator>::equals(b.begin(0));
+    test::check_return_type<local_iterator>::equals(a.end(0));
+    test::check_return_type<const_local_iterator>::equals(b.end(0));
+
+    test::check_return_type<const_local_iterator>::equals(a.cbegin(0));
+    test::check_return_type<const_local_iterator>::equals(b.cbegin(0));
+    test::check_return_type<const_local_iterator>::equals(a.cend(0));
+    test::check_return_type<const_local_iterator>::equals(b.cend(0));
+
+    test::check_return_type<float>::equals(b.load_factor());
+    test::check_return_type<float>::equals(b.max_load_factor());
+    a.max_load_factor((float) 2.0);
+    a.rehash(100);
+}
diff --git a/test/unordered/map_compile.cpp b/test/unordered/map_compile.cpp
index e498a934..cdb785e9 100644
--- a/test/unordered/map_compile.cpp
+++ b/test/unordered/map_compile.cpp
@@ -13,7 +13,7 @@
 #include "../objects/minimal.hpp"
 #include "./compile_tests.hpp"
 
-int main()
+void test0()
 {
     typedef std::pair<test::minimal::assignable const,
             test::minimal::copy_constructible> value_type;
@@ -40,6 +40,92 @@ int main()
         test::minimal::allocator<value_type> > multimap;
 
     container_test(multimap, value);
+}
+
+void test1()
+{
+    boost::hash<int> hash;
+    std::equal_to<int> equal_to;
+    int value = 0;
+    std::pair<int const, int> map_value(0, 0);
+
+    std::cout<<"Test unordered_map.\n";
+
+    boost::unordered_map<int, int> map;
+
+    unordered_unique_test(map, map_value);
+    unordered_map_test(map, value, value);
+    unordered_test(map, value, map_value, hash, equal_to);
+    unordered_map_functions(map, value, value);
+
+    std::cout<<"Test unordered_multimap.\n";
+
+    boost::unordered_multimap<int, int> multimap;
+
+    unordered_equivalent_test(multimap, map_value);
+    unordered_map_test(multimap, value, value);
+    unordered_test(multimap, value, map_value, hash, equal_to);
+}
+
+void test2()
+{
+    test::minimal::assignable assignable
+        = test::minimal::assignable::create();
+    test::minimal::copy_constructible copy_constructible
+        = test::minimal::copy_constructible::create();
+    test::minimal::hash<test::minimal::assignable> hash
+        = test::minimal::hash<test::minimal::assignable>::create();
+    test::minimal::equal_to<test::minimal::assignable> equal_to
+        = test::minimal::equal_to<test::minimal::assignable>::create();
+
+    typedef std::pair<test::minimal::assignable const,
+            test::minimal::copy_constructible> map_value_type;
+    map_value_type map_value(assignable, copy_constructible);
+
+    std::cout<<"Test unordered_map.\n";
+
+    boost::unordered_map<
+        test::minimal::assignable,
+        test::minimal::copy_constructible,
+        test::minimal::hash<test::minimal::assignable>,
+        test::minimal::equal_to<test::minimal::assignable>,
+        test::minimal::allocator<map_value_type> > map;
+
+    unordered_unique_test(map, map_value);
+    unordered_map_test(map, assignable, copy_constructible);
+    unordered_test(map, assignable, map_value, hash, equal_to);
+
+
+    boost::unordered_map<
+        test::minimal::assignable,
+        test::minimal::default_copy_constructible,
+        test::minimal::hash<test::minimal::assignable>,
+        test::minimal::equal_to<test::minimal::assignable>,
+        test::minimal::allocator<map_value_type> > map2;
+
+    test::minimal::default_copy_constructible default_copy_constructible;
+
+    unordered_map_functions(map2, assignable, default_copy_constructible);
+
+    std::cout<<"Test unordered_multimap.\n";
+
+    boost::unordered_multimap<
+        test::minimal::assignable,
+        test::minimal::copy_constructible,
+        test::minimal::hash<test::minimal::assignable>,
+        test::minimal::equal_to<test::minimal::assignable>,
+        test::minimal::allocator<map_value_type> > multimap;
+
+    unordered_equivalent_test(multimap, map_value);
+    unordered_map_test(multimap, assignable, copy_constructible);
+    unordered_test(multimap, assignable, map_value, hash, equal_to);
+}
+
+int main()
+{
+    test0();
+    test1();
+    test2();
 
     return boost::report_errors();
 }
diff --git a/test/unordered/set_compile.cpp b/test/unordered/set_compile.cpp
index f34de5d7..099b8030 100644
--- a/test/unordered/set_compile.cpp
+++ b/test/unordered/set_compile.cpp
@@ -13,7 +13,7 @@
 #include "../objects/minimal.hpp"
 #include "./compile_tests.hpp"
 
-int main()
+void test0()
 {
     test::minimal::assignable assignable = test::minimal::assignable::create();
 
@@ -34,6 +34,71 @@ int main()
         test::minimal::allocator<test::minimal::assignable> > multiset;
 
     container_test(multiset, assignable);
+}
+
+void test1()
+{
+    boost::hash<int> hash;
+    std::equal_to<int> equal_to;
+    int value = 0;
+
+    std::cout<<"Test unordered_set.\n";
+
+    boost::unordered_set<int> set;
+    
+    unordered_unique_test(set, value);
+    unordered_set_test(set, value);
+    unordered_test(set, value, value, hash, equal_to);
+
+    std::cout<<"Test unordered_multiset.\n";
+
+    boost::unordered_multiset<int> multiset;
+    
+    unordered_equivalent_test(multiset, value);
+    unordered_set_test(multiset, value);
+    unordered_test(multiset, value, value, hash, equal_to);
+}
+
+void test2()
+{
+    test::minimal::assignable assignable
+        = test::minimal::assignable::create();
+    test::minimal::copy_constructible copy_constructible
+        = test::minimal::copy_constructible::create();
+    test::minimal::hash<test::minimal::assignable> hash
+        = test::minimal::hash<test::minimal::assignable>::create();
+    test::minimal::equal_to<test::minimal::assignable> equal_to
+        = test::minimal::equal_to<test::minimal::assignable>::create();
+
+    std::cout<<"Test unordered_set.\n";
+
+    boost::unordered_set<
+        test::minimal::assignable,
+        test::minimal::hash<test::minimal::assignable>,
+        test::minimal::equal_to<test::minimal::assignable>,
+        test::minimal::allocator<test::minimal::assignable> > set;
+
+    unordered_unique_test(set, assignable);
+    unordered_set_test(set, assignable);
+    unordered_test(set, assignable, assignable, hash, equal_to);
+
+    std::cout<<"Test unordered_multiset.\n";
+
+    boost::unordered_multiset<
+        test::minimal::assignable,
+        test::minimal::hash<test::minimal::assignable>,
+        test::minimal::equal_to<test::minimal::assignable>,
+        test::minimal::allocator<test::minimal::assignable> > multiset;
+
+    unordered_equivalent_test(multiset, assignable);
+    unordered_set_test(multiset, assignable);
+    unordered_test(multiset, assignable, assignable, hash, equal_to);
+}
+
+int main() {
+    test0();
+    test1();
+    test2();
 
     return boost::report_errors();
 }