diff --git a/test/deque_test.cpp b/test/deque_test.cpp
index f54fec3..9ed8cf8 100644
--- a/test/deque_test.cpp
+++ b/test/deque_test.cpp
@@ -16,8 +16,6 @@
 
 #include <boost/container/deque.hpp>
 #include <boost/container/allocator.hpp>
-#include <boost/container/node_allocator.hpp>
-#include <boost/container/adaptive_pool.hpp>
 
 #include "print_container.hpp"
 #include "check_equal_containers.hpp"
@@ -45,26 +43,10 @@ template class boost::container::deque
  < test::movable_and_copyable_int
  , test::simple_allocator<test::movable_and_copyable_int> >;
 
-template class boost::container::deque
- < test::movable_and_copyable_int
- , test::dummy_test_allocator<test::movable_and_copyable_int> >;
-
-template class boost::container::deque
- < test::movable_and_copyable_int
- , std::allocator<test::movable_and_copyable_int> >;
-
 template class boost::container::deque
    < test::movable_and_copyable_int
    , allocator<test::movable_and_copyable_int> >;
 
-template class boost::container::deque
-   < test::movable_and_copyable_int
-   , adaptive_pool<test::movable_and_copyable_int> >;
-
-template class boost::container::deque
-   < test::movable_and_copyable_int
-   , node_allocator<test::movable_and_copyable_int> >;
-
 }}
 
 //Function to check if both sets are equal
@@ -388,16 +370,6 @@ int main ()
       std::cerr << "test_cont_variants< allocator<void> > failed" << std::endl;
       return 1;
    }
-   //       boost::container::node_allocator
-   if(test_cont_variants< node_allocator<void> >()){
-      std::cerr << "test_cont_variants< node_allocator<void> > failed" << std::endl;
-      return 1;
-   }
-   //       boost::container::adaptive_pool
-   if(test_cont_variants< adaptive_pool<void> >()){
-      std::cerr << "test_cont_variants< adaptive_pool<void> > failed" << std::endl;
-      return 1;
-   }
    ////////////////////////////////////
    //    Default init test
    ////////////////////////////////////
diff --git a/test/dummy_test_allocator.hpp b/test/dummy_test_allocator.hpp
index 5b6e99a..7576d45 100644
--- a/test/dummy_test_allocator.hpp
+++ b/test/dummy_test_allocator.hpp
@@ -73,138 +73,6 @@ class simple_allocator
    {  return false;  }
 };
 
-//Version 2 allocator with rebind
-template<class T>
-class dummy_test_allocator
-{
- private:
-   typedef dummy_test_allocator<T>  self_t;
-   typedef void *                   aux_pointer_t;
-   typedef const void *             cvoid_ptr;
-
-   public:
-   typedef T                                    value_type;
-   typedef T *                                  pointer;
-   typedef const T *                            const_pointer;
-   typedef typename container_detail::
-      unvoid_ref<value_type>::type              reference;
-   typedef typename container_detail::
-      unvoid_ref<const value_type>::type        const_reference;
-   typedef std::size_t                          size_type;
-   typedef std::ptrdiff_t                       difference_type;
-
-   typedef container_detail::basic_multiallocation_chain
-      <void*>                                            multialloc_cached_counted;
-   typedef boost::container::container_detail::transform_multiallocation_chain
-      <multialloc_cached_counted, value_type>            multiallocation_chain;
-
-   typedef boost::container::container_detail::version_type<dummy_test_allocator, 2>   version;
-
-   template<class T2>
-   struct rebind
-   {  typedef dummy_test_allocator<T2>   other;   };
-
-   //!Default constructor. Never throws
-   dummy_test_allocator()
-   {}
-
-   //!Constructor from other dummy_test_allocator. Never throws
-   dummy_test_allocator(const dummy_test_allocator &)
-   {}
-
-   //!Constructor from related dummy_test_allocator. Never throws
-   template<class T2>
-   dummy_test_allocator(const dummy_test_allocator<T2> &)
-   {}
-
-   pointer address(reference value)
-   {  return pointer(container_detail::addressof(value));  }
-
-   const_pointer address(const_reference value) const
-   {  return const_pointer(container_detail::addressof(value));  }
-
-   pointer allocate(size_type, cvoid_ptr = 0)
-   {  return 0; }
-
-   void deallocate(const pointer &, size_type)
-   { }
-
-   template<class Convertible>
-   void construct(pointer, const Convertible &)
-   {}
-
-   void destroy(pointer)
-   {}
-
-   size_type max_size() const
-   {  return 0;   }
-
-   friend void swap(self_t &, self_t &)
-   {}
-
-   //Experimental version 2 dummy_test_allocator functions
-
-   pointer allocation_command(boost::container::allocation_type, size_type, size_type &, pointer &p)
-   {  p = pointer();   return pointer();  }
-
-   //!Returns maximum the number of objects the previously allocated memory
-   //!pointed by p can hold.
-   size_type size(const pointer &) const
-   {  return 0; }
-
-   //!Allocates just one object. Memory allocated with this function
-   //!must be deallocated only with deallocate_one().
-   //!Throws boost::container::bad_alloc if there is no enough memory
-   pointer allocate_one()
-   {  return pointer();  }
-
-   //!Deallocates memory previously allocated with allocate_one().
-   //!You should never use deallocate_one to deallocate memory allocated
-   //!with other functions different from allocate_one(). Never throws
-   void deallocate_one(const pointer &)
-   {}
-
-   //!Allocates many elements of size == 1 in a contiguous block
-   //!of memory. The minimum number to be allocated is min_elements,
-   //!the preferred and maximum number is
-   //!preferred_elements. The number of actually allocated elements is
-   //!will be assigned to received_size. Memory allocated with this function
-   //!must be deallocated only with deallocate_one().
-   void allocate_individual(size_type, multiallocation_chain &)
-   {}
-
-   //!Allocates many elements of size == 1 in a contiguous block
-   //!of memory. The minimum number to be allocated is min_elements,
-   //!the preferred and maximum number is
-   //!preferred_elements. The number of actually allocated elements is
-   //!will be assigned to received_size. Memory allocated with this function
-   //!must be deallocated only with deallocate_one().
-   void deallocate_individual(multiallocation_chain &)
-   {}
-
-   //!Allocates many elements of size elem_size in a contiguous block
-   //!of memory. The minimum number to be allocated is min_elements,
-   //!the preferred and maximum number is
-   //!preferred_elements. The number of actually allocated elements is
-   //!will be assigned to received_size. The elements must be deallocated
-   //!with deallocate(...)
-   void deallocate_many(multiallocation_chain &)
-   {}
-};
-
-//!Equality test for same type of dummy_test_allocator
-template<class T> inline
-bool operator==(const dummy_test_allocator<T>  &,
-                const dummy_test_allocator<T>  &)
-{  return true; }
-
-//!Inequality test for same type of dummy_test_allocator
-template<class T> inline
-bool operator!=(const dummy_test_allocator<T>  &,
-                const dummy_test_allocator<T>  &)
-{  return false; }
-
-
 template< class T
         , bool PropagateOnContCopyAssign
         , bool PropagateOnContMoveAssign
diff --git a/test/flat_map_test.cpp b/test/flat_map_test.cpp
index 00d8b6f..b6a7d4e 100644
--- a/test/flat_map_test.cpp
+++ b/test/flat_map_test.cpp
@@ -11,8 +11,6 @@
 #include <boost/container/detail/config_begin.hpp>
 #include <boost/container/flat_map.hpp>
 #include <boost/container/allocator.hpp>
-#include <boost/container/node_allocator.hpp>
-#include <boost/container/adaptive_pool.hpp>
 #include <boost/container/detail/flat_tree.hpp>
 
 #include "print_container.hpp"
@@ -36,13 +34,6 @@ namespace container {
 //Explicit instantiation to detect compilation errors
 
 //flat_map
-template class flat_map
-   < test::movable_and_copyable_int
-   , test::movable_and_copyable_int
-   , std::less<test::movable_and_copyable_int>
-   , test::dummy_test_allocator
-      < std::pair<test::movable_and_copyable_int, test::movable_and_copyable_int> >
-   >;
 
 template class flat_map
    < test::movable_and_copyable_int
@@ -68,31 +59,7 @@ template class flat_map
       < std::pair<test::movable_and_copyable_int, test::movable_and_copyable_int> >
    >;
 
-template class flat_map
-   < test::movable_and_copyable_int
-   , test::movable_and_copyable_int
-   , std::less<test::movable_and_copyable_int>
-   , adaptive_pool
-      < std::pair<test::movable_and_copyable_int, test::movable_and_copyable_int> >
-   >;
-
-template class flat_map
-   < test::movable_and_copyable_int
-   , test::movable_and_copyable_int
-   , std::less<test::movable_and_copyable_int>
-   , node_allocator
-      < std::pair<test::movable_and_copyable_int, test::movable_and_copyable_int> >
-   >;
-
 //flat_multimap
-template class flat_multimap
-   < test::movable_and_copyable_int
-   , test::movable_and_copyable_int
-   , std::less<test::movable_and_copyable_int>
-   , test::dummy_test_allocator
-      < std::pair<test::movable_and_copyable_int, test::movable_and_copyable_int> >
-   >;
-
 template class flat_multimap
    < test::movable_and_copyable_int
    , test::movable_and_copyable_int
@@ -117,22 +84,6 @@ template class flat_multimap
       < std::pair<test::movable_and_copyable_int, test::movable_and_copyable_int> >
    >;
 
-template class flat_multimap
-   < test::movable_and_copyable_int
-   , test::movable_and_copyable_int
-   , std::less<test::movable_and_copyable_int>
-   , adaptive_pool
-      < std::pair<test::movable_and_copyable_int, test::movable_and_copyable_int> >
-   >;
-
-template class flat_multimap
-   < test::movable_and_copyable_int
-   , test::movable_and_copyable_int
-   , std::less<test::movable_and_copyable_int>
-   , node_allocator
-      < std::pair<test::movable_and_copyable_int, test::movable_and_copyable_int> >
-   >;
-
 //As flat container iterators are typedefs for vector::[const_]iterator,
 //no need to explicit instantiate them
 
@@ -463,16 +414,6 @@ int main()
       std::cerr << "test_map_variants< allocator<void> > failed" << std::endl;
       return 1;
    }
-   //       boost::container::node_allocator
-   if(test_map_variants< node_allocator<void> >()){
-      std::cerr << "test_map_variants< node_allocator<void> > failed" << std::endl;
-      return 1;
-   }
-   //       boost::container::adaptive_pool
-   if(test_map_variants< adaptive_pool<void> >()){
-      std::cerr << "test_map_variants< adaptive_pool<void> > failed" << std::endl;
-      return 1;
-   }
 
    if(!boost::container::test::test_map_support_for_initialization_list_for<flat_map<int, int> >())
       return 1;
diff --git a/test/flat_set_test.cpp b/test/flat_set_test.cpp
index 02f2fbc..67b5dfb 100644
--- a/test/flat_set_test.cpp
+++ b/test/flat_set_test.cpp
@@ -12,8 +12,6 @@
 #include <set>
 #include <boost/container/flat_set.hpp>
 #include <boost/container/allocator.hpp>
-#include <boost/container/node_allocator.hpp>
-#include <boost/container/adaptive_pool.hpp>
 
 #include "print_container.hpp"
 #include "dummy_test_allocator.hpp"
@@ -34,90 +32,34 @@ namespace container {
 //Explicit instantiation to detect compilation errors
 
 //flat_set
-template class flat_set
-   < test::movable_and_copyable_int
-   , std::less<test::movable_and_copyable_int>
-   , test::dummy_test_allocator<test::movable_and_copyable_int>
-   >;
-
 template class flat_set
    < test::movable_and_copyable_int
    , std::less<test::movable_and_copyable_int>
    , test::simple_allocator<test::movable_and_copyable_int>
    >;
 
-template class flat_set
-   < test::movable_and_copyable_int
-   , std::less<test::movable_and_copyable_int>
-   , std::allocator<test::movable_and_copyable_int>
-   >;
-
 template class flat_set
    < test::movable_and_copyable_int
    , std::less<test::movable_and_copyable_int>
    , allocator<test::movable_and_copyable_int>
    >;
 
-template class flat_set
-   < test::movable_and_copyable_int
-   , std::less<test::movable_and_copyable_int>
-   , adaptive_pool<test::movable_and_copyable_int>
-   >;
-
-template class flat_set
-   < test::movable_and_copyable_int
-   , std::less<test::movable_and_copyable_int>
-   , node_allocator<test::movable_and_copyable_int>
-   >;
-
 //flat_multiset
-template class flat_multiset
-   < test::movable_and_copyable_int
-   , std::less<test::movable_and_copyable_int>
-   , test::dummy_test_allocator<test::movable_and_copyable_int>
-   >;
-
 template class flat_multiset
    < test::movable_and_copyable_int
    , std::less<test::movable_and_copyable_int>
    , test::simple_allocator<test::movable_and_copyable_int>
    >;
 
-template class flat_multiset
-   < test::movable_and_copyable_int
-   , std::less<test::movable_and_copyable_int>
-   , std::allocator<test::movable_and_copyable_int>
-   >;
-
 template class flat_multiset
    < test::movable_and_copyable_int
    , std::less<test::movable_and_copyable_int>
    , allocator<test::movable_and_copyable_int>
    >;
 
-template class flat_multiset
-   < test::movable_and_copyable_int
-   , std::less<test::movable_and_copyable_int>
-   , adaptive_pool<test::movable_and_copyable_int>
-   >;
-
-template class flat_multiset
-   < test::movable_and_copyable_int
-   , std::less<test::movable_and_copyable_int>
-   , node_allocator<test::movable_and_copyable_int>
-   >;
-
 namespace container_detail {
 
 //Instantiate base class as previous instantiations don't instantiate inherited members
-template class flat_tree
-   < test::movable_and_copyable_int
-   , test::movable_and_copyable_int
-   , identity<test::movable_and_copyable_int>
-   , std::less<test::movable_and_copyable_int>
-   , test::dummy_test_allocator<test::movable_and_copyable_int>
-   >;
-
 template class flat_tree
    < test::movable_and_copyable_int
    , test::movable_and_copyable_int
@@ -126,14 +68,6 @@ template class flat_tree
    , test::simple_allocator<test::movable_and_copyable_int>
    >;
 
-template class flat_tree
-   < test::movable_and_copyable_int
-   , test::movable_and_copyable_int
-   , identity<test::movable_and_copyable_int>
-   , std::less<test::movable_and_copyable_int>
-   , std::allocator<test::movable_and_copyable_int>
-   >;
-
 template class flat_tree
    < test::movable_and_copyable_int
    , test::movable_and_copyable_int
@@ -142,22 +76,6 @@ template class flat_tree
    , allocator<test::movable_and_copyable_int>
    >;
 
-template class flat_tree
-   < test::movable_and_copyable_int
-   , test::movable_and_copyable_int
-   , identity<test::movable_and_copyable_int>
-   , std::less<test::movable_and_copyable_int>
-   , adaptive_pool<test::movable_and_copyable_int>
-   >;
-
-template class flat_tree
-   < test::movable_and_copyable_int
-   , test::movable_and_copyable_int
-   , identity<test::movable_and_copyable_int>
-   , std::less<test::movable_and_copyable_int>
-   , node_allocator<test::movable_and_copyable_int>
-   >;
-
 }  //container_detail {
 
 //As flat container iterators are typedefs for vector::[const_]iterator,
@@ -588,16 +506,6 @@ int main()
       std::cerr << "test_set_variants< allocator<void> > failed" << std::endl;
       return 1;
    }
-   //       boost::container::node_allocator
-   if(test_set_variants< node_allocator<void> >()){
-      std::cerr << "test_set_variants< node_allocator<void> > failed" << std::endl;
-      return 1;
-   }
-   //       boost::container::adaptive_pool
-   if(test_set_variants< adaptive_pool<void> >()){
-      std::cerr << "test_set_variants< adaptive_pool<void> > failed" << std::endl;
-      return 1;
-   }
 
    ////////////////////////////////////
    //    Emplace testing
diff --git a/test/list_test.cpp b/test/list_test.cpp
index b79a41d..065fa28 100644
--- a/test/list_test.cpp
+++ b/test/list_test.cpp
@@ -10,8 +10,6 @@
 
 #include <boost/container/detail/config_begin.hpp>
 #include <boost/container/list.hpp>
-#include <boost/container/allocator.hpp>
-#include <boost/container/node_allocator.hpp>
 #include <boost/container/adaptive_pool.hpp>
 
 #include "dummy_test_allocator.hpp"
@@ -32,26 +30,10 @@ template class boost::container::list
    < test::movable_and_copyable_int
    , test::simple_allocator<test::movable_and_copyable_int> >;
 
-template class boost::container::list
-   < test::movable_and_copyable_int
-   , test::dummy_test_allocator<test::movable_and_copyable_int> >;
-
-template class boost::container::list
-   < test::movable_and_copyable_int
-   , std::allocator<test::movable_and_copyable_int> >;
-
-template class boost::container::list
-   < test::movable_and_copyable_int
-   , allocator<test::movable_and_copyable_int> >;
-
 template class boost::container::list
    < test::movable_and_copyable_int
    , adaptive_pool<test::movable_and_copyable_int> >;
 
-template class boost::container::list
-   < test::movable_and_copyable_int
-   , node_allocator<test::movable_and_copyable_int> >;
-
 namespace container_detail {
 
 template class iterator_from_iiterator
@@ -191,16 +173,6 @@ int main ()
       std::cerr << "test_cont_variants< std::allocator<void> > failed" << std::endl;
       return 1;
    }
-   //       boost::container::allocator
-   if(test_cont_variants< allocator<void> >()){
-      std::cerr << "test_cont_variants< allocator<void> > failed" << std::endl;
-      return 1;
-   }
-   //       boost::container::node_allocator
-   if(test_cont_variants< node_allocator<void> >()){
-      std::cerr << "test_cont_variants< node_allocator<void> > failed" << std::endl;
-      return 1;
-   }
    //       boost::container::adaptive_pool
    if(test_cont_variants< adaptive_pool<void> >()){
       std::cerr << "test_cont_variants< adaptive_pool<void> > failed" << std::endl;
diff --git a/test/map_test.cpp b/test/map_test.cpp
index 3eb4deb..1573dc9 100644
--- a/test/map_test.cpp
+++ b/test/map_test.cpp
@@ -9,8 +9,6 @@
 //////////////////////////////////////////////////////////////////////////////
 #include <boost/container/detail/config_begin.hpp>
 #include <boost/container/map.hpp>
-#include <boost/container/allocator.hpp>
-#include <boost/container/node_allocator.hpp>
 #include <boost/container/adaptive_pool.hpp>
 
 #include <map>
@@ -31,14 +29,6 @@ namespace container {
 //Explicit instantiation to detect compilation errors
 
 //map
-template class map
-   < test::movable_and_copyable_int
-   , test::movable_and_copyable_int
-   , std::less<test::movable_and_copyable_int>
-   , test::dummy_test_allocator
-      < std::pair<const test::movable_and_copyable_int, test::movable_and_copyable_int> >
-   >;
-
 template class map
    < test::movable_and_copyable_int
    , test::movable_and_copyable_int
@@ -55,15 +45,6 @@ template class map
       < std::pair<const test::movable_and_copyable_int, test::movable_and_copyable_int> >
    >;
 
-
-template class map
-   < test::movable_and_copyable_int
-   , test::movable_and_copyable_int
-   , std::less<test::movable_and_copyable_int>
-   , allocator
-      < std::pair<const test::movable_and_copyable_int, test::movable_and_copyable_int> >
-   >;
-
 template class map
    < test::movable_and_copyable_int
    , test::movable_and_copyable_int
@@ -72,23 +53,7 @@ template class map
       < std::pair<const test::movable_and_copyable_int, test::movable_and_copyable_int> >
    >;
 
-template class map
-   < test::movable_and_copyable_int
-   , test::movable_and_copyable_int
-   , std::less<test::movable_and_copyable_int>
-   , node_allocator
-      < std::pair<const test::movable_and_copyable_int, test::movable_and_copyable_int> >
-   >;
-
 //multimap
-template class multimap
-   < test::movable_and_copyable_int
-   , test::movable_and_copyable_int
-   , std::less<test::movable_and_copyable_int>
-   , test::dummy_test_allocator
-      < std::pair<const test::movable_and_copyable_int, test::movable_and_copyable_int> >
-   >;
-
 template class multimap
    < test::movable_and_copyable_int
    , test::movable_and_copyable_int
@@ -105,14 +70,6 @@ template class multimap
       < std::pair<const test::movable_and_copyable_int, test::movable_and_copyable_int> >
    >;
 
-template class multimap
-   < test::movable_and_copyable_int
-   , test::movable_and_copyable_int
-   , std::less<test::movable_and_copyable_int>
-   , allocator
-      < std::pair<const test::movable_and_copyable_int, test::movable_and_copyable_int> >
-   >;
-
 template class multimap
    < test::movable_and_copyable_int
    , test::movable_and_copyable_int
@@ -121,25 +78,8 @@ template class multimap
       < std::pair<const test::movable_and_copyable_int, test::movable_and_copyable_int> >
    >;
 
-template class multimap
-   < test::movable_and_copyable_int
-   , test::movable_and_copyable_int
-   , std::less<test::movable_and_copyable_int>
-   , node_allocator
-      < std::pair<const test::movable_and_copyable_int, test::movable_and_copyable_int> >
-   >;
-
 namespace container_detail {
 
-template class tree
-   < const test::movable_and_copyable_int
-   , std::pair<const test::movable_and_copyable_int, test::movable_and_copyable_int>
-   , container_detail::select1st< std::pair<const test::movable_and_copyable_int, test::movable_and_copyable_int> >
-   , std::less<test::movable_and_copyable_int>
-   , test::dummy_test_allocator
-      < std::pair<const test::movable_and_copyable_int, test::movable_and_copyable_int> >
-   , tree_assoc_defaults >;
-
 template class tree
    < const test::movable_and_copyable_int
    , std::pair<const test::movable_and_copyable_int, test::movable_and_copyable_int>
@@ -158,15 +98,6 @@ template class tree
       < std::pair<const test::movable_and_copyable_int, test::movable_and_copyable_int> >
    , tree_assoc_defaults >;
 
-template class tree
-   < const test::movable_and_copyable_int
-   , std::pair<const test::movable_and_copyable_int, test::movable_and_copyable_int>
-   , container_detail::select1st< std::pair<const test::movable_and_copyable_int, test::movable_and_copyable_int> >
-   , std::less<test::movable_and_copyable_int>
-   , allocator
-      < std::pair<const test::movable_and_copyable_int, test::movable_and_copyable_int> >
-   , tree_assoc_defaults >;
-
 template class tree
    < const test::movable_and_copyable_int
    , std::pair<const test::movable_and_copyable_int, test::movable_and_copyable_int>
@@ -176,15 +107,6 @@ template class tree
       < std::pair<const test::movable_and_copyable_int, test::movable_and_copyable_int> >
    , tree_assoc_defaults >;
 
-template class tree
-   < const test::movable_and_copyable_int
-   , std::pair<const test::movable_and_copyable_int, test::movable_and_copyable_int>
-   , container_detail::select1st< std::pair<const test::movable_and_copyable_int, test::movable_and_copyable_int> >
-   , std::less<test::movable_and_copyable_int>
-   , node_allocator
-      < std::pair<const test::movable_and_copyable_int, test::movable_and_copyable_int> >
-   , tree_assoc_defaults >;
-
 }  //container_detail {
 
 }} //boost::container
@@ -376,16 +298,6 @@ int main ()
       std::cerr << "test_map_variants< std::allocator<void> > failed" << std::endl;
       return 1;
    }
-   //       boost::container::allocator
-   if(test_map_variants< allocator<void>, red_black_tree >()){
-      std::cerr << "test_map_variants< allocator<void> > failed" << std::endl;
-      return 1;
-   }
-   //       boost::container::node_allocator
-   if(test_map_variants< node_allocator<void>, red_black_tree >()){
-      std::cerr << "test_map_variants< node_allocator<void> > failed" << std::endl;
-      return 1;
-   }
    //       boost::container::adaptive_pool
    if(test_map_variants< adaptive_pool<void>, red_black_tree >()){
       std::cerr << "test_map_variants< adaptive_pool<void> > failed" << std::endl;
diff --git a/test/set_test.cpp b/test/set_test.cpp
index 6a60f98..c59bd3d 100644
--- a/test/set_test.cpp
+++ b/test/set_test.cpp
@@ -10,8 +10,6 @@
 #include <boost/container/detail/config_begin.hpp>
 #include <set>
 #include <boost/container/set.hpp>
-#include <boost/container/allocator.hpp>
-#include <boost/container/node_allocator.hpp>
 #include <boost/container/adaptive_pool.hpp>
 
 #include "print_container.hpp"
@@ -30,91 +28,34 @@ namespace container {
 //Explicit instantiation to detect compilation errors
 
 //set
-template class set
-   < test::movable_and_copyable_int
-   , std::less<test::movable_and_copyable_int>
-   , test::dummy_test_allocator<test::movable_and_copyable_int>
-   >;
-
 template class set
    < test::movable_and_copyable_int
    , std::less<test::movable_and_copyable_int>
    , test::simple_allocator<test::movable_and_copyable_int>
    >;
 
-template class set
-   < test::movable_and_copyable_int
-   , std::less<test::movable_and_copyable_int>
-   , std::allocator<test::movable_and_copyable_int>
-   >;
-
-template class set
-   < test::movable_and_copyable_int
-   , std::less<test::movable_and_copyable_int>
-   , allocator<test::movable_and_copyable_int>
-   >;
-
 template class set
    < test::movable_and_copyable_int
    , std::less<test::movable_and_copyable_int>
    , adaptive_pool<test::movable_and_copyable_int>
    >;
 
-template class set
-   < test::movable_and_copyable_int
-   , std::less<test::movable_and_copyable_int>
-   , node_allocator<test::movable_and_copyable_int>
-   >;
-
 //multiset
-template class multiset
-   < test::movable_and_copyable_int
-   , std::less<test::movable_and_copyable_int>
-   , test::dummy_test_allocator<test::movable_and_copyable_int>
-   >;
-
 template class multiset
    < test::movable_and_copyable_int
    , std::less<test::movable_and_copyable_int>
    , test::simple_allocator<test::movable_and_copyable_int>
    >;
 
-template class multiset
-   < test::movable_and_copyable_int
-   , std::less<test::movable_and_copyable_int>
-   , std::allocator<test::movable_and_copyable_int>
-   >;
-
-template class multiset
-   < test::movable_and_copyable_int
-   , std::less<test::movable_and_copyable_int>
-   , allocator<test::movable_and_copyable_int>
-   >;
-
 template class multiset
    < test::movable_and_copyable_int
    , std::less<test::movable_and_copyable_int>
    , adaptive_pool<test::movable_and_copyable_int>
    >;
 
-template class multiset
-   < test::movable_and_copyable_int
-   , std::less<test::movable_and_copyable_int>
-   , node_allocator<test::movable_and_copyable_int>
-   >;
-
 namespace container_detail {
 
 //Instantiate base class as previous instantiations don't instantiate inherited members
-template class tree
-   < test::movable_and_copyable_int
-   , test::movable_and_copyable_int
-   , identity<test::movable_and_copyable_int>
-   , std::less<test::movable_and_copyable_int>
-   , test::dummy_test_allocator<test::movable_and_copyable_int>
-   , tree_assoc_defaults
-   >;
-
 template class tree
    < test::movable_and_copyable_int
    , test::movable_and_copyable_int
@@ -133,15 +74,6 @@ template class tree
    , tree_assoc_defaults
    >;
 
-template class tree
-   < test::movable_and_copyable_int
-   , test::movable_and_copyable_int
-   , identity<test::movable_and_copyable_int>
-   , std::less<test::movable_and_copyable_int>
-   , allocator<test::movable_and_copyable_int>
-   , tree_assoc_defaults
-   >;
-
 template class tree
    < test::movable_and_copyable_int
    , test::movable_and_copyable_int
@@ -151,15 +83,6 @@ template class tree
    , tree_assoc_defaults
    >;
 
-template class tree
-   < test::movable_and_copyable_int
-   , test::movable_and_copyable_int
-   , identity<test::movable_and_copyable_int>
-   , std::less<test::movable_and_copyable_int>
-   , node_allocator<test::movable_and_copyable_int>
-   , tree_assoc_defaults
-   >;
-
 }  //container_detail {
 
 }} //boost::container
@@ -350,16 +273,6 @@ int main ()
       std::cerr << "test_set_variants< std::allocator<void> > failed" << std::endl;
       return 1;
    }
-   //       boost::container::allocator
-   if(test_set_variants< allocator<void>, red_black_tree>()){
-      std::cerr << "test_set_variants< allocator<void> > failed" << std::endl;
-      return 1;
-   }
-   //       boost::container::node_allocator
-   if(test_set_variants< node_allocator<void>, red_black_tree>()){
-      std::cerr << "test_set_variants< node_allocator<void> > failed" << std::endl;
-      return 1;
-   }
    //       boost::container::adaptive_pool
    if(test_set_variants< adaptive_pool<void>, red_black_tree>()){
       std::cerr << "test_set_variants< adaptive_pool<void> > failed" << std::endl;
diff --git a/test/slist_test.cpp b/test/slist_test.cpp
index fb2a8f5..c07af62 100644
--- a/test/slist_test.cpp
+++ b/test/slist_test.cpp
@@ -9,9 +9,7 @@
 //////////////////////////////////////////////////////////////////////////////
 #include <boost/container/detail/config_begin.hpp>
 #include <boost/container/slist.hpp>
-#include <boost/container/allocator.hpp>
 #include <boost/container/node_allocator.hpp>
-#include <boost/container/adaptive_pool.hpp>
 
 #include <memory>
 #include "dummy_test_allocator.hpp"
@@ -31,22 +29,6 @@ template class boost::container::slist
    < test::movable_and_copyable_int
    , test::simple_allocator<test::movable_and_copyable_int> >;
 
-template class boost::container::slist
-   < test::movable_and_copyable_int
-   , test::dummy_test_allocator<test::movable_and_copyable_int> >;
-
-template class boost::container::slist
-   < test::movable_and_copyable_int
-   , std::allocator<test::movable_and_copyable_int> >;
-
-template class boost::container::slist
-   < test::movable_and_copyable_int
-   , allocator<test::movable_and_copyable_int> >;
-
-template class boost::container::slist
-   < test::movable_and_copyable_int
-   , adaptive_pool<test::movable_and_copyable_int> >;
-
 template class boost::container::slist
    < test::movable_and_copyable_int
    , node_allocator<test::movable_and_copyable_int> >;
@@ -197,21 +179,11 @@ int main ()
       std::cerr << "test_cont_variants< std::allocator<void> > failed" << std::endl;
       return 1;
    }
-   //       boost::container::allocator
-   if(test_cont_variants< allocator<void> >()){
-      std::cerr << "test_cont_variants< allocator<void> > failed" << std::endl;
-      return 1;
-   }
    //       boost::container::node_allocator
    if(test_cont_variants< node_allocator<void> >()){
       std::cerr << "test_cont_variants< node_allocator<void> > failed" << std::endl;
       return 1;
    }
-   //       boost::container::adaptive_pool
-   if(test_cont_variants< adaptive_pool<void> >()){
-      std::cerr << "test_cont_variants< adaptive_pool<void> > failed" << std::endl;
-      return 1;
-   }
 
    ////////////////////////////////////
    //    Emplace testing
diff --git a/test/small_vector_test.cpp b/test/small_vector_test.cpp
index 952dbc8..5c1fc3b 100644
--- a/test/small_vector_test.cpp
+++ b/test/small_vector_test.cpp
@@ -15,8 +15,6 @@
 #include "../../intrusive/test/iterator_test.hpp"
 
 #include <boost/container/allocator.hpp>
-#include <boost/container/node_allocator.hpp>
-#include <boost/container/adaptive_pool.hpp>
 
 #include <iostream>
 
@@ -39,31 +37,11 @@ template class boost::container::small_vector
    , 10
    , test::simple_allocator<test::movable_and_copyable_int> >;
 
-template class boost::container::small_vector
-   < test::movable_and_copyable_int
-   , 10
-   , test::dummy_test_allocator<test::movable_and_copyable_int> >;
-
-template class boost::container::small_vector
-   < test::movable_and_copyable_int
-   , 10
-   , std::allocator<test::movable_and_copyable_int> >;
-
 template class boost::container::small_vector
    < test::movable_and_copyable_int
    , 10
    , allocator<test::movable_and_copyable_int> >;
 
-template class boost::container::small_vector
-   < test::movable_and_copyable_int
-   , 10
-   , adaptive_pool<test::movable_and_copyable_int> >;
-
-template class boost::container::small_vector
-   < test::movable_and_copyable_int
-   , 10
-   , node_allocator<test::movable_and_copyable_int> >;
-
 }}
 
 struct boost_container_small_vector;
diff --git a/test/stable_vector_test.cpp b/test/stable_vector_test.cpp
index be1b91e..1286285 100644
--- a/test/stable_vector_test.cpp
+++ b/test/stable_vector_test.cpp
@@ -12,9 +12,7 @@
 #include <memory>
 
 #include <boost/container/stable_vector.hpp>
-#include <boost/container/allocator.hpp>
 #include <boost/container/node_allocator.hpp>
-#include <boost/container/adaptive_pool.hpp>
 
 #include "check_equal_containers.hpp"
 #include "movable_int.hpp"
@@ -32,23 +30,9 @@ namespace boost {
 namespace container {
 
 //Explicit instantiation to detect compilation errors
-template class stable_vector<test::movable_and_copyable_int,
-   test::dummy_test_allocator<test::movable_and_copyable_int> >;
-
 template class stable_vector<test::movable_and_copyable_int,
    test::simple_allocator<test::movable_and_copyable_int> >;
 
-template class stable_vector<test::movable_and_copyable_int,
-   std::allocator<test::movable_and_copyable_int> >;
-
-template class stable_vector
-   < test::movable_and_copyable_int
-   , allocator<test::movable_and_copyable_int> >;
-
-template class stable_vector
-   < test::movable_and_copyable_int
-   , adaptive_pool<test::movable_and_copyable_int> >;
-
 template class stable_vector
    < test::movable_and_copyable_int
    , node_allocator<test::movable_and_copyable_int> >;
@@ -159,21 +143,11 @@ int main()
       std::cerr << "test_cont_variants< std::allocator<void> > failed" << std::endl;
       return 1;
    }
-   //       boost::container::allocator
-   if(test_cont_variants< allocator<void> >()){
-      std::cerr << "test_cont_variants< allocator<void> > failed" << std::endl;
-      return 1;
-   }
    //       boost::container::node_allocator
    if(test_cont_variants< node_allocator<void> >()){
       std::cerr << "test_cont_variants< node_allocator<void> > failed" << std::endl;
       return 1;
    }
-   //       boost::container::adaptive_pool
-   if(test_cont_variants< adaptive_pool<void> >()){
-      std::cerr << "test_cont_variants< adaptive_pool<void> > failed" << std::endl;
-      return 1;
-   }
 
    ////////////////////////////////////
    //    Default init test
diff --git a/test/string_test.cpp b/test/string_test.cpp
index 75c61a1..47d78c6 100644
--- a/test/string_test.cpp
+++ b/test/string_test.cpp
@@ -28,27 +28,25 @@
 
 using namespace boost::container;
 
-typedef test::dummy_test_allocator<char>           DummyCharAllocator;
-typedef basic_string<char, std::char_traits<char>, DummyCharAllocator> DummyString;
-typedef test::dummy_test_allocator<DummyString>    DummyStringAllocator;
-typedef test::dummy_test_allocator<wchar_t>              DummyWCharAllocator;
-typedef basic_string<wchar_t, std::char_traits<wchar_t>, DummyWCharAllocator> DummyWString;
-typedef test::dummy_test_allocator<DummyWString>         DummyWStringAllocator;
+typedef test::simple_allocator<char>           SimpleCharAllocator;
+typedef basic_string<char, std::char_traits<char>, SimpleCharAllocator> SimpleString;
+typedef test::simple_allocator<SimpleString>    SimpleStringAllocator;
+typedef test::simple_allocator<wchar_t>              SimpleWCharAllocator;
+typedef basic_string<wchar_t, std::char_traits<wchar_t>, SimpleWCharAllocator> SimpleWString;
+typedef test::simple_allocator<SimpleWString>         SimpleWStringAllocator;
 
 namespace boost {
 namespace container {
 
 //Explicit instantiations of container::basic_string
-template class basic_string<char,    std::char_traits<char>, DummyCharAllocator>;
-template class basic_string<wchar_t, std::char_traits<wchar_t>, DummyWCharAllocator>;
-template class basic_string<char,    std::char_traits<char>, test::simple_allocator<char> >;
-template class basic_string<wchar_t, std::char_traits<wchar_t>, test::simple_allocator<wchar_t> >;
+template class basic_string<char,    std::char_traits<char>, SimpleCharAllocator>;
+template class basic_string<wchar_t, std::char_traits<wchar_t>, SimpleWCharAllocator>;
 template class basic_string<char,    std::char_traits<char>, std::allocator<char> >;
 template class basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t> >;
 
 //Explicit instantiation of container::vectors of container::strings
-template class vector<DummyString, DummyStringAllocator>;
-template class vector<DummyWString, DummyWStringAllocator>;
+template class vector<SimpleString, SimpleStringAllocator>;
+template class vector<SimpleWString, SimpleWStringAllocator>;
 
 }}
 
diff --git a/test/vector_test.cpp b/test/vector_test.cpp
index c746440..36eb6dc 100644
--- a/test/vector_test.cpp
+++ b/test/vector_test.cpp
@@ -12,8 +12,6 @@
 
 #include <boost/container/vector.hpp>
 #include <boost/container/allocator.hpp>
-#include <boost/container/node_allocator.hpp>
-#include <boost/container/adaptive_pool.hpp>
 
 #include <boost/move/utility_core.hpp>
 #include "check_equal_containers.hpp"
@@ -36,26 +34,10 @@ template class boost::container::vector
    < test::movable_and_copyable_int
    , test::simple_allocator<test::movable_and_copyable_int> >;
 
-template class boost::container::vector
-   < test::movable_and_copyable_int
-   , test::dummy_test_allocator<test::movable_and_copyable_int> >;
-
-template class boost::container::vector
-   < test::movable_and_copyable_int
-   , std::allocator<test::movable_and_copyable_int> >;
-
 template class boost::container::vector
    < test::movable_and_copyable_int
    , allocator<test::movable_and_copyable_int> >;
 
-template class boost::container::vector
-   < test::movable_and_copyable_int
-   , adaptive_pool<test::movable_and_copyable_int> >;
-
-template class boost::container::vector
-   < test::movable_and_copyable_int
-   , node_allocator<test::movable_and_copyable_int> >;
-
 namespace container_detail {
 
 #ifndef BOOST_CONTAINER_VECTOR_ITERATOR_IS_POINTER
@@ -210,16 +192,6 @@ int main()
       std::cerr << "test_cont_variants< allocator<void> > failed" << std::endl;
       return 1;
    }
-   //       boost::container::node_allocator
-   if(test_cont_variants< node_allocator<void> >()){
-      std::cerr << "test_cont_variants< node_allocator<void> > failed" << std::endl;
-      return 1;
-   }
-   //       boost::container::adaptive_pool
-   if(test_cont_variants< adaptive_pool<void> >()){
-      std::cerr << "test_cont_variants< adaptive_pool<void> > failed" << std::endl;
-      return 1;
-   }
 
    {
       typedef vector<Test, std::allocator<Test> > MyEnumCont;