Adding upstream version 16.2.11+ds.upstream/16.2.11+dsupstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

88 files changed, 21805 insertions, 0 deletions

diff --git a/src/boost/libs/container/test/Jamfile.v2 b/src/boost/libs/container/test/Jamfile.v2
new file mode 100644
index 000000000..2b4995bee
--- /dev/null
+++ b/src/boost/libs/container/test/Jamfile.v2
@@ -0,0 +1,40 @@
+# Boost Container Library Test Jamfile
+
+#  (C) Copyright Ion Gaztanaga 2009-2013.
+# Use, modification and distribution are subject to 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)
+
+# Adapted from John Maddock's TR1 Jamfile.v2
+# Copyright John Maddock 2005.
+# Use, modification and distribution are subject to 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)
+
+project
+    : requirements 
+      <link>shared:<define>BOOST_CONTAINER_DYN_LINK=1 
+      <toolset>gcc-cygwin:<link>static
+    ;
+
+# this rule enumerates through all the sources and invokes
+# the run rule for each source, the result is a list of all
+# the run rules, which we can pass on to the test_suite rule:
+
+rule test_all
+{
+   local all_rules = ;
+
+   for local fileb in [ glob *.cpp ]
+   {
+      all_rules += [ run $(fileb)  /boost/container//boost_container
+      :  # additional args
+      :  # test-files
+      :  # requirements
+      ] ;
+   }
+
+   return $(all_rules) ;
+}
+
+test-suite container_test : [ test_all r ] ;
diff --git a/src/boost/libs/container/test/alloc_basic_test.cpp b/src/boost/libs/container/test/alloc_basic_test.cpp
new file mode 100644
index 000000000..4bfdcf48b
--- /dev/null
+++ b/src/boost/libs/container/test/alloc_basic_test.cpp
@@ -0,0 +1,119 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2007-2013. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/container for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#include <boost/container/detail/dlmalloc.hpp>
+#include <boost/container/allocator.hpp>
+#include <boost/container/vector.hpp>
+#include <boost/container/list.hpp>
+
+using namespace boost::container;
+
+bool basic_test()
+{
+   size_t received = 0;
+   if(!dlmalloc_all_deallocated())
+      return false;
+   void *ptr = dlmalloc_alloc(50, 98, &received);
+   if(dlmalloc_size(ptr) != received)
+      return false;
+   if(dlmalloc_allocated_memory() != dlmalloc_chunksize(ptr))
+      return false;
+
+   if(dlmalloc_all_deallocated())
+      return false;
+
+   dlmalloc_grow(ptr, received + 20, received + 30, &received);
+
+   if(dlmalloc_allocated_memory() != dlmalloc_chunksize(ptr))
+      return false;
+
+   if(dlmalloc_size(ptr) != received)
+      return false;
+
+   if(!dlmalloc_shrink(ptr, 100, 140, &received, 1))
+      return false;
+
+   if(dlmalloc_allocated_memory() != dlmalloc_chunksize(ptr))
+      return false;
+
+   if(!dlmalloc_shrink(ptr, 0, 140, &received, 1))
+      return false;
+
+   if(dlmalloc_allocated_memory() != dlmalloc_chunksize(ptr))
+      return false;
+
+   if(dlmalloc_shrink(ptr, 0, received/2, &received, 1))
+      return false;
+
+   if(dlmalloc_allocated_memory() != dlmalloc_chunksize(ptr))
+      return false;
+
+   if(dlmalloc_size(ptr) != received)
+      return false;
+
+   dlmalloc_free(ptr);
+
+   dlmalloc_malloc_check();
+   if(!dlmalloc_all_deallocated())
+      return false;
+   return true;
+}
+
+bool vector_test()
+{
+   typedef boost::container::vector<int, allocator<int> > Vector;
+   if(!dlmalloc_all_deallocated())
+      return false;
+   {
+      const int NumElem = 1000;
+      Vector v;
+      v.resize(NumElem);
+      int *orig_buf = &v[0];
+      int *new_buf  = &v[0];
+      while(orig_buf == new_buf){
+         Vector::size_type cl = v.capacity() - v.size();
+         while(cl--){
+            v.push_back(0);
+         }
+         v.push_back(0);
+         new_buf = &v[0];
+      }
+   }
+   if(!dlmalloc_all_deallocated())
+      return false;
+   return true;
+}
+
+bool list_test()
+{
+   typedef boost::container::list<int, allocator<int> > List;
+   if(!dlmalloc_all_deallocated())
+      return false;
+   {
+      const int NumElem = 1000;
+      List l;
+      int values[NumElem];
+      l.insert(l.end(), &values[0], &values[NumElem]);
+   }
+   if(!dlmalloc_all_deallocated())
+      return false;
+   return true;
+}
+
+int main()
+{
+   if(!basic_test())
+      return 1;
+   if(!vector_test())
+      return 1;
+   if(!list_test())
+      return 1;
+   return 0;
+}
diff --git a/src/boost/libs/container/test/alloc_full_test.cpp b/src/boost/libs/container/test/alloc_full_test.cpp
new file mode 100644
index 000000000..54e1160c9
--- /dev/null
+++ b/src/boost/libs/container/test/alloc_full_test.cpp
@@ -0,0 +1,849 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2007-2013. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/container for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+
+#ifdef _MSC_VER
+#pragma warning (disable:4702)
+#endif
+
+#include <vector>
+#include <iostream>
+#include <cstring>
+#include <algorithm>    //std::remove
+#include <boost/container/detail/dlmalloc.hpp>
+
+namespace boost { namespace container { namespace test {
+
+static const int NumIt = 200;
+
+enum deallocation_type { DirectDeallocation, InverseDeallocation, MixedDeallocation, EndDeallocationType };
+
+//This test allocates until there is no more memory
+//and after that deallocates all in the inverse order
+
+bool test_allocation()
+{
+   if(!dlmalloc_all_deallocated())
+      return false;
+   dlmalloc_malloc_check();
+   for( deallocation_type t = DirectDeallocation
+      ; t != EndDeallocationType
+      ; t = (deallocation_type)((int)t + 1)){
+      std::vector<void*> buffers;
+      //std::size_t free_memory = a.get_free_memory();
+
+      for(int i = 0; i != NumIt; ++i){
+         void *ptr = dlmalloc_malloc(i);
+         if(!ptr)
+            break;
+         buffers.push_back(ptr);
+      }
+
+      switch(t){
+         case DirectDeallocation:
+         {
+            for(int j = 0, max = (int)buffers.size()
+               ;j < max
+               ;++j){
+               dlmalloc_free(buffers[j]);
+            }
+         }
+         break;
+         case InverseDeallocation:
+         {
+            for(int j = (int)buffers.size()
+               ;j--
+               ;){
+               dlmalloc_free(buffers[j]);
+            }
+         }
+         break;
+         case MixedDeallocation:
+         {
+            for(int j = 0, max = (int)buffers.size()
+               ;j < max
+               ;++j){
+               int pos = (j%4)*((int)buffers.size())/4;
+               dlmalloc_free(buffers[pos]);
+               buffers.erase(buffers.begin()+pos);
+            }
+         }
+         break;
+         default:
+         break;
+      }
+      if(!dlmalloc_all_deallocated())
+         return false;
+      //bool ok = free_memory == a.get_free_memory() &&
+               //a.all_memory_deallocated() && a.check_sanity();
+      //if(!ok)  return ok;
+   }
+   dlmalloc_malloc_check();
+   return 0 != dlmalloc_all_deallocated();
+}
+
+//This test allocates until there is no more memory
+//and after that tries to shrink all the buffers to the
+//half of the original size
+
+bool test_allocation_shrink()
+{
+   dlmalloc_malloc_check();
+   std::vector<void*> buffers;
+
+   //Allocate buffers with extra memory
+   for(int i = 0; i != NumIt; ++i){
+      void *ptr = dlmalloc_malloc(i*2);
+      if(!ptr)
+         break;
+      buffers.push_back(ptr);
+   }
+
+   //Now shrink to half
+   for(int i = 0, max = (int)buffers.size()
+      ;i < max
+      ; ++i){
+      std::size_t try_received_size = 0;
+      void* try_result = dlmalloc_allocation_command
+               ( BOOST_CONTAINER_TRY_SHRINK_IN_PLACE, 1, i*2
+               , i, &try_received_size, (char*)buffers[i]).first;
+
+      std::size_t received_size = 0;
+      void* result = dlmalloc_allocation_command
+         ( BOOST_CONTAINER_SHRINK_IN_PLACE, 1, i*2
+         , i, &received_size, (char*)buffers[i]).first;
+
+      if(result != try_result)
+         return false;
+
+      if(received_size != try_received_size)
+         return false;
+
+      if(result){
+         if(received_size > std::size_t(i*2)){
+            return false;
+         }
+         if(received_size < std::size_t(i)){
+            return false;
+         }
+      }
+   }
+
+   //Deallocate it in non sequential order
+   for(int j = 0, max = (int)buffers.size()
+      ;j < max
+      ;++j){
+      int pos = (j%4)*((int)buffers.size())/4;
+      dlmalloc_free(buffers[pos]);
+      buffers.erase(buffers.begin()+pos);
+   }
+   dlmalloc_malloc_check();
+   return 0 != dlmalloc_all_deallocated();//a.all_memory_deallocated() && a.check_sanity();
+}
+
+//This test allocates until there is no more memory
+//and after that tries to expand all the buffers to
+//avoid the wasted internal fragmentation
+
+bool test_allocation_expand()
+{
+   dlmalloc_malloc_check();
+   std::vector<void*> buffers;
+
+   //Allocate buffers with extra memory
+   for(int i = 0; i != NumIt; ++i){
+      void *ptr = dlmalloc_malloc(i);
+      if(!ptr)
+         break;
+      buffers.push_back(ptr);
+   }
+
+   //Now try to expand to the double of the size
+   for(int i = 0, max = (int)buffers.size()
+      ;i < max
+      ;++i){
+      std::size_t received_size = 0;
+      std::size_t min_size = i+1;
+      std::size_t preferred_size = i*2;
+      preferred_size = min_size > preferred_size ? min_size : preferred_size;
+      while(dlmalloc_allocation_command
+         ( BOOST_CONTAINER_EXPAND_FWD, 1, min_size
+         , preferred_size, &received_size, (char*)buffers[i]).first){
+         //Check received size is bigger than minimum
+         if(received_size < min_size){
+            return false;
+         }
+         //Now, try to expand further
+         min_size       = received_size+1;
+         preferred_size = min_size*2;
+      }
+   }
+
+   //Deallocate it in non sequential order
+   for(int j = 0, max = (int)buffers.size()
+      ;j < max
+      ;++j){
+      int pos = (j%4)*((int)buffers.size())/4;
+      dlmalloc_free(buffers[pos]);
+      buffers.erase(buffers.begin()+pos);
+   }
+   dlmalloc_malloc_check();
+   return 0 != dlmalloc_all_deallocated();//a.all_memory_deallocated() && a.check_sanity();
+}
+
+//This test allocates until there is no more memory
+//and after that tries to expand all the buffers to
+//avoid the wasted internal fragmentation
+bool test_allocation_shrink_and_expand()
+{
+   std::vector<void*> buffers;
+   std::vector<std::size_t> received_sizes;
+   std::vector<bool>        size_reduced;
+
+   //Allocate buffers wand store received sizes
+   for(int i = 0; i != NumIt; ++i){
+      std::size_t received_size = 0;
+      void *ptr = dlmalloc_allocation_command
+         (BOOST_CONTAINER_ALLOCATE_NEW, 1, i, i*2, &received_size, 0).first;
+      if(!ptr){
+         ptr = dlmalloc_allocation_command
+            ( BOOST_CONTAINER_ALLOCATE_NEW, 1, 1, i*2, &received_size, 0).first;
+         if(!ptr)
+            break;
+      }
+      buffers.push_back(ptr);
+      received_sizes.push_back(received_size);
+   }
+
+   //Now shrink to half
+   for(int i = 0, max = (int)buffers.size()
+      ; i < max
+      ; ++i){
+      std::size_t received_size = 0;
+      bool size_reduced_flag;
+      if(true == (size_reduced_flag = !!
+         dlmalloc_allocation_command
+         ( BOOST_CONTAINER_SHRINK_IN_PLACE, 1, received_sizes[i]
+         , i, &received_size, (char*)buffers[i]).first)){
+         if(received_size > std::size_t(received_sizes[i])){
+            return false;
+         }
+         if(received_size < std::size_t(i)){
+            return false;
+         }
+      }
+      size_reduced.push_back(size_reduced_flag);
+   }
+
+   //Now try to expand to the original size
+   for(int i = 0, max = (int)buffers.size()
+      ;i < max
+      ;++i){
+      if(!size_reduced[i])  continue;
+      std::size_t received_size = 0;
+      std::size_t request_size =  received_sizes[i];
+      if(dlmalloc_allocation_command
+         ( BOOST_CONTAINER_EXPAND_FWD, 1, request_size
+         , request_size, &received_size, (char*)buffers[i]).first){
+         if(received_size != request_size){
+            return false;
+         }
+      }
+      else{
+         return false;
+      }
+   }
+
+   //Deallocate it in non sequential order
+   for(int j = 0, max = (int)buffers.size()
+      ;j < max
+      ;++j){
+      int pos = (j%4)*((int)buffers.size())/4;
+      dlmalloc_free(buffers[pos]);
+      buffers.erase(buffers.begin()+pos);
+   }
+
+   return 0 != dlmalloc_all_deallocated();//a.all_memory_deallocated() && a.check_sanity();
+}
+
+//This test allocates until there is no more memory
+//and after that deallocates the odd buffers to
+//make room for expansions. The expansion will probably
+//success since the deallocation left room for that.
+
+bool test_allocation_deallocation_expand()
+{
+   dlmalloc_malloc_check();
+   std::vector<void*> buffers;
+
+   //Allocate buffers with extra memory
+   for(int i = 0; i != NumIt; ++i){
+      void *ptr = dlmalloc_malloc(i);
+      if(!ptr)
+         break;
+      buffers.push_back(ptr);
+   }
+
+   //Now deallocate the half of the blocks
+   //so expand maybe can merge new free blocks
+   for(int i = 0, max = (int)buffers.size()
+      ;i < max
+      ;++i){
+      if(i%2){
+         dlmalloc_free(buffers[i]);
+         buffers[i] = 0;
+      }
+   }
+
+   //Now try to expand to the double of the size
+   for(int i = 0, max = (int)buffers.size()
+      ;i < max
+      ;++i){
+      //
+      if(buffers[i]){
+         std::size_t received_size = 0;
+         std::size_t min_size = i+1;
+         std::size_t preferred_size = i*2;
+         preferred_size = min_size > preferred_size ? min_size : preferred_size;
+
+         while(dlmalloc_allocation_command
+            ( BOOST_CONTAINER_EXPAND_FWD, 1, min_size
+            , preferred_size, &received_size, (char*)buffers[i]).first){
+            //Check received size is bigger than minimum
+            if(received_size < min_size){
+               return false;
+            }
+            //Now, try to expand further
+            min_size       = received_size+1;
+            preferred_size = min_size*2;
+         }
+      }
+   }
+
+   //Now erase null values from the vector
+   buffers.erase(std::remove(buffers.begin(), buffers.end(), (void*)0)
+                ,buffers.end());
+
+   //Deallocate it in non sequential order
+   for(int j = 0, max = (int)buffers.size()
+      ;j < max
+      ;++j){
+      int pos = (j%4)*((int)buffers.size())/4;
+      dlmalloc_free(buffers[pos]);
+      buffers.erase(buffers.begin()+pos);
+   }
+   dlmalloc_malloc_check();
+   return 0 != dlmalloc_all_deallocated();//a.all_memory_deallocated() && a.check_sanity();
+}
+
+//This test allocates until there is no more memory
+//and after that deallocates all except the last.
+//If the allocation algorithm is a bottom-up algorithm
+//the last buffer will be in the end of the segment.
+//Then the test will start expanding backwards, until
+//the buffer fills all the memory
+
+bool test_allocation_with_reuse()
+{
+   dlmalloc_malloc_check();
+   //We will repeat this test for different sized elements
+   for(int sizeof_object = 1; sizeof_object < 20; ++sizeof_object){
+      std::vector<void*> buffers;
+
+      //Allocate buffers with extra memory
+      for(int i = 0; i != NumIt; ++i){
+         void *ptr = dlmalloc_malloc(i*sizeof_object);
+         if(!ptr)
+            break;
+         buffers.push_back(ptr);
+      }
+
+      //Now deallocate all except the latest
+      //Now try to expand to the double of the size
+      for(int i = 0, max = (int)buffers.size() - 1
+         ;i < max
+         ;++i){
+         dlmalloc_free(buffers[i]);
+      }
+
+      //Save the unique buffer and clear vector
+      void *ptr = buffers.back();
+      buffers.clear();
+
+      //Now allocate with reuse
+      std::size_t received_size = 0;
+      for(int i = 0; i != NumIt; ++i){
+         std::size_t min_size = (received_size/sizeof_object + 1)*sizeof_object;
+         std::size_t prf_size = (received_size/sizeof_object + (i+1)*2)*sizeof_object;
+         dlmalloc_command_ret_t ret = dlmalloc_allocation_command
+            ( BOOST_CONTAINER_EXPAND_BWD, sizeof_object, min_size
+            , prf_size, &received_size, (char*)ptr);
+         //If we have memory, this must be a buffer reuse
+         if(!ret.first)
+            break;
+         //If we have memory, this must be a buffer reuse
+         if(!ret.second)
+            return false;
+         if(received_size < min_size)
+            return false;
+         ptr = ret.first;
+      }
+      //There should be only a single block so deallocate it
+      dlmalloc_free(ptr);
+      dlmalloc_malloc_check();
+      if(!dlmalloc_all_deallocated())
+         return false;
+   }
+   return true;
+}
+
+
+//This test allocates memory with different alignments
+//and checks returned memory is aligned.
+
+bool test_aligned_allocation()
+{
+   dlmalloc_malloc_check();
+   //Allocate aligned buffers in a loop
+   //and then deallocate it
+   for(unsigned int i = 1; i != (1 << (sizeof(int)/2)); i <<= 1){
+      for(unsigned int j = 1; j != 512; j <<= 1){
+         void *ptr = dlmalloc_memalign(i-1, j);
+         if(!ptr){
+            return false;
+         }
+
+         if(((std::size_t)ptr & (j - 1)) != 0)
+            return false;
+         dlmalloc_free(ptr);
+         //if(!a.all_memory_deallocated() || !a.check_sanity()){
+         //   return false;
+         //}
+      }
+   }
+   dlmalloc_malloc_check();
+   return 0 != dlmalloc_all_deallocated();//a.all_memory_deallocated() && a.check_sanity();
+}
+
+//This test allocates memory with different alignments
+//and checks returned memory is aligned.
+
+bool test_continuous_aligned_allocation()
+{
+   dlmalloc_malloc_check();
+   std::vector<void*> buffers;
+   //Allocate aligned buffers in a loop
+   //and then deallocate it
+   bool continue_loop = true;
+   unsigned int MaxAlign = 4096;
+   unsigned int MaxSize  = 4096;
+   for(unsigned i = 1; i < MaxSize; i <<= 1){
+      for(unsigned int j = 1; j < MaxAlign; j <<= 1){
+         for(int k = 0; k != NumIt; ++k){
+            void *ptr = dlmalloc_memalign(i-1, j);
+            buffers.push_back(ptr);
+            if(!ptr){
+               continue_loop = false;
+               break;
+            }
+
+            if(((std::size_t)ptr & (j - 1)) != 0)
+               return false;
+         }
+         //Deallocate all
+         for(int k = (int)buffers.size(); k--;){
+            dlmalloc_free(buffers[k]);
+         }
+         buffers.clear();
+         //if(!a.all_memory_deallocated() && a.check_sanity())
+         //   return false;
+         if(!continue_loop)
+            break;
+      }
+   }
+   dlmalloc_malloc_check();
+   return 0 != dlmalloc_all_deallocated();//a.all_memory_deallocated() && a.check_sanity();
+}
+
+//This test allocates multiple values until there is no more memory
+//and after that deallocates all in the inverse order
+bool test_many_equal_allocation()
+{
+   dlmalloc_malloc_check();
+   for( deallocation_type t = DirectDeallocation
+      ; t != EndDeallocationType
+      ; t = (deallocation_type)((int)t + 1)){
+      //std::size_t free_memory = a.get_free_memory();
+
+      std::vector<void*> buffers2;
+
+      //Allocate buffers with extra memory
+      for(int i = 0; i != NumIt; ++i){
+         void *ptr = dlmalloc_malloc(i);
+         if(!ptr)
+            break;
+         //if(!a.check_sanity())
+            //return false;
+         buffers2.push_back(ptr);
+      }
+
+      //Now deallocate the half of the blocks
+      //so expand maybe can merge new free blocks
+      for(int i = 0, max = (int)buffers2.size()
+         ;i < max
+         ;++i){
+         if(i%2){
+            dlmalloc_free(buffers2[i]);
+            buffers2[i] = 0;
+         }
+      }
+
+      //if(!a.check_sanity())
+         //return false;
+
+      std::vector<void*> buffers;
+      for(int i = 0; i != NumIt/10; ++i){
+         dlmalloc_memchain chain;
+         BOOST_CONTAINER_MEMCHAIN_INIT(&chain);
+         dlmalloc_multialloc_nodes((i+1)*2, i+1, DL_MULTIALLOC_DEFAULT_CONTIGUOUS, &chain);
+         dlmalloc_memchain_it it = BOOST_CONTAINER_MEMCHAIN_BEGIN_IT(&chain);
+         if(BOOST_CONTAINER_MEMCHAIN_IS_END_IT(chain, it))
+            break;
+
+         std::size_t n = 0;
+         for(; !BOOST_CONTAINER_MEMCHAIN_IS_END_IT(chain, it); ++n){
+            buffers.push_back(BOOST_CONTAINER_MEMIT_ADDR(it));
+            BOOST_CONTAINER_MEMIT_NEXT(it);
+         }
+         if(n != std::size_t((i+1)*2))
+            return false;
+      }
+
+      //if(!a.check_sanity())
+         //return false;
+
+      switch(t){
+         case DirectDeallocation:
+         {
+            for(int j = 0, max = (int)buffers.size()
+               ;j < max
+               ;++j){
+               dlmalloc_free(buffers[j]);
+            }
+         }
+         break;
+         case InverseDeallocation:
+         {
+            for(int j = (int)buffers.size()
+               ;j--
+               ;){
+               dlmalloc_free(buffers[j]);
+            }
+         }
+         break;
+         case MixedDeallocation:
+         {
+            for(int j = 0, max = (int)buffers.size()
+               ;j < max
+               ;++j){
+               int pos = (j%4)*((int)buffers.size())/4;
+               dlmalloc_free(buffers[pos]);
+               buffers.erase(buffers.begin()+pos);
+            }
+         }
+         break;
+         default:
+         break;
+      }
+
+      //Deallocate the rest of the blocks
+
+      //Deallocate it in non sequential order
+      for(int j = 0, max = (int)buffers2.size()
+         ;j < max
+         ;++j){
+         int pos = (j%4)*((int)buffers2.size())/4;
+         dlmalloc_free(buffers2[pos]);
+         buffers2.erase(buffers2.begin()+pos);
+      }
+
+      //bool ok = free_memory == a.get_free_memory() &&
+               //a.all_memory_deallocated() && a.check_sanity();
+      //if(!ok)  return ok;
+   }
+   dlmalloc_malloc_check();
+   return 0 != dlmalloc_all_deallocated();
+}
+
+//This test allocates multiple values until there is no more memory
+//and after that deallocates all in the inverse order
+
+bool test_many_different_allocation()
+{
+   dlmalloc_malloc_check();
+   const std::size_t ArraySize = 11;
+   std::size_t requested_sizes[ArraySize];
+   for(std::size_t i = 0; i < ArraySize; ++i){
+      requested_sizes[i] = 4*i;
+   }
+
+   for( deallocation_type t = DirectDeallocation
+      ; t != EndDeallocationType
+      ; t = (deallocation_type)((int)t + 1)){
+      //std::size_t free_memory = a.get_free_memory();
+
+      std::vector<void*> buffers2;
+
+      //Allocate buffers with extra memory
+      for(int i = 0; i != NumIt; ++i){
+         void *ptr = dlmalloc_malloc(i);
+         if(!ptr)
+            break;
+         buffers2.push_back(ptr);
+      }
+
+      //Now deallocate the half of the blocks
+      //so expand maybe can merge new free blocks
+      for(int i = 0, max = (int)buffers2.size()
+         ;i < max
+         ;++i){
+         if(i%2){
+            dlmalloc_free(buffers2[i]);
+            buffers2[i] = 0;
+         }
+      }
+
+      std::vector<void*> buffers;
+      for(int i = 0; i != NumIt; ++i){
+         dlmalloc_memchain chain;
+         BOOST_CONTAINER_MEMCHAIN_INIT(&chain);
+         dlmalloc_multialloc_arrays(ArraySize, requested_sizes, 1, DL_MULTIALLOC_DEFAULT_CONTIGUOUS, &chain);
+         dlmalloc_memchain_it it = BOOST_CONTAINER_MEMCHAIN_BEGIN_IT(&chain);
+         if(BOOST_CONTAINER_MEMCHAIN_IS_END_IT(chain, it))
+            break;
+         std::size_t n = 0;
+         for(; !BOOST_CONTAINER_MEMCHAIN_IS_END_IT(chain, it); ++n){
+            buffers.push_back(BOOST_CONTAINER_MEMIT_ADDR(it));
+            BOOST_CONTAINER_MEMIT_NEXT(it);
+         }
+         if(n != ArraySize)
+            return false;
+      }
+
+      switch(t){
+         case DirectDeallocation:
+         {
+            for(int j = 0, max = (int)buffers.size()
+               ;j < max
+               ;++j){
+               dlmalloc_free(buffers[j]);
+            }
+         }
+         break;
+         case InverseDeallocation:
+         {
+            for(int j = (int)buffers.size()
+               ;j--
+               ;){
+               dlmalloc_free(buffers[j]);
+            }
+         }
+         break;
+         case MixedDeallocation:
+         {
+            for(int j = 0, max = (int)buffers.size()
+               ;j < max
+               ;++j){
+               int pos = (j%4)*((int)buffers.size())/4;
+               dlmalloc_free(buffers[pos]);
+               buffers.erase(buffers.begin()+pos);
+            }
+         }
+         break;
+         default:
+         break;
+      }
+
+      //Deallocate the rest of the blocks
+
+      //Deallocate it in non sequential order
+      for(int j = 0, max = (int)buffers2.size()
+         ;j < max
+         ;++j){
+         int pos = (j%4)*((int)buffers2.size())/4;
+         dlmalloc_free(buffers2[pos]);
+         buffers2.erase(buffers2.begin()+pos);
+      }
+
+      //bool ok = free_memory == a.get_free_memory() &&
+               //a.all_memory_deallocated() && a.check_sanity();
+      //if(!ok)  return ok;
+   }
+   dlmalloc_malloc_check();
+   return 0 != dlmalloc_all_deallocated();
+}
+
+bool test_many_deallocation()
+{
+   const std::size_t ArraySize = 11;
+   std::vector<dlmalloc_memchain> buffers;
+   std::size_t requested_sizes[ArraySize];
+   for(std::size_t i = 0; i < ArraySize; ++i){
+      requested_sizes[i] = 4*i;
+   }
+
+   for(int i = 0; i != NumIt; ++i){
+      dlmalloc_memchain chain;
+      BOOST_CONTAINER_MEMCHAIN_INIT(&chain);
+      dlmalloc_multialloc_arrays(ArraySize, requested_sizes, 1, DL_MULTIALLOC_DEFAULT_CONTIGUOUS, &chain);
+      dlmalloc_memchain_it it = BOOST_CONTAINER_MEMCHAIN_BEGIN_IT(&chain);
+      if(BOOST_CONTAINER_MEMCHAIN_IS_END_IT(chain, it))
+         return false;
+      buffers.push_back(chain);
+   }
+   for(int i = 0; i != NumIt; ++i){
+      dlmalloc_multidealloc(&buffers[i]);
+   }
+   buffers.clear();
+
+   dlmalloc_malloc_check();
+   if(!dlmalloc_all_deallocated())
+      return false;
+
+   for(int i = 0; i != NumIt; ++i){
+      dlmalloc_memchain chain;
+      BOOST_CONTAINER_MEMCHAIN_INIT(&chain);
+      dlmalloc_multialloc_nodes(ArraySize, i*4+1, DL_MULTIALLOC_DEFAULT_CONTIGUOUS, &chain);
+      dlmalloc_memchain_it it = BOOST_CONTAINER_MEMCHAIN_BEGIN_IT(&chain);
+      if(BOOST_CONTAINER_MEMCHAIN_IS_END_IT(chain, it))
+         return false;
+      buffers.push_back(chain);
+   }
+   for(int i = 0; i != NumIt; ++i){
+      dlmalloc_multidealloc(&buffers[i]);
+   }
+   buffers.clear();
+
+   dlmalloc_malloc_check();
+   if(!dlmalloc_all_deallocated())
+      return false;
+
+   return true;
+}
+
+//This function calls all tests
+
+bool test_all_allocation()
+{
+   std::cout << "Starting test_allocation"
+             << std::endl;
+
+   if(!test_allocation()){
+      std::cout << "test_allocation_direct_deallocation failed"
+                << std::endl;
+      return false;
+   }
+
+   std::cout << "Starting test_many_equal_allocation"
+             << std::endl;
+
+   if(!test_many_equal_allocation()){
+      std::cout << "test_many_equal_allocation failed"
+                << std::endl;
+      return false;
+   }
+
+   std::cout << "Starting test_many_different_allocation"
+             << std::endl;
+
+   if(!test_many_different_allocation()){
+      std::cout << "test_many_different_allocation failed"
+                << std::endl;
+      return false;
+   }
+
+   std::cout << "Starting test_allocation_shrink"
+             << std::endl;
+
+   if(!test_allocation_shrink()){
+      std::cout << "test_allocation_shrink failed"
+                << std::endl;
+      return false;
+   }
+
+   if(!test_allocation_shrink_and_expand()){
+      std::cout << "test_allocation_shrink_and_expand failed"
+                << std::endl;
+      return false;
+   }
+
+   std::cout << "Starting test_allocation_expand"
+             << std::endl;
+
+   if(!test_allocation_expand()){
+      std::cout << "test_allocation_expand failed"
+                << std::endl;
+      return false;
+   }
+
+   std::cout << "Starting test_allocation_deallocation_expand"
+             << std::endl;
+
+   if(!test_allocation_deallocation_expand()){
+      std::cout << "test_allocation_deallocation_expand failed"
+                << std::endl;
+      return false;
+   }
+
+   std::cout << "Starting test_allocation_with_reuse"
+             << std::endl;
+
+   if(!test_allocation_with_reuse()){
+      std::cout << "test_allocation_with_reuse failed"
+                << std::endl;
+      return false;
+   }
+
+   std::cout << "Starting test_aligned_allocation"
+             << std::endl;
+
+   if(!test_aligned_allocation()){
+      std::cout << "test_aligned_allocation failed"
+                << std::endl;
+      return false;
+   }
+
+   std::cout << "Starting test_continuous_aligned_allocation"
+             << std::endl;
+
+   if(!test_continuous_aligned_allocation()){
+      std::cout << "test_continuous_aligned_allocation failed"
+                << std::endl;
+      return false;
+   }
+
+   if(!test_many_deallocation()){
+      std::cout << "test_many_deallocation failed"
+                << std::endl;
+      return false;
+   }
+
+   return 0 != dlmalloc_all_deallocated();
+}
+
+}}}   //namespace boost { namespace container { namespace test {
+
+
+int main()
+{
+   if(!boost::container::test::test_all_allocation())
+      return 1;
+   return 0;
+}
diff --git a/src/boost/libs/container/test/allocator_argument_tester.hpp b/src/boost/libs/container/test/allocator_argument_tester.hpp
new file mode 100644
index 000000000..73993285e
--- /dev/null
+++ b/src/boost/libs/container/test/allocator_argument_tester.hpp
@@ -0,0 +1,233 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2015-2015. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/container for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#ifndef BOOST_CONTAINER_TEST_ALLOCATOR_ARGUMENT_TESTER_HPP
+#define BOOST_CONTAINER_TEST_ALLOCATOR_ARGUMENT_TESTER_HPP
+
+#include <boost/container/uses_allocator.hpp>
+#include <boost/container/detail/mpl.hpp>
+#include <boost/move/core.hpp>
+
+template<class T, unsigned int Id, bool HasTrueTypes = false>
+class propagation_test_allocator
+{
+   BOOST_COPYABLE_AND_MOVABLE(propagation_test_allocator)
+   public:
+
+   template<class U>
+   struct rebind
+   {
+      typedef propagation_test_allocator<U, Id, HasTrueTypes> other;
+   };
+
+   typedef boost::container::dtl::bool_<HasTrueTypes>  propagate_on_container_copy_assignment;
+   typedef boost::container::dtl::bool_<HasTrueTypes>  propagate_on_container_move_assignment;
+   typedef boost::container::dtl::bool_<HasTrueTypes>  propagate_on_container_swap;
+   typedef boost::container::dtl::bool_<HasTrueTypes>  is_always_equal;
+   typedef T value_type;
+
+   propagation_test_allocator()
+      : m_move_contructed(false), m_move_assigned(false)
+   {}
+
+   propagation_test_allocator(const propagation_test_allocator&)
+      : m_move_contructed(false), m_move_assigned(false)
+   {}
+
+   propagation_test_allocator(BOOST_RV_REF(propagation_test_allocator) )
+      : m_move_contructed(true), m_move_assigned(false)
+   {}
+
+   template<class U>
+   propagation_test_allocator(BOOST_RV_REF_BEG propagation_test_allocator<U, Id, HasTrueTypes> BOOST_RV_REF_END)
+      : m_move_contructed(true), m_move_assigned(false)
+   {}
+
+   template<class U>
+   propagation_test_allocator(const propagation_test_allocator<U, Id, HasTrueTypes> &)
+   {}
+
+   propagation_test_allocator & operator=(BOOST_COPY_ASSIGN_REF(propagation_test_allocator))
+   {
+      return *this;
+   }
+
+   propagation_test_allocator & operator=(BOOST_RV_REF(propagation_test_allocator))
+   {
+      m_move_assigned = true;
+      return *this;
+   }
+
+   std::size_t max_size() const
+   {  return std::size_t(-1);  }
+
+   T* allocate(std::size_t n)
+   {  return (T*)::new char[n*sizeof(T)];  }
+
+   void deallocate(T*p, std::size_t)
+   {  delete []static_cast<char*>(static_cast<void*>(p));  }
+
+   bool m_move_contructed;
+   bool m_move_assigned;
+};
+
+template <class T1, class T2, unsigned int Id, bool HasTrueTypes>
+bool operator==( const propagation_test_allocator<T1, Id, HasTrueTypes>&
+               , const propagation_test_allocator<T2, Id, HasTrueTypes>&)
+{  return true;   }
+
+template <class T1, class T2, unsigned int Id, bool HasTrueTypes>
+bool operator!=( const propagation_test_allocator<T1, Id, HasTrueTypes>&
+               , const propagation_test_allocator<T2, Id, HasTrueTypes>&)
+{  return false;   }
+
+//This enum lists the construction options
+//for an allocator-aware type
+enum ConstructionTypeEnum
+{
+   ConstructiblePrefix,
+   ConstructibleSuffix,
+   NotUsesAllocator
+};
+
+//This base class provices types for
+//the derived class to implement each construction
+//type. If a construction type does not apply
+//the typedef is set to an internal nat
+//so that the class is not constructible from
+//the user arguments.
+template<ConstructionTypeEnum ConstructionType, unsigned int AllocatorTag>
+struct uses_allocator_base;
+
+template<unsigned int AllocatorTag>
+struct uses_allocator_base<ConstructibleSuffix, AllocatorTag>
+{
+   typedef propagation_test_allocator<int, AllocatorTag> allocator_type;
+   typedef allocator_type allocator_constructor_type;
+   struct nat{};
+   typedef nat allocator_arg_type;
+};
+
+template<unsigned int AllocatorTag>
+struct uses_allocator_base<ConstructiblePrefix, AllocatorTag>
+{
+   typedef propagation_test_allocator<int, AllocatorTag> allocator_type;
+   typedef allocator_type allocator_constructor_type;
+   typedef boost::container::allocator_arg_t allocator_arg_type;
+};
+
+template<unsigned int AllocatorTag>
+struct uses_allocator_base<NotUsesAllocator, AllocatorTag>
+{
+   struct nat{};
+   typedef nat allocator_constructor_type;
+   typedef nat allocator_arg_type;
+};
+
+template<ConstructionTypeEnum ConstructionType, unsigned int AllocatorTag>
+struct allocator_argument_tester
+   : uses_allocator_base<ConstructionType, AllocatorTag>
+{
+   private:
+   BOOST_COPYABLE_AND_MOVABLE(allocator_argument_tester)
+
+   public:
+
+   typedef uses_allocator_base<ConstructionType, AllocatorTag> base_type;
+
+   //0 user argument constructors
+   allocator_argument_tester()
+      : construction_type(NotUsesAllocator), value(0)
+   {}
+
+   explicit allocator_argument_tester
+      (typename base_type::allocator_constructor_type)
+      : construction_type(ConstructibleSuffix), value(0)
+   {}
+
+   explicit allocator_argument_tester
+      (typename base_type::allocator_arg_type, typename base_type::allocator_constructor_type)
+      : construction_type(ConstructiblePrefix), value(0)
+   {}
+
+   //1 user argument constructors
+   explicit allocator_argument_tester(int i)
+      : construction_type(NotUsesAllocator), value(i)
+   {}
+
+   allocator_argument_tester
+      (int i, typename base_type::allocator_constructor_type)
+      : construction_type(ConstructibleSuffix), value(i)
+   {}
+
+   allocator_argument_tester
+      ( typename base_type::allocator_arg_type
+      , typename base_type::allocator_constructor_type
+      , int i)
+      : construction_type(ConstructiblePrefix), value(i)
+   {}
+
+   //Copy constructors
+   allocator_argument_tester(const allocator_argument_tester &other)
+      : construction_type(NotUsesAllocator), value(other.value)
+   {}
+
+   allocator_argument_tester( const allocator_argument_tester &other
+                            , typename base_type::allocator_constructor_type)
+      : construction_type(ConstructibleSuffix), value(other.value)
+   {}
+
+   allocator_argument_tester( typename base_type::allocator_arg_type
+                            , typename base_type::allocator_constructor_type
+                            , const allocator_argument_tester &other)
+      : construction_type(ConstructiblePrefix), value(other.value)
+   {}
+
+   //Move constructors
+   allocator_argument_tester(BOOST_RV_REF(allocator_argument_tester) other)
+      : construction_type(NotUsesAllocator), value(other.value)
+   {  other.value = 0;  other.construction_type = NotUsesAllocator;  }
+
+   allocator_argument_tester( BOOST_RV_REF(allocator_argument_tester) other
+                            , typename base_type::allocator_constructor_type)
+      : construction_type(ConstructibleSuffix), value(other.value)
+   {  other.value = 0;  other.construction_type = ConstructibleSuffix;  }
+
+   allocator_argument_tester( typename base_type::allocator_arg_type
+                            , typename base_type::allocator_constructor_type
+                            , BOOST_RV_REF(allocator_argument_tester) other)
+      : construction_type(ConstructiblePrefix), value(other.value)
+   {  other.value = 0;  other.construction_type = ConstructiblePrefix;  }
+
+   ConstructionTypeEnum construction_type;
+   int                  value;
+};
+
+namespace boost {
+namespace container {
+
+template<unsigned int AllocatorTag>
+struct constructible_with_allocator_prefix
+   < ::allocator_argument_tester<ConstructiblePrefix, AllocatorTag> >
+{
+   static const bool value = true;
+};
+
+template<unsigned int AllocatorTag>
+struct constructible_with_allocator_suffix
+   < ::allocator_argument_tester<ConstructibleSuffix, AllocatorTag> >
+{
+   static const bool value = true;
+};
+
+}  //namespace container {
+}  //namespace boost {
+
+#endif   //BOOST_CONTAINER_TEST_ALLOCATOR_ARGUMENT_TESTER_HPP
diff --git a/src/boost/libs/container/test/allocator_traits_test.cpp b/src/boost/libs/container/test/allocator_traits_test.cpp
new file mode 100644
index 000000000..401442414
--- /dev/null
+++ b/src/boost/libs/container/test/allocator_traits_test.cpp
@@ -0,0 +1,447 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2011-2013. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/container for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+#include <boost/container/detail/config_begin.hpp>
+#include <cstddef>
+#include <boost/container/allocator_traits.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/container/detail/type_traits.hpp>
+#include <boost/container/detail/function_detector.hpp>
+#include <boost/move/utility_core.hpp>
+#include <memory>
+#if defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+#include <boost/move/detail/fwd_macros.hpp>
+#endif
+#include <boost/core/lightweight_test.hpp>
+
+template<class T>
+class SimpleAllocator
+{
+   public:
+   bool allocate_called_;
+   bool deallocate_called_;
+
+   typedef boost::container::dtl::
+      true_type                                 is_always_equal;
+
+   typedef T value_type;
+
+   template <class U>
+   SimpleAllocator(SimpleAllocator<U>)
+      : allocate_called_(false)
+      , deallocate_called_(false)
+   {}
+
+   SimpleAllocator()
+      : allocate_called_(false)
+      , deallocate_called_(false)
+   {}
+
+   T* allocate(std::size_t)
+   {  allocate_called_ = true; return 0;  }
+
+   void deallocate(T*, std::size_t)
+   {  deallocate_called_ = true;  }
+
+   bool allocate_called() const
+   {  return allocate_called_;  }
+
+   bool deallocate_called() const
+   {  return deallocate_called_;  }
+
+   friend bool operator==(const SimpleAllocator &, const SimpleAllocator &)
+   {  return true;  }
+
+   friend bool operator!=(const SimpleAllocator &, const SimpleAllocator &)
+   {  return false;  }
+};
+
+template<class T>
+class SimpleSmartPtr
+{
+   void unspecified_bool_type_func() const {}
+   typedef void (SimpleSmartPtr::*unspecified_bool_type)() const;
+
+   public:
+
+   typedef T* pointer;
+
+   explicit SimpleSmartPtr(pointer p = 0)
+    : ptr_(p)
+   {}
+
+   SimpleSmartPtr(const SimpleSmartPtr &c)
+   {  this->ptr_ = c.ptr_; }
+
+   SimpleSmartPtr & operator=(const SimpleSmartPtr &c)
+   {  this->ptr_ = c.ptr_; }
+
+   operator unspecified_bool_type() const
+   {  return ptr_? &SimpleSmartPtr::unspecified_bool_type_func : 0;   }
+
+   private:
+   T *ptr_;
+};
+
+template<class T>
+class ComplexAllocator
+{
+   public:
+   bool allocate_called_;
+   bool deallocate_called_;
+   bool allocate_hint_called_;
+   bool destroy_called_;
+   mutable bool max_size_called_;
+   mutable bool select_on_container_copy_construction_called_;
+   bool construct_called_;
+   mutable bool storage_is_unpropagable_;
+
+   typedef T value_type;
+   typedef SimpleSmartPtr<T>                    pointer;
+   typedef SimpleSmartPtr<const T>              const_pointer;
+   typedef typename ::boost::container::
+      dtl::unvoid_ref<T>::type     reference;
+   typedef typename ::boost::container::
+      dtl::unvoid_ref<const T>::type     const_reference;
+   typedef SimpleSmartPtr<void>                 void_pointer;
+   typedef SimpleSmartPtr<const void>           const_void_pointer;
+   typedef signed short                         difference_type;
+   typedef unsigned short                       size_type;
+   typedef boost::container::dtl::
+      true_type                                 propagate_on_container_copy_assignment;
+   typedef boost::container::dtl::
+      true_type                                 propagate_on_container_move_assignment;
+   typedef boost::container::dtl::
+      true_type                                 propagate_on_container_swap;
+   typedef boost::container::dtl::
+      true_type                                 is_partially_propagable;
+
+   ComplexAllocator()
+      : allocate_called_(false)
+      , deallocate_called_(false)
+      , allocate_hint_called_(false)
+      , destroy_called_(false)
+      , max_size_called_(false)
+      , select_on_container_copy_construction_called_(false)
+      , construct_called_(false)
+   {}
+
+   pointer allocate(size_type)
+   {  allocate_called_ = true; return pointer();  }
+
+   void deallocate(pointer, size_type)
+   {  deallocate_called_ = true;  }
+
+   //optional
+   ComplexAllocator select_on_container_copy_construction() const
+   {  select_on_container_copy_construction_called_ = true; return *this;  }
+
+   pointer allocate(size_type n, const const_void_pointer &)
+   {  allocate_hint_called_ = true; return allocate(n);  }
+
+   template<class U>
+   void destroy(U*)
+   {  destroy_called_ = true;  }
+
+   size_type max_size() const
+   {  max_size_called_ = true; return size_type(size_type(0)-1);  }
+
+   #if defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+
+   #define BOOST_CONTAINER_COMPLEXALLOCATOR_CONSTRUCT_IMPL(N)\
+   \
+   template< class U BOOST_MOVE_I##N BOOST_MOVE_CLASS##N > \
+   void construct(U *p BOOST_MOVE_I##N BOOST_MOVE_UREF##N) \
+   {  construct_called_ = true;  ::new(p) U ( BOOST_MOVE_FWD##N ); }\
+   //
+   BOOST_MOVE_ITERATE_0TO9(BOOST_CONTAINER_COMPLEXALLOCATOR_CONSTRUCT_IMPL)
+   #undef BOOST_CONTAINER_COMPLEXALLOCATOR_CONSTRUCT_IMPL
+   #else
+
+   template< class U, class ...Args>
+   void construct(U *p, BOOST_FWD_REF(Args) ...args)
+   {  construct_called_ = true;  ::new(p) U( ::boost::forward<Args>(args)...); }
+
+   #endif
+
+   template<class U>
+   void construct(U *p, boost::container::default_init_t)
+   {  construct_called_ = true;  ::new(p)U;   }
+
+   bool storage_is_unpropagable(pointer p) const
+   {  storage_is_unpropagable_ = true; return !p;  }
+
+   //getters
+   bool allocate_called() const
+   {  return allocate_called_;  }
+
+   bool deallocate_called() const
+   {  return deallocate_called_;  }
+
+   bool allocate_hint_called() const
+   {  return allocate_hint_called_;  }
+
+   bool destroy_called() const
+   {  return destroy_called_;  }
+
+   bool max_size_called() const
+   {  return max_size_called_;  }
+
+   bool select_on_container_copy_construction_called() const
+   {  return select_on_container_copy_construction_called_;  }
+
+   bool construct_called() const
+   {  return construct_called_;  }
+
+   bool storage_is_unpropagable_called() const
+   {  return storage_is_unpropagable_;  }
+};
+
+class copymovable
+{
+   BOOST_COPYABLE_AND_MOVABLE(copymovable)
+
+   public:
+
+   bool copymoveconstructed_;
+   bool moved_;
+
+   copymovable(int, int, int)
+      : copymoveconstructed_(false), moved_(false)
+   {}
+
+   copymovable()
+      : copymoveconstructed_(false), moved_(false)
+   {}
+
+   copymovable(const copymovable &)
+      : copymoveconstructed_(true), moved_(false)
+   {}
+
+   copymovable(BOOST_RV_REF(copymovable))
+      : copymoveconstructed_(true), moved_(true)
+   {}
+
+   copymovable & operator=(BOOST_COPY_ASSIGN_REF(copymovable) ){ return *this; }
+   copymovable & operator=(BOOST_RV_REF(copymovable) ){ return *this; }
+
+   bool copymoveconstructed() const
+   {  return copymoveconstructed_;  }
+
+   bool moved() const
+   {  return moved_;  }
+};
+
+void test_void_allocator()
+{
+   boost::container::allocator_traits<std::allocator<void>   > stdtraits; (void)stdtraits;
+   boost::container::allocator_traits<SimpleAllocator<void>  > simtraits; (void)simtraits;
+   boost::container::allocator_traits<ComplexAllocator<void> > comtraits; (void)comtraits;
+}
+
+int main()
+{
+   using namespace boost::container::dtl;
+   test_void_allocator();
+
+   //SimpleAllocator
+   BOOST_STATIC_ASSERT(( is_same<boost::container::allocator_traits
+                       < SimpleAllocator<int> >::value_type, int>::value ));
+   BOOST_STATIC_ASSERT(( is_same<boost::container::allocator_traits
+                       < SimpleAllocator<int> >::pointer, int*>::value ));
+   BOOST_STATIC_ASSERT(( is_same<boost::container::allocator_traits
+                       < SimpleAllocator<int> >::const_pointer, const int*>::value ));
+   BOOST_STATIC_ASSERT(( is_same<boost::container::allocator_traits
+                       < SimpleAllocator<int> >::void_pointer, void*>::value ));
+   BOOST_STATIC_ASSERT(( is_same<boost::container::allocator_traits
+                       < SimpleAllocator<int> >::const_void_pointer, const void*>::value ));
+   BOOST_STATIC_ASSERT(( is_same<boost::container::allocator_traits
+                       < SimpleAllocator<int> >::difference_type, std::ptrdiff_t>::value ));
+   BOOST_STATIC_ASSERT(( is_same<boost::container::allocator_traits
+                       < SimpleAllocator<int> >::size_type, std::size_t>::value ));
+   BOOST_STATIC_ASSERT(( boost::container::allocator_traits
+                       < SimpleAllocator<int> >::propagate_on_container_copy_assignment::value == false ));
+   BOOST_STATIC_ASSERT(( boost::container::allocator_traits
+                       < SimpleAllocator<int> >::propagate_on_container_move_assignment::value == false ));
+   BOOST_STATIC_ASSERT(( boost::container::allocator_traits
+                       < SimpleAllocator<int> >::propagate_on_container_swap::value == false ));
+   BOOST_STATIC_ASSERT(( boost::container::allocator_traits
+                       < SimpleAllocator<int> >::is_always_equal::value == true ));
+   BOOST_STATIC_ASSERT(( boost::container::allocator_traits
+                       < SimpleAllocator<int> >::is_partially_propagable::value == false ));
+   BOOST_STATIC_ASSERT(( is_same<boost::container::allocator_traits
+                       < SimpleAllocator<int> >::rebind_traits<double>::allocator_type
+                       , SimpleAllocator<double> >::value ));
+   BOOST_STATIC_ASSERT(( is_same<boost::container::allocator_traits
+                       < SimpleAllocator<int> >::rebind_alloc<double>::value_type
+                       , double >::value ));
+
+   //ComplexAllocator
+   BOOST_STATIC_ASSERT(( is_same<boost::container::allocator_traits
+                       < ComplexAllocator<int> >::value_type, int>::value ));
+   BOOST_STATIC_ASSERT(( is_same<boost::container::allocator_traits
+                       < ComplexAllocator<int> >::pointer,  SimpleSmartPtr<int> >::value ));
+   BOOST_STATIC_ASSERT(( is_same<boost::container::allocator_traits
+                       < ComplexAllocator<int> >::const_pointer, SimpleSmartPtr<const int> >::value ));
+   BOOST_STATIC_ASSERT(( is_same<boost::container::allocator_traits
+                       < ComplexAllocator<int> >::void_pointer, SimpleSmartPtr<void> >::value ));
+   BOOST_STATIC_ASSERT(( is_same<boost::container::allocator_traits
+                       < ComplexAllocator<int> >::const_void_pointer, SimpleSmartPtr<const void> >::value ));
+   BOOST_STATIC_ASSERT(( is_same<boost::container::allocator_traits
+                       < ComplexAllocator<int> >::difference_type, signed short>::value ));
+   BOOST_STATIC_ASSERT(( is_same<boost::container::allocator_traits
+                       < ComplexAllocator<int> >::size_type, unsigned short>::value ));
+   BOOST_STATIC_ASSERT(( boost::container::allocator_traits
+                       < ComplexAllocator<int> >::propagate_on_container_copy_assignment::value == true ));
+   BOOST_STATIC_ASSERT(( boost::container::allocator_traits
+                       < ComplexAllocator<int> >::propagate_on_container_move_assignment::value == true ));
+   BOOST_STATIC_ASSERT(( boost::container::allocator_traits
+                       < ComplexAllocator<int> >::propagate_on_container_swap::value == true ));
+   BOOST_STATIC_ASSERT(( boost::container::allocator_traits
+                       < ComplexAllocator<int> >::is_always_equal::value == false ));
+   BOOST_STATIC_ASSERT(( boost::container::allocator_traits
+                       < ComplexAllocator<int> >::is_partially_propagable::value == true ));
+   BOOST_STATIC_ASSERT(( is_same<boost::container::allocator_traits
+                       < ComplexAllocator<int> >::rebind_traits<double>::allocator_type
+                       , ComplexAllocator<double> >::value ));
+   BOOST_STATIC_ASSERT(( is_same<boost::container::allocator_traits
+                       < ComplexAllocator<int> >::rebind_alloc<double>::value_type
+                       , double >::value ));
+
+   typedef ComplexAllocator<int> CAlloc;
+   typedef SimpleAllocator<int> SAlloc;
+   typedef boost::container::allocator_traits<CAlloc> CAllocTraits;
+   typedef boost::container::allocator_traits<SAlloc> SAllocTraits;
+   CAlloc c_alloc;
+   SAlloc s_alloc;
+
+   //allocate
+   CAllocTraits::allocate(c_alloc, 1);
+   BOOST_TEST(c_alloc.allocate_called());
+
+   SAllocTraits::allocate(s_alloc, 1);
+   BOOST_TEST(s_alloc.allocate_called());
+
+   //deallocate
+   CAllocTraits::deallocate(c_alloc, CAllocTraits::pointer(), 1);
+   BOOST_TEST(c_alloc.deallocate_called());
+
+   SAllocTraits::deallocate(s_alloc, SAllocTraits::pointer(), 1);
+   BOOST_TEST(s_alloc.deallocate_called());
+
+   //allocate with hint
+   CAllocTraits::allocate(c_alloc, 1, CAllocTraits::const_void_pointer());
+   BOOST_TEST(c_alloc.allocate_hint_called());
+
+   s_alloc.allocate_called_ = false;
+   SAllocTraits::allocate(s_alloc, 1, SAllocTraits::const_void_pointer());
+   BOOST_TEST(s_alloc.allocate_called());
+
+   //destroy
+   float dummy;
+   CAllocTraits::destroy(c_alloc, &dummy);
+   BOOST_TEST(c_alloc.destroy_called());
+
+   SAllocTraits::destroy(s_alloc, &dummy);
+
+   //max_size
+   CAllocTraits::max_size(c_alloc);
+   BOOST_TEST(c_alloc.max_size_called());
+
+   BOOST_TEST(SAllocTraits::size_type(-1)/sizeof(SAllocTraits::value_type) == SAllocTraits::max_size(s_alloc));
+
+   //select_on_container_copy_construction
+   CAllocTraits::select_on_container_copy_construction(c_alloc);
+   BOOST_TEST(c_alloc.select_on_container_copy_construction_called());
+
+   SAllocTraits::select_on_container_copy_construction(s_alloc);
+
+   //construct
+   {
+      copymovable c;
+      c.copymoveconstructed_ = true;
+      c.copymoveconstructed_ = true;
+      CAllocTraits::construct(c_alloc, &c);
+      BOOST_TEST(c_alloc.construct_called() && !c.copymoveconstructed() && !c.moved());
+   }
+   {
+      int i = 5;
+      CAllocTraits::construct(c_alloc, &i, boost::container::default_init);
+      BOOST_TEST(c_alloc.construct_called() && i == 5);
+   }
+   {
+      copymovable c;
+      copymovable c2;
+      CAllocTraits::construct(c_alloc, &c, c2);
+      BOOST_TEST(c_alloc.construct_called() && c.copymoveconstructed() && !c.moved());
+   }
+   {
+      copymovable c;
+      copymovable c2;
+      CAllocTraits::construct(c_alloc, &c, ::boost::move(c2));
+      BOOST_TEST(c_alloc.construct_called() && c.copymoveconstructed() && c.moved());
+   }
+   {
+      copymovable c;
+      c.copymoveconstructed_ = true;
+      c.copymoveconstructed_ = true;
+      SAllocTraits::construct(s_alloc, &c);
+      BOOST_TEST(!c.copymoveconstructed() && !c.moved());
+   }
+   {
+      int i = 4;
+      SAllocTraits::construct(s_alloc, &i, boost::container::default_init);
+      BOOST_TEST(i == 4);
+   }
+   {
+      copymovable c;
+      copymovable c2;
+      SAllocTraits::construct(s_alloc, &c, c2);
+      BOOST_TEST(c.copymoveconstructed() && !c.moved());
+   }
+   {
+      copymovable c;
+      copymovable c2;
+      SAllocTraits::construct(s_alloc, &c, ::boost::move(c2));
+      BOOST_TEST(c.copymoveconstructed() && c.moved());
+   }
+   {
+      copymovable c;
+      CAllocTraits::construct(c_alloc, &c, 0, 1, 2);
+      BOOST_TEST(c_alloc.construct_called() && !c.copymoveconstructed() && !c.moved());
+   }
+   {
+      copymovable c;
+      copymovable c2;
+      SAllocTraits::construct(s_alloc, &c, 0, 1, 2);
+      BOOST_TEST(!c.copymoveconstructed() && !c.moved());
+   }
+   //storage_is_unpropagable
+   {
+      SAlloc s_alloc2;
+      BOOST_TEST(!SAllocTraits::storage_is_unpropagable(s_alloc, SAllocTraits::pointer()));
+   }
+   {
+      {
+         CAlloc c_alloc2;
+         CAlloc::value_type v;
+         BOOST_TEST(!CAllocTraits::storage_is_unpropagable(c_alloc, CAllocTraits::pointer(&v)));
+         BOOST_TEST(c_alloc.storage_is_unpropagable_called());
+      }
+      {
+         CAlloc c_alloc2;
+         BOOST_TEST( CAllocTraits::storage_is_unpropagable(c_alloc2, CAllocTraits::pointer()));
+         BOOST_TEST(c_alloc2.storage_is_unpropagable_called());
+      }
+
+   }
+
+   return ::boost::report_errors();
+}
+#include <boost/container/detail/config_end.hpp>
diff --git a/src/boost/libs/container/test/check_equal_containers.hpp b/src/boost/libs/container/test/check_equal_containers.hpp
new file mode 100644
index 000000000..758780a7f
--- /dev/null
+++ b/src/boost/libs/container/test/check_equal_containers.hpp
@@ -0,0 +1,159 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2006. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/container for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#ifndef BOOST_CONTAINER_TEST_CHECK_EQUAL_CONTAINER_HPP
+#define BOOST_CONTAINER_TEST_CHECK_EQUAL_CONTAINER_HPP
+
+#include <boost/container/detail/config_begin.hpp>
+#include <boost/container/detail/pair.hpp>
+#include <boost/container/detail/mpl.hpp>
+#include <boost/move/unique_ptr.hpp>
+#include <boost/move/utility_core.hpp>
+
+#include <cstddef>
+#include <boost/container/detail/iterator.hpp>
+
+namespace boost{
+namespace container {
+namespace test{
+
+template< class T1, class T2>
+bool CheckEqual( const T1 &t1, const T2 &t2
+               , typename boost::container::dtl::enable_if_c
+                  <!boost::container::dtl::is_pair<T1>::value &&
+                   !boost::container::dtl::is_pair<T2>::value
+                  >::type* = 0)
+{  return t1 == t2;  }
+
+
+template<class T1, class T2, class C1, class C2>
+bool CheckEqualIt( const T1 &i1, const T2 &i2, const C1 &c1, const C2 &c2 )
+{
+   bool c1end = i1 == c1.end();
+   bool c2end = i2 == c2.end();
+   if( c1end != c2end ){
+      return false;
+   }
+   else if(c1end){
+      return true;
+   }
+   else{
+      return CheckEqual(*i1, *i2);
+   }
+}
+
+template< class Pair1, class Pair2>
+bool CheckEqual( const Pair1 &pair1, const Pair2 &pair2
+               , typename boost::container::dtl::enable_if_c
+                  <boost::container::dtl::is_pair<Pair1>::value &&
+                   boost::container::dtl::is_pair<Pair2>::value
+                  >::type* = 0)
+{
+   return CheckEqual(pair1.first, pair2.first) && CheckEqual(pair1.second, pair2.second);
+}
+
+//Function to check if both containers are equal
+template<class ContA
+        ,class ContB>
+bool CheckEqualContainers(const ContA &cont_a, const ContB &cont_b)
+{
+   if(cont_a.size() != cont_b.size())
+      return false;
+
+   typename ContA::const_iterator itcont_a(cont_a.begin()), itcont_a_end(cont_a.end());
+   typename ContB::const_iterator itcont_b(cont_b.begin()), itcont_b_end(cont_b.end());;
+   typename ContB::size_type dist = (typename ContB::size_type)boost::container::iterator_distance(itcont_a, itcont_a_end);
+   if(dist != cont_a.size()){
+      return false;
+   }
+   typename ContA::size_type dist2 = (typename ContA::size_type)boost::container::iterator_distance(itcont_b, itcont_b_end);
+   if(dist2 != cont_b.size()){
+      return false;
+   }
+   std::size_t i = 0;
+   for(; itcont_a != itcont_a_end; ++itcont_a, ++itcont_b, ++i){
+      if(!CheckEqual(*itcont_a, *itcont_b))
+         return false;
+   }
+   return true;
+}
+
+template<class MyBoostCont
+        ,class MyStdCont>
+bool CheckEqualPairContainers(const MyBoostCont &boostcont, const MyStdCont &stdcont)
+{
+   if(boostcont.size() != stdcont.size())
+      return false;
+
+   typedef typename MyBoostCont::key_type      key_type;
+   typedef typename MyBoostCont::mapped_type   mapped_type;
+
+   typename MyBoostCont::const_iterator itboost(boostcont.begin()), itboostend(boostcont.end());
+   typename MyStdCont::const_iterator itstd(stdcont.begin());
+   for(; itboost != itboostend; ++itboost, ++itstd){
+      key_type k(itstd->first);
+      if(itboost->first != k)
+         return false;
+
+      mapped_type m(itstd->second);
+      if(itboost->second != m)
+         return false;
+   }
+   return true;
+}
+
+struct less_transparent
+{
+   typedef void is_transparent;
+
+   template<class T, class U>
+   bool operator()(const T &t, const U &u) const
+   {
+      return t < u;
+   }
+};
+
+struct equal_transparent
+{
+   typedef void is_transparent;
+
+   template<class T, class U>
+   bool operator()(const T &t, const U &u) const
+   {
+      return t == u;
+   }
+};
+
+struct move_op
+{
+   template<class T>
+   typename boost::move_detail::add_rvalue_reference<T>::type operator()(T &t)
+   {
+      return boost::move(t);
+   }
+};
+
+struct const_ref_op
+{
+   template<class T>
+   const T & operator()(const T &t)
+   {
+      return t;
+   }
+
+};
+
+}  //namespace test{
+}  //namespace container {
+}  //namespace boost{
+
+#include <boost/container/detail/config_end.hpp>
+
+#endif //#ifndef BOOST_CONTAINER_TEST_CHECK_EQUAL_CONTAINER_HPP
diff --git a/src/boost/libs/container/test/comparison_test.hpp b/src/boost/libs/container/test/comparison_test.hpp
new file mode 100644
index 000000000..7f3f1b3a0
--- /dev/null
+++ b/src/boost/libs/container/test/comparison_test.hpp
@@ -0,0 +1,58 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2017-2017. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/container for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#ifndef BOOST_CONTAINER_TEST_COMPARISON_TEST_HPP
+#define BOOST_CONTAINER_TEST_COMPARISON_TEST_HPP
+
+#include <deque>
+#include <boost/core/lightweight_test.hpp>
+
+namespace boost {
+namespace container {
+namespace test {
+
+
+template<class Cont>
+bool test_container_comparisons()
+{
+   typedef typename Cont::value_type value_type;
+
+   Cont cont;
+   cont.push_back(value_type(1));
+   cont.push_back(value_type(2));
+   cont.push_back(value_type(3));
+
+   Cont cont_equal(cont);
+
+   Cont cont_less;
+   cont_less.push_back(value_type(1));
+   cont_less.push_back(value_type(2));
+   cont_less.push_back(value_type(2));
+
+   BOOST_TEST(cont == cont_equal);
+   BOOST_TEST(!(cont != cont_equal));
+   BOOST_TEST(cont != cont_less);
+   BOOST_TEST(cont_less < cont);
+   BOOST_TEST(cont_less <= cont);
+   BOOST_TEST(!(cont_less > cont));
+   BOOST_TEST(!(cont_less >= cont));
+   BOOST_TEST(!(cont < cont_less));
+   BOOST_TEST(!(cont <= cont_less));
+   BOOST_TEST(cont > cont_less);
+   BOOST_TEST(cont >= cont_less);
+
+   return ::boost::report_errors() == 0;
+}
+
+}  //namespace test {
+}  //namespace container {
+}  //namespace boost {
+
+#endif   //#ifndef BOOST_CONTAINER_TEST_COMPARISON_TEST_HPP
diff --git a/src/boost/libs/container/test/container_common_tests.hpp b/src/boost/libs/container/test/container_common_tests.hpp
new file mode 100644
index 000000000..63e15477f
--- /dev/null
+++ b/src/boost/libs/container/test/container_common_tests.hpp
@@ -0,0 +1,86 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2014-2014. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/container for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#ifndef BOOST_CONTAINER_TEST_CONTAINER_COMMON_TESTS_HPP
+#define BOOST_CONTAINER_TEST_CONTAINER_COMMON_TESTS_HPP
+
+#include <boost/container/detail/config_begin.hpp>
+
+namespace boost{
+namespace container {
+namespace test{
+
+
+template<class Container>
+const Container &as_const(Container &c)
+{  return c;   }
+
+//nth, index_of
+template<class Container>
+bool test_nth_index_of(Container &c)
+{
+   typename Container::iterator it;
+   typename Container::const_iterator cit;
+   typename Container::size_type sz, csz;
+   //index 0
+   it = c.nth(0);
+   sz = c.index_of(it);
+   cit = (as_const)(c).nth(0);
+   csz = (as_const)(c).index_of(cit);
+
+   if(it != c.begin())
+      return false;
+   if(cit != c.cbegin())
+      return false;
+   if(sz != 0)
+      return false;
+   if(csz != 0)
+      return false;
+
+   //index size()/2
+   const typename Container::size_type sz_div_2 = c.size()/2;
+   it = c.nth(sz_div_2);
+   sz = c.index_of(it);
+   cit = (as_const)(c).nth(sz_div_2);
+   csz = (as_const)(c).index_of(cit);
+
+   if(it != (c.begin()+sz_div_2))
+      return false;
+   if(cit != (c.cbegin()+sz_div_2))
+      return false;
+   if(sz != sz_div_2)
+      return false;
+   if(csz != sz_div_2)
+      return false;
+
+   //index size()
+   it = c.nth(c.size());
+   sz = c.index_of(it);
+   cit = (as_const)(c).nth(c.size());
+   csz = (as_const)(c).index_of(cit);
+
+   if(it != c.end())
+      return false;
+   if(cit != c.cend())
+      return false;
+   if(sz != c.size())
+      return false;
+   if(csz != c.size())
+      return false;
+   return true;
+}
+
+}  //namespace test{
+}  //namespace container {
+}  //namespace boost{
+
+#include <boost/container/detail/config_end.hpp>
+
+#endif //#ifndef BOOST_CONTAINER_TEST_CONTAINER_COMMON_TESTS_HPP
diff --git a/src/boost/libs/container/test/default_init_test.hpp b/src/boost/libs/container/test/default_init_test.hpp
new file mode 100644
index 000000000..2e83a361f
--- /dev/null
+++ b/src/boost/libs/container/test/default_init_test.hpp
@@ -0,0 +1,155 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2013-2013. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/container for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#ifndef BOOST_CONTAINER_TEST_DEFAULT_INIT_TEST_HEADER
+#define BOOST_CONTAINER_TEST_DEFAULT_INIT_TEST_HEADER
+
+#include <boost/container/detail/config_begin.hpp>
+#include <cstddef>
+
+namespace boost{
+namespace container {
+namespace test{
+
+//
+template<int Dummy = 0>
+class default_init_allocator_base
+{
+   protected:
+   static unsigned char s_pattern;
+   static bool          s_ascending;
+
+   public:
+   static void reset_pattern(unsigned char value)
+   {  s_pattern = value;   }
+
+   static void set_ascending(bool enable)
+   {  s_ascending = enable;   }
+};
+
+template<int Dummy>
+unsigned char default_init_allocator_base<Dummy>::s_pattern = 0u;
+
+template<int Dummy>
+bool default_init_allocator_base<Dummy>::s_ascending = true;
+
+template<class Integral>
+class default_init_allocator
+   : public default_init_allocator_base<0>
+{
+   typedef default_init_allocator_base<0> base_t;
+   public:
+   typedef Integral value_type;
+
+   default_init_allocator()
+   {}
+
+   template <class U>
+   default_init_allocator(default_init_allocator<U>)
+   {}
+
+   Integral* allocate(std::size_t n)
+   {
+      //Initialize memory to a pattern
+      const std::size_t max = sizeof(Integral)*n;
+      unsigned char *puc_raw = ::new unsigned char[max];
+
+      if(base_t::s_ascending){
+         for(std::size_t i = 0; i != max; ++i){
+            puc_raw[i] = static_cast<unsigned char>(s_pattern++);
+         }
+      }
+      else{
+         for(std::size_t i = 0; i != max; ++i){
+            puc_raw[i] = static_cast<unsigned char>(s_pattern--);
+         }
+      }
+      return (Integral*)puc_raw;;
+   }
+
+   void deallocate(Integral *p, std::size_t)
+   {  delete[] (unsigned char*)p;  }
+};
+
+template<class Integral>
+inline bool check_ascending_byte_pattern(const Integral&t)
+{
+   const unsigned char *pch = &reinterpret_cast<const unsigned char &>(t);
+   const std::size_t max = sizeof(Integral);
+   for(std::size_t i = 1; i != max; ++i){
+      if( (pch[i-1] != ((unsigned char)(pch[i]-1u))) ){
+         return false;
+      }
+   }
+   return true;
+}
+
+template<class Integral>
+inline bool check_descending_byte_pattern(const Integral&t)
+{
+   const unsigned char *pch = &reinterpret_cast<const unsigned char &>(t);
+   const std::size_t max = sizeof(Integral);
+   for(std::size_t i = 1; i != max; ++i){
+      if( (pch[i-1] != ((unsigned char)(pch[i]+1u))) ){
+         return false;
+      }
+   }
+   return true;
+}
+
+template<class IntDefaultInitAllocVector>
+bool default_init_test()//Test for default initialization
+{
+   const std::size_t Capacity = 100;
+
+   {
+      test::default_init_allocator<int>::reset_pattern(0);
+      test::default_init_allocator<int>::set_ascending(true);
+      IntDefaultInitAllocVector v(Capacity, default_init);
+      typename IntDefaultInitAllocVector::iterator it = v.begin();
+      //Compare with the pattern
+      for(std::size_t i = 0; i != Capacity; ++i, ++it){
+         if(!test::check_ascending_byte_pattern(*it))
+            return false;
+      }
+   }
+   {
+      test::default_init_allocator<int>::reset_pattern(0);
+      test::default_init_allocator<int>::set_ascending(true);
+      IntDefaultInitAllocVector v(Capacity, default_init, typename IntDefaultInitAllocVector::allocator_type());
+      typename IntDefaultInitAllocVector::iterator it = v.begin();
+      //Compare with the pattern
+      for(std::size_t i = 0; i != Capacity; ++i, ++it){
+         if(!test::check_ascending_byte_pattern(*it))
+            return false;
+      }
+   }
+   {
+      test::default_init_allocator<int>::reset_pattern(100);
+      test::default_init_allocator<int>::set_ascending(false);
+      IntDefaultInitAllocVector v;
+      v.resize(Capacity, default_init);
+      typename IntDefaultInitAllocVector::iterator it = v.begin();
+      //Compare with the pattern
+      for(std::size_t i = 0; i != Capacity; ++i, ++it){
+         if(!test::check_descending_byte_pattern(*it))
+            return false;
+      }
+   }
+   return true;
+}
+
+}  //namespace test{
+}  //namespace container {
+}  //namespace boost{
+
+#include <boost/container/detail/config_end.hpp>
+
+#endif //BOOST_CONTAINER_TEST_DEFAULT_INIT_TEST_HEADER
diff --git a/src/boost/libs/container/test/deque_options_test.cpp b/src/boost/libs/container/test/deque_options_test.cpp
new file mode 100644
index 000000000..9a7a43ae9
--- /dev/null
+++ b/src/boost/libs/container/test/deque_options_test.cpp
@@ -0,0 +1,43 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2004-2013. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/container for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+#include <boost/container/deque.hpp>
+#include <boost/container/allocator.hpp>
+#include <boost/core/lightweight_test.hpp>
+
+using namespace boost::container;
+
+void test_block_bytes()
+{
+   #if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
+   using options_t = deque_options_t< block_bytes<128u> >;
+   #else
+   typedef deque_options< block_bytes<128u> >::type options_t;
+   #endif
+   typedef deque<unsigned short, void, options_t> deque_t;
+   BOOST_TEST(deque_t::get_block_size() == 128u/sizeof(unsigned short));
+}
+
+void test_block_elements()
+{
+   #if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
+   using options_t = deque_options_t< block_size<64> >;
+   #else
+   typedef deque_options< block_size<64 > >::type options_t;
+   #endif
+   typedef deque<unsigned char, void, options_t> deque_t;
+   BOOST_TEST(deque_t::get_block_size() == 64U);
+}
+
+int main()
+{
+   test_block_bytes();
+   test_block_elements();
+   return ::boost::report_errors();
+}
diff --git a/src/boost/libs/container/test/deque_test.cpp b/src/boost/libs/container/test/deque_test.cpp
new file mode 100644
index 000000000..22b87f49b
--- /dev/null
+++ b/src/boost/libs/container/test/deque_test.cpp
@@ -0,0 +1,446 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2004-2013. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/container for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#include <boost/container/detail/config_begin.hpp>
+#include <memory>
+#include <deque>
+#include <iostream>
+#include <list>
+
+#include <boost/container/deque.hpp>
+#include <boost/container/allocator.hpp>
+
+#include "print_container.hpp"
+#include "check_equal_containers.hpp"
+#include "dummy_test_allocator.hpp"
+#include "movable_int.hpp"
+#include <boost/move/utility_core.hpp>
+#include <boost/move/iterator.hpp>
+#include <boost/container/detail/mpl.hpp>
+#include <boost/container/detail/type_traits.hpp>
+#include <string>
+#include "emplace_test.hpp"
+#include "propagate_allocator_test.hpp"
+#include "vector_test.hpp"
+#include "default_init_test.hpp"
+#include <boost/core/no_exceptions_support.hpp>
+#include "../../intrusive/test/iterator_test.hpp"
+
+using namespace boost::container;
+
+//Function to check if both sets are equal
+template<class V1, class V2>
+bool deque_copyable_only(V1 &, V2 &, dtl::false_type)
+{
+   return true;
+}
+
+//Function to check if both sets are equal
+template<class V1, class V2>
+bool deque_copyable_only(V1 &cntdeque, V2 &stddeque, dtl::true_type)
+{
+   typedef typename V1::value_type IntType;
+   std::size_t size = cntdeque.size();
+   stddeque.insert(stddeque.end(), 50, 1);
+   cntdeque.insert(cntdeque.end(), 50, IntType(1));
+   if(!test::CheckEqualContainers(cntdeque, stddeque)) return false;
+   {
+      IntType move_me(1);
+      stddeque.insert(stddeque.begin()+size/2, 50, 1);
+      cntdeque.insert(cntdeque.begin()+size/2, 50, boost::move(move_me));
+      if(!test::CheckEqualContainers(cntdeque, stddeque)) return false;
+   }
+   {
+      IntType move_me(2);
+      cntdeque.assign(cntdeque.size()/2, boost::move(move_me));
+      stddeque.assign(stddeque.size()/2, 2);
+      if(!test::CheckEqualContainers(cntdeque, stddeque)) return false;
+   }
+   {
+      IntType move_me(1);
+      stddeque.clear();
+      cntdeque.clear();
+      stddeque.insert(stddeque.begin(), 50, 1);
+      cntdeque.insert(cntdeque.begin(), 50, boost::move(move_me));
+      if(!test::CheckEqualContainers(cntdeque, stddeque)) return false;
+      stddeque.insert(stddeque.begin()+20, 50, 1);
+      cntdeque.insert(cntdeque.begin()+20, 50, boost::move(move_me));
+      if(!test::CheckEqualContainers(cntdeque, stddeque)) return false;
+      stddeque.insert(stddeque.begin()+20, 20, 1);
+      cntdeque.insert(cntdeque.begin()+20, 20, boost::move(move_me));
+      if(!test::CheckEqualContainers(cntdeque, stddeque)) return false;
+   }
+   {
+      IntType move_me(1);
+      stddeque.clear();
+      cntdeque.clear();
+      stddeque.insert(stddeque.end(), 50, 1);
+      cntdeque.insert(cntdeque.end(), 50, boost::move(move_me));
+      if(!test::CheckEqualContainers(cntdeque, stddeque)) return false;
+      stddeque.insert(stddeque.end()-20, 50, 1);
+      cntdeque.insert(cntdeque.end()-20, 50, boost::move(move_me));
+      if(!test::CheckEqualContainers(cntdeque, stddeque)) return false;
+      stddeque.insert(stddeque.end()-20, 20, 1);
+      cntdeque.insert(cntdeque.end()-20, 20, boost::move(move_me));
+      if(!test::CheckEqualContainers(cntdeque, stddeque)) return false;
+   }
+
+   return true;
+}
+
+//Test recursive structures
+class recursive_deque
+{
+public:
+
+   recursive_deque & operator=(const recursive_deque &x)
+   {  this->deque_ = x.deque_;   return *this; }
+
+   int id_;
+   deque<recursive_deque> deque_;
+   deque<recursive_deque>::iterator it_;
+   deque<recursive_deque>::const_iterator cit_;
+   deque<recursive_deque>::reverse_iterator rit_;
+   deque<recursive_deque>::const_reverse_iterator crit_;
+};
+
+template<class IntType>
+bool do_test()
+{
+   //Test for recursive types
+   {
+      deque<recursive_deque> recursive_deque_deque;
+   }
+
+   {
+      //Now test move semantics
+      deque<recursive_deque> original;
+      deque<recursive_deque> move_ctor(boost::move(original));
+      deque<recursive_deque> move_assign;
+      move_assign = boost::move(move_ctor);
+      move_assign.swap(original);
+   }
+
+   //Alias deque types
+   typedef deque<IntType>  MyCntDeque;
+   typedef std::deque<int> MyStdDeque;
+   const int max = 100;
+   {
+      ::boost::movelib::unique_ptr<MyCntDeque> const pcntdeque = ::boost::movelib::make_unique<MyCntDeque>();
+      ::boost::movelib::unique_ptr<MyStdDeque> const pstddeque = ::boost::movelib::make_unique<MyStdDeque>();
+      MyCntDeque &cntdeque = *pcntdeque;
+      MyStdDeque &stddeque = *pstddeque;
+      for(int i = 0; i < max*100; ++i){
+         IntType move_me(i);
+         cntdeque.insert(cntdeque.end(), boost::move(move_me));
+         stddeque.insert(stddeque.end(), i);
+      }
+      if(!test::CheckEqualContainers(cntdeque, stddeque)) return false;
+
+      cntdeque.clear();
+      stddeque.clear();
+
+      for(int i = 0; i < max*100; ++i){
+         IntType move_me(i);
+         cntdeque.push_back(boost::move(move_me));
+         stddeque.push_back(i);
+      }
+      if(!test::CheckEqualContainers(cntdeque, stddeque)) return false;
+
+      cntdeque.clear();
+      stddeque.clear();
+
+      for(int i = 0; i < max*100; ++i){
+         IntType move_me(i);
+         cntdeque.push_front(boost::move(move_me));
+         stddeque.push_front(i);
+      }
+      if(!test::CheckEqualContainers(cntdeque, stddeque)) return false;
+
+      typename MyCntDeque::iterator it;
+      typename MyCntDeque::const_iterator cit = it;
+      (void)cit;
+
+      cntdeque.erase(cntdeque.begin()++);
+      stddeque.erase(stddeque.begin()++);
+      if(!test::CheckEqualContainers(cntdeque, stddeque)) return false;
+
+      cntdeque.erase(cntdeque.begin());
+      stddeque.erase(stddeque.begin());
+      if(!test::CheckEqualContainers(cntdeque, stddeque)) return false;
+
+      {
+         //Initialize values
+         IntType aux_vect[50];
+         for(int i = 0; i < 50; ++i){
+            IntType move_me (-1);
+            aux_vect[i] = boost::move(move_me);
+         }
+         int aux_vect2[50];
+         for(int i = 0; i < 50; ++i){
+            aux_vect2[i] = -1;
+         }
+
+         cntdeque.insert(cntdeque.end()
+                           ,boost::make_move_iterator(&aux_vect[0])
+                           ,boost::make_move_iterator(aux_vect + 50));
+         stddeque.insert(stddeque.end(), aux_vect2, aux_vect2 + 50);
+         if(!test::CheckEqualContainers(cntdeque, stddeque)) return false;
+
+         for(int i = 0; i < 50; ++i){
+            IntType move_me (i);
+            aux_vect[i] = boost::move(move_me);
+         }
+         for(int i = 0; i < 50; ++i){
+            aux_vect2[i] = i;
+         }
+
+         cntdeque.insert(cntdeque.begin()+cntdeque.size()
+                           ,boost::make_move_iterator(&aux_vect[0])
+                           ,boost::make_move_iterator(aux_vect + 50));
+         stddeque.insert(stddeque.begin()+stddeque.size(), aux_vect2, aux_vect2 + 50);
+         if(!test::CheckEqualContainers(cntdeque, stddeque)) return false;
+
+         for(int i = 0, j = static_cast<int>(cntdeque.size()); i < j; ++i){
+            cntdeque.erase(cntdeque.begin());
+            stddeque.erase(stddeque.begin());
+         }
+         if(!test::CheckEqualContainers(cntdeque, stddeque)) return false;
+      }
+      {
+         IntType aux_vect[50];
+         for(int i = 0; i < 50; ++i){
+            IntType move_me(-1);
+            aux_vect[i] = boost::move(move_me);
+         }
+         int aux_vect2[50];
+         for(int i = 0; i < 50; ++i){
+            aux_vect2[i] = -1;
+         }
+         cntdeque.insert(cntdeque.begin()
+                           ,boost::make_move_iterator(&aux_vect[0])
+                           ,boost::make_move_iterator(aux_vect + 50));
+         stddeque.insert(stddeque.begin(), aux_vect2, aux_vect2 + 50);
+         if(!test::CheckEqualContainers(cntdeque, stddeque)) return false;
+      }
+
+      if(!deque_copyable_only(cntdeque, stddeque
+                     ,dtl::bool_<boost::container::test::is_copyable<IntType>::value>())){
+         return false;
+      }
+
+      cntdeque.erase(cntdeque.begin());
+      stddeque.erase(stddeque.begin());
+
+      if(!test::CheckEqualContainers(cntdeque, stddeque)) return false;
+
+      for(int i = 0; i < max; ++i){
+         IntType move_me(i);
+         cntdeque.insert(cntdeque.begin(), boost::move(move_me));
+         stddeque.insert(stddeque.begin(), i);
+      }
+      if(!test::CheckEqualContainers(cntdeque, stddeque)) return false;
+
+      //Test insertion from list
+      {
+         std::list<int> l(50, int(1));
+         cntdeque.insert(cntdeque.begin(), l.begin(), l.end());
+         stddeque.insert(stddeque.begin(), l.begin(), l.end());
+         if(!test::CheckEqualContainers(cntdeque, stddeque)) return 1;
+         cntdeque.assign(l.begin(), l.end());
+         stddeque.assign(l.begin(), l.end());
+         if(!test::CheckEqualContainers(cntdeque, stddeque)) return 1;
+      }
+
+      cntdeque.resize(100);
+      stddeque.resize(100);
+      if(!test::CheckEqualContainers(cntdeque, stddeque)) return 1;
+
+      cntdeque.resize(200);
+      stddeque.resize(200);
+      if(!test::CheckEqualContainers(cntdeque, stddeque)) return 1;
+   }
+
+#ifndef BOOST_CONTAINER_NO_CXX17_CTAD
+   //Check Constructor Template Auto Deduction
+   {
+      auto gold = MyStdDeque{ 1, 2, 3 };
+      auto test = deque(gold.begin(), gold.end());
+      if(!test::CheckEqualContainers(gold, test)) return false;
+   }
+   {
+      auto gold = MyStdDeque{ 1, 2, 3 };
+      auto test = deque(gold.begin(), gold.end(), new_allocator<int>());
+      if(!test::CheckEqualContainers(gold, test)) return false;
+   }
+#endif
+
+   std::cout << std::endl << "Test OK!" << std::endl;
+   return true;
+}
+
+template<class VoidAllocator>
+struct GetAllocatorCont
+{
+   template<class ValueType>
+   struct apply
+   {
+      typedef deque< ValueType
+                    , typename allocator_traits<VoidAllocator>
+                        ::template portable_rebind_alloc<ValueType>::type
+                    > type;
+   };
+};
+
+template<class VoidAllocator>
+int test_cont_variants()
+{
+   typedef typename GetAllocatorCont<VoidAllocator>::template apply<int>::type MyCont;
+   typedef typename GetAllocatorCont<VoidAllocator>::template apply<test::movable_int>::type MyMoveCont;
+   typedef typename GetAllocatorCont<VoidAllocator>::template apply<test::movable_and_copyable_int>::type MyCopyMoveCont;
+   typedef typename GetAllocatorCont<VoidAllocator>::template apply<test::copyable_int>::type MyCopyCont;
+
+   if(test::vector_test<MyCont>())
+      return 1;
+   if(test::vector_test<MyMoveCont>())
+      return 1;
+   if(test::vector_test<MyCopyMoveCont>())
+      return 1;
+   if(test::vector_test<MyCopyCont>())
+      return 1;
+   return 0;
+}
+
+struct boost_container_deque;
+
+namespace boost { namespace container {   namespace test {
+
+template<>
+struct alloc_propagate_base<boost_container_deque>
+{
+   template <class T, class Allocator>
+   struct apply
+   {
+      typedef boost::container::deque<T, Allocator> type;
+   };
+};
+
+}}}   //namespace boost::container::test
+
+int main ()
+{
+   if(!do_test<int>())
+      return 1;
+
+   if(!do_test<test::movable_int>())
+      return 1;
+
+   if(!do_test<test::movable_and_copyable_int>())
+      return 1;
+
+   if(!do_test<test::copyable_int>())
+      return 1;
+
+   //Test non-copy-move operations
+   {
+      deque<test::non_copymovable_int> d;
+      d.emplace_back();
+      d.emplace_front(1);
+      d.resize(10);
+      d.resize(1);
+   }
+
+   ////////////////////////////////////
+   //    Allocator implementations
+   ////////////////////////////////////
+   //       std:allocator
+   if(test_cont_variants< std::allocator<void> >()){
+      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;
+   }
+   ////////////////////////////////////
+   //    Default init test
+   ////////////////////////////////////
+   if(!test::default_init_test< deque<int, test::default_init_allocator<int> > >()){
+      std::cerr << "Default init test failed" << std::endl;
+      return 1;
+   }
+
+   ////////////////////////////////////
+   //    Emplace testing
+   ////////////////////////////////////
+   const test::EmplaceOptions Options = (test::EmplaceOptions)(test::EMPLACE_BACK | test::EMPLACE_FRONT | test::EMPLACE_BEFORE);
+
+   if(!boost::container::test::test_emplace
+      < deque<test::EmplaceInt>, Options>())
+      return 1;
+   ////////////////////////////////////
+   //    Allocator propagation testing
+   ////////////////////////////////////
+   if(!boost::container::test::test_propagate_allocator<boost_container_deque>())
+      return 1;
+
+   ////////////////////////////////////
+   //    Initializer lists testing
+   ////////////////////////////////////
+   if(!boost::container::test::test_vector_methods_with_initializer_list_as_argument_for
+      < boost::container::deque<int> >()) {
+      return 1;
+   }
+
+   ////////////////////////////////////
+   //    Iterator testing
+   ////////////////////////////////////
+   {
+      typedef boost::container::deque<int> cont_int;
+      cont_int a; a.push_back(0); a.push_back(1); a.push_back(2);
+      boost::intrusive::test::test_iterator_random< cont_int >(a);
+      if(boost::report_errors() != 0) {
+         return 1;
+      }
+   }
+
+   ////////////////////////////////////
+   //    has_trivial_destructor_after_move testing
+   ////////////////////////////////////
+   // default allocator
+   {
+      typedef boost::container::deque<int> cont;
+      typedef cont::allocator_type allocator_type;
+      typedef boost::container::allocator_traits<allocator_type>::pointer pointer;
+      if (boost::has_trivial_destructor_after_move<cont>::value !=
+          boost::has_trivial_destructor_after_move<allocator_type>::value &&
+          boost::has_trivial_destructor_after_move<pointer>::value) {
+         std::cerr << "has_trivial_destructor_after_move(default allocator) test failed" << std::endl;
+         return 1;
+      }
+   }
+   // std::allocator
+   {
+      typedef boost::container::deque<int, std::allocator<int> > cont;
+      typedef cont::allocator_type allocator_type;
+      typedef boost::container::allocator_traits<allocator_type>::pointer pointer;
+      if (boost::has_trivial_destructor_after_move<cont>::value !=
+          boost::has_trivial_destructor_after_move<allocator_type>::value &&
+          boost::has_trivial_destructor_after_move<pointer>::value) {
+         std::cerr << "has_trivial_destructor_after_move(std::allocator) test failed" << std::endl;
+         return 1;
+      }
+   }
+
+   return 0;
+}
+
+#include <boost/container/detail/config_end.hpp>
diff --git a/src/boost/libs/container/test/derived_from_memory_resource.hpp b/src/boost/libs/container/test/derived_from_memory_resource.hpp
new file mode 100644
index 000000000..a8097a783
--- /dev/null
+++ b/src/boost/libs/container/test/derived_from_memory_resource.hpp
@@ -0,0 +1,87 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2015-2015. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/container for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#ifndef BOOST_CONTAINER_TEST_DERIVED_FROM_MEMORY_RESOURCE_HPP
+#define BOOST_CONTAINER_TEST_DERIVED_FROM_MEMORY_RESOURCE_HPP
+
+#include <boost/container/pmr/memory_resource.hpp>
+
+class derived_from_memory_resource
+   : public boost::container::pmr::memory_resource
+{
+   public:
+   explicit derived_from_memory_resource(unsigned i = 0u)
+      : id(i)
+   {}
+
+   virtual ~derived_from_memory_resource()
+   {  destructor_called = true;  }
+
+   virtual void* do_allocate(std::size_t bytes, std::size_t alignment)
+   {
+      do_allocate_called = true;
+      do_allocate_bytes = bytes;
+      do_allocate_alignment = alignment;
+      return do_allocate_return;
+   }
+
+   virtual void do_deallocate(void* p, std::size_t bytes, std::size_t alignment)
+   {
+      do_deallocate_called = true;
+      do_deallocate_p = p;
+      do_deallocate_bytes = bytes;
+      do_deallocate_alignment = alignment;
+   }
+
+   virtual bool do_is_equal(const boost::container::pmr::memory_resource& other) const BOOST_NOEXCEPT
+   {
+      do_is_equal_called = true;
+      do_is_equal_other = &other;
+      return static_cast<const derived_from_memory_resource&>(other).id == this->id;
+   }
+
+   void reset()
+   {
+      destructor_called = false;
+
+      do_allocate_return = 0;
+      do_allocate_called = false;
+      do_allocate_bytes = 0u;
+      do_allocate_alignment = 0u;
+
+      do_deallocate_called = false;
+      do_deallocate_p = 0;
+      do_deallocate_bytes = 0u;
+      do_deallocate_alignment = 0u;
+
+      do_is_equal_called = false;
+      do_is_equal_other = 0;
+   }
+   //checkers
+   static bool destructor_called;
+
+   unsigned id;
+   void *do_allocate_return;
+   mutable bool do_allocate_called;
+   mutable std::size_t do_allocate_bytes;
+   mutable std::size_t do_allocate_alignment;
+
+   mutable bool do_deallocate_called;
+   mutable void *do_deallocate_p;
+   mutable std::size_t do_deallocate_bytes;
+   mutable std::size_t do_deallocate_alignment;
+
+   mutable bool do_is_equal_called;
+   mutable const boost::container::pmr::memory_resource *do_is_equal_other;
+};
+
+bool derived_from_memory_resource::destructor_called = false;
+
+#endif   //#ifndef BOOST_CONTAINER_TEST_DERIVED_FROM_MEMORY_RESOURCE_HPP
diff --git a/src/boost/libs/container/test/dummy_test_allocator.hpp b/src/boost/libs/container/test/dummy_test_allocator.hpp
new file mode 100644
index 000000000..024ab0e0e
--- /dev/null
+++ b/src/boost/libs/container/test/dummy_test_allocator.hpp
@@ -0,0 +1,232 @@
+///////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2005-2013. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/container for documentation.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef BOOST_CONTAINER_DUMMY_TEST_ALLOCATOR_HPP
+#define BOOST_CONTAINER_DUMMY_TEST_ALLOCATOR_HPP
+
+#ifndef BOOST_CONFIG_HPP
+#  include <boost/config.hpp>
+#endif
+
+#if defined(BOOST_HAS_PRAGMA_ONCE)
+#  pragma once
+#endif
+
+#include <boost/container/detail/config_begin.hpp>
+#include <boost/container/detail/workaround.hpp>
+#include <boost/container/container_fwd.hpp>
+
+#include <boost/container/throw_exception.hpp>
+
+#include <boost/container/detail/addressof.hpp>
+#include <boost/container/detail/allocation_type.hpp>
+#include <boost/container/detail/mpl.hpp>
+#include <boost/container/detail/multiallocation_chain.hpp>
+#include <boost/container/detail/type_traits.hpp>
+#include <boost/container/detail/version_type.hpp>
+
+#include <boost/move/utility_core.hpp>
+#include <boost/move/adl_move_swap.hpp>
+
+#include <boost/assert.hpp>
+
+#include <memory>
+#include <algorithm>
+#include <cstddef>
+#include <cassert>
+
+namespace boost {
+namespace container {
+namespace test {
+
+//Very simple version 1 allocator
+template<class T>
+class simple_allocator
+{
+   public:
+   typedef T value_type;
+
+   simple_allocator()
+   {}
+
+   template<class U>
+   simple_allocator(const simple_allocator<U> &)
+   {}
+
+   T* allocate(std::size_t n)
+   { return (T*)::new char[sizeof(T)*n];  }
+
+   void deallocate(T*p, std::size_t)
+   { delete[] ((char*)p);}
+
+   friend bool operator==(const simple_allocator &, const simple_allocator &)
+   {  return true;  }
+
+   friend bool operator!=(const simple_allocator &, const simple_allocator &)
+   {  return false;  }
+};
+
+template< class T
+        , bool PropagateOnContCopyAssign
+        , bool PropagateOnContMoveAssign
+        , bool PropagateOnContSwap
+        , bool CopyOnPropagateOnContSwap
+        >
+class propagation_test_allocator
+{
+   BOOST_COPYABLE_AND_MOVABLE(propagation_test_allocator)
+
+   public:
+   typedef T value_type;
+   typedef boost::container::dtl::bool_<PropagateOnContCopyAssign>
+      propagate_on_container_copy_assignment;
+   typedef boost::container::dtl::bool_<PropagateOnContMoveAssign>
+      propagate_on_container_move_assignment;
+   typedef boost::container::dtl::bool_<PropagateOnContSwap>
+      propagate_on_container_swap;
+
+   template<class T2>
+   struct rebind
+   {  typedef propagation_test_allocator
+         < T2
+         , PropagateOnContCopyAssign
+         , PropagateOnContMoveAssign
+         , PropagateOnContSwap
+         , CopyOnPropagateOnContSwap>   other;
+   };
+
+   propagation_test_allocator select_on_container_copy_construction() const
+   {  return CopyOnPropagateOnContSwap ? propagation_test_allocator(*this) : propagation_test_allocator();  }
+
+   explicit propagation_test_allocator()
+      : id_(++unique_id_)
+      , ctr_copies_(0)
+      , ctr_moves_(0)
+      , assign_copies_(0)
+      , assign_moves_(0)
+      , swaps_(0)
+   {}
+
+   propagation_test_allocator(const propagation_test_allocator &x)
+      : id_(x.id_)
+      , ctr_copies_(x.ctr_copies_+1)
+      , ctr_moves_(x.ctr_moves_)
+      , assign_copies_(x.assign_copies_)
+      , assign_moves_(x.assign_moves_)
+      , swaps_(x.swaps_)
+   {}
+
+   template<class U>
+   propagation_test_allocator(const propagation_test_allocator
+                                       < U
+                                       , PropagateOnContCopyAssign
+                                       , PropagateOnContMoveAssign
+                                       , PropagateOnContSwap
+                                       , CopyOnPropagateOnContSwap> &x)
+      : id_(x.id_)
+      , ctr_copies_(x.ctr_copies_+1)
+      , ctr_moves_(0)
+      , assign_copies_(0)
+      , assign_moves_(0)
+      , swaps_(0)
+   {}
+
+   propagation_test_allocator(BOOST_RV_REF(propagation_test_allocator) x)
+      : id_(x.id_)
+      , ctr_copies_(x.ctr_copies_)
+      , ctr_moves_(x.ctr_moves_ + 1)
+      , assign_copies_(x.assign_copies_)
+      , assign_moves_(x.assign_moves_)
+      , swaps_(x.swaps_)
+   {}
+
+   propagation_test_allocator &operator=(BOOST_COPY_ASSIGN_REF(propagation_test_allocator) x)
+   {
+      id_ = x.id_;
+      ctr_copies_ = x.ctr_copies_;
+      ctr_moves_ = x.ctr_moves_;
+      assign_copies_ = x.assign_copies_+1;
+      assign_moves_ = x.assign_moves_;
+      swaps_ = x.swaps_;
+      return *this;
+   }
+
+   propagation_test_allocator &operator=(BOOST_RV_REF(propagation_test_allocator) x)
+   {
+      id_ = x.id_;
+      ctr_copies_ = x.ctr_copies_;
+      ctr_moves_ = x.ctr_moves_;
+      assign_copies_ = x.assign_copies_;
+      assign_moves_ = x.assign_moves_+1;
+      swaps_ = x.swaps_;
+      return *this;
+   }
+
+   static void reset_unique_id(unsigned id = 0)
+   {  unique_id_ = id;  }
+
+   T* allocate(std::size_t n)
+   {  return (T*)::new char[sizeof(T)*n];  }
+
+   void deallocate(T*p, std::size_t)
+   { delete[] ((char*)p);}
+
+   friend bool operator==(const propagation_test_allocator &, const propagation_test_allocator &)
+   {  return true;  }
+
+   friend bool operator!=(const propagation_test_allocator &, const propagation_test_allocator &)
+   {  return false;  }
+
+   void swap(propagation_test_allocator &r)
+   {
+      ++this->swaps_; ++r.swaps_;
+      boost::adl_move_swap(this->id_, r.id_);
+      boost::adl_move_swap(this->ctr_copies_, r.ctr_copies_);
+      boost::adl_move_swap(this->ctr_moves_, r.ctr_moves_);
+      boost::adl_move_swap(this->assign_copies_, r.assign_copies_);
+      boost::adl_move_swap(this->assign_moves_, r.assign_moves_);
+      boost::adl_move_swap(this->swaps_, r.swaps_);
+   }
+
+   friend void swap(propagation_test_allocator &l, propagation_test_allocator &r)
+   {
+      l.swap(r);
+   }
+
+   unsigned int id_;
+   unsigned int ctr_copies_;
+   unsigned int ctr_moves_;
+   unsigned int assign_copies_;
+   unsigned int assign_moves_;
+   unsigned int swaps_;
+   static unsigned unique_id_;
+};
+
+template< class T
+        , bool PropagateOnContCopyAssign
+        , bool PropagateOnContMoveAssign
+        , bool PropagateOnContSwap
+        , bool CopyOnPropagateOnContSwap
+        >
+unsigned int propagation_test_allocator< T
+                                       , PropagateOnContCopyAssign
+                                       , PropagateOnContMoveAssign
+                                       , PropagateOnContSwap
+                                       , CopyOnPropagateOnContSwap>::unique_id_ = 0;
+
+
+}  //namespace test {
+}  //namespace container {
+}  //namespace boost {
+
+#include <boost/container/detail/config_end.hpp>
+
+#endif   //BOOST_CONTAINER_DUMMY_TEST_ALLOCATOR_HPP
+
diff --git a/src/boost/libs/container/test/emplace_test.hpp b/src/boost/libs/container/test/emplace_test.hpp
new file mode 100644
index 000000000..f017d9550
--- /dev/null
+++ b/src/boost/libs/container/test/emplace_test.hpp
@@ -0,0 +1,686 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2008. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/container for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+#ifndef BOOST_CONTAINER_TEST_EMPLACE_TEST_HPP
+#define BOOST_CONTAINER_TEST_EMPLACE_TEST_HPP
+
+#include <iostream>
+#include <typeinfo>
+#include <boost/container/detail/config_begin.hpp>
+#include <boost/container/detail/workaround.hpp>
+#include <boost/container/detail/mpl.hpp>
+#include <boost/move/utility_core.hpp>
+#include <boost/container/detail/type_traits.hpp>
+
+namespace boost{
+namespace container {
+namespace test{
+
+class EmplaceInt
+{
+   BOOST_MOVABLE_BUT_NOT_COPYABLE(EmplaceInt)
+
+   public:
+   EmplaceInt(int a = 0, int b = 0, int c = 0, int d = 0, int e = 0)
+      : a_(a), b_(b), c_(c), d_(d), e_(e)
+   {}
+
+   EmplaceInt(BOOST_RV_REF(EmplaceInt) o)
+      : a_(o.a_), b_(o.b_), c_(o.c_), d_(o.d_), e_(o.e_)
+   {}
+
+   EmplaceInt& operator=(BOOST_RV_REF(EmplaceInt) o)
+   {
+      this->a_ = o.a_;
+      this->b_ = o.b_;
+      this->c_ = o.c_;
+      this->d_ = o.d_;
+      this->e_ = o.e_;
+      return *this;
+   }
+
+   friend bool operator==(const EmplaceInt &l, const EmplaceInt &r)
+   {
+      return l.a_ == r.a_ &&
+             l.b_ == r.b_ &&
+             l.c_ == r.c_ &&
+             l.d_ == r.d_ &&
+             l.e_ == r.e_;
+   }
+
+   friend bool operator<(const EmplaceInt &l, const EmplaceInt &r)
+   {  return l.sum() < r.sum(); }
+
+   friend bool operator>(const EmplaceInt &l, const EmplaceInt &r)
+   {  return l.sum() > r.sum(); }
+
+   friend bool operator!=(const EmplaceInt &l, const EmplaceInt &r)
+   {  return !(l == r); }
+
+   friend std::size_t hash_value(const EmplaceInt &v)
+   {  return std::size_t(v.a_); }
+
+   friend std::ostream &operator <<(std::ostream &os, const EmplaceInt &v)
+   {
+      os << "EmplaceInt: " << v.a_ << ' ' << v.b_ << ' ' << v.c_ << ' ' << v.d_ << ' ' << v.e_;
+      return os;
+   }
+
+   ~EmplaceInt()
+   {  a_ = b_ = c_ = d_ = e_ = 0; }
+
+   //private:
+   int sum() const
+   {  return this->a_ + this->b_ + this->c_ + this->d_ + this->e_; }
+
+   int a_, b_, c_, d_, e_;
+   int padding[6];
+};
+
+
+}  //namespace test {
+
+namespace test {
+
+enum EmplaceOptions{
+   EMPLACE_BACK         = 1 << 0,
+   EMPLACE_FRONT        = 1 << 1,
+   EMPLACE_BEFORE       = 1 << 2,
+   EMPLACE_AFTER        = 1 << 3,
+   EMPLACE_ASSOC        = 1 << 4,
+   EMPLACE_HINT         = 1 << 5,
+   EMPLACE_ASSOC_PAIR   = 1 << 6,
+   EMPLACE_HINT_PAIR    = 1 << 7
+};
+
+template<class Container>
+bool test_expected_container(const Container &ec, const EmplaceInt *Expected, unsigned int only_first_n, unsigned int cont_offset = 0)
+{
+   typedef typename Container::const_iterator const_iterator;
+   const_iterator itb(ec.begin()), ite(ec.end());
+   unsigned int cur = 0;
+   if(cont_offset > ec.size()){
+      return false;
+   }
+   if(only_first_n > (ec.size() - cont_offset)){
+      return false;
+   }
+   while(cont_offset--){
+      ++itb;
+   }
+   for(; itb != ite && only_first_n--; ++itb, ++cur){
+      const EmplaceInt & cr = *itb;
+      if(cr != Expected[cur]){
+         return false;
+      }
+   }
+   return true;
+}
+
+template<class Container>
+bool test_expected_container(const Container &ec, const std::pair<EmplaceInt, EmplaceInt> *Expected, unsigned int only_first_n)
+{
+   typedef typename Container::const_iterator const_iterator;
+   const_iterator itb(ec.begin()), ite(ec.end());
+   unsigned int cur = 0;
+   if(only_first_n > ec.size()){
+      return false;
+   }
+   for(; itb != ite && only_first_n--; ++itb, ++cur){
+      if(itb->first != Expected[cur].first){
+         std::cout << "Error in first: " << itb->first << ' ' << Expected[cur].first << std::endl;
+         return false;
+
+      }
+      else if(itb->second != Expected[cur].second){
+         std::cout << "Error in second: " << itb->second << ' ' << Expected[cur].second << std::endl;
+         return false;
+      }
+   }
+   return true;
+}
+
+typedef std::pair<EmplaceInt, EmplaceInt> EmplaceIntPair;
+static boost::container::dtl::aligned_storage<sizeof(EmplaceIntPair)*10>::type pair_storage;
+
+static EmplaceIntPair* initialize_emplace_int_pair()
+{
+   EmplaceIntPair* ret = reinterpret_cast<EmplaceIntPair*>(&pair_storage);
+   for(unsigned int i = 0; i != 10; ++i){
+      new(&ret->first)EmplaceInt();
+      new(&ret->second)EmplaceInt();
+   }
+   return ret;
+}
+
+static EmplaceIntPair * expected_pair = initialize_emplace_int_pair();
+
+
+template<class Container>
+bool test_emplace_back(dtl::true_)
+{
+   std::cout << "Starting test_emplace_back." << std::endl << "  Class: "
+      << typeid(Container).name() << std::endl;
+   static EmplaceInt expected [10];
+
+   {
+      new(&expected [0]) EmplaceInt();
+      new(&expected [1]) EmplaceInt(1);
+      new(&expected [2]) EmplaceInt(1, 2);
+      new(&expected [3]) EmplaceInt(1, 2, 3);
+      new(&expected [4]) EmplaceInt(1, 2, 3, 4);
+      new(&expected [5]) EmplaceInt(1, 2, 3, 4, 5);
+      Container c;
+      typedef typename Container::reference reference;
+      {
+         reference r = c.emplace_back();
+         if(&r != &c.back() && !test_expected_container(c, &expected[0], 1)){
+            return false;
+         }
+      }
+      {
+         reference r = c.emplace_back(1);
+         if(&r != &c.back() && !test_expected_container(c, &expected[0], 2)){
+            return false;
+         }
+      }
+      c.emplace_back(1, 2);
+      if(!test_expected_container(c, &expected[0], 3)){
+         return false;
+      }
+      c.emplace_back(1, 2, 3);
+      if(!test_expected_container(c, &expected[0], 4)){
+         return false;
+      }
+      c.emplace_back(1, 2, 3, 4);
+      if(!test_expected_container(c, &expected[0], 5)){
+         return false;
+      }
+      c.emplace_back(1, 2, 3, 4, 5);
+      if(!test_expected_container(c, &expected[0], 6)){
+         return false;
+      }
+   }
+   std::cout << "...OK" << std::endl;
+   return true;
+}
+
+template<class Container>
+bool test_emplace_back(dtl::false_)
+{  return true;   }
+
+template<class Container>
+bool test_emplace_front(dtl::true_)
+{
+   std::cout << "Starting test_emplace_front." << std::endl << "  Class: "
+      << typeid(Container).name() << std::endl;
+   static EmplaceInt expected [10];
+   {
+      new(&expected [0]) EmplaceInt(1, 2, 3, 4, 5);
+      new(&expected [1]) EmplaceInt(1, 2, 3, 4);
+      new(&expected [2]) EmplaceInt(1, 2, 3);
+      new(&expected [3]) EmplaceInt(1, 2);
+      new(&expected [4]) EmplaceInt(1);
+      new(&expected [5]) EmplaceInt();
+      Container c;
+      typedef typename Container::reference reference;
+      {
+         reference r = c.emplace_front();
+         if(&r != &c.front() && !test_expected_container(c, &expected[0] + 5, 1)){
+            return false;
+         }
+      }
+      {
+         reference r = c.emplace_front(1);
+         if(&r != &c.front() && !test_expected_container(c, &expected[0] + 4, 2)){
+            return false;
+         }
+      }
+      c.emplace_front(1, 2);
+      if(!test_expected_container(c, &expected[0] + 3, 3)){
+         return false;
+      }
+      c.emplace_front(1, 2, 3);
+      if(!test_expected_container(c, &expected[0] + 2, 4)){
+         return false;
+      }
+      c.emplace_front(1, 2, 3, 4);
+      if(!test_expected_container(c, &expected[0] + 1, 5)){
+         return false;
+      }
+      c.emplace_front(1, 2, 3, 4, 5);
+      if(!test_expected_container(c, &expected[0] + 0, 6)){
+         return false;
+      }
+   }
+   std::cout << "...OK" << std::endl;
+   return true;
+}
+
+template<class Container>
+bool test_emplace_front(dtl::false_)
+{  return true;   }
+
+template<class Container>
+bool test_emplace_before(dtl::true_)
+{
+   std::cout << "Starting test_emplace_before." << std::endl << "  Class: "
+      << typeid(Container).name() << std::endl;
+   static EmplaceInt expected [10];
+   {
+      new(&expected [0]) EmplaceInt();
+      new(&expected [1]) EmplaceInt(1);
+      new(&expected [2]) EmplaceInt();
+      Container c;
+      c.emplace(c.cend(), 1);
+      c.emplace(c.cbegin());
+      if(!test_expected_container(c, &expected[0], 2)){
+         return false;
+      }
+      c.emplace(c.cend());
+      if(!test_expected_container(c, &expected[0], 3)){
+         return false;
+      }
+   }
+   {
+      new(&expected [0]) EmplaceInt();
+      new(&expected [1]) EmplaceInt(1);
+      new(&expected [2]) EmplaceInt(1, 2);
+      new(&expected [3]) EmplaceInt(1, 2, 3);
+      new(&expected [4]) EmplaceInt(1, 2, 3, 4);
+      new(&expected [5]) EmplaceInt(1, 2, 3, 4, 5);
+      //emplace_front-like
+      Container c;
+      c.emplace(c.cbegin(), 1, 2, 3, 4, 5);
+      c.emplace(c.cbegin(), 1, 2, 3, 4);
+      c.emplace(c.cbegin(), 1, 2, 3);
+      c.emplace(c.cbegin(), 1, 2);
+      c.emplace(c.cbegin(), 1);
+      c.emplace(c.cbegin());
+      if(!test_expected_container(c, &expected[0], 6)){
+         return false;
+      }
+      c.clear();
+      //emplace_back-like
+      typename Container::const_iterator i = c.emplace(c.cend());
+      if(!test_expected_container(c, &expected[0], 1)){
+         return false;
+      }
+      i = c.emplace(++i, 1);
+      if(!test_expected_container(c, &expected[0], 2)){
+         return false;
+      }
+      i = c.emplace(++i, 1, 2);
+      if(!test_expected_container(c, &expected[0], 3)){
+         return false;
+      }
+      i = c.emplace(++i, 1, 2, 3);
+      if(!test_expected_container(c, &expected[0], 4)){
+         return false;
+      }
+      i = c.emplace(++i, 1, 2, 3, 4);
+      if(!test_expected_container(c, &expected[0], 5)){
+         return false;
+      }
+      i = c.emplace(++i, 1, 2, 3, 4, 5);
+      if(!test_expected_container(c, &expected[0], 6)){
+         return false;
+      }
+      c.clear();
+      //emplace in the middle
+      c.emplace(c.cbegin());
+      if(!test_expected_container(c, &expected[0], 1)){
+         return false;
+      }
+      i = c.emplace(c.cend(), 1, 2, 3, 4, 5);
+      if(!test_expected_container(c, &expected[0], 1)){
+         return false;
+      }
+      if(!test_expected_container(c, &expected[5], 1, 1)){
+         return false;
+      }
+      i = c.emplace(i, 1, 2, 3, 4);
+      if(!test_expected_container(c, &expected[0], 1)){
+         return false;
+      }
+      if(!test_expected_container(c, &expected[4], 2, 1)){
+         return false;
+      }
+      i = c.emplace(i, 1, 2, 3);
+      if(!test_expected_container(c, &expected[0], 1)){
+         return false;
+      }
+      if(!test_expected_container(c, &expected[3], 3, 1)){
+         return false;
+      }
+      i = c.emplace(i, 1, 2);
+      if(!test_expected_container(c, &expected[0], 1)){
+         return false;
+      }
+      if(!test_expected_container(c, &expected[2], 4, 1)){
+         return false;
+      }
+      i = c.emplace(i, 1);
+      if(!test_expected_container(c, &expected[0], 6)){
+         return false;
+      }
+      std::cout << "...OK" << std::endl;
+   }
+   return true;
+}
+
+template<class Container>
+bool test_emplace_before(dtl::false_)
+{  return true;   }
+
+template<class Container>
+bool test_emplace_after(dtl::true_)
+{
+   std::cout << "Starting test_emplace_after." << std::endl << "  Class: "
+      << typeid(Container).name() << std::endl;
+   static EmplaceInt expected [10];
+   {
+      new(&expected [0]) EmplaceInt();
+      new(&expected [1]) EmplaceInt(1);
+      new(&expected [2]) EmplaceInt();
+      Container c;
+      typename Container::const_iterator i = c.emplace_after(c.cbefore_begin(), 1);
+      c.emplace_after(c.cbefore_begin());
+      if(!test_expected_container(c, &expected[0], 2)){
+         return false;
+      }
+      c.emplace_after(i);
+      if(!test_expected_container(c, &expected[0], 3)){
+         return false;
+      }
+   }
+   {
+      new(&expected [0]) EmplaceInt();
+      new(&expected [1]) EmplaceInt(1);
+      new(&expected [2]) EmplaceInt(1, 2);
+      new(&expected [3]) EmplaceInt(1, 2, 3);
+      new(&expected [4]) EmplaceInt(1, 2, 3, 4);
+      new(&expected [5]) EmplaceInt(1, 2, 3, 4, 5);
+      //emplace_front-like
+      Container c;
+      c.emplace_after(c.cbefore_begin(), 1, 2, 3, 4, 5);
+      c.emplace_after(c.cbefore_begin(), 1, 2, 3, 4);
+      c.emplace_after(c.cbefore_begin(), 1, 2, 3);
+      c.emplace_after(c.cbefore_begin(), 1, 2);
+      c.emplace_after(c.cbefore_begin(), 1);
+      c.emplace_after(c.cbefore_begin());
+      if(!test_expected_container(c, &expected[0], 6)){
+         return false;
+      }
+      c.clear();
+      //emplace_back-like
+      typename Container::const_iterator i = c.emplace_after(c.cbefore_begin());
+      if(!test_expected_container(c, &expected[0], 1)){
+         return false;
+      }
+      i = c.emplace_after(i, 1);
+      if(!test_expected_container(c, &expected[0], 2)){
+         return false;
+      }
+      i = c.emplace_after(i, 1, 2);
+      if(!test_expected_container(c, &expected[0], 3)){
+         return false;
+      }
+      i = c.emplace_after(i, 1, 2, 3);
+      if(!test_expected_container(c, &expected[0], 4)){
+         return false;
+      }
+      i = c.emplace_after(i, 1, 2, 3, 4);
+      if(!test_expected_container(c, &expected[0], 5)){
+         return false;
+      }
+      i = c.emplace_after(i, 1, 2, 3, 4, 5);
+      if(!test_expected_container(c, &expected[0], 6)){
+         return false;
+      }
+      c.clear();
+      //emplace_after in the middle
+      i = c.emplace_after(c.cbefore_begin());
+      c.emplace_after(i, 1, 2, 3, 4, 5);
+      c.emplace_after(i, 1, 2, 3, 4);
+      c.emplace_after(i, 1, 2, 3);
+      c.emplace_after(i, 1, 2);
+      c.emplace_after(i, 1);
+
+      if(!test_expected_container(c, &expected[0], 6)){
+         return false;
+      }
+      std::cout << "...OK" << std::endl;
+   }
+   return true;
+}
+
+template<class Container>
+bool test_emplace_after(dtl::false_)
+{  return true;   }
+
+template<class Container>
+bool test_emplace_assoc(dtl::true_)
+{
+   std::cout << "Starting test_emplace_assoc." << std::endl << "  Class: "
+      << typeid(Container).name() << std::endl;
+   static EmplaceInt expected [10];
+   new(&expected [0]) EmplaceInt();
+   new(&expected [1]) EmplaceInt(1);
+   new(&expected [2]) EmplaceInt(1, 2);
+   new(&expected [3]) EmplaceInt(1, 2, 3);
+   new(&expected [4]) EmplaceInt(1, 2, 3, 4);
+   new(&expected [5]) EmplaceInt(1, 2, 3, 4, 5);
+   {
+      Container c;
+      c.emplace();
+      if(!test_expected_container(c, &expected[0], 1)){
+         return false;
+      }
+      c.emplace(1);
+      if(!test_expected_container(c, &expected[0], 2)){
+         return false;
+      }
+      c.emplace(1, 2);
+      if(!test_expected_container(c, &expected[0], 3)){
+         return false;
+      }
+      c.emplace(1, 2, 3);
+      if(!test_expected_container(c, &expected[0], 4)){
+         return false;
+      }
+      c.emplace(1, 2, 3, 4);
+      if(!test_expected_container(c, &expected[0], 5)){
+         return false;
+      }
+      c.emplace(1, 2, 3, 4, 5);
+      if(!test_expected_container(c, &expected[0], 6)){
+         return false;
+      }
+      std::cout << "...OK" << std::endl;
+   }
+   return true;
+}
+
+template<class Container>
+bool test_emplace_assoc(dtl::false_)
+{  return true;   }
+
+template<class Container>
+bool test_emplace_hint(dtl::true_)
+{
+   std::cout << "Starting test_emplace_hint." << std::endl << "  Class: "
+      << typeid(Container).name() << std::endl;
+   static EmplaceInt expected [10];
+   new(&expected [0]) EmplaceInt();
+   new(&expected [1]) EmplaceInt(1);
+   new(&expected [2]) EmplaceInt(1, 2);
+   new(&expected [3]) EmplaceInt(1, 2, 3);
+   new(&expected [4]) EmplaceInt(1, 2, 3, 4);
+   new(&expected [5]) EmplaceInt(1, 2, 3, 4, 5);
+
+   {
+      Container c;
+      typename Container::const_iterator it;
+      it = c.emplace_hint(c.begin());
+      if(!test_expected_container(c, &expected[0], 1)){
+         return false;
+      }
+      it = c.emplace_hint(it, 1);
+      if(!test_expected_container(c, &expected[0], 2)){
+         return false;
+      }
+      it = c.emplace_hint(it, 1, 2);
+      if(!test_expected_container(c, &expected[0], 3)){
+         return false;
+      }
+      it = c.emplace_hint(it, 1, 2, 3);
+      if(!test_expected_container(c, &expected[0], 4)){
+         return false;
+      }
+      it = c.emplace_hint(it, 1, 2, 3, 4);
+      if(!test_expected_container(c, &expected[0], 5)){
+         return false;
+      }
+      it = c.emplace_hint(it, 1, 2, 3, 4, 5);
+      if(!test_expected_container(c, &expected[0], 6)){
+         return false;
+      }
+      std::cout << "...OK" << std::endl;
+   }
+
+   return true;
+}
+
+template<class Container>
+bool test_emplace_hint(dtl::false_)
+{  return true;   }
+
+template<class Container>
+bool test_emplace_assoc_pair(dtl::true_)
+{
+   std::cout << "Starting test_emplace_assoc_pair." << std::endl << "  Class: "
+      << typeid(Container).name() << std::endl;
+
+   new(&expected_pair[0].first)  EmplaceInt();
+   new(&expected_pair[0].second) EmplaceInt();
+   new(&expected_pair[1].first)  EmplaceInt(1);
+   new(&expected_pair[1].second) EmplaceInt(1);
+   new(&expected_pair[2].first)  EmplaceInt(2);
+   new(&expected_pair[2].second) EmplaceInt(2);
+   {
+      Container c;
+      c.emplace();
+      if(!test_expected_container(c, &expected_pair[0], 1)){
+         std::cout << "Error after c.emplace();\n";
+         return false;
+      }
+      c.emplace(1, 1);
+      if(!test_expected_container(c, &expected_pair[0], 2)){
+         std::cout << "Error after c.emplace(1);\n";
+         return false;
+      }
+      c.emplace(2, 2);
+      if(!test_expected_container(c, &expected_pair[0], 3)){
+         std::cout << "Error after c.emplace(2, 2);\n";
+         return false;
+      }
+      std::cout << "...OK" << std::endl;
+   }
+   return true;
+}
+
+template<class Container>
+bool test_emplace_assoc_pair(dtl::false_)
+{  return true;   }
+
+template<class Container>
+bool test_emplace_hint_pair(dtl::true_)
+{
+   std::cout << "Starting test_emplace_hint_pair." << std::endl << "  Class: "
+      << typeid(Container).name() << std::endl;
+
+   new(&expected_pair[0].first)  EmplaceInt();
+   new(&expected_pair[0].second) EmplaceInt();
+   new(&expected_pair[1].first)  EmplaceInt(1);
+   new(&expected_pair[1].second) EmplaceInt(1);
+   new(&expected_pair[2].first)  EmplaceInt(2);
+   new(&expected_pair[2].second) EmplaceInt(2);
+   {
+      Container c;
+      typename Container::const_iterator it;
+      it = c.emplace_hint(c.begin());
+      if(!test_expected_container(c, &expected_pair[0], 1)){
+         std::cout << "Error after c.emplace(1);\n";
+         return false;
+      }
+      it = c.emplace_hint(it, 1, 1);
+      if(!test_expected_container(c, &expected_pair[0], 2)){
+         std::cout << "Error after c.emplace(it, 1);\n";
+         return false;
+      }
+      it = c.emplace_hint(it, 2, 2);
+      if(!test_expected_container(c, &expected_pair[0], 3)){
+         std::cout << "Error after c.emplace(it, 2, 2);\n";
+         return false;
+      }
+      std::cout << "...OK" << std::endl;
+   }
+   return true;
+}
+
+template<class Container>
+bool test_emplace_hint_pair(dtl::false_)
+{  return true;   }
+
+template <EmplaceOptions O, EmplaceOptions Mask>
+struct emplace_active
+{
+   static const bool value = (0 != (O & Mask));
+   typedef dtl::bool_<value> type;
+   operator type() const{  return type(); }
+};
+
+template<class Container, EmplaceOptions O>
+bool test_emplace()
+{
+   if(!test_emplace_back<Container>(emplace_active<O, EMPLACE_BACK>())){
+      return false;
+   }
+   if(!test_emplace_front<Container>(emplace_active<O, EMPLACE_FRONT>())){
+      return false;
+   }
+   if(!test_emplace_before<Container>(emplace_active<O, EMPLACE_BEFORE>())){
+      return false;
+   }
+   if(!test_emplace_after<Container>(emplace_active<O, EMPLACE_AFTER>())){
+      return false;
+   }
+   if(!test_emplace_assoc<Container>(emplace_active<O, EMPLACE_ASSOC>())){
+      return false;
+   }
+   if(!test_emplace_hint<Container>(emplace_active<O, EMPLACE_HINT>())){
+      return false;
+   }
+   if(!test_emplace_assoc_pair<Container>(emplace_active<O, EMPLACE_ASSOC_PAIR>())){
+      return false;
+   }
+   if(!test_emplace_hint_pair<Container>(emplace_active<O, EMPLACE_HINT_PAIR>())){
+      return false;
+   }
+   return true;
+}
+
+}  //namespace test{
+}  //namespace container {
+}  //namespace boost{
+
+#include <boost/container/detail/config_end.hpp>
+
+#endif   //#ifndef BOOST_CONTAINER_TEST_EMPLACE_TEST_HPP
diff --git a/src/boost/libs/container/test/expand_bwd_test_allocator.hpp b/src/boost/libs/container/test/expand_bwd_test_allocator.hpp
new file mode 100644
index 000000000..60b32839e
--- /dev/null
+++ b/src/boost/libs/container/test/expand_bwd_test_allocator.hpp
@@ -0,0 +1,200 @@
+///////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2005-2013. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/container for documentation.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef BOOST_CONTAINER_EXPAND_BWD_TEST_ALLOCATOR_HPP
+#define BOOST_CONTAINER_EXPAND_BWD_TEST_ALLOCATOR_HPP
+
+#ifndef BOOST_CONFIG_HPP
+#  include <boost/config.hpp>
+#endif
+
+#if defined(BOOST_HAS_PRAGMA_ONCE)
+#  pragma once
+#endif
+
+#include <boost/container/detail/config_begin.hpp>
+#include <boost/container/detail/workaround.hpp>
+#include <boost/container/container_fwd.hpp>
+
+#include <boost/container/throw_exception.hpp>
+
+#include <boost/container/detail/addressof.hpp>
+#include <boost/container/detail/allocation_type.hpp>
+#include <boost/container/detail/version_type.hpp>
+
+#include <boost/move/adl_move_swap.hpp>
+
+#include <boost/assert.hpp>
+
+#include <memory>
+#include <algorithm>
+#include <cstddef>
+#include <cassert>
+
+namespace boost {
+namespace container {
+namespace test {
+
+//This allocator just allows two allocations. The first one will return
+//mp_buffer + m_offset configured in the constructor. The second one
+//will return mp_buffer.
+template<class T>
+class expand_bwd_test_allocator
+{
+ private:
+   typedef expand_bwd_test_allocator<T> self_t;
+   typedef void *                   aux_pointer_t;
+   typedef const void *             cvoid_ptr;
+
+   template<class T2>
+   expand_bwd_test_allocator& operator=(const expand_bwd_test_allocator<T2>&);
+
+   expand_bwd_test_allocator& operator=(const expand_bwd_test_allocator&);
+
+   public:
+   typedef T                                    value_type;
+   typedef T *                                  pointer;
+   typedef const T *                            const_pointer;
+   typedef typename dtl::add_reference
+                     <value_type>::type         reference;
+   typedef typename dtl::add_reference
+                     <const value_type>::type   const_reference;
+   typedef std::size_t                          size_type;
+   typedef std::ptrdiff_t                       difference_type;
+
+   typedef boost::container::dtl::version_type<expand_bwd_test_allocator, 2>   version;
+
+   //Dummy multiallocation chain
+   struct multiallocation_chain{};
+
+   template<class T2>
+   struct rebind
+   {  typedef expand_bwd_test_allocator<T2>   other;   };
+
+   //!Constructor from the segment manager. Never throws
+   expand_bwd_test_allocator(T *buffer, size_type sz, difference_type offset)
+      : mp_buffer(buffer), m_size(sz)
+      , m_offset(offset),  m_allocations(0){ }
+
+   //!Constructor from other expand_bwd_test_allocator. Never throws
+   expand_bwd_test_allocator(const expand_bwd_test_allocator &other)
+      : mp_buffer(other.mp_buffer), m_size(other.m_size)
+      , m_offset(other.m_offset),  m_allocations(0){ }
+
+   //!Constructor from related expand_bwd_test_allocator. Never throws
+   template<class T2>
+   expand_bwd_test_allocator(const expand_bwd_test_allocator<T2> &other)
+      : mp_buffer(other.mp_buffer), m_size(other.m_size)
+      , m_offset(other.m_offset),  m_allocations(0){ }
+
+   pointer address(reference value)
+   {  return pointer(dtl::addressof(value));  }
+
+   const_pointer address(const_reference value) const
+   {  return const_pointer(dtl::addressof(value));  }
+
+   pointer allocate(size_type , cvoid_ptr hint = 0)
+   {  (void)hint; return 0; }
+
+   void deallocate(const pointer &, size_type)
+   {}
+
+   template<class Convertible>
+   void construct(pointer ptr, const Convertible &value)
+   {  new((void*)ptr) value_type(value);  }
+
+   void destroy(pointer ptr)
+   {  (*ptr).~value_type();  }
+
+   size_type max_size() const
+   {  return m_size;   }
+
+   friend void swap(self_t &alloc1, self_t &alloc2)
+   {
+      boost::adl_move_swap(alloc1.mp_buffer, alloc2.mp_buffer);
+      boost::adl_move_swap(alloc1.m_size,    alloc2.m_size);
+      boost::adl_move_swap(alloc1.m_offset,  alloc2.m_offset);
+   }
+
+   //Experimental version 2 expand_bwd_test_allocator functions
+
+   pointer allocation_command(boost::container::allocation_type command,
+                         size_type limit_size,size_type &prefer_in_recvd_out_size,pointer &reuse)
+   {
+      (void)reuse;   (void)command;
+      //This allocator only expands backwards!
+      assert(m_allocations == 0 || (command & boost::container::expand_bwd));
+
+      prefer_in_recvd_out_size = limit_size;
+
+      if(m_allocations == 0){
+         if((m_offset + limit_size) > m_size){
+            assert(0);
+         }
+         ++m_allocations;
+         reuse = 0;
+         return (mp_buffer + m_offset);
+      }
+      else if(m_allocations == 1){
+         if(limit_size > m_size){
+            assert(0);
+         }
+         ++m_allocations;
+         return mp_buffer;
+      }
+      else{
+         throw_bad_alloc();
+         return mp_buffer;
+      }
+   }
+
+   //!Returns maximum the number of objects the previously allocated memory
+   //!pointed by p can hold.
+   size_type size(const pointer &p) const
+   {  (void)p; return m_size; }
+
+   //!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 this->allocate(1);  }
+
+   //!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 &p)
+   {  return this->deallocate(p, 1);  }
+
+   pointer           mp_buffer;
+   size_type         m_size;
+   difference_type   m_offset;
+   char              m_allocations;
+};
+
+//!Equality test for same type of expand_bwd_test_allocator
+template<class T> inline
+bool operator==(const expand_bwd_test_allocator<T>  &,
+                const expand_bwd_test_allocator<T>  &)
+{  return false; }
+
+//!Inequality test for same type of expand_bwd_test_allocator
+template<class T> inline
+bool operator!=(const expand_bwd_test_allocator<T>  &,
+                const expand_bwd_test_allocator<T>  &)
+{  return true; }
+
+}  //namespace test {
+}  //namespace container {
+}  //namespace boost {
+
+#include <boost/container/detail/config_end.hpp>
+
+#endif   //BOOST_CONTAINER_EXPAND_BWD_TEST_ALLOCATOR_HPP
+
diff --git a/src/boost/libs/container/test/expand_bwd_test_template.hpp b/src/boost/libs/container/test/expand_bwd_test_template.hpp
new file mode 100644
index 000000000..1c193ac66
--- /dev/null
+++ b/src/boost/libs/container/test/expand_bwd_test_template.hpp
@@ -0,0 +1,218 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2006. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/container for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#ifndef BOOST_CONTAINER_TEST_ALLOCATION_TEST_TEMPLATE_HEADER
+#define BOOST_CONTAINER_TEST_ALLOCATION_TEST_TEMPLATE_HEADER
+
+#include <boost/container/detail/config_begin.hpp>
+#include <vector>
+#include <typeinfo>
+#include <iostream>
+#include "expand_bwd_test_allocator.hpp"
+#include <boost/container/detail/algorithm.hpp> //equal()
+#include "movable_int.hpp"
+#include <boost/move/make_unique.hpp>
+
+namespace boost { namespace container { namespace test {
+
+//Function to check if both sets are equal
+template <class Vector1, class Vector2>
+bool CheckEqualVector(const Vector1 &vector1, const Vector2 &vector2)
+{
+   if(vector1.size() != vector2.size())
+      return false;
+   return boost::container::algo_equal(vector1.begin(), vector1.end(), vector2.begin());
+}
+
+template<class Vector>
+bool CheckUninitializedIsZero(const Vector & v)
+{
+   typedef  typename Vector::value_type value_type;
+   typename Vector::size_type sz    = v.size();
+   typename Vector::size_type extra = v.capacity() - v.size();
+   value_type comp(0);
+
+   const value_type *holder = &v[0] + sz;
+
+   while(extra--){
+      if(*holder++ != comp)
+         return false;
+   }
+   return true;
+}
+
+
+//This function tests all the possible combinations when
+//inserting data in a vector and expanding backwards
+template<class VectorWithExpandBwdAllocator>
+bool test_insert_with_expand_bwd()
+{
+   typedef typename VectorWithExpandBwdAllocator::value_type value_type;
+   typedef std::vector<value_type> Vect;
+   const unsigned int MemorySize = 1000;
+
+   //Distance old and new buffer
+   const unsigned int Offset[]      =
+      {  350, 300, 250, 200, 150, 100, 150, 100,
+         150,  50,  50,  50    };
+   //Initial vector size
+   const unsigned int InitialSize[] =
+      {  200, 200, 200, 200, 200, 200, 200, 200,
+         200, 200, 200, 200   };
+   //Size of the data to insert
+   const unsigned int InsertSize[]  =
+      {  100, 100, 100, 100, 100, 100, 200, 200,
+         300,  25, 100, 200   };
+   //Number of tests
+   const unsigned int Iterations    = sizeof(InsertSize)/sizeof(int);
+
+   //Insert position
+   const int Position[]    =
+      {  0, 100,  200  };
+
+   for(unsigned int pos = 0; pos < sizeof(Position)/sizeof(Position[0]); ++pos){
+      if(!life_count<value_type>::check(0))
+         return false;
+
+      for(unsigned int iteration = 0; iteration < Iterations; ++iteration)
+      {
+         boost::movelib::unique_ptr<char[]> memptr =
+            boost::movelib::make_unique_definit<char[]>(MemorySize*sizeof(value_type));
+         value_type *memory = (value_type*)memptr.get();
+         std::vector<value_type> initial_data;
+         initial_data.resize(InitialSize[iteration]);
+         for(unsigned int i = 0; i < InitialSize[iteration]; ++i){
+            initial_data[i] = i;
+         }
+
+         if(!life_count<value_type>::check(InitialSize[iteration]))
+            return false;
+         Vect data_to_insert;
+         data_to_insert.resize(InsertSize[iteration]);
+         for(unsigned int i = 0; i < InsertSize[iteration]; ++i){
+            data_to_insert[i] = -i;
+         }
+
+         if(!life_count<value_type>::check(InitialSize[iteration]+InsertSize[iteration]))
+            return false;
+
+         expand_bwd_test_allocator<value_type> alloc
+            (memory, MemorySize, Offset[iteration]);
+         VectorWithExpandBwdAllocator vector(alloc);
+         vector.insert( vector.begin()
+                     , initial_data.begin(), initial_data.end());
+         vector.insert( vector.begin() + Position[pos]
+                     , data_to_insert.begin(), data_to_insert.end());
+
+         if(!life_count<value_type>::check(InitialSize[iteration]*2+InsertSize[iteration]*2))
+            return false;
+
+         initial_data.insert(initial_data.begin() + Position[pos]
+                           , data_to_insert.begin(), data_to_insert.end());
+         //Now check that values are equal
+         if(!CheckEqualVector(vector, initial_data)){
+            std::cout << "test_assign_with_expand_bwd::CheckEqualVector failed." << std::endl
+                     << "   Class: " << typeid(VectorWithExpandBwdAllocator).name() << std::endl
+                     << "   Iteration: " << iteration << std::endl;
+            return false;
+         }
+      }
+      if(!life_count<value_type>::check(0))
+         return false;
+   }
+
+   return true;
+}
+
+//This function tests all the possible combinations when
+//inserting data in a vector and expanding backwards
+template<class VectorWithExpandBwdAllocator>
+bool test_assign_with_expand_bwd()
+{
+   typedef typename VectorWithExpandBwdAllocator::value_type value_type;
+   const unsigned int MemorySize = 200;
+
+   const unsigned int Offset[]      = { 50, 50, 50};
+   const unsigned int InitialSize[] = { 25, 25, 25};
+   const unsigned int InsertSize[]  = { 15, 35, 55};
+   const unsigned int Iterations    = sizeof(InsertSize)/sizeof(int);
+
+   for(unsigned int iteration = 0; iteration <Iterations; ++iteration)
+   {
+      boost::movelib::unique_ptr<char[]> memptr =
+         boost::movelib::make_unique_definit<char[]>(MemorySize*sizeof(value_type));
+      value_type *memory = (value_type*)memptr.get();
+      //Create initial data
+      std::vector<value_type> initial_data;
+      initial_data.resize(InitialSize[iteration]);
+      for(unsigned int i = 0; i < InitialSize[iteration]; ++i){
+         initial_data[i] = i;
+      }
+
+      //Create data to assign
+      std::vector<value_type> data_to_insert;
+      data_to_insert.resize(InsertSize[iteration]);
+      for(unsigned int i = 0; i < InsertSize[iteration]; ++i){
+         data_to_insert[i] = -i;
+      }
+
+      //Insert initial data to the vector to test
+      expand_bwd_test_allocator<value_type> alloc
+         (memory, MemorySize, Offset[iteration]);
+      VectorWithExpandBwdAllocator vector(alloc);
+      vector.insert( vector.begin()
+                  , initial_data.begin(), initial_data.end());
+
+      //Assign data
+      vector.insert(vector.cbegin(), data_to_insert.begin(), data_to_insert.end());
+      initial_data.insert(initial_data.begin(), data_to_insert.begin(), data_to_insert.end());
+
+      //Now check that values are equal
+      if(!CheckEqualVector(vector, initial_data)){
+         std::cout << "test_assign_with_expand_bwd::CheckEqualVector failed." << std::endl
+                  << "   Class: " << typeid(VectorWithExpandBwdAllocator).name() << std::endl
+                  << "   Iteration: " << iteration << std::endl;
+         return false;
+      }
+   }
+
+   return true;
+}
+
+//This function calls all tests
+template<class VectorWithExpandBwdAllocator>
+bool test_all_expand_bwd()
+{
+   std::cout << "Starting test_insert_with_expand_bwd." << std::endl << "  Class: "
+             << typeid(VectorWithExpandBwdAllocator).name() << std::endl;
+
+   if(!test_insert_with_expand_bwd<VectorWithExpandBwdAllocator>()){
+      std::cout << "test_allocation_direct_deallocation failed. Class: "
+                << typeid(VectorWithExpandBwdAllocator).name() << std::endl;
+      return false;
+   }
+
+   std::cout << "Starting test_assign_with_expand_bwd." << std::endl << "  Class: "
+             << typeid(VectorWithExpandBwdAllocator).name() << std::endl;
+
+   if(!test_assign_with_expand_bwd<VectorWithExpandBwdAllocator>()){
+      std::cout << "test_allocation_direct_deallocation failed. Class: "
+                << typeid(VectorWithExpandBwdAllocator).name() << std::endl;
+      return false;
+   }
+
+   return true;
+}
+
+}}}   //namespace boost { namespace container { namespace test {
+
+#include <boost/container/detail/config_end.hpp>
+
+#endif   //BOOST_CONTAINER_TEST_ALLOCATION_TEST_TEMPLATE_HEADER
diff --git a/src/boost/libs/container/test/explicit_inst_deque_test.cpp b/src/boost/libs/container/test/explicit_inst_deque_test.cpp
new file mode 100644
index 000000000..6fec8116b
--- /dev/null
+++ b/src/boost/libs/container/test/explicit_inst_deque_test.cpp
@@ -0,0 +1,46 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2015-2015. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/container for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#include <boost/container/deque.hpp>
+#include <boost/container/allocator.hpp>
+#include "movable_int.hpp"
+#include "dummy_test_allocator.hpp"
+
+
+struct empty
+{
+   friend bool operator == (const empty &, const empty &){ return true; }
+   friend bool operator <  (const empty &, const empty &){ return true; }
+};
+
+template class ::boost::container::deque<empty>;
+
+volatile ::boost::container::deque<empty> dummy;
+
+namespace boost {
+namespace container {
+
+//Explicit instantiation to detect compilation errors
+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
+   , allocator<test::movable_and_copyable_int> >;
+
+}  //namespace boost {
+}  //namespace container {
+
+int main()
+{
+   return 0;
+}
+
diff --git a/src/boost/libs/container/test/explicit_inst_flat_map_test.cpp b/src/boost/libs/container/test/explicit_inst_flat_map_test.cpp
new file mode 100644
index 000000000..3a8ff6fa3
--- /dev/null
+++ b/src/boost/libs/container/test/explicit_inst_flat_map_test.cpp
@@ -0,0 +1,94 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2015-2015. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/container for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#include <boost/container/flat_map.hpp>
+#include <boost/container/allocator.hpp>
+#include "movable_int.hpp"
+#include "dummy_test_allocator.hpp"
+#include <boost/container/stable_vector.hpp>
+#include <boost/container/small_vector.hpp>
+#include <boost/container/deque.hpp>
+#include <boost/container/static_vector.hpp>
+
+struct empty
+{
+   friend bool operator == (const empty &, const empty &){ return true; }
+   friend bool operator <  (const empty &, const empty &){ return true; }
+};
+
+template class ::boost::container::flat_map<empty, empty>;
+template class ::boost::container::flat_multimap<empty, empty>;
+
+volatile ::boost::container::flat_map<empty, empty> dummy;
+volatile ::boost::container::flat_multimap<empty, empty> dummy2;
+
+namespace boost {
+namespace container {
+
+//Explicit instantiation to detect compilation errors
+
+//flat_map
+typedef std::pair<test::movable_and_copyable_int, test::movable_and_copyable_int> test_pair_t;
+
+template class flat_map
+   < test::movable_and_copyable_int
+   , test::movable_and_copyable_int
+   , std::less<test::movable_and_copyable_int>
+   , small_vector< test_pair_t, 10, std::allocator< test_pair_t > >
+   >;
+
+//flat_multimap
+template class flat_multimap
+   < test::movable_and_copyable_int
+   , test::movable_and_copyable_int
+   , std::less<test::movable_and_copyable_int>
+   , stable_vector< test_pair_t, allocator< test_pair_t > >
+   >;
+
+template class flat_multimap
+   < test::movable_and_copyable_int
+   , test::movable_and_copyable_int
+   , std::less<test::movable_and_copyable_int>
+   , deque<test_pair_t, test::simple_allocator< test_pair_t > >
+   >;
+
+template class flat_multimap
+   < test::movable_and_copyable_int
+   , test::movable_and_copyable_int
+   , std::less<test::movable_and_copyable_int>
+   , static_vector<test_pair_t, 10 >
+   >;
+
+//As flat container iterators are typedefs for vector::[const_]iterator,
+//no need to explicit instantiate them
+
+}} //boost::container
+
+#if (__cplusplus > 201103L)
+#include <vector>
+
+namespace boost{
+namespace container{
+
+template class flat_map
+   < test::movable_and_copyable_int
+   , test::movable_and_copyable_int
+   , std::less<test::movable_and_copyable_int>
+   , std::vector<test_pair_t>
+>;
+
+}} //boost::container
+
+#endif
+
+int main()
+{
+   return 0;
+}
diff --git a/src/boost/libs/container/test/explicit_inst_flat_set_test.cpp b/src/boost/libs/container/test/explicit_inst_flat_set_test.cpp
new file mode 100644
index 000000000..eeb8366ed
--- /dev/null
+++ b/src/boost/libs/container/test/explicit_inst_flat_set_test.cpp
@@ -0,0 +1,88 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2015-2015. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/container for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#include <boost/container/flat_set.hpp>
+
+struct empty
+{
+   friend bool operator == (const empty &, const empty &){ return true; }
+   friend bool operator <  (const empty &, const empty &){ return true; }
+};
+
+template class ::boost::container::flat_set<empty>;
+template class ::boost::container::flat_multiset<empty>;
+
+volatile ::boost::container::flat_set<empty> dummy;
+volatile ::boost::container::flat_multiset<empty> dummy2;
+
+#include <boost/container/allocator.hpp>
+#include "movable_int.hpp"
+#include "dummy_test_allocator.hpp"
+#include <boost/container/stable_vector.hpp>
+#include <boost/container/small_vector.hpp>
+#include <boost/container/deque.hpp>
+#include <boost/container/static_vector.hpp>
+
+namespace boost {
+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>
+   , small_vector<test::movable_and_copyable_int, 10, allocator<test::movable_and_copyable_int> >
+   >;
+
+//flat_multiset
+template class flat_multiset
+   < test::movable_and_copyable_int
+   , std::less<test::movable_and_copyable_int>
+   , stable_vector<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>
+   , deque<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>
+   , static_vector<test::movable_and_copyable_int, 10 >
+   >;
+
+//As flat container iterators are typedefs for vector::[const_]iterator,
+//no need to explicit instantiate them
+
+}} //boost::container
+
+#if (__cplusplus > 201103L)
+#include <vector>
+
+namespace boost{
+namespace container{
+
+template class flat_set
+   < test::movable_and_copyable_int
+   , std::less<test::movable_and_copyable_int>
+   , std::vector<test::movable_and_copyable_int>
+>;
+
+}} //boost::container
+
+#endif
+
+int main()
+{
+   return 0;
+}
diff --git a/src/boost/libs/container/test/explicit_inst_list_test.cpp b/src/boost/libs/container/test/explicit_inst_list_test.cpp
new file mode 100644
index 000000000..4faeaebae
--- /dev/null
+++ b/src/boost/libs/container/test/explicit_inst_list_test.cpp
@@ -0,0 +1,25 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2015-2015. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/container for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#include <boost/container/list.hpp>
+
+struct empty
+{
+   friend bool operator == (const empty &, const empty &){ return true; }
+   friend bool operator <  (const empty &, const empty &){ return true; }
+};
+
+template class ::boost::container::list<empty>;
+
+int main()
+{
+   ::boost::container::list<empty> dummy;
+   return 0;
+}
diff --git a/src/boost/libs/container/test/explicit_inst_map_test.cpp b/src/boost/libs/container/test/explicit_inst_map_test.cpp
new file mode 100644
index 000000000..5a4a2b408
--- /dev/null
+++ b/src/boost/libs/container/test/explicit_inst_map_test.cpp
@@ -0,0 +1,56 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2015-2015. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/container for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#include <boost/container/map.hpp>
+
+struct empty
+{
+   friend bool operator == (const empty &, const empty &){ return true; }
+   friend bool operator <  (const empty &, const empty &){ return true; }
+};
+
+template class ::boost::container::map<empty, empty>;
+template class ::boost::container::multimap<empty, empty>;
+
+volatile ::boost::container::map<empty, empty> dummy;
+volatile ::boost::container::multimap<empty, empty> dummy2;
+
+#include <boost/container/allocator.hpp>
+#include <boost/container/adaptive_pool.hpp>
+#include "movable_int.hpp"
+#include "dummy_test_allocator.hpp"
+
+namespace boost {
+namespace container {
+
+typedef std::pair<const test::movable_and_copyable_int, test::movable_and_copyable_int> pair_t;
+
+//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::simple_allocator< pair_t >
+   >;
+
+template class map
+   < test::movable_and_copyable_int
+   , test::movable_and_copyable_int
+   , std::less<test::movable_and_copyable_int>
+   , adaptive_pool< pair_t >
+   >;
+}} //boost::container
+
+int main()
+{
+   return 0;
+}
diff --git a/src/boost/libs/container/test/explicit_inst_set_test.cpp b/src/boost/libs/container/test/explicit_inst_set_test.cpp
new file mode 100644
index 000000000..fa0312356
--- /dev/null
+++ b/src/boost/libs/container/test/explicit_inst_set_test.cpp
@@ -0,0 +1,54 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2015-2015. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/container for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#include <boost/container/set.hpp>
+
+struct empty
+{
+   friend bool operator == (const empty &, const empty &){ return true; }
+   friend bool operator <  (const empty &, const empty &){ return true; }
+};
+
+template class ::boost::container::set<empty>;
+template class ::boost::container::multiset<empty>;
+
+volatile ::boost::container::set<empty> dummy;
+volatile ::boost::container::multiset<empty> dummy2;
+
+#include <boost/container/allocator.hpp>
+#include <boost/container/adaptive_pool.hpp>
+#include "movable_int.hpp"
+#include "dummy_test_allocator.hpp"
+
+namespace boost {
+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::simple_allocator<test::movable_and_copyable_int>
+   >;
+
+//multiset
+template class multiset
+   < test::movable_and_copyable_int
+   , std::less<test::movable_and_copyable_int>
+   , adaptive_pool<test::movable_and_copyable_int>
+   >;
+
+}} //boost::container
+
+int main()
+{
+   return 0;
+}
diff --git a/src/boost/libs/container/test/explicit_inst_slist_test.cpp b/src/boost/libs/container/test/explicit_inst_slist_test.cpp
new file mode 100644
index 000000000..f825c10c7
--- /dev/null
+++ b/src/boost/libs/container/test/explicit_inst_slist_test.cpp
@@ -0,0 +1,44 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2015-2015. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/container for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#include <boost/container/slist.hpp>
+
+struct empty
+{
+   friend bool operator == (const empty &, const empty &){ return true; }
+   friend bool operator <  (const empty &, const empty &){ return true; }
+};
+
+template class ::boost::container::slist<empty>;
+volatile ::boost::container::slist<empty> dummy;
+
+#include <boost/container/allocator.hpp>
+#include <boost/container/node_allocator.hpp>
+#include "movable_int.hpp"
+#include "dummy_test_allocator.hpp"
+
+namespace boost {
+namespace container {
+
+//Explicit instantiation to detect compilation errors
+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
+   , node_allocator<test::movable_and_copyable_int> >;
+
+}}
+
+int main()
+{
+   return 0;
+}
diff --git a/src/boost/libs/container/test/explicit_inst_small_vector_test.cpp b/src/boost/libs/container/test/explicit_inst_small_vector_test.cpp
new file mode 100644
index 000000000..6259aae82
--- /dev/null
+++ b/src/boost/libs/container/test/explicit_inst_small_vector_test.cpp
@@ -0,0 +1,56 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2015-2015. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/container for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#include <boost/container/small_vector.hpp>
+
+struct empty
+{
+   friend bool operator == (const empty &, const empty &){ return true; }
+   friend bool operator <  (const empty &, const empty &){ return true; }
+};
+
+template class ::boost::container::small_vector<empty, 2>;
+volatile ::boost::container::small_vector<empty, 2> dummy;
+
+#include <boost/container/allocator.hpp>
+#include "movable_int.hpp"
+#include "dummy_test_allocator.hpp"
+
+namespace boost {
+namespace container {
+
+template class small_vector<char, 0>;
+template class small_vector<char, 1>;
+template class small_vector<char, 2>;
+template class small_vector<char, 10>;
+
+template class small_vector<int, 0>;
+template class small_vector<int, 1>;
+template class small_vector<int, 2>;
+template class small_vector<int, 10>;
+
+//Explicit instantiation to detect compilation errors
+template class boost::container::small_vector
+   < test::movable_and_copyable_int
+   , 10
+   , test::simple_allocator<test::movable_and_copyable_int> >;
+
+template class boost::container::small_vector
+   < test::movable_and_copyable_int
+   , 10
+   , allocator<test::movable_and_copyable_int> >;
+
+}}
+
+
+int main()
+{
+   return 0;
+}
diff --git a/src/boost/libs/container/test/explicit_inst_stable_vector_test.cpp b/src/boost/libs/container/test/explicit_inst_stable_vector_test.cpp
new file mode 100644
index 000000000..b11b4c65c
--- /dev/null
+++ b/src/boost/libs/container/test/explicit_inst_stable_vector_test.cpp
@@ -0,0 +1,45 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2015-2015. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/container for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#include <boost/container/stable_vector.hpp>
+
+struct empty
+{
+   friend bool operator == (const empty &, const empty &){ return true; }
+   friend bool operator <  (const empty &, const empty &){ return true; }
+};
+
+template class ::boost::container::stable_vector<empty>;
+volatile ::boost::container::stable_vector<empty> dummy;
+
+#include <boost/container/node_allocator.hpp>
+#include "movable_int.hpp"
+#include "dummy_test_allocator.hpp"
+
+namespace boost {
+namespace container {
+
+//Explicit instantiation to detect compilation errors
+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
+   , node_allocator<test::movable_and_copyable_int> >;
+
+template class stable_vector_iterator<int*, false>;
+template class stable_vector_iterator<int*, true >;
+
+}}
+
+int main()
+{
+   return 0;
+}
diff --git a/src/boost/libs/container/test/explicit_inst_static_vector_test.cpp b/src/boost/libs/container/test/explicit_inst_static_vector_test.cpp
new file mode 100644
index 000000000..081775df8
--- /dev/null
+++ b/src/boost/libs/container/test/explicit_inst_static_vector_test.cpp
@@ -0,0 +1,33 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2015-2015. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/container for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#include <boost/container/static_vector.hpp>
+
+struct empty
+{
+   friend bool operator == (const empty &, const empty &){ return true; }
+   friend bool operator <  (const empty &, const empty &){ return true; }
+};
+
+template class ::boost::container::static_vector<empty, 2>;
+volatile ::boost::container::static_vector<empty, 2> dummy;
+
+namespace boost {
+namespace container {
+
+//Explicit instantiation to detect compilation errors
+template class boost::container::static_vector<int, 10>;
+
+}}
+
+int main()
+{
+   return 0;
+}
diff --git a/src/boost/libs/container/test/explicit_inst_string_test.cpp b/src/boost/libs/container/test/explicit_inst_string_test.cpp
new file mode 100644
index 000000000..fd7696921
--- /dev/null
+++ b/src/boost/libs/container/test/explicit_inst_string_test.cpp
@@ -0,0 +1,44 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2015-2015. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/container for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#include <boost/container/string.hpp>
+
+template class ::boost::container::basic_string<char>;
+volatile ::boost::container::basic_string<char> dummy;
+
+#include <boost/container/vector.hpp>
+#include "dummy_test_allocator.hpp"
+
+namespace boost {
+namespace container {
+
+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;
+
+//Explicit instantiations of container::basic_string
+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<SimpleString, SimpleStringAllocator>;
+template class vector<SimpleWString, SimpleWStringAllocator>;
+
+}}
+
+int main()
+{
+   return 0;
+}
diff --git a/src/boost/libs/container/test/explicit_inst_vector_test.cpp b/src/boost/libs/container/test/explicit_inst_vector_test.cpp
new file mode 100644
index 000000000..619dfc956
--- /dev/null
+++ b/src/boost/libs/container/test/explicit_inst_vector_test.cpp
@@ -0,0 +1,47 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2015-2015. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/container for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#include <boost/container/vector.hpp>
+
+struct empty
+{
+   friend bool operator == (const empty &, const empty &){ return true; }
+   friend bool operator <  (const empty &, const empty &){ return true; }
+};
+
+template class ::boost::container::vector<empty>;
+volatile ::boost::container::vector<empty> dummy;
+
+#include <boost/container/allocator.hpp>
+#include "movable_int.hpp"
+#include "dummy_test_allocator.hpp"
+
+namespace boost {
+namespace container {
+
+//Explicit instantiation to detect compilation errors
+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
+   , allocator<test::movable_and_copyable_int> >;
+
+template class vec_iterator<int*, true >;
+template class vec_iterator<int*, false>;
+
+}  //namespace boost {
+}  //namespace container {
+
+int main()
+{
+   return 0;
+}
diff --git a/src/boost/libs/container/test/flat_map_adaptor_test.cpp b/src/boost/libs/container/test/flat_map_adaptor_test.cpp
new file mode 100644
index 000000000..520ef3c14
--- /dev/null
+++ b/src/boost/libs/container/test/flat_map_adaptor_test.cpp
@@ -0,0 +1,104 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2004-2019. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/container for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+#include <boost/container/flat_map.hpp>
+#include <boost/container/small_vector.hpp>
+#include <boost/container/static_vector.hpp>
+#include <boost/container/stable_vector.hpp>
+#include <boost/container/vector.hpp>
+#include <boost/container/deque.hpp>
+
+#include <boost/container/detail/container_or_allocator_rebind.hpp>
+
+#include "map_test.hpp"
+#include <map>
+
+using namespace boost::container;
+
+template<class VoidAllocatorOrContainer>
+struct GetMapContainer
+{
+   template<class ValueType>
+   struct apply
+   {
+      typedef std::pair<ValueType, ValueType> type_t;
+      typedef flat_map< ValueType
+                 , ValueType
+                 , std::less<ValueType>
+                 , typename boost::container::dtl::container_or_allocator_rebind<VoidAllocatorOrContainer, type_t>::type
+                 > map_type;
+
+      typedef flat_multimap< ValueType
+                 , ValueType
+                 , std::less<ValueType>
+                 , typename boost::container::dtl::container_or_allocator_rebind<VoidAllocatorOrContainer, type_t>::type
+                 > multimap_type;
+   };
+};
+
+int main()
+{
+   using namespace boost::container::test;
+
+   ////////////////////////////////////
+   //    Testing sequence container implementations
+   ////////////////////////////////////
+   {
+      typedef std::map<int, int>                                     MyStdMap;
+      typedef std::multimap<int, int>                                MyStdMultiMap;
+
+      if (0 != test::map_test
+         < GetMapContainer<vector<std::pair<int, int> > >::apply<int>::map_type
+         , MyStdMap
+         , GetMapContainer<vector<std::pair<int, int> > >::apply<int>::multimap_type
+         , MyStdMultiMap>()) {
+         std::cout << "Error in map_test<vector<std::pair<int, int> > >" << std::endl;
+         return 1;
+      }
+
+      if (0 != test::map_test
+         < GetMapContainer<small_vector<std::pair<int, int>, 7> >::apply<int>::map_type
+         , MyStdMap
+         , GetMapContainer<small_vector<std::pair<int, int>, 7> >::apply<int>::multimap_type
+         , MyStdMultiMap>()) {
+         std::cout << "Error in map_test<small_vector<std::pair<int, int>, 7> >" << std::endl;
+         return 1;
+      }
+
+       if (0 != test::map_test
+         < GetMapContainer<static_vector<std::pair<int, int>, MaxElem * 10> >::apply<int>::map_type
+         , MyStdMap
+         , GetMapContainer<static_vector<std::pair<int, int>, MaxElem * 10> >::apply<int>::multimap_type
+         , MyStdMultiMap>()) {
+         std::cout << "Error in map_test<static_vector<std::pair<int, int>, MaxElem * 10> >" << std::endl;
+         return 1;
+      }
+
+      if (0 != test::map_test
+         < GetMapContainer<stable_vector<std::pair<int, int> > >::apply<int>::map_type
+         , MyStdMap
+         , GetMapContainer<stable_vector<std::pair<int, int> > >::apply<int>::multimap_type
+         , MyStdMultiMap>()) {
+         std::cout << "Error in map_test<stable_vector<std::pair<int, int> > >" << std::endl;
+         return 1;
+      }
+
+
+      if (0 != test::map_test
+         < GetMapContainer<deque<std::pair<int, int> > >::apply<int>::map_type
+         , MyStdMap
+         , GetMapContainer<deque<std::pair<int, int> > >::apply<int>::multimap_type
+         , MyStdMultiMap>()) {
+         std::cout << "Error in map_test<deque<std::pair<int, int> > >" << std::endl;
+         return 1;
+      }
+   }
+
+   return 0;
+}
diff --git a/src/boost/libs/container/test/flat_map_test.cpp b/src/boost/libs/container/test/flat_map_test.cpp
new file mode 100644
index 000000000..f5caff7ac
--- /dev/null
+++ b/src/boost/libs/container/test/flat_map_test.cpp
@@ -0,0 +1,838 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2004-2013. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/container for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+#include <boost/container/detail/config_begin.hpp>
+
+#include <vector>
+
+#include <boost/container/flat_map.hpp>
+#include <boost/container/allocator.hpp>
+#include <boost/container/detail/container_or_allocator_rebind.hpp>
+
+#include "print_container.hpp"
+#include "dummy_test_allocator.hpp"
+#include "movable_int.hpp"
+#include "map_test.hpp"
+#include "propagate_allocator_test.hpp"
+#include "container_common_tests.hpp"
+#include "emplace_test.hpp"
+#include "../../intrusive/test/iterator_test.hpp"
+
+#include <map>
+#include <utility>
+
+
+using namespace boost::container;
+
+class recursive_flat_map
+{
+   public:
+   recursive_flat_map(const recursive_flat_map &c)
+      : id_(c.id_), map_(c.map_)
+   {}
+
+   recursive_flat_map & operator =(const recursive_flat_map &c)
+   {
+      id_ = c.id_;
+      map_= c.map_;
+      return *this;
+   }
+
+   int id_;
+   flat_map<recursive_flat_map, recursive_flat_map> map_;
+   flat_map<recursive_flat_map, recursive_flat_map>::iterator it_;
+   flat_map<recursive_flat_map, recursive_flat_map>::const_iterator cit_;
+   flat_map<recursive_flat_map, recursive_flat_map>::reverse_iterator rit_;
+   flat_map<recursive_flat_map, recursive_flat_map>::const_reverse_iterator crit_;
+
+   friend bool operator< (const recursive_flat_map &a, const recursive_flat_map &b)
+   {  return a.id_ < b.id_;   }
+};
+
+
+class recursive_flat_multimap
+{
+public:
+   recursive_flat_multimap(const recursive_flat_multimap &c)
+      : id_(c.id_), map_(c.map_)
+   {}
+
+   recursive_flat_multimap & operator =(const recursive_flat_multimap &c)
+   {
+      id_ = c.id_;
+      map_= c.map_;
+      return *this;
+   }
+   int id_;
+   flat_multimap<recursive_flat_multimap, recursive_flat_multimap> map_;
+   flat_multimap<recursive_flat_multimap, recursive_flat_multimap>::iterator it_;
+   flat_multimap<recursive_flat_multimap, recursive_flat_multimap>::const_iterator cit_;
+   flat_multimap<recursive_flat_multimap, recursive_flat_multimap>::reverse_iterator rit_;
+   flat_multimap<recursive_flat_multimap, recursive_flat_multimap>::const_reverse_iterator crit_;
+
+   friend bool operator< (const recursive_flat_multimap &a, const recursive_flat_multimap &b)
+   {  return a.id_ < b.id_;   }
+};
+
+template<class C>
+void test_move()
+{
+   //Now test move semantics
+   C original;
+   C move_ctor(boost::move(original));
+   C move_assign;
+   move_assign = boost::move(move_ctor);
+   move_assign.swap(original);
+}
+
+
+namespace boost{
+namespace container {
+namespace test{
+
+bool flat_tree_ordered_insertion_test()
+{
+   using namespace boost::container;
+   const std::size_t NumElements = 100;
+
+   //Ordered insertion multimap
+   {
+      std::multimap<int, int> int_mmap;
+      for(std::size_t i = 0; i != NumElements; ++i){
+         int_mmap.insert(std::multimap<int, int>::value_type(static_cast<int>(i), static_cast<int>(i)));
+      }
+      //Construction insertion
+      flat_multimap<int, int> fmmap(ordered_range, int_mmap.begin(), int_mmap.end());
+      if(!CheckEqualContainers(int_mmap, fmmap))
+         return false;
+      //Insertion when empty
+      fmmap.clear();
+      fmmap.insert(ordered_range, int_mmap.begin(), int_mmap.end());
+      if(!CheckEqualContainers(int_mmap, fmmap))
+         return false;
+      //Re-insertion
+      fmmap.insert(ordered_range, int_mmap.begin(), int_mmap.end());
+      std::multimap<int, int> int_mmap2(int_mmap);
+      int_mmap2.insert(int_mmap.begin(), int_mmap.end());
+      if(!CheckEqualContainers(int_mmap2, fmmap))
+         return false;
+      //Re-re-insertion
+      fmmap.insert(ordered_range, int_mmap2.begin(), int_mmap2.end());
+      std::multimap<int, int> int_mmap4(int_mmap2);
+      int_mmap4.insert(int_mmap2.begin(), int_mmap2.end());
+      if(!CheckEqualContainers(int_mmap4, fmmap))
+         return false;
+      //Re-re-insertion of even
+      std::multimap<int, int> int_even_mmap;
+      for(std::size_t i = 0; i < NumElements; i+=2){
+         int_mmap.insert(std::multimap<int, int>::value_type(static_cast<int>(i), static_cast<int>(i)));
+      }
+      fmmap.insert(ordered_range, int_even_mmap.begin(), int_even_mmap.end());
+      int_mmap4.insert(int_even_mmap.begin(), int_even_mmap.end());
+      if(!CheckEqualContainers(int_mmap4, fmmap))
+         return false;
+   }
+
+   //Ordered insertion map
+   {
+      std::map<int, int> int_map;
+      for(std::size_t i = 0; i != NumElements; ++i){
+         int_map.insert(std::map<int, int>::value_type(static_cast<int>(i), static_cast<int>(i)));
+      }
+      //Construction insertion
+      flat_map<int, int> fmap(ordered_unique_range, int_map.begin(), int_map.end());
+      if(!CheckEqualContainers(int_map, fmap))
+         return false;
+      //Insertion when empty
+      fmap.clear();
+      fmap.insert(ordered_unique_range, int_map.begin(), int_map.end());
+      if(!CheckEqualContainers(int_map, fmap))
+         return false;
+      //Re-insertion
+      fmap.insert(ordered_unique_range, int_map.begin(), int_map.end());
+      std::map<int, int> int_map2(int_map);
+      int_map2.insert(int_map.begin(), int_map.end());
+      if(!CheckEqualContainers(int_map2, fmap))
+         return false;
+      //Re-re-insertion
+      fmap.insert(ordered_unique_range, int_map2.begin(), int_map2.end());
+      std::map<int, int> int_map4(int_map2);
+      int_map4.insert(int_map2.begin(), int_map2.end());
+      if(!CheckEqualContainers(int_map4, fmap))
+         return false;
+      //Re-re-insertion of even
+      std::map<int, int> int_even_map;
+      for(std::size_t i = 0; i < NumElements; i+=2){
+         int_map.insert(std::map<int, int>::value_type(static_cast<int>(i), static_cast<int>(i)));
+      }
+      fmap.insert(ordered_unique_range, int_even_map.begin(), int_even_map.end());
+      int_map4.insert(int_even_map.begin(), int_even_map.end());
+      if(!CheckEqualContainers(int_map4, fmap))
+         return false;
+   }
+
+   return true;
+}
+
+bool constructor_template_auto_deduction_test()
+{
+
+#ifndef BOOST_CONTAINER_NO_CXX17_CTAD
+   using namespace boost::container;
+   const std::size_t NumElements = 100;
+   {
+      std::map<int, int> int_map;
+      for(std::size_t i = 0; i != NumElements; ++i){
+         int_map.insert(std::map<int, int>::value_type(static_cast<int>(i), static_cast<int>(i)));
+      }
+      std::multimap<int, int> int_mmap;
+      for (std::size_t i = 0; i != NumElements; ++i) {
+         int_mmap.insert(std::multimap<int, int>::value_type(static_cast<int>(i), static_cast<int>(i)));
+      }
+
+      typedef std::less<int> comp_int_t;
+      typedef std::allocator<std::pair<int, int> > alloc_pair_int_t;
+
+      //range
+      {
+         auto fmap = flat_map(int_map.begin(), int_map.end());
+         if (!CheckEqualContainers(int_map, fmap))
+            return false;
+         auto fmmap = flat_multimap(int_mmap.begin(), int_mmap.end());
+         if (!CheckEqualContainers(int_mmap, fmmap))
+            return false;
+      }
+      //range+comp
+      {
+         auto fmap = flat_map(int_map.begin(), int_map.end(), comp_int_t());
+         if (!CheckEqualContainers(int_map, fmap))
+            return false;
+         auto fmmap = flat_multimap(int_mmap.begin(), int_mmap.end(), comp_int_t());
+         if (!CheckEqualContainers(int_mmap, fmmap))
+            return false;
+      }
+      //range+comp+alloc
+      {
+         auto fmap = flat_map(int_map.begin(), int_map.end(), comp_int_t(), alloc_pair_int_t());
+         if (!CheckEqualContainers(int_map, fmap))
+            return false;
+         auto fmmap = flat_multimap(int_mmap.begin(), int_mmap.end(), comp_int_t(), alloc_pair_int_t());
+         if (!CheckEqualContainers(int_mmap, fmmap))
+            return false;
+      }
+      //range+alloc
+      {
+         auto fmap = flat_map(int_map.begin(), int_map.end(), alloc_pair_int_t());
+         if (!CheckEqualContainers(int_map, fmap))
+            return false;
+         auto fmmap = flat_multimap(int_mmap.begin(), int_mmap.end(), alloc_pair_int_t());
+         if (!CheckEqualContainers(int_mmap, fmmap))
+            return false;
+      }
+
+      //ordered_unique_range / ordered_range
+
+      //range
+      {
+         auto fmap = flat_map(ordered_unique_range, int_map.begin(), int_map.end());
+         if(!CheckEqualContainers(int_map, fmap))
+            return false;
+         auto fmmap = flat_multimap(ordered_range, int_mmap.begin(), int_mmap.end());
+         if(!CheckEqualContainers(int_mmap, fmmap))
+            return false;
+      }
+      //range+comp
+      {
+         auto fmap = flat_map(ordered_unique_range, int_map.begin(), int_map.end(), comp_int_t());
+         if (!CheckEqualContainers(int_map, fmap))
+            return false;
+         auto fmmap = flat_multimap(ordered_range, int_mmap.begin(), int_mmap.end(), comp_int_t());
+         if (!CheckEqualContainers(int_mmap, fmmap))
+            return false;
+      }
+      //range+comp+alloc
+      {
+         auto fmap = flat_map(ordered_unique_range, int_map.begin(), int_map.end(), comp_int_t(), alloc_pair_int_t());
+         if (!CheckEqualContainers(int_map, fmap))
+            return false;
+         auto fmmap = flat_multimap(ordered_range, int_mmap.begin(), int_mmap.end(), comp_int_t(), alloc_pair_int_t());
+         if (!CheckEqualContainers(int_mmap, fmmap))
+            return false;
+      }
+      //range+alloc
+      {
+         auto fmap = flat_map(ordered_unique_range, int_map.begin(), int_map.end(),alloc_pair_int_t());
+         if (!CheckEqualContainers(int_map, fmap))
+            return false;
+         auto fmmap = flat_multimap(ordered_range, int_mmap.begin(), int_mmap.end(),alloc_pair_int_t());
+         if (!CheckEqualContainers(int_mmap, fmmap))
+            return false;
+      }
+   }
+#endif
+
+   return true;
+}
+
+template< class RandomIt >
+void random_shuffle( RandomIt first, RandomIt last )
+{
+   typedef typename boost::container::iterator_traits<RandomIt>::difference_type difference_type;
+   difference_type n = last - first;
+   for (difference_type i = n-1; i > 0; --i) {
+      difference_type j = std::rand() % (i+1);
+      if(j != i) {
+         boost::adl_move_swap(first[i], first[j]);
+      }
+   }
+}
+
+bool flat_tree_extract_adopt_test()
+{
+   using namespace boost::container;
+   const std::size_t NumElements = 100;
+
+   //extract/adopt map
+   {
+      //Construction insertion
+      flat_map<int, int> fmap;
+
+      for(std::size_t i = 0; i != NumElements; ++i){
+         fmap.emplace(static_cast<int>(i), -static_cast<int>(i));
+      }
+
+      flat_map<int, int> fmap_copy(fmap);
+      flat_map<int, int>::sequence_type seq(fmap.extract_sequence());
+      if(!fmap.empty())
+         return false;
+      if(!CheckEqualContainers(seq, fmap_copy))
+         return false;
+
+      seq.insert(seq.end(), fmap_copy.begin(), fmap_copy.end());
+      boost::container::test::random_shuffle(seq.begin(), seq.end());
+      fmap.adopt_sequence(boost::move(seq));
+      if(!CheckEqualContainers(fmap, fmap_copy))
+         return false;
+   }
+
+   //extract/adopt map, ordered_unique_range
+   {
+      //Construction insertion
+      flat_map<int, int> fmap;
+
+      for(std::size_t i = 0; i != NumElements; ++i){
+         fmap.emplace(static_cast<int>(i), -static_cast<int>(i));
+      }
+
+      flat_map<int, int> fmap_copy(fmap);
+      flat_map<int, int>::sequence_type seq(fmap.extract_sequence());
+      if(!fmap.empty())
+         return false;
+      if(!CheckEqualContainers(seq, fmap_copy))
+         return false;
+
+      fmap.adopt_sequence(ordered_unique_range, boost::move(seq));
+      if(!CheckEqualContainers(fmap, fmap_copy))
+         return false;
+   }
+
+   //extract/adopt multimap
+   {
+      //Construction insertion
+      flat_multimap<int, int> fmmap;
+
+      for(std::size_t i = 0; i != NumElements; ++i){
+         fmmap.emplace(static_cast<int>(i), -static_cast<int>(i));
+         fmmap.emplace(static_cast<int>(i), -static_cast<int>(i));
+      }
+
+      flat_multimap<int, int> fmmap_copy(fmmap);
+      flat_multimap<int, int>::sequence_type seq(fmmap.extract_sequence());
+      if(!fmmap.empty())
+         return false;
+      if(!CheckEqualContainers(seq, fmmap_copy))
+         return false;
+
+      boost::container::test::random_shuffle(seq.begin(), seq.end());
+      fmmap.adopt_sequence(boost::move(seq));
+      if(!CheckEqualContainers(fmmap, fmmap_copy))
+         return false;
+   }
+
+   //extract/adopt multimap, ordered_range
+   {
+      //Construction insertion
+      flat_multimap<int, int> fmmap;
+
+      for(std::size_t i = 0; i != NumElements; ++i){
+         fmmap.emplace(static_cast<int>(i), -static_cast<int>(i));
+         fmmap.emplace(static_cast<int>(i), -static_cast<int>(i));
+      }
+
+      flat_multimap<int, int> fmmap_copy(fmmap);
+      flat_multimap<int, int>::sequence_type seq(fmmap.extract_sequence());
+      if(!fmmap.empty())
+         return false;
+      if(!CheckEqualContainers(seq, fmmap_copy))
+         return false;
+
+      fmmap.adopt_sequence(ordered_range, boost::move(seq));
+      if(!CheckEqualContainers(fmmap, fmmap_copy))
+         return false;
+   }
+
+   return true;
+}
+
+}}}
+
+template<class VoidAllocatorOrContainer>
+struct GetMapContainer
+{
+   template<class ValueType>
+   struct apply
+   {
+      typedef std::pair<ValueType, ValueType> type_t;
+      typedef flat_map< ValueType
+                 , ValueType
+                 , std::less<ValueType>
+                 , typename boost::container::dtl::container_or_allocator_rebind<VoidAllocatorOrContainer, type_t>::type
+                 > map_type;
+
+      typedef flat_multimap< ValueType
+                 , ValueType
+                 , std::less<ValueType>
+                 , typename boost::container::dtl::container_or_allocator_rebind<VoidAllocatorOrContainer, type_t>::type
+                 > multimap_type;
+   };
+};
+
+struct boost_container_flat_map;
+struct boost_container_flat_multimap;
+
+namespace boost { namespace container {   namespace test {
+
+template<>
+struct alloc_propagate_base<boost_container_flat_map>
+{
+   template <class T, class Allocator>
+   struct apply
+   {
+      typedef typename boost::container::allocator_traits<Allocator>::
+         template portable_rebind_alloc<std::pair<T, T> >::type TypeAllocator;
+      typedef boost::container::flat_map<T, T, std::less<T>, TypeAllocator> type;
+   };
+};
+
+template<>
+struct alloc_propagate_base<boost_container_flat_multimap>
+{
+   template <class T, class Allocator>
+   struct apply
+   {
+      typedef typename boost::container::allocator_traits<Allocator>::
+         template portable_rebind_alloc<std::pair<T, T> >::type TypeAllocator;
+      typedef boost::container::flat_multimap<T, T, std::less<T>, TypeAllocator> type;
+   };
+};
+
+template <class Key, class T, class Compare, class Allocator>
+struct get_real_stored_allocator<flat_map<Key, T, Compare, Allocator> >
+{
+   typedef typename flat_map<Key, T, Compare, Allocator>::impl_stored_allocator_type type;
+};
+
+template <class Key, class T, class Compare, class Allocator>
+struct get_real_stored_allocator<flat_multimap<Key, T, Compare, Allocator> >
+{
+   typedef typename flat_multimap<Key, T, Compare, Allocator>::impl_stored_allocator_type type;
+};
+
+bool test_heterogeneous_lookups()
+{
+   BOOST_STATIC_ASSERT((dtl::is_transparent<less_transparent>::value));
+   BOOST_STATIC_ASSERT(!(dtl::is_transparent<std::less<int> >::value));
+   typedef flat_map<int, char, less_transparent> map_t;
+   typedef flat_multimap<int, char, less_transparent> mmap_t;
+   typedef map_t::value_type value_type;
+
+   map_t map1;
+   mmap_t mmap1;
+
+   const map_t &cmap1 = map1;
+   const mmap_t &cmmap1 = mmap1;
+
+   if(!map1.insert_or_assign(1, 'a').second)
+      return false;
+   if( map1.insert_or_assign(1, 'b').second)
+      return false;
+   if(!map1.insert_or_assign(2, 'c').second)
+      return false;
+   if( map1.insert_or_assign(2, 'd').second)
+      return false;
+   if(!map1.insert_or_assign(3, 'e').second)
+      return false;
+
+   if(map1.insert_or_assign(1, 'a').second)
+      return false;
+   if(map1.insert_or_assign(1, 'b').second)
+      return false;
+   if(map1.insert_or_assign(2, 'c').second)
+      return false;
+   if(map1.insert_or_assign(2, 'd').second)
+      return false;
+   if(map1.insert_or_assign(3, 'e').second)
+      return false;
+
+   mmap1.insert(value_type(1, 'a'));
+   mmap1.insert(value_type(1, 'b'));
+   mmap1.insert(value_type(2, 'c'));
+   mmap1.insert(value_type(2, 'd'));
+   mmap1.insert(value_type(3, 'e'));
+
+   const test::non_copymovable_int find_me(2);
+
+   //find
+   if(map1.find(find_me)->second != 'd')
+      return false;
+   if(cmap1.find(find_me)->second != 'd')
+      return false;
+   if(mmap1.find(find_me)->second != 'c')
+      return false;
+   if(cmmap1.find(find_me)->second != 'c')
+      return false;
+
+   //count
+   if(map1.count(find_me) != 1)
+      return false;
+   if(cmap1.count(find_me) != 1)
+      return false;
+   if(mmap1.count(find_me) != 2)
+      return false;
+   if(cmmap1.count(find_me) != 2)
+      return false;
+
+   //contains
+   if(!map1.contains(find_me))
+      return false;
+   if(!cmap1.contains(find_me))
+      return false;
+   if(!mmap1.contains(find_me))
+      return false;
+   if(!cmmap1.contains(find_me))
+      return false;
+
+   //lower_bound
+   if(map1.lower_bound(find_me)->second != 'd')
+      return false;
+   if(cmap1.lower_bound(find_me)->second != 'd')
+      return false;
+   if(mmap1.lower_bound(find_me)->second != 'c')
+      return false;
+   if(cmmap1.lower_bound(find_me)->second != 'c')
+      return false;
+
+   //upper_bound
+   if(map1.upper_bound(find_me)->second != 'e')
+      return false;
+   if(cmap1.upper_bound(find_me)->second != 'e')
+      return false;
+   if(mmap1.upper_bound(find_me)->second != 'e')
+      return false;
+   if(cmmap1.upper_bound(find_me)->second != 'e')
+      return false;
+
+   //equal_range
+   if(map1.equal_range(find_me).first->second != 'd')
+      return false;
+   if(cmap1.equal_range(find_me).second->second != 'e')
+      return false;
+   if(mmap1.equal_range(find_me).first->second != 'c')
+      return false;
+   if(cmmap1.equal_range(find_me).second->second != 'e')
+      return false;
+
+   return true;
+}
+
+// An ordered sequence of std:pair is also ordered by std::pair::first.
+struct with_lookup_by_first
+{
+   typedef void is_transparent;
+   inline bool operator()(std::pair<int, int> a, std::pair<int, int> b) const
+   {
+      return a < b;
+   }
+   inline bool operator()(std::pair<int, int> a, int first) const
+   {
+      return a.first < first;
+   }
+   inline bool operator()(int first, std::pair<int, int> b) const
+   {
+      return first < b.first;
+   }
+};
+
+bool test_heterogeneous_lookup_by_partial_key()
+{
+   typedef flat_map<std::pair<int, int>,int, with_lookup_by_first> map_t;
+
+   map_t map1;
+   map1[std::pair<int, int>(0, 1)] = 3;
+   map1[std::pair<int, int>(0, 2)] = 3;
+
+   std::pair<map_t::iterator, map_t::iterator> const first_0_range = map1.equal_range(0);
+
+   if(2 != (first_0_range.second - first_0_range.first))
+      return false;
+
+   if(2 != map1.count(0))
+      return false;
+   return true;
+}
+
+}}}   //namespace boost::container::test
+
+int main()
+{
+   using namespace boost::container::test;
+
+   //Allocator argument container
+   {
+      flat_map<int, int> map_((flat_map<int, int>::allocator_type()));
+      flat_multimap<int, int> multimap_((flat_multimap<int, int>::allocator_type()));
+   }
+   //Now test move semantics
+   {
+      test_move<flat_map<recursive_flat_map, recursive_flat_map> >();
+      test_move<flat_multimap<recursive_flat_multimap, recursive_flat_multimap> >();
+   }
+   //Now test nth/index_of
+   {
+      flat_map<int, int> map;
+      flat_multimap<int, int> mmap;
+
+      map.insert(std::pair<int, int>(0, 0));
+      map.insert(std::pair<int, int>(1, 0));
+      map.insert(std::pair<int, int>(2, 0));
+      mmap.insert(std::pair<int, int>(0, 0));
+      mmap.insert(std::pair<int, int>(1, 0));
+      mmap.insert(std::pair<int, int>(2, 0));
+      if(!boost::container::test::test_nth_index_of(map))
+         return 1;
+      if(!boost::container::test::test_nth_index_of(mmap))
+         return 1;
+   }
+
+   ////////////////////////////////////
+   //    Ordered insertion test
+   ////////////////////////////////////
+   if(!flat_tree_ordered_insertion_test()){
+      return 1;
+   }
+
+   ////////////////////////////////////
+   //    Constructor Template Auto Deduction test
+   ////////////////////////////////////
+   if(!constructor_template_auto_deduction_test()){
+      return 1;
+   }
+
+   ////////////////////////////////////
+   //    Extract/Adopt test
+   ////////////////////////////////////
+   if(!flat_tree_extract_adopt_test()){
+      return 1;
+   }
+
+   if (!boost::container::test::instantiate_constructors<flat_map<int, int>, flat_multimap<int, int> >())
+      return 1;
+
+   if (!test_heterogeneous_lookups())
+      return 1;
+
+   if (!test_heterogeneous_lookup_by_partial_key())
+      return 1;
+
+   ////////////////////////////////////
+   //    Testing allocator implementations
+   ////////////////////////////////////
+   {
+      typedef std::map<int, int>                                     MyStdMap;
+      typedef std::multimap<int, int>                                MyStdMultiMap;
+
+      if (0 != test::map_test
+         < GetMapContainer<std::allocator<void> >::apply<int>::map_type
+         , MyStdMap
+         , GetMapContainer<std::allocator<void> >::apply<int>::multimap_type
+         , MyStdMultiMap>()) {
+         std::cout << "Error in map_test<std::allocator<void> >" << std::endl;
+         return 1;
+      }
+
+      if (0 != test::map_test
+         < GetMapContainer<new_allocator<void> >::apply<int>::map_type
+         , MyStdMap
+         , GetMapContainer<new_allocator<void> >::apply<int>::multimap_type
+         , MyStdMultiMap>()) {
+         std::cout << "Error in map_test<new_allocator<void> >" << std::endl;
+         return 1;
+      }
+
+      if (0 != test::map_test
+         < GetMapContainer<new_allocator<void> >::apply<test::movable_int>::map_type
+         , MyStdMap
+         , GetMapContainer<new_allocator<void> >::apply<test::movable_int>::multimap_type
+         , MyStdMultiMap>()) {
+         std::cout << "Error in map_test<new_allocator<void> >" << std::endl;
+         return 1;
+      }
+
+      if (0 != test::map_test
+         < GetMapContainer<new_allocator<void> >::apply<test::copyable_int>::map_type
+         , MyStdMap
+         , GetMapContainer<new_allocator<void> >::apply<test::copyable_int>::multimap_type
+         , MyStdMultiMap>()) {
+         std::cout << "Error in map_test<new_allocator<void> >" << std::endl;
+         return 1;
+      }
+
+      if (0 != test::map_test
+         < GetMapContainer<new_allocator<void> >::apply<test::movable_and_copyable_int>::map_type
+         , MyStdMap
+         , GetMapContainer<new_allocator<void> >::apply<test::movable_and_copyable_int>::multimap_type
+         , MyStdMultiMap>()) {
+         std::cout << "Error in map_test<new_allocator<void> >" << std::endl;
+         return 1;
+      }
+   }
+
+   if(!boost::container::test::test_map_support_for_initialization_list_for<flat_map<int, int> >())
+      return 1;
+
+   if (!boost::container::test::test_map_support_for_initialization_list_for<flat_multimap<int, int> >())
+      return 1;
+
+   ////////////////////////////////////
+   //    Emplace testing
+   ////////////////////////////////////
+   const test::EmplaceOptions MapOptions = (test::EmplaceOptions)(test::EMPLACE_HINT_PAIR | test::EMPLACE_ASSOC_PAIR);
+
+   if(!boost::container::test::test_emplace<flat_map<test::EmplaceInt, test::EmplaceInt>, MapOptions>())
+      return 1;
+   if(!boost::container::test::test_emplace<flat_multimap<test::EmplaceInt, test::EmplaceInt>, MapOptions>())
+      return 1;
+
+   ////////////////////////////////////
+   //    Allocator propagation testing
+   ////////////////////////////////////
+   if(!boost::container::test::test_propagate_allocator<boost_container_flat_map>())
+      return 1;
+
+   if(!boost::container::test::test_propagate_allocator<boost_container_flat_multimap>())
+      return 1;
+
+   ////////////////////////////////////
+   //    Iterator testing
+   ////////////////////////////////////
+   {
+      typedef boost::container::flat_map<int, int> cont_int;
+      cont_int a; a.insert(cont_int::value_type(0, 9)); a.insert(cont_int::value_type(1, 9)); a.insert(cont_int::value_type(2, 9));
+      boost::intrusive::test::test_iterator_random< cont_int >(a);
+      if(boost::report_errors() != 0) {
+         return 1;
+      }
+   }
+   {
+      typedef boost::container::flat_multimap<int, int> cont_int;
+      cont_int a; a.insert(cont_int::value_type(0, 9)); a.insert(cont_int::value_type(1, 9)); a.insert(cont_int::value_type(2, 9));
+      boost::intrusive::test::test_iterator_random< cont_int >(a);
+      if(boost::report_errors() != 0) {
+         return 1;
+      }
+   }
+
+   ////////////////////////////////////
+   //    has_trivial_destructor_after_move testing
+   ////////////////////////////////////
+   {
+      typedef boost::container::dtl::pair<int, int> value_t;
+      typedef boost::container::dtl::select1st<int> key_of_value_t;
+      // flat_map, default
+      {
+         typedef boost::container::new_allocator<value_t> alloc_or_cont_t;
+         typedef boost::container::flat_map<int, int> cont;
+         typedef boost::container::dtl::flat_tree<value_t, key_of_value_t, std::less<int>, alloc_or_cont_t> tree;
+         if (boost::has_trivial_destructor_after_move<cont>::value !=
+             boost::has_trivial_destructor_after_move<tree>::value) {
+            std::cerr << "has_trivial_destructor_after_move(flat_map, default) test failed" << std::endl;
+            return 1;
+         }
+      }
+      // flat_map, vector
+      {
+         typedef boost::container::vector<value_t> alloc_or_cont_t;
+         typedef boost::container::flat_map<int, int, std::less<int>, alloc_or_cont_t> cont;
+         typedef boost::container::dtl::flat_tree<value_t, key_of_value_t, std::less<int>, alloc_or_cont_t> tree;
+         if (boost::has_trivial_destructor_after_move<cont>::value !=
+             boost::has_trivial_destructor_after_move<tree>::value) {
+            std::cerr << "has_trivial_destructor_after_move(flat_map, vector) test failed" << std::endl;
+            return 1;
+         }
+      }
+      // flat_map, std::vector
+      {
+         typedef std::vector<value_t> alloc_or_cont_t;
+         typedef boost::container::flat_map<int, int, std::less<int>, alloc_or_cont_t> cont;
+         typedef boost::container::dtl::flat_tree<value_t, key_of_value_t, std::less<int>, alloc_or_cont_t> tree;
+         if (boost::has_trivial_destructor_after_move<cont>::value !=
+             boost::has_trivial_destructor_after_move<tree>::value) {
+            std::cerr << "has_trivial_destructor_after_move(flat_map, std::vector) test failed" << std::endl;
+            return 1;
+         }
+      }
+      // flat_multimap, default
+      {
+         typedef boost::container::new_allocator<value_t> alloc_or_cont_t;
+         typedef boost::container::flat_multimap<int, int> cont;
+         typedef boost::container::dtl::flat_tree<value_t, key_of_value_t, std::less<int>, alloc_or_cont_t> tree;
+         if (boost::has_trivial_destructor_after_move<cont>::value !=
+             boost::has_trivial_destructor_after_move<tree>::value) {
+            std::cerr << "has_trivial_destructor_after_move(flat_multimap, default) test failed" << std::endl;
+            return 1;
+         }
+      }
+      // flat_multimap, vector
+      {
+         typedef boost::container::vector<value_t> alloc_or_cont_t;
+         typedef boost::container::flat_multimap<int, int, std::less<int>, alloc_or_cont_t> cont;
+         typedef boost::container::dtl::flat_tree<value_t, key_of_value_t, std::less<int>, alloc_or_cont_t> tree;
+         if (boost::has_trivial_destructor_after_move<cont>::value !=
+             boost::has_trivial_destructor_after_move<tree>::value) {
+            std::cerr << "has_trivial_destructor_after_move(flat_multimap, vector) test failed" << std::endl;
+            return 1;
+         }
+      }
+      // flat_multimap, std::vector
+      {
+         typedef std::vector<value_t> alloc_or_cont_t;
+         typedef boost::container::flat_multimap<int, int, std::less<int>, alloc_or_cont_t> cont;
+         typedef boost::container::dtl::flat_tree<value_t, key_of_value_t, std::less<int>, alloc_or_cont_t> tree;
+         if (boost::has_trivial_destructor_after_move<cont>::value !=
+             boost::has_trivial_destructor_after_move<tree>::value) {
+            std::cerr << "has_trivial_destructor_after_move(flat_multimap, std::vector) test failed" << std::endl;
+            return 1;
+         }
+      }
+   }
+
+   return 0;
+}
+
+#include <boost/container/detail/config_end.hpp>
diff --git a/src/boost/libs/container/test/flat_set_adaptor_test.cpp b/src/boost/libs/container/test/flat_set_adaptor_test.cpp
new file mode 100644
index 000000000..b59ab1794
--- /dev/null
+++ b/src/boost/libs/container/test/flat_set_adaptor_test.cpp
@@ -0,0 +1,101 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2004-2019. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/container for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+#include <boost/container/flat_set.hpp>
+#include <boost/container/small_vector.hpp>
+#include <boost/container/static_vector.hpp>
+#include <boost/container/stable_vector.hpp>
+#include <boost/container/vector.hpp>
+#include <boost/container/deque.hpp>
+
+#include <boost/container/detail/container_or_allocator_rebind.hpp>
+
+#include "set_test.hpp"
+#include <set>
+
+using namespace boost::container;
+
+template<class VoidAllocatorOrContainer>
+struct GetSetContainer
+{
+   template<class ValueType>
+   struct apply
+   {
+      typedef flat_set < ValueType
+                       , std::less<ValueType>
+                       , typename boost::container::dtl::container_or_allocator_rebind<VoidAllocatorOrContainer, ValueType>::type
+                        > set_type;
+
+      typedef flat_multiset < ValueType
+                            , std::less<ValueType>
+                            , typename boost::container::dtl::container_or_allocator_rebind<VoidAllocatorOrContainer, ValueType>::type
+                            > multiset_type;
+   };
+};
+
+int main()
+{
+   using namespace boost::container::test;
+
+   ////////////////////////////////////
+   //    Testing sequence container implementations
+   ////////////////////////////////////
+   {
+      typedef std::set<int>                                     MyStdSet;
+      typedef std::multiset<int>                                MyStdMultiSet;
+
+      if (0 != test::set_test
+         < GetSetContainer<vector<int> >::apply<int>::set_type
+         , MyStdSet
+         , GetSetContainer<vector<int> >::apply<int>::multiset_type
+         , MyStdMultiSet>()) {
+         std::cout << "Error in set_test<vector<int> >" << std::endl;
+         return 1;
+      }
+
+      if (0 != test::set_test
+         < GetSetContainer<small_vector<int, 7> >::apply<int>::set_type
+         , MyStdSet
+         , GetSetContainer<small_vector<int, 7> >::apply<int>::multiset_type
+         , MyStdMultiSet>()) {
+         std::cout << "Error in set_test<small_vector<int, 7> >" << std::endl;
+         return 1;
+      }
+
+       if (0 != test::set_test
+         < GetSetContainer<static_vector<int, MaxElem * 10> >::apply<int>::set_type
+         , MyStdSet
+         , GetSetContainer<static_vector<int, MaxElem * 10> >::apply<int>::multiset_type
+         , MyStdMultiSet>()) {
+         std::cout << "Error in set_test<static_vector<int, MaxElem * 10> >" << std::endl;
+         return 1;
+      }
+
+      if (0 != test::set_test
+         < GetSetContainer<stable_vector<int> >::apply<int>::set_type
+         , MyStdSet
+         , GetSetContainer<stable_vector<int> >::apply<int>::multiset_type
+         , MyStdMultiSet>()) {
+         std::cout << "Error in set_test<stable_vector<int> >" << std::endl;
+         return 1;
+      }
+
+
+      if (0 != test::set_test
+         < GetSetContainer<deque<int> >::apply<int>::set_type
+         , MyStdSet
+         , GetSetContainer<deque<int> >::apply<int>::multiset_type
+         , MyStdMultiSet>()) {
+         std::cout << "Error in set_test<deque<int> >" << std::endl;
+         return 1;
+      }
+   }
+
+   return 0;
+}
diff --git a/src/boost/libs/container/test/flat_set_test.cpp b/src/boost/libs/container/test/flat_set_test.cpp
new file mode 100644
index 000000000..7927b99a4
--- /dev/null
+++ b/src/boost/libs/container/test/flat_set_test.cpp
@@ -0,0 +1,933 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2004-2013. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/container for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#include <boost/container/detail/config_begin.hpp>
+
+#include <iostream>
+#include <set>
+#include <utility>
+#include <vector>
+
+#include <boost/container/flat_set.hpp>
+#include <boost/container/detail/container_or_allocator_rebind.hpp>
+
+#include "print_container.hpp"
+#include "dummy_test_allocator.hpp"
+#include "movable_int.hpp"
+#include "set_test.hpp"
+#include "propagate_allocator_test.hpp"
+#include "emplace_test.hpp"
+#include "container_common_tests.hpp"
+#include "../../intrusive/test/iterator_test.hpp"
+
+using namespace boost::container;
+
+//Test recursive structures
+class recursive_flat_set
+{
+   public:
+   recursive_flat_set(const recursive_flat_set &c)
+      : id_(c.id_), flat_set_(c.flat_set_)
+   {}
+
+   recursive_flat_set & operator =(const recursive_flat_set &c)
+   {
+      id_ = c.id_;
+      flat_set_= c.flat_set_;
+      return *this;
+   }
+   int id_;
+   flat_set<recursive_flat_set> flat_set_;
+   flat_set<recursive_flat_set>::iterator it_;
+   flat_set<recursive_flat_set>::const_iterator cit_;
+   flat_set<recursive_flat_set>::reverse_iterator rit_;
+   flat_set<recursive_flat_set>::const_reverse_iterator crit_;
+
+   friend bool operator< (const recursive_flat_set &a, const recursive_flat_set &b)
+   {  return a.id_ < b.id_;   }
+};
+
+
+//Test recursive structures
+class recursive_flat_multiset
+{
+   public:
+   recursive_flat_multiset(const recursive_flat_multiset &c)
+      : id_(c.id_), flat_multiset_(c.flat_multiset_)
+   {}
+
+   recursive_flat_multiset & operator =(const recursive_flat_multiset &c)
+   {
+      id_ = c.id_;
+      flat_multiset_= c.flat_multiset_;
+      return *this;
+   }
+   int id_;
+   flat_multiset<recursive_flat_multiset> flat_multiset_;
+   flat_multiset<recursive_flat_multiset>::iterator it_;
+   flat_multiset<recursive_flat_multiset>::const_iterator cit_;
+   flat_multiset<recursive_flat_multiset>::reverse_iterator rit_;
+   flat_multiset<recursive_flat_multiset>::const_reverse_iterator crit_;
+
+   friend bool operator< (const recursive_flat_multiset &a, const recursive_flat_multiset &b)
+   {  return a.id_ < b.id_;   }
+};
+
+
+template<class C>
+void test_move()
+{
+   //Now test move semantics
+   C original;
+   C move_ctor(boost::move(original));
+   C move_assign;
+   move_assign = boost::move(move_ctor);
+   move_assign.swap(original);
+}
+
+namespace boost{
+namespace container {
+namespace test{
+
+bool flat_tree_ordered_insertion_test()
+{
+   using namespace boost::container;
+   const std::size_t NumElements = 100;
+
+   //Ordered insertion multiset
+   {
+      std::multiset<int> int_mset;
+      for(std::size_t i = 0; i != NumElements; ++i){
+         int_mset.insert(static_cast<int>(i));
+      }
+      //Construction insertion
+      flat_multiset<int> fmset(ordered_range, int_mset.begin(), int_mset.end());
+      if(!CheckEqualContainers(int_mset, fmset))
+         return false;
+      //Insertion when empty
+      fmset.clear();
+      fmset.insert(ordered_range, int_mset.begin(), int_mset.end());
+      if(!CheckEqualContainers(int_mset, fmset))
+         return false;
+      //Re-insertion
+      fmset.insert(ordered_range, int_mset.begin(), int_mset.end());
+      std::multiset<int> int_mset2(int_mset);
+      int_mset2.insert(int_mset.begin(), int_mset.end());
+      if(!CheckEqualContainers(int_mset2, fmset))
+         return false;
+      //Re-re-insertion
+      fmset.insert(ordered_range, int_mset2.begin(), int_mset2.end());
+      std::multiset<int> int_mset4(int_mset2);
+      int_mset4.insert(int_mset2.begin(), int_mset2.end());
+      if(!CheckEqualContainers(int_mset4, fmset))
+         return false;
+      //Re-re-insertion of even
+      std::multiset<int> int_even_mset;
+      for(std::size_t i = 0; i < NumElements; i+=2){
+         int_mset.insert(static_cast<int>(i));
+      }
+      fmset.insert(ordered_range, int_even_mset.begin(), int_even_mset.end());
+      int_mset4.insert(int_even_mset.begin(), int_even_mset.end());
+      if(!CheckEqualContainers(int_mset4, fmset))
+         return false;
+
+      //Re-re-insertion using in-place merge
+      fmset.reserve(fmset.size() + int_mset2.size());
+      fmset.insert(ordered_range, int_mset2.begin(), int_mset2.end());
+      std::multiset<int> int_mset5(int_mset2);
+      int_mset4.insert(int_mset5.begin(), int_mset5.end());
+      if(!CheckEqualContainers(int_mset4, fmset))
+         return false;
+      //Re-re-insertion of even
+      std::multiset<int> int_even_mset2;
+      for(std::size_t i = 0; i < NumElements; i+=2){
+         int_even_mset2.insert(static_cast<int>(i));
+      }
+      fmset.reserve(fmset.size() + int_even_mset2.size());
+      fmset.insert(ordered_range, int_even_mset2.begin(), int_even_mset2.end());
+      int_mset4.insert(int_even_mset2.begin(), int_even_mset2.end());
+      if(!CheckEqualContainers(int_mset4, fmset))
+         return false;
+   }
+
+   //Ordered insertion set
+   {
+      std::set<int> int_set;
+      for(std::size_t i = 0; i != NumElements; ++i){
+         int_set.insert(static_cast<int>(i));
+      }
+      //Construction insertion
+      flat_set<int> fset(ordered_unique_range, int_set.begin(), int_set.end());
+      if(!CheckEqualContainers(int_set, fset))
+         return false;
+      //Insertion when empty
+      fset.clear();
+      fset.insert(ordered_unique_range, int_set.begin(), int_set.end());
+      if(!CheckEqualContainers(int_set, fset))
+         return false;
+      //Re-insertion
+      fset.insert(ordered_unique_range, int_set.begin(), int_set.end());
+      std::set<int> int_set2(int_set);
+      int_set2.insert(int_set.begin(), int_set.end());
+      if(!CheckEqualContainers(int_set2, fset))
+         return false;
+      //Re-re-insertion
+      fset.insert(ordered_unique_range, int_set2.begin(), int_set2.end());
+      std::set<int> int_set4(int_set2);
+      int_set4.insert(int_set2.begin(), int_set2.end());
+      if(!CheckEqualContainers(int_set4, fset))
+         return false;
+      //Re-re-insertion of even
+      std::set<int> int_even_set;
+      for(std::size_t i = 0; i < NumElements; i+=2){
+         int_even_set.insert(static_cast<int>(i));
+      }
+      fset.insert(ordered_unique_range, int_even_set.begin(), int_even_set.end());
+      int_set4.insert(int_even_set.begin(), int_even_set.end());
+      if(!CheckEqualContainers(int_set4, fset))
+         return false;
+      //Partial Re-re-insertion of even
+      int_even_set.clear();
+      for(std::size_t i = 0; i < NumElements; i+=4){
+         int_even_set.insert(static_cast<int>(i));
+      }
+      fset.clear();
+      int_set4.clear();
+      //insert 0,4,8,12...
+      fset.insert(ordered_unique_range, int_even_set.begin(), int_even_set.end());
+      int_set4.insert(int_even_set.begin(), int_even_set.end());
+      if(!CheckEqualContainers(int_set4, fset))
+         return false;
+      for(std::size_t i = 2; i < NumElements; i+=4){
+         int_even_set.insert(static_cast<int>(i));
+      }
+      //insert 0,2,4,6,8,10,12...
+      fset.insert(ordered_unique_range, int_even_set.begin(), int_even_set.end());
+      int_set4.insert(int_even_set.begin(), int_even_set.end());
+      if(!CheckEqualContainers(int_set4, fset))
+         return false;
+      int_even_set.clear();
+      for(std::size_t i = 0; i < NumElements; i+=8){
+         int_even_set.insert(static_cast<int>(i));
+      }
+      fset.clear();
+      int_set4.clear();
+      //insert 0,8,16...
+      fset.insert(ordered_unique_range, int_even_set.begin(), int_even_set.end());
+      int_set4.insert(int_even_set.begin(), int_even_set.end());
+      if(!CheckEqualContainers(int_set4, fset))
+         return false;
+      for(std::size_t i = 0; i < NumElements; i+=2){
+         int_even_set.insert(static_cast<int>(i));
+      }
+      //insert 0,2,4,6,8,10,12...
+      fset.insert(ordered_unique_range, int_even_set.begin(), int_even_set.end());
+      int_set4.insert(int_even_set.begin(), int_even_set.end());
+      if(!CheckEqualContainers(int_set4, fset))
+         return false;
+
+
+      int_even_set.clear();
+      for(std::size_t i = 0; i < NumElements; i+=8){
+         int_even_set.insert(static_cast<int>(i));
+         int_even_set.insert(static_cast<int>(i+2));
+      }
+      int_even_set.insert(static_cast<int>(NumElements-2));
+      fset.clear();
+      int_set4.clear();
+      //insert 0,2,8,10...
+      fset.insert(ordered_unique_range, int_even_set.begin(), int_even_set.end());
+      int_set4.insert(int_even_set.begin(), int_even_set.end());
+      if(!CheckEqualContainers(int_set4, fset))
+         return false;
+      for(std::size_t i = 0; i < NumElements; i+=2){
+         int_even_set.insert(static_cast<int>(i));
+      }
+      //insert 0,2,4,6,8,10,12...
+      fset.insert(ordered_unique_range, int_even_set.begin(), int_even_set.end());
+      int_set4.insert(int_even_set.begin(), int_even_set.end());
+      if(!CheckEqualContainers(int_set4, fset))
+         return false;
+
+      //add even/odd values with not enough capacity 
+      flat_set<int>().swap(fset);
+      int_set4.clear();
+      int_set.clear();
+
+      fset.reserve(int_even_set.size());
+      fset.insert(ordered_unique_range, int_even_set.begin(), int_even_set.end());
+      int_set4.insert(int_even_set.begin(), int_even_set.end());
+
+      for(std::size_t i = 0; i < NumElements*2; i+=2){
+         int_set.insert(static_cast<int>(i));
+         int_set.insert(static_cast<int>(i+1));
+      }
+
+      fset.insert(ordered_unique_range, int_set.begin(), int_set.end());
+      int_set4.insert(int_set.begin(), int_set.end());
+      if(!CheckEqualContainers(int_set4, fset))
+         return false;
+   }
+
+   return true;
+}
+
+bool constructor_template_auto_deduction_test()
+{
+
+#ifndef BOOST_CONTAINER_NO_CXX17_CTAD
+   using namespace boost::container;
+   const std::size_t NumElements = 100;
+   {
+      std::set<int> int_set;
+      for (std::size_t i = 0; i != NumElements; ++i) {
+         int_set.insert(static_cast<int>(i));
+      }
+      std::multiset<int> int_mset;
+      for (std::size_t i = 0; i != NumElements; ++i) {
+         int_mset.insert(static_cast<int>(i));
+      }
+
+      typedef std::less<int> comp_int_t;
+      typedef std::allocator<int> alloc_int_t;
+
+      //range
+      {
+         auto fset = flat_set(int_set.begin(), int_set.end());
+         if (!CheckEqualContainers(int_set, fset))
+            return false;
+         auto fmset = flat_multiset(int_mset.begin(), int_mset.end());
+         if (!CheckEqualContainers(int_mset, fmset))
+            return false;
+      }
+      //range+comp
+      {
+         auto fset = flat_set(int_set.begin(), int_set.end(), comp_int_t());
+         if (!CheckEqualContainers(int_set, fset))
+            return false;
+         auto fmset = flat_multiset(int_mset.begin(), int_mset.end(), comp_int_t());
+         if (!CheckEqualContainers(int_mset, fmset))
+            return false;
+      }
+      //range+comp+alloc
+      {
+         auto fset = flat_set(int_set.begin(), int_set.end(), comp_int_t(), alloc_int_t());
+         if (!CheckEqualContainers(int_set, fset))
+            return false;
+         auto fmset = flat_multiset(int_mset.begin(), int_mset.end(), comp_int_t(), alloc_int_t());
+         if (!CheckEqualContainers(int_mset, fmset))
+            return false;
+      }
+      //range+alloc
+      {
+         auto fset = flat_set(int_set.begin(), int_set.end(), alloc_int_t());
+         if (!CheckEqualContainers(int_set, fset))
+            return false;
+         auto fmset = flat_multiset(int_mset.begin(), int_mset.end(), alloc_int_t());
+         if (!CheckEqualContainers(int_mset, fmset))
+            return false;
+      }
+
+      //ordered_unique_range / ordered_range
+
+      //range
+      {
+         auto fset = flat_set(ordered_unique_range, int_set.begin(), int_set.end());
+         if (!CheckEqualContainers(int_set, fset))
+            return false;
+         auto fmset = flat_multiset(ordered_range, int_mset.begin(), int_mset.end());
+         if (!CheckEqualContainers(int_mset, fmset))
+            return false;
+      }
+      //range+comp
+      {
+         auto fset = flat_set(ordered_unique_range, int_set.begin(), int_set.end(), comp_int_t());
+         if (!CheckEqualContainers(int_set, fset))
+            return false;
+         auto fmset = flat_multiset(ordered_range, int_mset.begin(), int_mset.end(), comp_int_t());
+         if (!CheckEqualContainers(int_mset, fmset))
+            return false;
+      }
+      //range+comp+alloc
+      {
+         auto fset = flat_set(ordered_unique_range, int_set.begin(), int_set.end(), comp_int_t(), alloc_int_t());
+         if (!CheckEqualContainers(int_set, fset))
+            return false;
+         auto fmset = flat_multiset(ordered_range, int_mset.begin(), int_mset.end(), comp_int_t(), alloc_int_t());
+         if (!CheckEqualContainers(int_mset, fmset))
+            return false;
+      }
+      //range+alloc
+      {
+         auto fset = flat_set(ordered_unique_range, int_set.begin(), int_set.end(), alloc_int_t());
+         if (!CheckEqualContainers(int_set, fset))
+            return false;
+         auto fmset = flat_multiset(ordered_range, int_mset.begin(), int_mset.end(), alloc_int_t());
+         if (!CheckEqualContainers(int_mset, fmset))
+            return false;
+      }
+   }
+#endif
+
+   return true;
+}
+
+template< class RandomIt >
+void random_shuffle( RandomIt first, RandomIt last )
+{
+   typedef typename boost::container::iterator_traits<RandomIt>::difference_type difference_type;
+   difference_type n = last - first;
+   for (difference_type i = n-1; i > 0; --i) {
+      difference_type j = std::rand() % (i+1);
+      if(j != i) {
+         boost::adl_move_swap(first[i], first[j]);
+      }
+   }
+}
+
+bool flat_tree_extract_adopt_test()
+{
+   using namespace boost::container;
+   const std::size_t NumElements = 100;
+
+   //extract/adopt set
+   {
+      //Construction insertion
+      flat_set<int> fset;
+
+      for(std::size_t i = 0; i != NumElements; ++i){
+         fset.insert(static_cast<int>(i));
+      }
+
+      flat_set<int> fset_copy(fset);
+      flat_set<int>::sequence_type seq(fset.extract_sequence());
+      if(!fset.empty())
+         return false;
+      if(!CheckEqualContainers(seq, fset_copy))
+         return false;
+
+      seq.insert(seq.end(), fset_copy.begin(), fset_copy.end());
+      boost::container::test::random_shuffle(seq.begin(), seq.end());
+      fset.adopt_sequence(boost::move(seq));
+      if(!CheckEqualContainers(fset, fset_copy))
+         return false;
+   }
+
+   //extract/adopt set, ordered_unique_range
+   {
+      //Construction insertion
+      flat_set<int> fset;
+
+      for(std::size_t i = 0; i != NumElements; ++i){
+         fset.insert(static_cast<int>(i));
+      }
+
+      flat_set<int> fset_copy(fset);
+      flat_set<int>::sequence_type seq(fset.extract_sequence());
+      if(!fset.empty())
+         return false;
+      if(!CheckEqualContainers(seq, fset_copy))
+         return false;
+
+      fset.adopt_sequence(ordered_unique_range, boost::move(seq));
+      if(!CheckEqualContainers(fset, fset_copy))
+         return false;
+   }
+
+   //extract/adopt multiset
+   {
+      //Construction insertion
+      flat_multiset<int> fmset;
+
+      for(std::size_t i = 0; i != NumElements; ++i){
+         fmset.insert(static_cast<int>(i));
+         fmset.insert(static_cast<int>(i));
+      }
+
+      flat_multiset<int> fmset_copy(fmset);
+      flat_multiset<int>::sequence_type seq(fmset.extract_sequence());
+      if(!fmset.empty())
+         return false;
+      if(!CheckEqualContainers(seq, fmset_copy))
+         return false;
+
+      boost::container::test::random_shuffle(seq.begin(), seq.end());
+      fmset.adopt_sequence(boost::move(seq));
+      if(!CheckEqualContainers(fmset, fmset_copy))
+         return false;
+   }
+
+   //extract/adopt multiset, ordered_range
+   {
+      //Construction insertion
+      flat_multiset<int> fmset;
+
+      for(std::size_t i = 0; i != NumElements; ++i){
+         fmset.insert(static_cast<int>(i));
+         fmset.insert(static_cast<int>(i));
+      }
+
+      flat_multiset<int> fmset_copy(fmset);
+      flat_multiset<int>::sequence_type seq(fmset.extract_sequence());
+      if(!fmset.empty())
+         return false;
+      if(!CheckEqualContainers(seq, fmset_copy))
+         return false;
+
+      fmset.adopt_sequence(ordered_range, boost::move(seq));
+      if(!CheckEqualContainers(fmset, fmset_copy))
+         return false;
+   }
+
+   return true;
+}
+
+bool test_heterogeneous_lookups()
+{
+   typedef flat_set<int, test::less_transparent> set_t;
+   typedef flat_multiset<int, test::less_transparent> mset_t;
+
+   set_t set1;
+   mset_t mset1;
+
+   const set_t &cset1 = set1;
+   const mset_t &cmset1 = mset1;
+
+   set1.insert(1);
+   set1.insert(1);
+   set1.insert(2);
+   set1.insert(2);
+   set1.insert(3);
+
+   mset1.insert(1);
+   mset1.insert(1);
+   mset1.insert(2);
+   mset1.insert(2);
+   mset1.insert(3);
+
+   const test::non_copymovable_int find_me(2);
+
+   //find
+   if(*set1.find(find_me) != 2)
+      return false;
+   if(*cset1.find(find_me) != 2)
+      return false;
+   if(*mset1.find(find_me) != 2)
+      return false;
+   if(*cmset1.find(find_me) != 2)
+      return false;
+
+   //count
+   if(set1.count(find_me) != 1)
+      return false;
+   if(cset1.count(find_me) != 1)
+      return false;
+   if(mset1.count(find_me) != 2)
+      return false;
+   if(cmset1.count(find_me) != 2)
+      return false;
+
+   //contains
+   if(!set1.contains(find_me))
+      return false;
+   if(!cset1.contains(find_me))
+      return false;
+   if(!mset1.contains(find_me))
+      return false;
+   if(!cmset1.contains(find_me))
+      return false;
+
+   //lower_bound
+   if(*set1.lower_bound(find_me) != 2)
+      return false;
+   if(*cset1.lower_bound(find_me) != 2)
+      return false;
+   if(*mset1.lower_bound(find_me) != 2)
+      return false;
+   if(*cmset1.lower_bound(find_me) != 2)
+      return false;
+
+   //upper_bound
+   if(*set1.upper_bound(find_me) != 3)
+      return false;
+   if(*cset1.upper_bound(find_me) != 3)
+      return false;
+   if(*mset1.upper_bound(find_me) != 3)
+      return false;
+   if(*cmset1.upper_bound(find_me) != 3)
+      return false;
+
+   //equal_range
+   if(*set1.equal_range(find_me).first != 2)
+      return false;
+   if(*cset1.equal_range(find_me).second != 3)
+      return false;
+   if(*mset1.equal_range(find_me).first != 2)
+      return false;
+   if(*cmset1.equal_range(find_me).second != 3)
+      return false;
+
+   return true;
+}
+
+// An ordered sequence of std:pair is also ordered by std::pair::first.
+struct with_lookup_by_first
+{
+   typedef void is_transparent;
+   inline bool operator()(std::pair<int, int> a, std::pair<int, int> b) const
+   {
+      return a < b;
+   }
+   inline bool operator()(std::pair<int, int> a, int first) const
+   {
+      return a.first < first;
+   }
+   inline bool operator()(int first, std::pair<int, int> b) const
+   {
+      return first < b.first;
+   }
+};
+
+bool test_heterogeneous_lookup_by_partial_key()
+{
+   typedef flat_set<std::pair<int, int>, with_lookup_by_first> set_t;
+
+   set_t set1;
+   set1.insert(std::pair<int, int>(0, 1));
+   set1.insert(std::pair<int, int>(0, 2));
+
+   std::pair<set_t::iterator, set_t::iterator> const first_0_range = set1.equal_range(0);
+   if(2 != (first_0_range.second - first_0_range.first))
+      return false;
+
+   if(2 != set1.count(0))
+      return false;
+   return true;
+}
+
+}}}
+
+template<class VoidAllocatorOrContainer>
+struct GetSetContainer
+{
+   template<class ValueType>
+   struct apply
+   {
+      typedef flat_set < ValueType
+                       , std::less<ValueType>
+                       , typename boost::container::dtl::container_or_allocator_rebind<VoidAllocatorOrContainer, ValueType>::type
+                        > set_type;
+
+      typedef flat_multiset < ValueType
+                            , std::less<ValueType>
+                            , typename boost::container::dtl::container_or_allocator_rebind<VoidAllocatorOrContainer, ValueType>::type
+                            > multiset_type;
+   };
+};
+
+template<typename FlatSetType>
+bool test_support_for_initialization_list_for()
+{
+#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
+   const std::initializer_list<int> il
+      = {1, 2};
+
+   const FlatSetType expected(il.begin(), il.end());
+   {
+      const FlatSetType sil = il;
+      if (sil != expected)
+         return false;
+
+      const FlatSetType sil_ordered(ordered_unique_range, il);
+      if(sil_ordered != expected)
+         return false;
+
+      FlatSetType sil_assign = {99};
+      sil_assign = il;
+      if(sil_assign != expected)
+         return false;
+   }
+   {
+      FlatSetType sil;
+      sil.insert(il);
+      if(sil != expected)
+         return false;
+   }
+   return true;
+#endif
+   return true;
+}
+
+struct boost_container_flat_set;
+struct boost_container_flat_multiset;
+
+namespace boost {
+namespace container {
+namespace test {
+
+template<>
+struct alloc_propagate_base<boost_container_flat_set>
+{
+   template <class T, class Allocator>
+   struct apply
+   {
+      typedef boost::container::flat_set<T, std::less<T>, Allocator> type;
+   };
+};
+
+template<>
+struct alloc_propagate_base<boost_container_flat_multiset>
+{
+   template <class T, class Allocator>
+   struct apply
+   {
+      typedef boost::container::flat_multiset<T, std::less<T>, Allocator> type;
+   };
+};
+
+}}}   //boost::container::test
+
+int main()
+{
+   using namespace boost::container::test;
+
+   //Allocator argument container
+   {
+      flat_set<int> set_((flat_set<int>::allocator_type()));
+      flat_multiset<int> multiset_((flat_multiset<int>::allocator_type()));
+   }
+   //Now test move semantics
+   {
+      test_move<flat_set<recursive_flat_set> >();
+      test_move<flat_multiset<recursive_flat_multiset> >();
+   }
+   //Now test nth/index_of
+   {
+      flat_set<int> set;
+      flat_multiset<int> mset;
+
+      set.insert(0);
+      set.insert(1);
+      set.insert(2);
+      mset.insert(0);
+      mset.insert(1);
+      mset.insert(2);
+      if(!boost::container::test::test_nth_index_of(set))
+         return 1;
+      if(!boost::container::test::test_nth_index_of(mset))
+         return 1;
+   }
+
+   ////////////////////////////////////
+   //    Ordered insertion test
+   ////////////////////////////////////
+   if(!flat_tree_ordered_insertion_test()){
+      return 1;
+   }
+
+   ////////////////////////////////////
+   //    Constructor Template Auto Deduction test
+   ////////////////////////////////////
+   if (!constructor_template_auto_deduction_test()) {
+      return 1;
+   }
+
+   ////////////////////////////////////
+   //    Extract/Adopt test
+   ////////////////////////////////////
+   if(!flat_tree_extract_adopt_test()){
+      return 1;
+   }
+
+   if (!boost::container::test::instantiate_constructors<flat_set<int>, flat_multiset<int> >())
+      return 1;
+
+   if(!test_heterogeneous_lookups()){
+      return 1;
+   }
+
+   if(!test_heterogeneous_lookup_by_partial_key()){
+      return 1;
+   }
+
+   ////////////////////////////////////
+   //    Testing allocator implementations
+   ////////////////////////////////////
+   {
+      typedef std::set<int>                                          MyStdSet;
+      typedef std::multiset<int>                                     MyStdMultiSet;
+
+      if (0 != test::set_test
+         < GetSetContainer<std::allocator<void> >::apply<int>::set_type
+         , MyStdSet
+         , GetSetContainer<std::allocator<void> >::apply<int>::multiset_type
+         , MyStdMultiSet>()) {
+         std::cout << "Error in set_test<std::allocator<void> >" << std::endl;
+         return 1;
+      }
+
+      if (0 != test::set_test
+         < GetSetContainer<new_allocator<void> >::apply<int>::set_type
+         , MyStdSet
+         , GetSetContainer<new_allocator<void> >::apply<int>::multiset_type
+         , MyStdMultiSet>()) {
+         std::cout << "Error in set_test<new_allocator<void> >" << std::endl;
+         return 1;
+      }
+
+      if (0 != test::set_test
+         < GetSetContainer<new_allocator<void> >::apply<test::movable_int>::set_type
+         , MyStdSet
+         , GetSetContainer<new_allocator<void> >::apply<test::movable_int>::multiset_type
+         , MyStdMultiSet>()) {
+         std::cout << "Error in set_test<new_allocator<void> >" << std::endl;
+         return 1;
+      }
+
+      if (0 != test::set_test
+         < GetSetContainer<new_allocator<void> >::apply<test::copyable_int>::set_type
+         , MyStdSet
+         , GetSetContainer<new_allocator<void> >::apply<test::copyable_int>::multiset_type
+         , MyStdMultiSet>()) {
+         std::cout << "Error in set_test<new_allocator<void> >" << std::endl;
+         return 1;
+      }
+
+      if (0 != test::set_test
+         < GetSetContainer<new_allocator<void> >::apply<test::movable_and_copyable_int>::set_type
+         , MyStdSet
+         , GetSetContainer<new_allocator<void> >::apply<test::movable_and_copyable_int>::multiset_type
+         , MyStdMultiSet>()) {
+         std::cout << "Error in set_test<new_allocator<void> >" << std::endl;
+         return 1;
+      }
+   }
+
+   ////////////////////////////////////
+   //    Emplace testing
+   ////////////////////////////////////
+   const test::EmplaceOptions SetOptions = (test::EmplaceOptions)(test::EMPLACE_HINT | test::EMPLACE_ASSOC);
+
+   if(!boost::container::test::test_emplace<flat_set<test::EmplaceInt>, SetOptions>())
+      return 1;
+   if(!boost::container::test::test_emplace<flat_multiset<test::EmplaceInt>, SetOptions>())
+      return 1;
+
+   if (!boost::container::test::test_set_methods_with_initializer_list_as_argument_for<flat_set<int> >())
+      return 1;
+
+   if (!boost::container::test::test_set_methods_with_initializer_list_as_argument_for<flat_multiset<int> >())
+      return 1;
+
+   ////////////////////////////////////
+   //    Allocator propagation testing
+   ////////////////////////////////////
+   if(!boost::container::test::test_propagate_allocator<boost_container_flat_set>())
+      return 1;
+
+   if(!boost::container::test::test_propagate_allocator<boost_container_flat_multiset>())
+      return 1;
+
+   ////////////////////////////////////
+   //    Iterator testing
+   ////////////////////////////////////
+   {
+      typedef boost::container::flat_set<int> cont_int;
+      cont_int a; a.insert(0); a.insert(1); a.insert(2);
+      boost::intrusive::test::test_iterator_random< cont_int >(a);
+      if(boost::report_errors() != 0) {
+         return 1;
+      }
+   }
+   {
+      typedef boost::container::flat_multiset<int> cont_int;
+      cont_int a; a.insert(0); a.insert(1); a.insert(2);
+      boost::intrusive::test::test_iterator_random< cont_int >(a);
+      if(boost::report_errors() != 0) {
+         return 1;
+      }
+   }
+
+   ////////////////////////////////////
+   //    has_trivial_destructor_after_move testing
+   ////////////////////////////////////
+   {
+      typedef boost::container::dtl::identity<int> key_of_value_t;
+      // flat_set, default
+      {
+         typedef boost::container::flat_set<int> cont;
+         typedef boost::container::dtl::flat_tree<int, key_of_value_t, std::less<int>, void> tree;
+         if (boost::has_trivial_destructor_after_move<cont>::value !=
+             boost::has_trivial_destructor_after_move<tree>::value) {
+            std::cerr << "has_trivial_destructor_after_move(flat_set, default) test failed" << std::endl;
+            return 1;
+         }
+      }
+      // flat_set, vector
+      {
+         typedef boost::container::vector<int> alloc_or_cont_t;
+         typedef boost::container::flat_set<int, std::less<int>, alloc_or_cont_t> cont;
+         typedef boost::container::dtl::flat_tree<int, key_of_value_t, std::less<int>, alloc_or_cont_t> tree;
+         if (boost::has_trivial_destructor_after_move<cont>::value !=
+             boost::has_trivial_destructor_after_move<tree>::value) {
+            std::cerr << "has_trivial_destructor_after_move(flat_set, vector) test failed" << std::endl;
+            return 1;
+         }
+      }
+      // flat_set, std::vector
+      {
+         typedef std::vector<int> alloc_or_cont_t;
+         typedef boost::container::flat_set<int, std::less<int>, alloc_or_cont_t> cont;
+         typedef boost::container::dtl::flat_tree<int, key_of_value_t, std::less<int>, alloc_or_cont_t> tree;
+         if (boost::has_trivial_destructor_after_move<cont>::value !=
+             boost::has_trivial_destructor_after_move<tree>::value) {
+            std::cerr << "has_trivial_destructor_after_move(flat_set, std::vector) test failed" << std::endl;
+            return 1;
+         }
+      }
+      // flat_multiset, default
+      {
+         typedef boost::container::flat_multiset<int> cont;
+         typedef boost::container::dtl::flat_tree<int, key_of_value_t, std::less<int>, void> tree;
+         if (boost::has_trivial_destructor_after_move<cont>::value !=
+             boost::has_trivial_destructor_after_move<tree>::value) {
+            std::cerr << "has_trivial_destructor_after_move(flat_multiset, default) test failed" << std::endl;
+            return 1;
+         }
+      }
+      // flat_multiset, vector
+      {
+         typedef boost::container::vector<int> alloc_or_cont_t;
+         typedef boost::container::flat_multiset<int, std::less<int>, alloc_or_cont_t> cont;
+         typedef boost::container::dtl::flat_tree<int, key_of_value_t, std::less<int>, alloc_or_cont_t> tree;
+         if (boost::has_trivial_destructor_after_move<cont>::value !=
+             boost::has_trivial_destructor_after_move<tree>::value) {
+            std::cerr << "has_trivial_destructor_after_move(flat_multiset, vector) test failed" << std::endl;
+            return 1;
+         }
+      }
+      // flat_multiset, std::vector
+      {
+         typedef std::vector<int> alloc_or_cont_t;
+         typedef boost::container::flat_multiset<int, std::less<int>, alloc_or_cont_t> cont;
+         typedef boost::container::dtl::flat_tree<int, key_of_value_t, std::less<int>, alloc_or_cont_t> tree;
+         if (boost::has_trivial_destructor_after_move<cont>::value !=
+             boost::has_trivial_destructor_after_move<tree>::value) {
+            std::cerr << "has_trivial_destructor_after_move(flat_multiset, std::vector) test failed" << std::endl;
+            return 1;
+         }
+      }
+   }
+
+   return 0;
+}
+
+#include <boost/container/detail/config_end.hpp>
+
diff --git a/src/boost/libs/container/test/flat_tree_test.cpp b/src/boost/libs/container/test/flat_tree_test.cpp
new file mode 100644
index 000000000..e94c0892b
--- /dev/null
+++ b/src/boost/libs/container/test/flat_tree_test.cpp
@@ -0,0 +1,156 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2004-2013. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/container for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+#include <boost/container/detail/flat_tree.hpp>
+#include <boost/container/small_vector.hpp>
+#include <boost/container/stable_vector.hpp>
+#include <boost/container/static_vector.hpp>
+
+#include <iostream>
+
+#include "movable_int.hpp"
+#include "dummy_test_allocator.hpp"
+
+using namespace boost::container;
+
+typedef boost::container::dtl::pair<test::movable_and_copyable_int, test::movable_and_copyable_int> pair_t;
+
+namespace boost {
+namespace container {
+
+//Explicit instantiation to detect compilation errors
+
+namespace dtl {
+
+template class flat_tree
+   < pair_t
+   , select1st<test::movable_and_copyable_int>
+   , std::less<test::movable_and_copyable_int>
+   , test::simple_allocator<pair_t>
+   >;
+
+template class flat_tree
+   < pair_t
+   , select1st<test::movable_and_copyable_int>
+   , std::less<test::movable_and_copyable_int>
+   , std::allocator<pair_t>
+   >;
+
+template class flat_tree
+   < pair_t
+   , select1st<test::movable_and_copyable_int>
+   , std::less<test::movable_and_copyable_int>
+   , small_vector<pair_t, 10>
+   >;
+
+template class flat_tree
+   < pair_t
+   , select1st<test::movable_and_copyable_int>
+   , std::less<test::movable_and_copyable_int>
+   , stable_vector<pair_t>
+   >;
+
+template class flat_tree
+   < test::movable_and_copyable_int
+   , identity<test::movable_and_copyable_int>
+   , std::less<test::movable_and_copyable_int>
+   , test::simple_allocator<test::movable_and_copyable_int>
+   >;
+
+template class flat_tree
+   < 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
+   , identity<test::movable_and_copyable_int>
+   , std::less<test::movable_and_copyable_int>
+   , small_vector<test::movable_and_copyable_int, 10>
+   >;
+
+template class flat_tree
+   < test::movable_and_copyable_int
+   , identity<test::movable_and_copyable_int>
+   , std::less<test::movable_and_copyable_int>
+   , stable_vector<test::movable_and_copyable_int>
+   >;
+
+template class flat_tree
+< test::movable_and_copyable_int
+   , identity<test::movable_and_copyable_int>
+   , std::less<test::movable_and_copyable_int>
+   , static_vector<test::movable_and_copyable_int, 10>
+>;
+
+}  //dtl {
+}} //boost::container
+
+#if (__cplusplus > 201103L)
+#include <vector>
+
+namespace boost{
+namespace container{
+namespace dtl{
+
+template class flat_tree
+< test::movable_and_copyable_int
+   , identity<test::movable_and_copyable_int>
+   , std::less<test::movable_and_copyable_int>
+   , std::vector<test::movable_and_copyable_int>
+>;
+
+template class flat_tree
+< pair_t
+   , select1st<test::movable_and_copyable_int>
+   , std::less<test::movable_and_copyable_int>
+   , std::vector<pair_t>
+>;
+
+}  //dtl {
+}} //boost::container
+
+#endif
+
+int main ()
+{
+   ////////////////////////////////////
+   //    has_trivial_destructor_after_move testing
+   ////////////////////////////////////
+   // default
+   {
+      typedef boost::container::dtl::flat_tree<int, boost::container::dtl::identity<int>,
+              std::less<int>, void> tree;
+      typedef tree::container_type container_type;
+      typedef tree::key_compare key_compare;
+      if (boost::has_trivial_destructor_after_move<tree>::value !=
+          boost::has_trivial_destructor_after_move<container_type>::value &&
+          boost::has_trivial_destructor_after_move<key_compare>::value) {
+         std::cerr << "has_trivial_destructor_after_move(default allocator) test failed" << std::endl;
+         return 1;
+      }
+   }
+   // std::allocator
+   {
+      typedef boost::container::dtl::flat_tree<int, boost::container::dtl::identity<int>,
+              std::less<int>, std::allocator<int> > tree;
+      typedef tree::container_type container_type;
+      typedef tree::key_compare key_compare;
+      if (boost::has_trivial_destructor_after_move<tree>::value !=
+          boost::has_trivial_destructor_after_move<container_type>::value &&
+          boost::has_trivial_destructor_after_move<key_compare>::value) {
+         std::cerr << "has_trivial_destructor_after_move(std::allocator) test failed" << std::endl;
+         return 1;
+      }
+   }
+
+   return 0;
+}
diff --git a/src/boost/libs/container/test/global_resource_test.cpp b/src/boost/libs/container/test/global_resource_test.cpp
new file mode 100644
index 000000000..bb6e96837
--- /dev/null
+++ b/src/boost/libs/container/test/global_resource_test.cpp
@@ -0,0 +1,127 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2015-2015. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/container for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+#include <boost/container/pmr/global_resource.hpp>
+#include <boost/container/pmr/memory_resource.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <boost/core/no_exceptions_support.hpp>
+
+#include "derived_from_memory_resource.hpp"
+
+#include <cstdlib>
+#include <new>
+
+using namespace boost::container;
+using namespace boost::container::pmr;
+
+#ifdef BOOST_MSVC
+#pragma warning (push)
+#pragma warning (disable : 4290)
+#endif
+
+#if __cplusplus >= 201103L
+#define BOOST_CONTAINER_NEW_EXCEPTION_SPECIFIER
+#define BOOST_CONTAINER_DELETE_EXCEPTION_SPECIFIER noexcept
+#else
+#define BOOST_CONTAINER_NEW_EXCEPTION_SPECIFIER    throw(std::bad_alloc)
+#define BOOST_CONTAINER_DELETE_EXCEPTION_SPECIFIER throw()
+#endif
+
+#if defined(BOOST_GCC) && (BOOST_GCC >= 50000)
+#pragma GCC diagnostic ignored "-Wsized-deallocation"
+#endif
+
+//ASAN does not support operator new overloading
+#ifndef BOOST_CONTAINER_ASAN
+
+std::size_t allocation_count = 0;
+
+void* operator new[](std::size_t count) BOOST_CONTAINER_NEW_EXCEPTION_SPECIFIER
+{
+   ++allocation_count;
+   return std::malloc(count);
+}
+
+void operator delete[](void *p) BOOST_CONTAINER_DELETE_EXCEPTION_SPECIFIER
+{
+   --allocation_count;
+   return std::free(p);
+}
+
+#endif   //BOOST_CONTAINER_ASAN
+
+#ifdef BOOST_MSVC
+#pragma warning (pop)
+#endif
+
+#ifndef BOOST_CONTAINER_ASAN
+
+void test_new_delete_resource()
+{
+   //Make sure new_delete_resource calls new[]/delete[]
+   std::size_t memcount = allocation_count;
+   memory_resource *mr = new_delete_resource();
+   //each time should return the same pointer
+   BOOST_TEST(mr == new_delete_resource());
+   #if !defined(BOOST_CONTAINER_DYNAMIC_LINKING)  //No new delete replacement possible new_delete is a DLL
+   BOOST_TEST(memcount == allocation_count);
+   #endif
+   void *addr = mr->allocate(16, 1);
+   #if !defined(BOOST_CONTAINER_DYNAMIC_LINKING)  //No new delete replacement possible new_delete is a DLL
+   BOOST_TEST((allocation_count - memcount) == 1);
+   #endif
+   mr->deallocate(addr, 16, 1);
+   BOOST_TEST(memcount == allocation_count);
+}
+
+#endif   //BOOST_CONTAINER_ASAN
+
+void test_null_memory_resource()
+{
+   //Make sure it throw or returns null
+   memory_resource *mr = null_memory_resource();
+   #if !defined(BOOST_NO_EXCEPTIONS)
+   bool bad_allocexception_thrown = false;
+   try{
+      mr->allocate(1, 1);
+   }
+   catch(std::bad_alloc&) {
+      bad_allocexception_thrown = true;
+   }
+   catch(...) {
+   }
+   BOOST_TEST(bad_allocexception_thrown == true);
+   #else
+   BOOST_TEST(0 == mr->allocate(1, 1));
+   #endif
+}
+
+void test_default_resource()
+{
+   //Default resource must be new/delete before set_default_resource
+   BOOST_TEST(get_default_resource() == new_delete_resource());
+   //Set default resource and obtain previous
+   derived_from_memory_resource d;
+   memory_resource *prev_default = set_default_resource(&d);
+   BOOST_TEST(get_default_resource() == &d);
+   //Set default resource with null, which should be new/delete
+   prev_default = set_default_resource(0);
+   BOOST_TEST(prev_default == &d);
+   BOOST_TEST(get_default_resource() == new_delete_resource());
+}
+
+int main()
+{
+   #ifndef BOOST_CONTAINER_ASAN
+   test_new_delete_resource();
+   #endif
+   test_null_memory_resource();
+   test_default_resource();
+   return ::boost::report_errors();
+}
diff --git a/src/boost/libs/container/test/hash_table_test.cppx b/src/boost/libs/container/test/hash_table_test.cppx
new file mode 100644
index 000000000..e69de29bb
--- /dev/null
+++ b/src/boost/libs/container/test/hash_table_test.cppx
diff --git a/src/boost/libs/container/test/input_from_forward_iterator.hpp b/src/boost/libs/container/test/input_from_forward_iterator.hpp
new file mode 100644
index 000000000..9436ceffa
--- /dev/null
+++ b/src/boost/libs/container/test/input_from_forward_iterator.hpp
@@ -0,0 +1,80 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2012-2013. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/container for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#ifndef BOOST_CONTAINER_TEST_FORWARD_TO_INPUT_ITERATOR_HPP
+#define BOOST_CONTAINER_TEST_FORWARD_TO_INPUT_ITERATOR_HPP
+
+#include <boost/container/detail/iterator.hpp>
+
+namespace boost{
+namespace container {
+namespace test{
+
+template<class FwdIterator>
+class input_iterator_wrapper
+   : public boost::container::iterator< std::input_iterator_tag
+                         , typename boost::container::iterator_traits<FwdIterator>::value_type
+                         , typename boost::container::iterator_traits<FwdIterator>::difference_type
+                         , typename boost::container::iterator_traits<FwdIterator>::pointer
+                         , typename boost::container::iterator_traits<FwdIterator>::reference
+                         >
+{
+   FwdIterator m_it;
+
+   public:
+   input_iterator_wrapper()
+      : m_it(0)
+   {}
+
+   explicit input_iterator_wrapper(FwdIterator it)
+      : m_it(it)
+   {}
+
+   //Default copy constructor...
+   //input_iterator_wrapper(const input_iterator_wrapper&);
+
+   //Default assignment...
+   //input_iterator_wrapper &operator=(const input_iterator_wrapper&);
+
+   //Default destructor...
+   //~input_iterator_wrapper();
+
+   typename boost::container::iterator_traits<FwdIterator>::reference operator*() const
+   { return *m_it; }
+
+   typename boost::container::iterator_traits<FwdIterator>::pointer operator->() const
+   { return m_it.operator->(); }
+
+   input_iterator_wrapper& operator++()
+   {  ++m_it;  return *this;  }
+
+   input_iterator_wrapper operator++(int )
+   {
+      input_iterator_wrapper tmp(m_it);
+      ++m_it;
+      return tmp;
+   }
+
+   friend bool operator==(const input_iterator_wrapper &left, const input_iterator_wrapper &right)
+   {  return left.m_it == right.m_it;  }
+
+   friend bool operator!=(const input_iterator_wrapper &left, const input_iterator_wrapper &right)
+   {  return left.m_it != right.m_it;  }
+};
+
+template<class FwdIterator>
+input_iterator_wrapper<FwdIterator> make_input_from_forward_iterator(const FwdIterator &it)
+{  return input_iterator_wrapper<FwdIterator>(it); }
+
+}  //namespace test{
+}  //namespace container {
+}  //namespace boost{
+
+#endif //BOOST_CONTAINER_TEST_FORWARD_TO_INPUT_ITERATOR_HPP
diff --git a/src/boost/libs/container/test/insert_test.hpp b/src/boost/libs/container/test/insert_test.hpp
new file mode 100644
index 000000000..cb862f3c5
--- /dev/null
+++ b/src/boost/libs/container/test/insert_test.hpp
@@ -0,0 +1,75 @@
+#ifndef BOOST_CONTAINER_TEST_INSERT_TEST_HPP
+#define BOOST_CONTAINER_TEST_INSERT_TEST_HPP
+
+// Copyright (C) 2013 Cromwell D. Enage
+// 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 <deque>
+#include <boost/core/lightweight_test.hpp>
+#include "check_equal_containers.hpp"
+
+namespace boost {
+namespace container {
+namespace test {
+
+template<class SeqContainer>
+void
+    test_insert_range(
+        std::deque<int> &std_deque
+      , SeqContainer &seq_container
+      , std::deque<int> const& input_deque
+      , std::size_t index
+    )
+{
+    BOOST_TEST(CheckEqualContainers(std_deque, seq_container));
+
+    std_deque.insert(
+        std_deque.begin() + index
+      , input_deque.begin()
+      , input_deque.end()
+    );
+
+    seq_container.insert(
+        seq_container.begin() + index
+      , input_deque.begin()
+      , input_deque.end()
+    );
+    BOOST_TEST(CheckEqualContainers(std_deque, seq_container));
+}
+
+template<class SeqContainer>
+bool test_range_insertion()
+{
+   int err_count = boost::report_errors();
+   typedef typename SeqContainer::value_type value_type;
+   std::deque<int> input_deque;
+   for (int element = -10; element < 10; ++element)
+   {
+      input_deque.push_back(element + 20);
+   }
+
+   for (std::size_t i = 0; i <= input_deque.size(); ++i)
+   {
+      std::deque<int> std_deque;
+      ::boost::movelib::unique_ptr<SeqContainer> const pseqcontainer = ::boost::movelib::make_unique<SeqContainer>();
+      SeqContainer &seq_container = *pseqcontainer;
+
+      for (int element = -10; element < 10; ++element)
+      {
+         std_deque.push_back(element);
+         seq_container.push_back(value_type(element));
+      }
+      test_insert_range(std_deque, seq_container, input_deque, i);
+   }
+
+   return err_count == boost::report_errors();
+}
+
+
+}  //namespace test {
+}  //namespace container {
+}  //namespace boost {
+
+#endif   //#ifndef BOOST_CONTAINER_TEST_INSERT_TEST_HPP
diff --git a/src/boost/libs/container/test/insert_vs_emplace_test.cpp b/src/boost/libs/container/test/insert_vs_emplace_test.cpp
new file mode 100644
index 000000000..b91a693c5
--- /dev/null
+++ b/src/boost/libs/container/test/insert_vs_emplace_test.cpp
@@ -0,0 +1,498 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Howard Hinnant 2014.
+// (C) Copyright Ion Gaztanaga 2014-2014. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/container for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+//
+// This testcase is based on H. Hinnant's article "Insert vs. Emplace",
+// (http://github.com/HowardHinnant/papers/blob/master/insert_vs_emplace.html)
+//
+//////////////////////////////////////////////////////////////////////////////
+#include <iostream>
+#include <boost/move/utility_core.hpp>
+#include <boost/container/vector.hpp>
+#include <boost/core/lightweight_test.hpp>
+
+class X
+{
+   int i_;
+   int* p_;
+
+   BOOST_COPYABLE_AND_MOVABLE(X)
+
+public:
+   struct special
+   {
+      unsigned c;
+      unsigned dt;
+      unsigned cc;
+      unsigned ca;
+      unsigned mc;
+      unsigned ma;
+
+      friend bool operator==(const special &l, const special &r)
+      {  return l.c == r.c && l.dt == r.dt && l.cc == r.cc && l.ca == r.ca && l.mc == r.mc && l.ma == r.ma;  }
+   };
+   static special sp;
+
+   X(int i, int* p)
+      : i_(i)
+      , p_(p)
+   {
+//         std::cout << "X(int i, int* p)\n";
+      sp.c++;
+   }
+
+   ~X()
+   {
+//         std::cout << "~X()\n";
+      sp.dt++;
+   }
+
+   X(const X& x)
+      : i_(x.i_)
+      , p_(x.p_)
+   {
+//         std::cout << "X(const X& x)\n";
+      sp.cc++;
+   }
+
+   X& operator=(BOOST_COPY_ASSIGN_REF(X) x)
+   {
+
+      i_ = x.i_;
+      p_ = x.p_;
+//         std::cout << "X& operator=(const X& x)\n";
+      sp.ca++;
+      return *this;
+   }
+
+   X(BOOST_RV_REF(X) x) BOOST_NOEXCEPT_OR_NOTHROW
+      : i_(x.i_)
+      , p_(x.p_)
+   {
+//         std::cout << "X(X&& x)\n";
+      sp.mc++;
+   }
+
+   X& operator=(BOOST_RV_REF(X) x) BOOST_NOEXCEPT_OR_NOTHROW
+   {
+
+      i_ = x.i_;
+      p_ = x.p_;
+//         std::cout << "X& operator=(X&& x)\n";
+      sp.ma++;
+      return *this;
+   }
+
+};
+
+std::ostream&
+operator<<(std::ostream& os, X::special const& sp)
+{
+   os << "Const: " << sp.c << '\n';
+   os << "Destr: " << sp.dt << '\n';
+   os << "CopyC: " << sp.cc << '\n';
+   os << "CopyA: " << sp.ca << '\n';
+   os << "MoveC: " << sp.mc << '\n';
+   os << "MoveA: " << sp.ma << '\n';
+   os << "Total: " << (sp.c + sp.dt + sp.cc + sp.ca + sp.mc + sp.ma) << '\n';
+   return os;
+}
+
+X::special X::sp = X::special();
+
+const X produce_const_prvalue()
+{   return X(0, 0);   }
+
+int main()
+{
+   X::special insert_results;
+   X::special emplace_results;
+   {
+      boost::container::vector<X> v;
+      v.reserve(4);
+      v.push_back(X(0,0));
+      v.push_back(X(0,0));
+      v.push_back(X(0,0));
+      X x(0,0);
+      std::cout << "--insert lvalue no reallocation--\n";
+      X::sp = X::special();
+      v.insert(v.begin(), x);
+      std::cout << X::sp;
+      std::cout << "----\n";
+      insert_results = X::sp;
+   }
+   {
+      boost::container::vector<X> v;
+      v.reserve(4);
+      v.push_back(X(0,0));
+      v.push_back(X(0,0));
+      v.push_back(X(0,0));
+      X x(0,0);
+      std::cout << "--emplace lvalue no reallocation--\n";
+      X::sp = X::special();
+      v.emplace(v.begin(), x);
+      std::cout << X::sp;
+      std::cout << "----\n";
+      emplace_results = X::sp;
+   }
+   {
+      boost::container::vector<X> v;
+      v.reserve(4);
+      v.push_back(X(0,0));
+      v.push_back(X(0,0));
+      v.push_back(X(0,0));
+      X x(0,0);
+      std::cout << "--insert xvalue no reallocation--\n";
+      X::sp = X::special();
+      v.insert(v.begin(), boost::move(x));
+      std::cout << X::sp;
+      std::cout << "----\n";
+      insert_results = X::sp;
+   }
+   {
+      boost::container::vector<X> v;
+      v.reserve(4);
+      v.push_back(X(0,0));
+      v.push_back(X(0,0));
+      v.push_back(X(0,0));
+      X x(0,0);
+      std::cout << "--emplace xvalue no reallocation--\n";
+      X::sp = X::special();
+      v.emplace(v.begin(), boost::move(x));
+      std::cout << X::sp;
+      std::cout << "----\n";
+      emplace_results = X::sp;
+   }
+   BOOST_TEST_EQ(insert_results == emplace_results, true);
+   {
+      boost::container::vector<X> v;
+      v.reserve(4);
+      v.push_back(X(0,0));
+      v.push_back(X(0,0));
+      v.push_back(X(0,0));
+      X x(0,0);
+      std::cout << "--emplace const prvalue no reallocation--\n";
+      X::sp = X::special();
+      v.emplace(v.begin(), produce_const_prvalue());
+      std::cout << X::sp;
+      std::cout << "----\n";
+      emplace_results = X::sp;
+   }
+   {
+      boost::container::vector<X> v;
+      v.reserve(4);
+      v.push_back(X(0,0));
+      v.push_back(X(0,0));
+      v.push_back(X(0,0));
+      X x(0,0);
+      std::cout << "--emplace const prvalue no reallocation--\n";
+      X::sp = X::special();
+      v.insert(v.begin(), produce_const_prvalue());
+      std::cout << X::sp;
+      std::cout << "----\n";
+      insert_results = X::sp;
+   }
+   BOOST_TEST_EQ(insert_results == emplace_results, true);
+   {
+      boost::container::vector<X> v;
+      v.reserve(4);
+      v.push_back(X(0,0));
+      v.push_back(X(0,0));
+      v.push_back(X(0,0));
+      std::cout << "--insert rvalue no reallocation--\n";
+      X::sp = X::special();
+      v.insert(v.begin(), X(0,0));
+      std::cout << X::sp;
+      std::cout << "----\n";
+      insert_results = X::sp;
+   }
+   {
+      boost::container::vector<X> v;
+      v.reserve(4);
+      v.push_back(X(0,0));
+      v.push_back(X(0,0));
+      v.push_back(X(0,0));
+      std::cout << "--emplace rvalue no reallocation--\n";
+      X::sp = X::special();
+      v.emplace(v.begin(), X(0,0));
+      std::cout << X::sp;
+      std::cout << "----\n";
+      emplace_results = X::sp;
+   }
+   //With emulated move semantics an extra copy is unavoidable
+   #if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+   BOOST_TEST_EQ(insert_results == emplace_results, true);
+   #endif
+   {
+      boost::container::vector<X> v;
+      v.reserve(3);
+      v.push_back(X(0,0));
+      v.push_back(X(0,0));
+      v.push_back(X(0,0));
+      X x(0,0);
+      std::cout << "--insert lvalue reallocation--\n";
+      X::sp = X::special();
+      v.insert(v.begin(), x);
+      std::cout << X::sp;
+      std::cout << "----\n";
+      insert_results = X::sp;
+   }
+   {
+      boost::container::vector<X> v;
+      v.reserve(3);
+      v.push_back(X(0,0));
+      v.push_back(X(0,0));
+      v.push_back(X(0,0));
+      X x(0,0);
+      std::cout << "--emplace lvalue reallocation--\n";
+      X::sp = X::special();
+      v.emplace(v.begin(), x);
+      std::cout << X::sp;
+      std::cout << "----\n";
+      emplace_results = X::sp;
+   }
+   BOOST_TEST_EQ(insert_results == emplace_results, true);
+   {
+      boost::container::vector<X> v;
+      v.reserve(3);
+      v.push_back(X(0,0));
+      v.push_back(X(0,0));
+      v.push_back(X(0,0));
+      X x(0,0);
+      std::cout << "--insert xvalue reallocation--\n";
+      X::sp = X::special();
+      v.insert(v.begin(), boost::move(x));
+      std::cout << X::sp;
+      std::cout << "----\n";
+      insert_results = X::sp;
+   }
+   {
+      boost::container::vector<X> v;
+      v.reserve(3);
+      v.push_back(X(0,0));
+      v.push_back(X(0,0));
+      v.push_back(X(0,0));
+      X x(0,0);
+      std::cout << "--emplace xvalue reallocation--\n";
+      X::sp = X::special();
+      v.emplace(v.begin(), boost::move(x));
+      std::cout << X::sp;
+      std::cout << "----\n";
+      emplace_results = X::sp;
+   }
+   BOOST_TEST_EQ(insert_results == emplace_results, true);
+   {
+      boost::container::vector<X> v;
+      v.reserve(3);
+      v.push_back(X(0,0));
+      v.push_back(X(0,0));
+      v.push_back(X(0,0));
+      std::cout << "--insert rvalue reallocation--\n";
+      X::sp = X::special();
+      v.insert(v.begin(), X(0,0));
+      std::cout << X::sp;
+      std::cout << "----\n";
+      insert_results = X::sp;
+   }
+   {
+      boost::container::vector<X> v;
+      v.reserve(3);
+      v.push_back(X(0,0));
+      v.push_back(X(0,0));
+      v.push_back(X(0,0));
+      std::cout << "--emplace rvalue reallocation--\n";
+      X::sp = X::special();
+      v.emplace(v.begin(), X(0,0));
+      std::cout << X::sp;
+      std::cout << "----\n";
+      emplace_results = X::sp;
+   }
+   //With emulated move semantics an extra copy is unavoidable
+   #if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+   BOOST_TEST_EQ(insert_results == emplace_results, true);
+   #endif
+   {
+      boost::container::vector<X> v;
+      v.reserve(4);
+      v.push_back(X(0,0));
+      v.push_back(X(0,0));
+      v.push_back(X(0,0));
+      X x(0,0);
+      std::cout << "--push_back lvalue no reallocation--\n";
+      X::sp = X::special();
+      v.push_back(x);
+      std::cout << X::sp;
+      std::cout << "----\n";
+      insert_results = X::sp;
+   }
+   {
+      boost::container::vector<X> v;
+      v.reserve(4);
+      v.push_back(X(0,0));
+      v.push_back(X(0,0));
+      v.push_back(X(0,0));
+      X x(0,0);
+      std::cout << "--emplace_back lvalue no reallocation--\n";
+      X::sp = X::special();
+      v.emplace_back(x);
+      std::cout << X::sp;
+      std::cout << "----\n";
+      emplace_results = X::sp;
+   }
+   BOOST_TEST_EQ(insert_results == emplace_results, true);
+   {
+      boost::container::vector<X> v;
+      v.reserve(4);
+      v.push_back(X(0,0));
+      v.push_back(X(0,0));
+      v.push_back(X(0,0));
+      X x(0,0);
+      std::cout << "--push_back xvalue no reallocation--\n";
+      X::sp = X::special();
+      v.push_back(boost::move(x));
+      std::cout << X::sp;
+      std::cout << "----\n";
+      insert_results = X::sp;
+   }
+   {
+      boost::container::vector<X> v;
+      v.reserve(4);
+      v.push_back(X(0,0));
+      v.push_back(X(0,0));
+      v.push_back(X(0,0));
+      X x(0,0);
+      std::cout << "--emplace_back xvalue no reallocation--\n";
+      X::sp = X::special();
+      v.emplace_back(boost::move(x));
+      std::cout << X::sp;
+      std::cout << "----\n";
+      emplace_results = X::sp;
+   }
+   BOOST_TEST_EQ(insert_results == emplace_results, true);
+   {
+      boost::container::vector<X> v;
+      v.reserve(4);
+      v.push_back(X(0,0));
+      v.push_back(X(0,0));
+      v.push_back(X(0,0));
+      std::cout << "--push_back rvalue no reallocation--\n";
+      X::sp = X::special();
+      v.push_back(X(0,0));
+      std::cout << X::sp;
+      std::cout << "----\n";
+      insert_results = X::sp;
+   }
+   {
+      boost::container::vector<X> v;
+      v.reserve(4);
+      v.push_back(X(0,0));
+      v.push_back(X(0,0));
+      v.push_back(X(0,0));
+      std::cout << "--emplace_back rvalue no reallocation--\n";
+      X::sp = X::special();
+      v.emplace_back(X(0,0));
+      std::cout << X::sp;
+      std::cout << "----\n";
+      emplace_results = X::sp;
+   }
+   //With emulated move semantics an extra copy is unavoidable
+   #if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+   BOOST_TEST_EQ(insert_results == emplace_results, true);
+   #endif
+   {
+      boost::container::vector<X> v;
+      v.reserve(3);
+      v.push_back(X(0,0));
+      v.push_back(X(0,0));
+      v.push_back(X(0,0));
+      X x(0,0);
+      std::cout << "--push_back lvalue reallocation--\n";
+      X::sp = X::special();
+      v.push_back(x);
+      std::cout << X::sp;
+      std::cout << "----\n";
+      insert_results = X::sp;
+   }
+   {
+      boost::container::vector<X> v;
+      v.reserve(3);
+      v.push_back(X(0,0));
+      v.push_back(X(0,0));
+      v.push_back(X(0,0));
+      X x(0,0);
+      std::cout << "--emplace_back lvalue reallocation--\n";
+      X::sp = X::special();
+      v.emplace_back(x);
+      std::cout << X::sp;
+      std::cout << "----\n";
+      emplace_results = X::sp;
+   }
+   BOOST_TEST_EQ(insert_results == emplace_results, true);
+   {
+      boost::container::vector<X> v;
+      v.reserve(3);
+      v.push_back(X(0,0));
+      v.push_back(X(0,0));
+      v.push_back(X(0,0));
+      X x(0,0);
+      std::cout << "--push_back xvalue reallocation--\n";
+      X::sp = X::special();
+      v.push_back(boost::move(x));
+      std::cout << X::sp;
+      std::cout << "----\n";
+      insert_results = X::sp;
+   }
+   {
+      boost::container::vector<X> v;
+      v.reserve(3);
+      v.push_back(X(0,0));
+      v.push_back(X(0,0));
+      v.push_back(X(0,0));
+      X x(0,0);
+      std::cout << "--emplace_back xvalue reallocation--\n";
+      X::sp = X::special();
+      v.emplace_back(boost::move(x));
+      std::cout << X::sp;
+      std::cout << "----\n";
+      emplace_results = X::sp;
+   }
+   BOOST_TEST_EQ(insert_results == emplace_results, true);
+   {
+      boost::container::vector<X> v;
+      v.reserve(3);
+      v.push_back(X(0,0));
+      v.push_back(X(0,0));
+      v.push_back(X(0,0));
+      std::cout << "--push_back rvalue reallocation--\n";
+      X::sp = X::special();
+      v.push_back(X(0,0));
+      std::cout << X::sp;
+      std::cout << "----\n";
+      insert_results = X::sp;
+   }
+   {
+      boost::container::vector<X> v;
+      v.reserve(3);
+      v.push_back(X(0,0));
+      v.push_back(X(0,0));
+      v.push_back(X(0,0));
+      std::cout << "--emplace_back rvalue reallocation--\n";
+      X::sp = X::special();
+      v.emplace_back(X(0,0));
+      std::cout << X::sp;
+      std::cout << "----\n";
+      emplace_results = X::sp;
+   }
+   //With emulated move semantics an extra copy is unavoidable
+   #if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+   BOOST_TEST_EQ(insert_results == emplace_results, true);
+   #endif
+   return boost::report_errors();
+}
diff --git a/src/boost/libs/container/test/list_test.cpp b/src/boost/libs/container/test/list_test.cpp
new file mode 100644
index 000000000..c4f9f41d4
--- /dev/null
+++ b/src/boost/libs/container/test/list_test.cpp
@@ -0,0 +1,286 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2004-2013. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/container for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#include <boost/container/detail/config_begin.hpp>
+#include <boost/container/list.hpp>
+#include <boost/container/adaptive_pool.hpp>
+
+#include "dummy_test_allocator.hpp"
+#include <memory>
+#include "movable_int.hpp"
+#include "list_test.hpp"
+#include "propagate_allocator_test.hpp"
+#include "emplace_test.hpp"
+#include "../../intrusive/test/iterator_test.hpp"
+
+using namespace boost::container;
+
+namespace boost {
+namespace container {
+
+//Explicit instantiation to detect compilation errors
+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
+   , adaptive_pool<test::movable_and_copyable_int> >;
+
+namespace dtl {
+
+template class iterator_from_iiterator
+   <intrusive_list_type< std::allocator<int> >::container_type::iterator, true >;
+template class iterator_from_iiterator
+   <intrusive_list_type< std::allocator<int> >::container_type::iterator, false>;
+
+}
+
+}}
+
+class recursive_list
+{
+public:
+   int id_;
+   list<recursive_list> list_;
+   list<recursive_list>::iterator it_;
+   list<recursive_list>::const_iterator cit_;
+   list<recursive_list>::reverse_iterator rit_;
+   list<recursive_list>::const_reverse_iterator crit_;
+
+   recursive_list &operator=(const recursive_list &o)
+   { list_ = o.list_;  return *this; }
+};
+
+void recursive_list_test()//Test for recursive types
+{
+   list<recursive_list> recursive, copy;
+   //Test to test both move emulations
+   if(!copy.size()){
+      copy = recursive;
+   }
+}
+
+template<class VoidAllocator>
+struct GetAllocatorCont
+{
+   template<class ValueType>
+   struct apply
+   {
+      typedef list< ValueType
+                  , typename allocator_traits<VoidAllocator>
+                        ::template portable_rebind_alloc<ValueType>::type
+                  > type;
+   };
+};
+
+template<class VoidAllocator>
+int test_cont_variants()
+{
+   typedef typename GetAllocatorCont<VoidAllocator>::template apply<int>::type MyCont;
+   typedef typename GetAllocatorCont<VoidAllocator>::template apply<test::movable_int>::type MyMoveCont;
+   typedef typename GetAllocatorCont<VoidAllocator>::template apply<test::movable_and_copyable_int>::type MyCopyMoveCont;
+   typedef typename GetAllocatorCont<VoidAllocator>::template apply<test::copyable_int>::type MyCopyCont;
+
+   if(test::list_test<MyCont, true>())
+      return 1;
+   if(test::list_test<MyMoveCont, true>())
+      return 1;
+   if(test::list_test<MyCopyMoveCont, true>())
+      return 1;
+   if(test::list_test<MyCopyMoveCont, true>())
+      return 1;
+   if(test::list_test<MyCopyCont, true>())
+      return 1;
+
+   return 0;
+}
+
+bool test_support_for_initializer_list()
+{
+#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
+   const std::initializer_list<int> il = {1, 10};
+   const list<int> expectedList(il.begin(), il.end());
+
+   const list<int> testConstructor((il));
+   if(testConstructor != expectedList)
+      return false;
+
+   const list<int> testConstructorAllocator(il, list<int>::allocator_type());
+   if (testConstructorAllocator != expectedList)
+      return false;
+
+   list<int> testAssignOperator = {10, 11};
+   testAssignOperator = il;
+   if(testAssignOperator != expectedList)
+      return false;
+
+   list<int> testAssignMethod = {99};
+   testAssignMethod = il;
+   if(testAssignMethod != expectedList)
+      return false;
+
+   list<int> testInsertMethod;
+   testInsertMethod.insert(testInsertMethod.cbegin(), il);
+   if(testInsertMethod != testInsertMethod)
+      return false;
+
+   return true;
+#endif
+   return true;
+}
+
+struct boost_container_list;
+
+namespace boost { namespace container {   namespace test {
+
+template<>
+struct alloc_propagate_base<boost_container_list>
+{
+   template <class T, class Allocator>
+   struct apply
+   {
+      typedef boost::container::list<T, Allocator> type;
+   };
+};
+
+}}}   //namespace boost::container::test
+
+int main ()
+{
+   recursive_list_test();
+   {
+      //Now test move semantics
+      list<recursive_list> original;
+      list<recursive_list> move_ctor(boost::move(original));
+      list<recursive_list> move_assign;
+      move_assign = boost::move(move_ctor);
+      move_assign.swap(original);
+   }
+
+   ////////////////////////////////////
+   //    Testing allocator implementations
+   ////////////////////////////////////
+   //       int variants
+   if (test::list_test<list<int, std::allocator<int> >, true>())
+      return 1;
+   if (test::list_test<list<int>, true>())
+      return 1;
+   if (test::list_test<list<int, adaptive_pool<int> >, true>())
+      return 1;
+   if (test::list_test<list<test::movable_int>, true>())
+      return 1;
+   if (test::list_test<list<test::movable_and_copyable_int>, true>())
+      return 1;
+   if (test::list_test<list<test::copyable_int>, true>())
+      return 1;
+
+   ////////////////////////////////////
+   //    Emplace testing
+   ////////////////////////////////////
+   const test::EmplaceOptions Options = (test::EmplaceOptions)(test::EMPLACE_BACK | test::EMPLACE_FRONT | test::EMPLACE_BEFORE);
+
+   if(!boost::container::test::test_emplace<list<test::EmplaceInt>, Options>())
+      return 1;
+
+   ////////////////////////////////////
+   //    Allocator propagation testing
+   ////////////////////////////////////
+   if(!boost::container::test::test_propagate_allocator<boost_container_list>())
+      return 1;
+
+   ////////////////////////////////////
+   //    Initializer lists
+   ////////////////////////////////////
+   if(!test_support_for_initializer_list())
+      return 1;
+
+   ////////////////////////////////////
+   //    Iterator testing
+   ////////////////////////////////////
+   {
+      typedef boost::container::list<int> cont_int;
+      cont_int a; a.push_back(0); a.push_back(1); a.push_back(2);
+      boost::intrusive::test::test_iterator_bidirectional< cont_int >(a);
+      if(boost::report_errors() != 0) {
+         return 1;
+      }
+   }
+
+#ifndef BOOST_CONTAINER_NO_CXX17_CTAD
+   ////////////////////////////////////
+   //    Constructor Template Auto Deduction Tests
+   ////////////////////////////////////
+   {
+      auto gold = std::list{ 1, 2, 3 };
+      auto test = boost::container::list(gold.begin(), gold.end());
+      if (test.size() != 3) {
+         return 1;
+      }
+      if (test.front() != 1)
+         return 1;
+      test.pop_front();
+      if (test.front() != 2)
+         return 1;
+      test.pop_front();
+      if (test.front() != 3)
+         return 1;
+      test.pop_front();
+   }
+   {
+      auto gold = std::list{ 1, 2, 3 };
+      auto test = boost::container::list(gold.begin(), gold.end(), new_allocator<int>());
+      if (test.size() != 3) {
+         return 1;
+      }
+      if (test.front() != 1)
+         return 1;
+      test.pop_front();
+      if (test.front() != 2)
+         return 1;
+      test.pop_front();
+      if (test.front() != 3)
+         return 1;
+      test.pop_front();
+   }
+#endif
+
+   ////////////////////////////////////
+   //    has_trivial_destructor_after_move testing
+   ////////////////////////////////////
+   // default allocator
+   {
+      typedef boost::container::list<int> cont;
+      typedef cont::allocator_type allocator_type;
+      typedef boost::container::allocator_traits<allocator_type>::pointer pointer;
+      if (boost::has_trivial_destructor_after_move<cont>::value !=
+          boost::has_trivial_destructor_after_move<allocator_type>::value &&
+          boost::has_trivial_destructor_after_move<pointer>::value) {
+         std::cerr << "has_trivial_destructor_after_move(default allocator) test failed" << std::endl;
+         return 1;
+      }
+   }
+   // std::allocator
+   {
+      typedef boost::container::list<int, std::allocator<int> > cont;
+      typedef cont::allocator_type allocator_type;
+      typedef boost::container::allocator_traits<allocator_type>::pointer pointer;
+      if (boost::has_trivial_destructor_after_move<cont>::value !=
+          boost::has_trivial_destructor_after_move<allocator_type>::value &&
+          boost::has_trivial_destructor_after_move<pointer>::value) {
+         std::cerr << "has_trivial_destructor_after_move(std::allocator) test failed" << std::endl;
+         return 1;
+      }
+   }
+
+   return 0;
+}
+
+#include <boost/container/detail/config_end.hpp>
diff --git a/src/boost/libs/container/test/list_test.hpp b/src/boost/libs/container/test/list_test.hpp
new file mode 100644
index 000000000..9640ec099
--- /dev/null
+++ b/src/boost/libs/container/test/list_test.hpp
@@ -0,0 +1,469 @@
+////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2006. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/container for documentation.
+//
+////////////////////////////////////////
+
+#ifndef BOOST_CONTAINER_TEST_LIST_TEST_HEADER
+#define BOOST_CONTAINER_TEST_LIST_TEST_HEADER
+
+#include <boost/container/detail/config_begin.hpp>
+#include <boost/container/detail/iterator.hpp>
+#include "check_equal_containers.hpp"
+#include "print_container.hpp"
+#include "input_from_forward_iterator.hpp"
+#include <boost/move/utility_core.hpp>
+#include <boost/move/iterator.hpp>
+#include <boost/move/make_unique.hpp>
+
+#include <list>
+#include <functional>   //std::greater
+
+namespace boost{
+namespace container {
+namespace test{
+
+template<class V1, class V2>
+bool list_copyable_only(V1 &, V2 &, boost::container::dtl::false_type)
+{
+   return true;
+}
+
+//Function to check if both sets are equal
+template<class V1, class V2>
+bool list_copyable_only(V1 &boostlist, V2 &stdlist, boost::container::dtl::true_type)
+{
+   typedef typename V1::value_type IntType;
+   boostlist.insert(boostlist.end(), 50, IntType(1));
+   stdlist.insert(stdlist.end(), 50, 1);
+   if(!test::CheckEqualContainers(boostlist, stdlist)) return false;
+
+   {
+      IntType move_me(1);
+      boostlist.insert(boostlist.begin(), 50, boost::move(move_me));
+      stdlist.insert(stdlist.begin(), 50, 1);
+      if(!test::CheckEqualContainers(boostlist, stdlist)) return false;
+   }
+   {
+      IntType move_me(2);
+      boostlist.assign(boostlist.size()/2, boost::move(move_me));
+      stdlist.assign(stdlist.size()/2, 2);
+      if(!test::CheckEqualContainers(boostlist, stdlist)) return false;
+   }
+   {
+      IntType move_me(3);
+      boostlist.assign(boostlist.size()*3-1, boost::move(move_me));
+      stdlist.assign(stdlist.size()*3-1, 3);
+      if(!test::CheckEqualContainers(boostlist, stdlist)) return false;
+   }
+
+   {
+      IntType copy_me(3);
+      const IntType ccopy_me(3);
+      boostlist.push_front(copy_me);
+      stdlist.push_front(int(3));
+      boostlist.push_front(ccopy_me);
+      stdlist.push_front(int(3));
+      if(!test::CheckEqualContainers(boostlist, stdlist)) return false;
+   }
+   {  //List(const List &)
+      ::boost::movelib::unique_ptr<V1> const pv1 = ::boost::movelib::make_unique<V1>(boostlist);
+      ::boost::movelib::unique_ptr<V2> const pv2 = ::boost::movelib::make_unique<V2>(stdlist);
+
+      V1 &v1 = *pv1;
+      V2 &v2 = *pv2;
+
+      boostlist.clear();
+      stdlist.clear();
+      boostlist.assign(v1.begin(), v1.end());
+      stdlist.assign(v2.begin(), v2.end());
+      if(!test::CheckEqualContainers(boostlist, stdlist)) return 1;
+   }
+   {  //List(const List &, alloc)
+      ::boost::movelib::unique_ptr<V1> const pv1 = ::boost::movelib::make_unique<V1>(boostlist, typename V1::allocator_type());
+      ::boost::movelib::unique_ptr<V2> const pv2 = ::boost::movelib::make_unique<V2>(stdlist);
+
+      V1 &v1 = *pv1;
+      V2 &v2 = *pv2;
+
+      boostlist.clear();
+      stdlist.clear();
+      boostlist.assign(v1.begin(), v1.end());
+      stdlist.assign(v2.begin(), v2.end());
+      if(!test::CheckEqualContainers(boostlist, stdlist)) return 1;
+   }
+
+   return true;
+}
+
+template<bool DoublyLinked>
+struct list_push_data_function
+{
+   template<class MyBoostList, class MyStdList>
+   static int execute(int max, MyBoostList &boostlist, MyStdList &stdlist)
+   {
+      typedef typename MyBoostList::value_type IntType;
+      for(int i = 0; i < max; ++i){
+         IntType move_me(i);
+         boostlist.push_back(boost::move(move_me));
+         stdlist.push_back(i);
+         boostlist.push_front(IntType(i));
+         stdlist.push_front(int(i));
+      }
+      if(!CheckEqualContainers(boostlist, stdlist))
+         return 1;
+      return 0;
+   }
+};
+
+template<>
+struct list_push_data_function<false>
+{
+   template<class MyBoostList, class MyStdList>
+   static int execute(int max, MyBoostList &boostlist, MyStdList &stdlist)
+   {
+      typedef typename MyBoostList::value_type IntType;
+      for(int i = 0; i < max; ++i){
+         IntType move_me(i);
+         boostlist.push_front(boost::move(move_me));
+         stdlist.push_front(i);
+         boostlist.push_front(IntType(i));
+         stdlist.push_front(int(i));
+      }
+      if(!CheckEqualContainers(boostlist, stdlist))
+         return 1;
+      return 0;
+   }
+};
+
+template<bool DoublyLinked>
+struct list_pop_back_function
+{
+   template<class MyStdList, class MyBoostList>
+   static int execute(MyBoostList &boostlist, MyStdList &stdlist)
+   {
+      boostlist.pop_back();
+      stdlist.pop_back();
+      if(!CheckEqualContainers(boostlist, stdlist))
+         return 1;
+      return 0;
+   }
+};
+
+template<>
+struct list_pop_back_function<false>
+{
+   template<class MyStdList, class MyBoostList>
+   static int execute(MyBoostList &boostlist, MyStdList &stdlist)
+   {
+      (void)boostlist; (void)stdlist;
+      return 0;
+   }
+};
+
+template<class MyBoostList
+        ,bool  DoublyLinked>
+int list_test (bool copied_allocators_equal = true)
+{
+   typedef std::list<int> MyStdList;
+   typedef typename MyBoostList::value_type IntType;
+   const int max = 100;
+   typedef list_push_data_function<DoublyLinked> push_data_t;
+
+   {  //List(n)
+      ::boost::movelib::unique_ptr<MyBoostList> const pboostlist = ::boost::movelib::make_unique<MyBoostList>(100);
+      ::boost::movelib::unique_ptr<MyStdList> const pstdlist = ::boost::movelib::make_unique<MyStdList>(100);
+      if(!test::CheckEqualContainers(*pboostlist, *pstdlist)) return 1;
+   }
+   {  //List(n, alloc)
+      ::boost::movelib::unique_ptr<MyBoostList> const pboostlist = ::boost::movelib::make_unique<MyBoostList>(100, typename MyBoostList::allocator_type());
+      ::boost::movelib::unique_ptr<MyStdList> const pstdlist = ::boost::movelib::make_unique<MyStdList>(100);
+      if(!test::CheckEqualContainers(*pboostlist, *pstdlist)) return 1;
+   }
+   {  //List(List &&)
+      ::boost::movelib::unique_ptr<MyStdList> const stdlistp = ::boost::movelib::make_unique<MyStdList>(100);
+      ::boost::movelib::unique_ptr<MyBoostList> const boostlistp = ::boost::movelib::make_unique<MyBoostList>(100);
+      ::boost::movelib::unique_ptr<MyBoostList> const boostlistp2 = ::boost::movelib::make_unique<MyBoostList>(::boost::move(*boostlistp));
+      if(!test::CheckEqualContainers(*boostlistp2, *stdlistp)) return 1;
+   }
+   {  //List(List &&, alloc)
+      ::boost::movelib::unique_ptr<MyStdList> const stdlistp = ::boost::movelib::make_unique<MyStdList>(100);
+      ::boost::movelib::unique_ptr<MyBoostList> const boostlistp = ::boost::movelib::make_unique<MyBoostList>(100);
+      ::boost::movelib::unique_ptr<MyBoostList> const boostlistp2 = ::boost::movelib::make_unique<MyBoostList>
+         (::boost::move(*boostlistp), typename MyBoostList::allocator_type());
+      if(!test::CheckEqualContainers(*boostlistp2, *stdlistp)) return 1;
+   }
+   {  //List operator=(List &&)
+      ::boost::movelib::unique_ptr<MyStdList> const stdlistp = ::boost::movelib::make_unique<MyStdList>(100);
+      ::boost::movelib::unique_ptr<MyBoostList> const boostlistp = ::boost::movelib::make_unique<MyBoostList>(100);
+      ::boost::movelib::unique_ptr<MyBoostList> const boostlistp2 = ::boost::movelib::make_unique<MyBoostList>();
+      *boostlistp2 = ::boost::move(*boostlistp);
+      if(!test::CheckEqualContainers(*boostlistp2, *stdlistp)) return 1;
+   }
+
+   ::boost::movelib::unique_ptr<MyBoostList> const pboostlist = ::boost::movelib::make_unique<MyBoostList>();
+   ::boost::movelib::unique_ptr<MyStdList>   const pstdlist   = ::boost::movelib::make_unique<MyStdList>();
+
+   MyBoostList &boostlist = *pboostlist;
+   MyStdList  &stdlist    = *pstdlist;
+
+   if(push_data_t::execute(max, boostlist, stdlist)){
+      return 1;
+   }
+
+   boostlist.erase(boostlist.begin()++);
+   stdlist.erase(stdlist.begin()++);
+   if(!CheckEqualContainers(boostlist, stdlist)) return 1;
+
+   if(list_pop_back_function<DoublyLinked>::execute(boostlist, stdlist)){
+      return 1;
+   }
+
+   boostlist.pop_front();
+   stdlist.pop_front();
+   if(!CheckEqualContainers(boostlist, stdlist)) return 1;
+
+   {
+      IntType aux_vect[50];
+      for(int i = 0; i < 50; ++i){
+         IntType move_me(-1);
+         aux_vect[i] = boost::move(move_me);
+      }
+      int aux_vect2[50];
+      for(int i = 0; i < 50; ++i){
+         aux_vect2[i] = -1;
+      }
+      boostlist.assign(boost::make_move_iterator(&aux_vect[0])
+                        ,boost::make_move_iterator(&aux_vect[50]));
+      stdlist.assign(&aux_vect2[0], &aux_vect2[50]);
+      if(!CheckEqualContainers(boostlist, stdlist)) return 1;
+
+      for(int i = 0; i < 50; ++i){
+         IntType move_me(-1);
+         aux_vect[i] = boost::move(move_me);
+      }
+
+      for(int i = 0; i < 50; ++i){
+         aux_vect2[i] = -1;
+      }
+      boostlist.assign(boost::make_move_iterator(make_input_from_forward_iterator(&aux_vect[0]))
+                        ,boost::make_move_iterator(make_input_from_forward_iterator(&aux_vect[50])));
+      stdlist.assign(&aux_vect2[0], &aux_vect2[50]);
+      if(!CheckEqualContainers(boostlist, stdlist)) return 1;
+   }
+
+   if(copied_allocators_equal){
+      boostlist.sort();
+      stdlist.sort();
+      if(!CheckEqualContainers(boostlist, stdlist)) return 1;
+   }
+
+   boostlist.reverse();
+   stdlist.reverse();
+   if(!CheckEqualContainers(boostlist, stdlist)) return 1;
+
+   boostlist.reverse();
+   stdlist.reverse();
+   if(!CheckEqualContainers(boostlist, stdlist)) return 1;
+
+   {
+      IntType aux_vect[50];
+      for(int i = 0; i < 50; ++i){
+         IntType move_me(-1);
+         aux_vect[i] = boost::move(move_me);
+      }
+      int aux_vect2[50];
+      for(int i = 0; i < 50; ++i){
+         aux_vect2[i] = -1;
+      }
+      typename MyBoostList::iterator old_begin = boostlist.begin();
+      typename MyBoostList::iterator it_insert =
+         boostlist.insert(boostlist.begin()
+                     ,boost::make_move_iterator(&aux_vect[0])
+                     ,boost::make_move_iterator(&aux_vect[50]));
+      if(it_insert != boostlist.begin() || boost::container::iterator_distance(it_insert, old_begin) != 50)
+         return 1;
+
+      stdlist.insert(stdlist.begin(), &aux_vect2[0], &aux_vect2[50]);
+      if(!CheckEqualContainers(boostlist, stdlist))
+         return 1;
+
+      for(int i = 0; i < 50; ++i){
+         IntType move_me(-1);
+         aux_vect[i] = boost::move(move_me);
+      }
+
+      for(int i = 0; i < 50; ++i){
+         aux_vect2[i] = -1;
+      }
+
+      old_begin = boostlist.begin();
+      it_insert = boostlist.insert(boostlist.end()
+                     ,boost::make_move_iterator(make_input_from_forward_iterator(&aux_vect[0]))
+                     ,boost::make_move_iterator(make_input_from_forward_iterator(&aux_vect[50])));
+      if(boost::container::iterator_distance(it_insert, boostlist.end()) != 50)
+         return 1;
+      stdlist.insert(stdlist.end(), &aux_vect2[0], &aux_vect2[50]);
+      if(!CheckEqualContainers(boostlist, stdlist))
+         return 1;
+   }
+
+   boostlist.unique();
+   stdlist.unique();
+   if(!CheckEqualContainers(boostlist, stdlist))
+      return 1;
+
+   if(copied_allocators_equal){
+      boostlist.sort(std::greater<IntType>());
+      stdlist.sort(std::greater<int>());
+      if(!CheckEqualContainers(boostlist, stdlist))
+         return 1;
+   }
+
+   for(int i = 0; i < max; ++i){
+      IntType new_int(i);
+      boostlist.insert(boostlist.end(), boost::move(new_int));
+      stdlist.insert(stdlist.end(), i);
+      if(!test::CheckEqualContainers(boostlist, stdlist)) return 1;
+   }
+   if(!test::CheckEqualContainers(boostlist, stdlist)) return 1;
+
+   boostlist.resize(25);
+   stdlist.resize(25);
+   boostlist.resize(50);
+   stdlist.resize(50);
+   boostlist.resize(0);
+   stdlist.resize(0);
+   if(!CheckEqualContainers(boostlist, stdlist))
+      return 1;
+
+   //some comparison operators
+   if(!(boostlist == boostlist))
+      return 1;
+   if(boostlist != boostlist)
+      return 1;
+   if(boostlist < boostlist)
+      return 1;
+   if(boostlist > boostlist)
+      return 1;
+   if(!(boostlist <= boostlist))
+      return 1;
+   if(!(boostlist >= boostlist))
+      return 1;
+
+   if(push_data_t::execute(max, boostlist, stdlist)){
+      return 1;
+   }
+   {
+      MyBoostList otherboostlist(boostlist.get_allocator());
+      MyStdList otherstdlist;
+
+      int listsize = (int)boostlist.size();
+
+      if(push_data_t::execute(listsize, boostlist, stdlist)){
+         return 1;
+      }
+
+      if(copied_allocators_equal){
+         boostlist.splice(boostlist.begin(), otherboostlist);
+         stdlist.splice(stdlist.begin(), otherstdlist);
+         if(!CheckEqualContainers(boostlist, stdlist))
+            return 1;
+      }
+
+      listsize = (int)boostlist.size();
+
+      if(push_data_t::execute(listsize, boostlist, stdlist)){
+         return 1;
+      }
+
+      if(push_data_t::execute(listsize, otherboostlist, otherstdlist)){
+         return 1;
+      }
+
+      if(copied_allocators_equal){
+         boostlist.sort(std::greater<IntType>());
+         stdlist.sort(std::greater<int>());
+         if(!CheckEqualContainers(boostlist, stdlist))
+            return 1;
+
+         otherboostlist.sort(std::greater<IntType>());
+         otherstdlist.sort(std::greater<int>());
+         if(!CheckEqualContainers(otherboostlist, otherstdlist))
+            return 1;
+
+         boostlist.merge(otherboostlist, std::greater<IntType>());
+         stdlist.merge(otherstdlist, std::greater<int>());
+         if(!CheckEqualContainers(boostlist, stdlist))
+            return 1;
+      }
+
+      if(!list_copyable_only(boostlist, stdlist
+                     ,dtl::bool_<boost::container::test::is_copyable<IntType>::value>())){
+         return 1;
+      }
+   }
+   return 0;
+}
+
+template<class List>
+bool test_list_methods_with_initializer_list_as_argument_for()
+{
+#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
+   const std::initializer_list<int> il = {5, 10, 15};
+   const List expected_list(il.begin(), il.end());
+   {
+      List sl = il;
+      if(sl != expected_list)
+         return false;
+   }
+
+   {
+      List sl = {1, 2};
+      sl = il;
+      if(sl != expected_list)
+         return false;
+   }
+   {
+      List sl({ 1, 2 }, typename List::allocator_type());
+      sl = il;
+      if (sl != expected_list)
+         return false;
+   }
+   {
+      List sl = {4, 5};
+      sl.assign(il);
+      if(sl != expected_list)
+         return false;
+   }
+
+   {
+      List sl = {15};
+      sl.insert(sl.cbegin(), {5, 10});
+      if(sl != expected_list)
+         return false;
+   }
+
+   {
+       List sl = {5};
+       sl.insert_after(sl.cbegin(), {10, 15});
+       if(sl != expected_list)
+          return false;
+   }
+   return true;
+#endif
+   return true;
+}
+
+
+}  //namespace test{
+}  //namespace container {
+}  //namespace boost{
+
+#include <boost/container/detail/config_end.hpp>
+
+#endif
diff --git a/src/boost/libs/container/test/map_test.cpp b/src/boost/libs/container/test/map_test.cpp
new file mode 100644
index 000000000..74483037d
--- /dev/null
+++ b/src/boost/libs/container/test/map_test.cpp
@@ -0,0 +1,693 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2004-2013. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/container for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+#include <boost/container/detail/config_begin.hpp>
+#include <boost/container/map.hpp>
+#include <boost/container/adaptive_pool.hpp>
+
+#include <map>
+
+#include "print_container.hpp"
+#include "movable_int.hpp"
+#include "dummy_test_allocator.hpp"
+#include "map_test.hpp"
+#include "propagate_allocator_test.hpp"
+#include "emplace_test.hpp"
+#include "../../intrusive/test/iterator_test.hpp"
+
+using namespace boost::container;
+
+typedef std::pair<const test::movable_and_copyable_int, test::movable_and_copyable_int> pair_t;
+
+class recursive_map
+{
+   public:
+   recursive_map & operator=(const recursive_map &x)
+   {  id_ = x.id_;  map_ = x.map_; return *this;  }
+
+   int id_;
+   map<recursive_map, recursive_map> map_;
+   map<recursive_map, recursive_map>::iterator it_;
+   map<recursive_map, recursive_map>::const_iterator cit_;
+   map<recursive_map, recursive_map>::reverse_iterator rit_;
+   map<recursive_map, recursive_map>::const_reverse_iterator crit_;
+
+   friend bool operator< (const recursive_map &a, const recursive_map &b)
+   {  return a.id_ < b.id_;   }
+};
+
+class recursive_multimap
+{
+   public:
+   recursive_multimap & operator=(const recursive_multimap &x)
+   {  id_ = x.id_;  multimap_ = x.multimap_; return *this;  }
+
+   int id_;
+   multimap<recursive_multimap, recursive_multimap> multimap_;
+   multimap<recursive_multimap, recursive_multimap>::iterator it_;
+   multimap<recursive_multimap, recursive_multimap>::const_iterator cit_;
+   multimap<recursive_multimap, recursive_multimap>::reverse_iterator rit_;
+   multimap<recursive_multimap, recursive_multimap>::const_reverse_iterator crit_;
+
+   friend bool operator< (const recursive_multimap &a, const recursive_multimap &b)
+   {  return a.id_ < b.id_;   }
+};
+
+template<class C>
+void test_move()
+{
+   //Now test move semantics
+   C original;
+   original.emplace();
+   C move_ctor(boost::move(original));
+   C move_assign;
+   move_assign.emplace();
+   move_assign = boost::move(move_ctor);
+   move_assign.swap(original);
+}
+
+bool node_type_test()
+{
+   using namespace boost::container;
+   {
+      typedef map<test::movable_int, test::movable_int> map_type;
+      map_type src;
+      {
+         test::movable_int mv_1(1), mv_2(2), mv_3(3), mv_11(11), mv_12(12), mv_13(13);
+         src.try_emplace(boost::move(mv_1), boost::move(mv_11)); 
+         src.try_emplace(boost::move(mv_2), boost::move(mv_12)); 
+         src.try_emplace(boost::move(mv_3), boost::move(mv_13)); 
+      }
+      if(src.size() != 3)
+         return false;
+
+      map_type dst;
+      {
+         test::movable_int mv_3(3), mv_33(33);
+         dst.try_emplace(boost::move(mv_3), boost::move(mv_33)); 
+      }
+
+      if(dst.size() != 1)
+         return false;
+
+      const test::movable_int mv_1(1);
+      const test::movable_int mv_2(2);
+      const test::movable_int mv_3(3);
+      const test::movable_int mv_33(33);
+      const test::movable_int mv_13(13);
+      map_type::insert_return_type r;
+
+      r = dst.insert(src.extract(mv_33)); // Key version, try to insert empty node
+      if(! (r.position == dst.end() && r.inserted == false && r.node.empty()) )
+         return false;
+      r = dst.insert(src.extract(src.find(mv_1))); // Iterator version, successful
+      if(! (r.position == dst.find(mv_1) && r.inserted == true && r.node.empty()) )
+         return false;
+      r = dst.insert(dst.begin(), src.extract(mv_2)); // Key type version, successful
+      if(! (r.position == dst.find(mv_2) && r.inserted == true && r.node.empty()) )
+         return false;
+      r = dst.insert(src.extract(mv_3)); // Key type version, unsuccessful
+
+      if(!src.empty())
+         return false;
+      if(dst.size() != 3)
+         return false;
+      if(! (r.position == dst.find(mv_3) && r.inserted == false && r.node.key() == mv_3 && r.node.mapped() == mv_13) )
+         return false;
+   }
+
+   {
+      typedef multimap<test::movable_int, test::movable_int> multimap_type;
+      multimap_type src;
+      {
+         test::movable_int mv_1(1), mv_2(2), mv_3(3), mv_3bis(3), mv_11(11), mv_12(12), mv_13(13), mv_23(23);
+         src.emplace(boost::move(mv_1), boost::move(mv_11));
+         src.emplace(boost::move(mv_2), boost::move(mv_12));
+         src.emplace(boost::move(mv_3), boost::move(mv_13));
+         src.emplace_hint(src.begin(), boost::move(mv_3bis), boost::move(mv_23));
+      }
+      if(src.size() != 4)
+         return false;
+
+      multimap_type dst;
+      {
+         test::movable_int mv_3(3), mv_33(33);
+         dst.emplace(boost::move(mv_3), boost::move(mv_33)); 
+      }
+
+      if(dst.size() != 1)
+         return false;
+
+      const test::movable_int mv_1(1);
+      const test::movable_int mv_2(2);
+      const test::movable_int mv_3(3);
+      const test::movable_int mv_4(4);
+      const test::movable_int mv_33(33);
+      const test::movable_int mv_13(13);
+      const test::movable_int mv_23(23);
+      multimap_type::iterator r;
+
+      multimap_type::node_type nt(src.extract(mv_3));
+      r = dst.insert(dst.begin(), boost::move(nt));
+      if(! (r->first == mv_3 && r->second == mv_23 && dst.find(mv_3) == r && nt.empty()) )
+         return false;
+
+      nt = src.extract(src.find(mv_1));
+      r = dst.insert(boost::move(nt)); // Iterator version, successful
+      if(! (r->first == mv_1 && nt.empty()) )
+         return false;
+
+      nt = src.extract(mv_2);
+      r = dst.insert(boost::move(nt)); // Key type version, successful
+      if(! (r->first == mv_2 && nt.empty()) )
+         return false;
+
+      r = dst.insert(src.extract(mv_3)); // Key type version, successful
+      if(! (r->first == mv_3 && r->second == mv_13 && r == --multimap_type::iterator(dst.upper_bound(mv_3)) && nt.empty()) )
+         return false;
+
+      r = dst.insert(src.extract(mv_4)); // Key type version, unsuccessful
+      if(! (r == dst.end()) )
+         return false;
+
+      if(!src.empty())
+         return false;
+      if(dst.size() != 5)
+         return false;
+   }
+   return true;
+}
+
+template<class VoidAllocator, boost::container::tree_type_enum tree_type_value>
+struct GetAllocatorMap
+{
+   template<class ValueType>
+   struct apply
+   {
+      typedef map< ValueType
+                 , ValueType
+                 , std::less<ValueType>
+                 , typename allocator_traits<VoidAllocator>
+                    ::template portable_rebind_alloc< std::pair<const ValueType, ValueType> >::type
+                  , typename boost::container::tree_assoc_options
+                        < boost::container::tree_type<tree_type_value>
+                        >::type
+                 > map_type;
+
+      typedef multimap< ValueType
+                 , ValueType
+                 , std::less<ValueType>
+                 , typename allocator_traits<VoidAllocator>
+                    ::template portable_rebind_alloc< std::pair<const ValueType, ValueType> >::type
+                  , typename boost::container::tree_assoc_options
+                        < boost::container::tree_type<tree_type_value>
+                        >::type
+                 > multimap_type;
+   };
+};
+
+struct boost_container_map;
+struct boost_container_multimap;
+
+namespace boost { namespace container {   namespace test {
+
+template<>
+struct alloc_propagate_base<boost_container_map>
+{
+   template <class T, class Allocator>
+   struct apply
+   {
+      typedef typename boost::container::allocator_traits<Allocator>::
+         template portable_rebind_alloc<std::pair<const T, T> >::type TypeAllocator;
+      typedef boost::container::map<T, T, std::less<T>, TypeAllocator> type;
+   };
+};
+
+template<>
+struct alloc_propagate_base<boost_container_multimap>
+{
+   template <class T, class Allocator>
+   struct apply
+   {
+      typedef typename boost::container::allocator_traits<Allocator>::
+         template portable_rebind_alloc<std::pair<const T, T> >::type TypeAllocator;
+      typedef boost::container::multimap<T, T, std::less<T>, TypeAllocator> type;
+   };
+};
+
+void test_merge_from_different_comparison()
+{
+   map<int, int> map1;
+   map<int, int, std::greater<int> > map2;
+   map1.merge(map2);
+}
+
+bool test_heterogeneous_lookups()
+{
+   typedef map<int, char, less_transparent> map_t;
+   typedef multimap<int, char, less_transparent> mmap_t;
+   typedef map_t::value_type value_type;
+
+   map_t map1;
+   mmap_t mmap1;
+
+   const map_t &cmap1 = map1;
+   const mmap_t &cmmap1 = mmap1;
+
+   if(!map1.insert_or_assign(1, 'a').second)
+      return false;
+   if( map1.insert_or_assign(1, 'b').second)
+      return false;
+   if(!map1.insert_or_assign(2, 'c').second)
+      return false;
+   if( map1.insert_or_assign(2, 'd').second)
+      return false;
+   if(!map1.insert_or_assign(3, 'e').second)
+      return false;
+
+   if(map1.insert_or_assign(1, 'a').second)
+      return false;
+   if(map1.insert_or_assign(1, 'b').second)
+      return false;
+   if(map1.insert_or_assign(2, 'c').second)
+      return false;
+   if(map1.insert_or_assign(2, 'd').second)
+      return false;
+   if(map1.insert_or_assign(3, 'e').second)
+      return false;
+
+   mmap1.insert(value_type(1, 'a'));
+   mmap1.insert(value_type(1, 'b'));
+   mmap1.insert(value_type(2, 'c'));
+   mmap1.insert(value_type(2, 'd'));
+   mmap1.insert(value_type(3, 'e'));
+
+   const test::non_copymovable_int find_me(2);
+
+   //find
+   if(map1.find(find_me)->second != 'd')
+      return false;
+   if(cmap1.find(find_me)->second != 'd')
+      return false;
+   if(mmap1.find(find_me)->second != 'c')
+      return false;
+   if(cmmap1.find(find_me)->second != 'c')
+      return false;
+
+   //count
+   if(map1.count(find_me) != 1)
+      return false;
+   if(cmap1.count(find_me) != 1)
+      return false;
+   if(mmap1.count(find_me) != 2)
+      return false;
+   if(cmmap1.count(find_me) != 2)
+      return false;
+
+   //contains
+   if(!map1.contains(find_me))
+      return false;
+   if(!cmap1.contains(find_me))
+      return false;
+   if(!mmap1.contains(find_me))
+      return false;
+   if(!cmmap1.contains(find_me))
+      return false;
+
+   //lower_bound
+   if(map1.lower_bound(find_me)->second != 'd')
+      return false;
+   if(cmap1.lower_bound(find_me)->second != 'd')
+      return false;
+   if(mmap1.lower_bound(find_me)->second != 'c')
+      return false;
+   if(cmmap1.lower_bound(find_me)->second != 'c')
+      return false;
+
+   //upper_bound
+   if(map1.upper_bound(find_me)->second != 'e')
+      return false;
+   if(cmap1.upper_bound(find_me)->second != 'e')
+      return false;
+   if(mmap1.upper_bound(find_me)->second != 'e')
+      return false;
+   if(cmmap1.upper_bound(find_me)->second != 'e')
+      return false;
+
+   //equal_range
+   if(map1.equal_range(find_me).first->second != 'd')
+      return false;
+   if(cmap1.equal_range(find_me).second->second != 'e')
+      return false;
+   if(mmap1.equal_range(find_me).first->second != 'c')
+      return false;
+   if(cmmap1.equal_range(find_me).second->second != 'e')
+      return false;
+
+   return true;
+}
+
+bool constructor_template_auto_deduction_test()
+{
+
+#ifndef BOOST_CONTAINER_NO_CXX17_CTAD
+   using namespace boost::container;
+   const std::size_t NumElements = 100;
+   {
+      std::map<int, int> int_map;
+      for(std::size_t i = 0; i != NumElements; ++i){
+         int_map.insert(std::map<int, int>::value_type(static_cast<int>(i), static_cast<int>(i)));
+      }
+      std::multimap<int, int> int_mmap;
+      for (std::size_t i = 0; i != NumElements; ++i) {
+         int_mmap.insert(std::multimap<int, int>::value_type(static_cast<int>(i), static_cast<int>(i)));
+      }
+
+      typedef std::less<int> comp_int_t;
+      typedef std::allocator<std::pair<const int, int> > alloc_pair_int_t;
+
+      //range
+      {
+         auto fmap = map(int_map.begin(), int_map.end());
+         if (!CheckEqualContainers(int_map, fmap))
+            return false;
+         auto fmmap = multimap(int_mmap.begin(), int_mmap.end());
+         if (!CheckEqualContainers(int_mmap, fmmap))
+            return false;
+      }
+      //range+comp
+      {
+         auto fmap = map(int_map.begin(), int_map.end(), comp_int_t());
+         if (!CheckEqualContainers(int_map, fmap))
+            return false;
+         auto fmmap = multimap(int_mmap.begin(), int_mmap.end(), comp_int_t());
+         if (!CheckEqualContainers(int_mmap, fmmap))
+            return false;
+      }
+      //range+comp+alloc
+      {
+         auto fmap = map(int_map.begin(), int_map.end(), comp_int_t(), alloc_pair_int_t());
+         if (!CheckEqualContainers(int_map, fmap))
+            return false;
+         auto fmmap = multimap(int_mmap.begin(), int_mmap.end(), comp_int_t(), alloc_pair_int_t());
+         if (!CheckEqualContainers(int_mmap, fmmap))
+            return false;
+      }
+      //range+alloc
+      {
+         auto fmap = map(int_map.begin(), int_map.end(), alloc_pair_int_t());
+         if (!CheckEqualContainers(int_map, fmap))
+            return false;
+         auto fmmap = multimap(int_mmap.begin(), int_mmap.end(), alloc_pair_int_t());
+         if (!CheckEqualContainers(int_mmap, fmmap))
+            return false;
+      }
+
+      //ordered_unique_range / ordered_range
+
+      //range
+      {
+         auto fmap = map(ordered_unique_range, int_map.begin(), int_map.end());
+         if(!CheckEqualContainers(int_map, fmap))
+            return false;
+         auto fmmap = multimap(ordered_range, int_mmap.begin(), int_mmap.end());
+         if(!CheckEqualContainers(int_mmap, fmmap))
+            return false;
+      }
+      //range+comp
+      {
+         auto fmap = map(ordered_unique_range, int_map.begin(), int_map.end(), comp_int_t());
+         if (!CheckEqualContainers(int_map, fmap))
+            return false;
+         auto fmmap = multimap(ordered_range, int_mmap.begin(), int_mmap.end(), comp_int_t());
+         if (!CheckEqualContainers(int_mmap, fmmap))
+            return false;
+      }
+      //range+comp+alloc
+      {
+         auto fmap = map(ordered_unique_range, int_map.begin(), int_map.end(), comp_int_t(), alloc_pair_int_t());
+         if (!CheckEqualContainers(int_map, fmap))
+            return false;
+         auto fmmap = multimap(ordered_range, int_mmap.begin(), int_mmap.end(), comp_int_t(), alloc_pair_int_t());
+         if (!CheckEqualContainers(int_mmap, fmmap))
+            return false;
+      }
+      //range+alloc
+      {
+         auto fmap = map(ordered_unique_range, int_map.begin(), int_map.end(),alloc_pair_int_t());
+         if (!CheckEqualContainers(int_map, fmap))
+            return false;
+         auto fmmap = multimap(ordered_range, int_mmap.begin(), int_mmap.end(),alloc_pair_int_t());
+         if (!CheckEqualContainers(int_mmap, fmmap))
+            return false;
+      }
+   }
+#endif
+
+   return true;
+}
+
+}}}   //namespace boost::container::test
+
+int main ()
+{
+   //Recursive container instantiation
+   {
+      map<recursive_map, recursive_map> map_;
+      multimap<recursive_multimap, recursive_multimap> multimap_;
+   }
+   //Allocator argument container
+   {
+      map<int, int> map_((map<int, int>::allocator_type()));
+      multimap<int, int> multimap_((multimap<int, int>::allocator_type()));
+   }
+   //Now test move semantics
+   {
+      test_move<map<recursive_map, recursive_map> >();
+      test_move<multimap<recursive_multimap, recursive_multimap> >();
+   }
+
+   //Test std::pair value type as tree has workarounds to make old std::pair
+   //implementations movable that can break things
+   {
+      boost::container::map<pair_t, pair_t> s;
+      std::pair<const pair_t,pair_t> p;
+      s.insert(p);
+      s.emplace(p);
+   }
+
+   ////////////////////////////////////
+   //    Testing allocator implementations
+   ////////////////////////////////////
+   {
+      typedef std::map<int, int>                                     MyStdMap;
+      typedef std::multimap<int, int>                                MyStdMultiMap;
+
+      if (0 != test::map_test
+         < GetAllocatorMap<std::allocator<void>, red_black_tree>::apply<int>::map_type
+         , MyStdMap
+         , GetAllocatorMap<std::allocator<void>, red_black_tree>::apply<int>::multimap_type
+         , MyStdMultiMap>()) {
+         std::cout << "Error in map_test<std::allocator<void>, red_black_tree>" << std::endl;
+         return 1;
+      }
+
+      if (0 != test::map_test
+         < GetAllocatorMap<new_allocator<void>, avl_tree>::apply<int>::map_type
+         , MyStdMap
+         , GetAllocatorMap<new_allocator<void>, avl_tree>::apply<int>::multimap_type
+         , MyStdMultiMap>()) {
+         std::cout << "Error in map_test<new_allocator<void>, avl_tree>" << std::endl;
+         return 1;
+      }
+
+      if (0 != test::map_test
+         < GetAllocatorMap<adaptive_pool<void>, scapegoat_tree>::apply<int>::map_type
+         , MyStdMap
+         , GetAllocatorMap<adaptive_pool<void>, scapegoat_tree>::apply<int>::multimap_type
+         , MyStdMultiMap>()) {
+         std::cout << "Error in map_test<adaptive_pool<void>, scapegoat_tree>" << std::endl;
+         return 1;
+      }
+
+      ///////////
+
+     if (0 != test::map_test
+         < GetAllocatorMap<new_allocator<void>, splay_tree>::apply<test::movable_int>::map_type
+         , MyStdMap
+         , GetAllocatorMap<new_allocator<void>, splay_tree>::apply<test::movable_int>::multimap_type
+         , MyStdMultiMap>()) {
+         std::cout << "Error in map_test<new_allocator<void>, splay_tree>" << std::endl;
+         return 1;
+      }
+
+      if (0 != test::map_test
+         < GetAllocatorMap<new_allocator<void>, red_black_tree>::apply<test::copyable_int>::map_type
+         , MyStdMap
+         , GetAllocatorMap<new_allocator<void>, red_black_tree>::apply<test::copyable_int>::multimap_type
+         , MyStdMultiMap>()) {
+         std::cout << "Error in map_test<new_allocator<void>, red_black_tree>" << std::endl;
+         return 1;
+      }
+
+      if (0 != test::map_test
+         < GetAllocatorMap<new_allocator<void>, red_black_tree>::apply<test::movable_and_copyable_int>::map_type
+         , MyStdMap
+         , GetAllocatorMap<new_allocator<void>, red_black_tree>::apply<test::movable_and_copyable_int>::multimap_type
+         , MyStdMultiMap>()) {
+         std::cout << "Error in map_test<new_allocator<void>, red_black_tree>" << std::endl;
+         return 1;
+      }
+   }
+
+   ////////////////////////////////////
+   //    Emplace testing
+   ////////////////////////////////////
+   const test::EmplaceOptions MapOptions = (test::EmplaceOptions)(test::EMPLACE_HINT_PAIR | test::EMPLACE_ASSOC_PAIR);
+   if(!boost::container::test::test_emplace<map<test::EmplaceInt, test::EmplaceInt>, MapOptions>())
+      return 1;
+   if(!boost::container::test::test_emplace<multimap<test::EmplaceInt, test::EmplaceInt>, MapOptions>())
+      return 1;
+
+   ////////////////////////////////////
+   //    Allocator propagation testing
+   ////////////////////////////////////
+   if(!boost::container::test::test_propagate_allocator<boost_container_map>())
+      return 1;
+
+   if(!boost::container::test::test_propagate_allocator<boost_container_multimap>())
+      return 1;
+
+   if (!boost::container::test::test_map_support_for_initialization_list_for<map<int, int> >())
+      return 1;
+
+   if (!boost::container::test::test_map_support_for_initialization_list_for<multimap<int, int> >())
+      return 1;
+
+   ////////////////////////////////////
+   //    Iterator testing
+   ////////////////////////////////////
+   {
+      typedef boost::container::map<int, int> cont_int;
+      cont_int a; a.insert(cont_int::value_type(0, 9)); a.insert(cont_int::value_type(1, 9)); a.insert(cont_int::value_type(2, 9));
+      boost::intrusive::test::test_iterator_bidirectional< cont_int >(a);
+      if(boost::report_errors() != 0) {
+         return 1;
+      }
+   }
+   {
+      typedef boost::container::multimap<int, int> cont_int;
+      cont_int a; a.insert(cont_int::value_type(0, 9)); a.insert(cont_int::value_type(1, 9)); a.insert(cont_int::value_type(2, 9));
+      boost::intrusive::test::test_iterator_bidirectional< cont_int >(a);
+      if(boost::report_errors() != 0) {
+         return 1;
+      }
+   }
+
+   ////////////////////////////////////
+   //    Node extraction/insertion testing functions
+   ////////////////////////////////////
+   if(!node_type_test())
+      return 1;
+
+   ////////////////////////////////////
+   //    Constructor Template Auto Deduction test
+   ////////////////////////////////////
+   if (!test::constructor_template_auto_deduction_test()) {
+      return 1;
+   }
+
+   if (!boost::container::test::instantiate_constructors<map<int, int>, multimap<int, int> >())
+      return 1;
+
+   test::test_merge_from_different_comparison();
+
+   if(!test::test_heterogeneous_lookups())
+      return 1;
+
+   ////////////////////////////////////
+   //    Test optimize_size option
+   ////////////////////////////////////
+   //
+   // map
+   //
+   typedef map< int*, int*, std::less<int*>, std::allocator< std::pair<int *const, int*> >
+              , tree_assoc_options< optimize_size<false>, tree_type<red_black_tree> >::type > rbmap_size_optimized_no;
+
+   typedef map< int*, int*, std::less<int*>, std::allocator< std::pair<int *const, int*> >
+              , tree_assoc_options< optimize_size<true>, tree_type<avl_tree>  >::type > avlmap_size_optimized_yes;
+   //
+   // multimap
+   //
+   typedef multimap< int*, int*, std::less<int*>, std::allocator< std::pair<int *const, int*> >
+                   , tree_assoc_options< optimize_size<true>, tree_type<red_black_tree>  >::type > rbmmap_size_optimized_yes;
+   typedef multimap< int*, int*, std::less<int*>, std::allocator< std::pair<int *const, int*> >
+                   , tree_assoc_options< optimize_size<false>, tree_type<avl_tree> >::type > avlmmap_size_optimized_no;
+
+   BOOST_STATIC_ASSERT(sizeof(rbmmap_size_optimized_yes) < sizeof(rbmap_size_optimized_no));
+   BOOST_STATIC_ASSERT(sizeof(avlmap_size_optimized_yes) < sizeof(avlmmap_size_optimized_no));
+
+   ////////////////////////////////////
+   //    has_trivial_destructor_after_move testing
+   ////////////////////////////////////
+   {
+      typedef std::pair<const int, int> value_type;
+      //
+      // map
+      //
+      // default allocator
+      {
+         typedef boost::container::map<int, int> cont;
+         typedef boost::container::dtl::tree<value_type, int, std::less<int>, void, void> tree;
+         if (boost::has_trivial_destructor_after_move<cont>::value !=
+             boost::has_trivial_destructor_after_move<tree>::value) {
+            std::cerr << "has_trivial_destructor_after_move(map, default allocator) test failed" << std::endl;
+            return 1;
+         }
+      }
+      // std::allocator
+      {
+         typedef boost::container::map<int, int, std::less<int>, std::allocator<value_type> > cont;
+         typedef boost::container::dtl::tree<value_type, int, std::less<int>, std::allocator<value_type>, void> tree;
+         if (boost::has_trivial_destructor_after_move<cont>::value !=
+             boost::has_trivial_destructor_after_move<tree>::value) {
+            std::cerr << "has_trivial_destructor_after_move(map, std::allocator) test failed" << std::endl;
+            return 1;
+         }
+      }
+      //
+      // multimap
+      //
+      // default allocator
+      {
+         //       default allocator
+         typedef boost::container::multimap<int, int> cont;
+         typedef boost::container::dtl::tree<value_type, int, std::less<int>, void, void> tree;
+         if (boost::has_trivial_destructor_after_move<cont>::value !=
+             boost::has_trivial_destructor_after_move<tree>::value) {
+            std::cerr << "has_trivial_destructor_after_move(multimap, default allocator) test failed" << std::endl;
+            return 1;
+         }
+      }
+      // std::allocator
+      {
+         typedef boost::container::multimap<int, int, std::less<int>, std::allocator<value_type> > cont;
+         typedef boost::container::dtl::tree<value_type, int, std::less<int>, std::allocator<value_type>, void> tree;
+         if (boost::has_trivial_destructor_after_move<cont>::value !=
+             boost::has_trivial_destructor_after_move<tree>::value) {
+            std::cerr << "has_trivial_destructor_after_move(multimap, std::allocator) test failed" << std::endl;
+            return 1;
+         }
+      }
+   }
+
+   return 0;
+}
+
+#include <boost/container/detail/config_end.hpp>
diff --git a/src/boost/libs/container/test/map_test.hpp b/src/boost/libs/container/test/map_test.hpp
new file mode 100644
index 000000000..160c46ad0
--- /dev/null
+++ b/src/boost/libs/container/test/map_test.hpp
@@ -0,0 +1,1264 @@
+////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2006. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/container for documentation.
+//
+////////////////////////////////////////
+
+#ifndef BOOST_CONTAINER_TEST_MAP_TEST_HEADER
+#define BOOST_CONTAINER_TEST_MAP_TEST_HEADER
+
+#include <boost/container/detail/config_begin.hpp>
+#include "check_equal_containers.hpp"
+#include "print_container.hpp"
+#include "movable_int.hpp"
+#include <boost/container/detail/pair.hpp>
+#include <boost/move/iterator.hpp>
+#include <boost/move/utility_core.hpp>
+#include <boost/move/make_unique.hpp>
+
+#include <boost/intrusive/detail/minimal_pair_header.hpp>      //pair
+#include <string>
+#include <iostream>
+
+#include <boost/intrusive/detail/mpl.hpp>
+
+namespace boost { namespace container { namespace test {
+
+BOOST_INTRUSIVE_HAS_MEMBER_FUNC_CALLED(has_member_rebalance, rebalance)
+
+}}}
+
+const int MaxElem = 50;
+
+template<class T1, class T2, class T3, class T4>
+bool operator ==(std::pair<T1, T2> &p1, std::pair<T1, T2> &p2)
+{
+   return p1.first == p2.first && p1.second == p2.second;
+}
+
+namespace boost{
+namespace container {
+namespace test{
+
+template<class C>
+void map_test_rebalanceable(C &, boost::container::dtl::false_type)
+{}
+
+template<class C>
+void map_test_rebalanceable(C &c, boost::container::dtl::true_type)
+{
+   c.rebalance();
+}
+
+template<class MyBoostMap
+        ,class MyStdMap
+        ,class MyBoostMultiMap
+        ,class MyStdMultiMap>
+int map_test_copyable(boost::container::dtl::false_type)
+{  return 0; }
+
+template<class MyBoostMap
+        ,class MyStdMap
+        ,class MyBoostMultiMap
+        ,class MyStdMultiMap>
+int map_test_copyable(boost::container::dtl::true_type)
+{
+   typedef typename MyBoostMap::key_type    IntType;
+   typedef dtl::pair<IntType, IntType>         IntPairType;
+   typedef typename MyStdMap::value_type  StdPairType;
+
+   ::boost::movelib::unique_ptr<MyBoostMap> const pboostmap = ::boost::movelib::make_unique<MyBoostMap>();
+   ::boost::movelib::unique_ptr<MyStdMap> const pstdmap = ::boost::movelib::make_unique<MyStdMap>();
+   ::boost::movelib::unique_ptr<MyBoostMultiMap> const pboostmultimap = ::boost::movelib::make_unique<MyBoostMultiMap>();
+   ::boost::movelib::unique_ptr<MyStdMultiMap> const pstdmultimap = ::boost::movelib::make_unique<MyStdMultiMap>();
+   MyBoostMap &boostmap = *pboostmap;
+   MyStdMap   &stdmap   = *pstdmap;
+   MyBoostMultiMap &boostmultimap = *pboostmultimap;
+   MyStdMultiMap   &stdmultimap   = *pstdmultimap;
+
+   //Just to test move aware catch conversions
+   boostmap.insert(boostmap.cbegin(), boostmap.cend());
+   boostmultimap.insert(boostmultimap.cbegin(), boostmultimap.cend());
+   boostmap.insert(boostmap.begin(), boostmap.end());
+   boostmultimap.insert(boostmultimap.begin(), boostmultimap.end());
+
+   int i;
+   for(i = 0; i < MaxElem; ++i){
+      {
+      IntType i1(i), i2(i);
+      IntPairType intpair1(boost::move(i1), boost::move(i2));
+      boostmap.insert(boost::move(intpair1));
+      stdmap.insert(StdPairType(i, i));
+      }
+      {
+      IntType i1(i), i2(i);
+      IntPairType intpair2(boost::move(i1), boost::move(i2));
+      boostmultimap.insert(boost::move(intpair2));
+      stdmultimap.insert(StdPairType(i, i));
+      }
+   }
+   if(!CheckEqualContainers(boostmap, stdmap)) return 1;
+   if(!CheckEqualContainers(boostmultimap, stdmultimap)) return 1;
+   {
+      //Now, test copy constructor
+      MyBoostMap boostmapcopy(boostmap);
+      MyStdMap stdmapcopy(stdmap);
+      MyBoostMultiMap boostmmapcopy(boostmultimap);
+      MyStdMultiMap stdmmapcopy(stdmultimap);
+
+      if(!CheckEqualContainers(boostmapcopy, stdmapcopy))
+         return 1;
+      if(!CheckEqualContainers(boostmmapcopy, stdmmapcopy))
+         return 1;
+
+      //And now assignment
+      boostmapcopy  = boostmap;
+      stdmapcopy  = stdmap;
+      boostmmapcopy = boostmultimap;
+      stdmmapcopy = stdmultimap;
+
+      if(!CheckEqualContainers(boostmapcopy, stdmapcopy))
+         return 1;
+      if(!CheckEqualContainers(boostmmapcopy, stdmmapcopy))
+         return 1;
+   }
+
+   return 0;
+}
+
+template<class MyBoostMap
+        ,class MyStdMap
+        ,class MyBoostMultiMap
+        ,class MyStdMultiMap>
+int map_test_range()
+{
+   typedef typename MyBoostMap::key_type    IntType;
+   typedef dtl::pair<IntType, IntType>         IntPairType;
+   typedef typename MyStdMap::value_type StdValueType;
+   typedef typename MyStdMap::key_type StdKeyType;
+   typedef typename MyStdMap::mapped_type StdMappedType;
+
+   //Test construction from a range
+   {
+      IntPairType aux_vect[MaxElem];
+      for(int i = 0; i < MaxElem; ++i){
+         IntType i1(i/2);
+         IntType i2(i/2);
+         new(&aux_vect[i])IntPairType(boost::move(i1), boost::move(i2));
+      }
+
+      StdValueType aux_vect2[MaxElem];
+      for(int i = 0; i < MaxElem; ++i){
+         new(&aux_vect2[i])StdValueType(StdKeyType(i/2), StdMappedType(i/2));
+      }
+
+      IntPairType aux_vect3[MaxElem];
+      for(int i = 0; i < MaxElem; ++i){
+         IntType i1(i/2);
+         IntType i2(i/2);
+         new(&aux_vect3[i])IntPairType(boost::move(i1), boost::move(i2));
+      }
+
+      ::boost::movelib::unique_ptr<MyBoostMap> const pboostmap = ::boost::movelib::make_unique<MyBoostMap>
+               ( boost::make_move_iterator(&aux_vect[0])
+               , boost::make_move_iterator(&aux_vect[0] + MaxElem), typename MyBoostMap::key_compare());
+      ::boost::movelib::unique_ptr<MyStdMap> const pstdmap = ::boost::movelib::make_unique<MyStdMap>
+         (&aux_vect2[0], &aux_vect2[0] + MaxElem, typename MyStdMap::key_compare());
+      if(!CheckEqualContainers(*pboostmap, *pstdmap)) return 1;
+
+      ::boost::movelib::unique_ptr<MyBoostMultiMap> const pboostmultimap = ::boost::movelib::make_unique<MyBoostMultiMap>
+               ( boost::make_move_iterator(&aux_vect3[0])
+               , boost::make_move_iterator(&aux_vect3[0] + MaxElem), typename MyBoostMap::key_compare());
+      ::boost::movelib::unique_ptr<MyStdMultiMap> const pstdmultimap = ::boost::movelib::make_unique<MyStdMultiMap>
+         (&aux_vect2[0], &aux_vect2[0] + MaxElem, typename MyStdMap::key_compare());
+      if(!CheckEqualContainers(*pboostmultimap, *pstdmultimap)) return 1;
+   }
+   {
+      IntPairType aux_vect[MaxElem];
+      for(int i = 0; i < MaxElem; ++i){
+         IntType i1(i/2);
+         IntType i2(i/2);
+         new(&aux_vect[i])IntPairType(boost::move(i1), boost::move(i2));
+      }
+
+      StdValueType aux_vect2[MaxElem];
+      for(int i = 0; i < MaxElem; ++i){
+         new(&aux_vect2[i])StdValueType(StdKeyType(i/2), StdMappedType(i/2));
+      }
+
+      IntPairType aux_vect3[MaxElem];
+      for(int i = 0; i < MaxElem; ++i){
+         IntType i1(i/2);
+         IntType i2(i/2);
+         new(&aux_vect3[i])IntPairType(boost::move(i1), boost::move(i2));
+      }
+
+      ::boost::movelib::unique_ptr<MyBoostMap> const pboostmap = ::boost::movelib::make_unique<MyBoostMap>
+               ( boost::make_move_iterator(&aux_vect[0])
+               , boost::make_move_iterator(&aux_vect[0] + MaxElem), typename MyBoostMap::allocator_type());
+      ::boost::movelib::unique_ptr<MyStdMap> const pstdmap = ::boost::movelib::make_unique<MyStdMap>
+         (&aux_vect2[0], &aux_vect2[0] + MaxElem, typename MyStdMap::key_compare());
+      if(!CheckEqualContainers(*pboostmap, *pstdmap)) return 1;
+
+      ::boost::movelib::unique_ptr<MyBoostMultiMap> const pboostmultimap = ::boost::movelib::make_unique<MyBoostMultiMap>
+               ( boost::make_move_iterator(&aux_vect3[0])
+               , boost::make_move_iterator(&aux_vect3[0] + MaxElem), typename MyBoostMap::allocator_type());
+      ::boost::movelib::unique_ptr<MyStdMultiMap> const pstdmultimap = ::boost::movelib::make_unique<MyStdMultiMap>
+         (&aux_vect2[0], &aux_vect2[0] + MaxElem, typename MyStdMap::key_compare());
+      if(!CheckEqualContainers(*pboostmultimap, *pstdmultimap)) return 1;
+   }
+   return 0;
+}
+
+
+template<class MyBoostMap
+        ,class MyStdMap
+        ,class MyBoostMultiMap
+        ,class MyStdMultiMap>
+int map_test_step(MyBoostMap &, MyStdMap &, MyBoostMultiMap &, MyStdMultiMap &)
+{
+   typedef typename MyBoostMap::key_type    IntType;
+   typedef dtl::pair<IntType, IntType>         IntPairType;
+
+   {
+      //This is really nasty, but we have no other simple choice
+      IntPairType aux_vect[MaxElem];
+      for(int i = 0; i < MaxElem; ++i){
+         IntType i1(i/2);
+         IntType i2(i/2);
+         new(&aux_vect[i])IntPairType(boost::move(i1), boost::move(i2));
+      }
+
+      typedef typename MyStdMap::value_type StdValueType;
+      typedef typename MyStdMap::key_type StdKeyType;
+      typedef typename MyStdMap::mapped_type StdMappedType;
+      StdValueType aux_vect2[MaxElem];
+      for(int i = 0; i < MaxElem; ++i){
+         new(&aux_vect2[i])StdValueType(StdKeyType(i/2), StdMappedType(i/2));
+      }
+
+      IntPairType aux_vect3[MaxElem];
+      for(int i = 0; i < MaxElem; ++i){
+         IntType i1(i/2);
+         IntType i2(i/2);
+         new(&aux_vect3[i])IntPairType(boost::move(i1), boost::move(i2));
+      }
+
+      ::boost::movelib::unique_ptr<MyBoostMap> const pboostmap2 = ::boost::movelib::make_unique<MyBoostMap>
+               ( boost::make_move_iterator(&aux_vect[0])
+               , boost::make_move_iterator(&aux_vect[0] + MaxElem));
+      ::boost::movelib::unique_ptr<MyStdMap> const pstdmap2 = ::boost::movelib::make_unique<MyStdMap>
+         (&aux_vect2[0], &aux_vect2[0] + MaxElem);
+      ::boost::movelib::unique_ptr<MyBoostMultiMap> const pboostmultimap2 = ::boost::movelib::make_unique<MyBoostMultiMap>
+               ( boost::make_move_iterator(&aux_vect3[0])
+               , boost::make_move_iterator(&aux_vect3[0] + MaxElem));
+      ::boost::movelib::unique_ptr<MyStdMultiMap> const pstdmultimap2 = ::boost::movelib::make_unique<MyStdMultiMap>
+         (&aux_vect2[0], &aux_vect2[0] + MaxElem);
+      MyBoostMap &boostmap2 = *pboostmap2;
+      MyStdMap   &stdmap2   = *pstdmap2;
+      MyBoostMultiMap &boostmultimap2 = *pboostmultimap2;
+      MyStdMultiMap   &stdmultimap2   = *pstdmultimap2;
+
+      if(!CheckEqualContainers(boostmap2, stdmap2)) return 1;
+      if(!CheckEqualContainers(boostmultimap2, stdmultimap2)) return 1;
+
+
+
+      //ordered range insertion
+      //This is really nasty, but we have no other simple choice
+      for(int i = 0; i < MaxElem; ++i){
+         IntType i1(i);
+         IntType i2(i);
+         new(&aux_vect[i])IntPairType(boost::move(i1), boost::move(i2));
+      }
+
+      for(int i = 0; i < MaxElem; ++i){
+         new(&aux_vect2[i])StdValueType(StdKeyType(i), StdMappedType(i));
+      }
+
+      for(int i = 0; i < MaxElem; ++i){
+         IntType i1(i);
+         IntType i2(i);
+         new(&aux_vect3[i])IntPairType(boost::move(i1), boost::move(i2));
+      }
+      if(!CheckEqualContainers(boostmap2, stdmap2)) return 1;
+      if(!CheckEqualContainers(boostmultimap2, stdmultimap2)) return 1;
+
+      //some comparison operators
+      if(!(boostmap2 == boostmap2))
+         return 1;
+      if(boostmap2 != boostmap2)
+         return 1;
+      if(boostmap2 < boostmap2)
+         return 1;
+      if(boostmap2 > boostmap2)
+         return 1;
+      if(!(boostmap2 <= boostmap2))
+         return 1;
+      if(!(boostmap2 >= boostmap2))
+         return 1;
+
+      ::boost::movelib::unique_ptr<MyBoostMap> const pboostmap3 = ::boost::movelib::make_unique<MyBoostMap>
+               ( boost::make_move_iterator(&aux_vect[0])
+               , boost::make_move_iterator(&aux_vect[0] + MaxElem));
+      ::boost::movelib::unique_ptr<MyStdMap> const pstdmap3 = ::boost::movelib::make_unique<MyStdMap>
+               (&aux_vect2[0], &aux_vect2[0] + MaxElem);
+      ::boost::movelib::unique_ptr<MyBoostMultiMap> const pboostmultimap3 = ::boost::movelib::make_unique<MyBoostMultiMap>
+               ( boost::make_move_iterator(&aux_vect3[0])
+               , boost::make_move_iterator(&aux_vect3[0] + MaxElem));
+      ::boost::movelib::unique_ptr<MyStdMultiMap> const pstdmultimap3 = ::boost::movelib::make_unique<MyStdMultiMap>
+               (&aux_vect2[0], &aux_vect2[0] + MaxElem);
+      MyBoostMap &boostmap3 = *pboostmap3;
+      MyStdMap   &stdmap3   = *pstdmap3;
+      MyBoostMultiMap &boostmultimap3 = *pboostmultimap3;
+      MyStdMultiMap   &stdmultimap3   = *pstdmultimap3;
+
+      if(!CheckEqualContainers(boostmap3, stdmap3)){
+         std::cout << "Error in construct<MyBoostMap>(MyBoostMap3)" << std::endl;
+         return 1;
+      }
+      if(!CheckEqualContainers(boostmultimap3, stdmultimap3)){
+         std::cout << "Error in construct<MyBoostMultiMap>(MyBoostMultiMap3)" << std::endl;
+         return 1;
+      }
+
+      {
+         IntType i0(0);
+         boostmap2.erase(i0);
+         boostmultimap2.erase(i0);
+         stdmap2.erase(0);
+         stdmultimap2.erase(0);
+      }
+      {
+         IntType i0(0);
+         IntType i1(1);
+         boostmap2[::boost::move(i0)] = ::boost::move(i1);
+      }
+      {
+         IntType i1(1);
+         boostmap2[IntType(0)] = ::boost::move(i1);
+      }
+      stdmap2[0] = 1;
+      if(!CheckEqualContainers(boostmap2, stdmap2)) return 1;
+   }
+   return 0;
+}
+
+template<class MyBoostMap
+        , class MyStdMap
+        , class MyBoostMultiMap
+        , class MyStdMultiMap>
+int map_test_insert(MyBoostMap &boostmap, MyStdMap &stdmap, MyBoostMultiMap &boostmultimap, MyStdMultiMap &stdmultimap)
+{
+   typedef typename MyBoostMap::key_type    IntType;
+   typedef dtl::pair<IntType, IntType>         IntPairType;
+   typedef typename MyStdMap::value_type  StdPairType;
+
+   {
+      //This is really nasty, but we have no other simple choice
+      IntPairType aux_vect[MaxElem];
+      for(int i = 0; i < MaxElem; ++i){
+         IntType i1(i);
+         IntType i2(i);
+         new(&aux_vect[i])IntPairType(boost::move(i1), boost::move(i2));
+      }
+      IntPairType aux_vect3[MaxElem];
+      for(int i = 0; i < MaxElem; ++i){
+         IntType i1(i);
+         IntType i2(i);
+         new(&aux_vect3[i])IntPairType(boost::move(i1), boost::move(i2));
+      }
+
+      for(int i = 0; i < MaxElem; ++i){
+         boostmap.insert(boost::move(aux_vect[i]));
+         stdmap.insert(StdPairType(i, i));
+         boostmultimap.insert(boost::move(aux_vect3[i]));
+         stdmultimap.insert(StdPairType(i, i));
+      }
+
+      if(!CheckEqualPairContainers(boostmap, stdmap)) return 1;
+      if(!CheckEqualPairContainers(boostmultimap, stdmultimap)) return 1;
+
+      typename MyBoostMap::iterator it = boostmap.begin();
+      typename MyBoostMap::const_iterator cit = it;
+      (void)cit;
+
+      boostmap.erase(boostmap.begin());
+      stdmap.erase(stdmap.begin());
+      boostmultimap.erase(boostmultimap.begin());
+      stdmultimap.erase(stdmultimap.begin());
+      if(!CheckEqualPairContainers(boostmap, stdmap)) return 1;
+      if(!CheckEqualPairContainers(boostmultimap, stdmultimap)) return 1;
+
+      boostmap.erase(boostmap.begin());
+      stdmap.erase(stdmap.begin());
+      boostmultimap.erase(boostmultimap.begin());
+      stdmultimap.erase(stdmultimap.begin());
+      if(!CheckEqualPairContainers(boostmap, stdmap)) return 1;
+      if(!CheckEqualPairContainers(boostmultimap, stdmultimap)) return 1;
+
+      //Swapping test
+      MyBoostMap tmpboostemap2;
+      MyStdMap tmpstdmap2;
+      MyBoostMultiMap tmpboostemultimap2;
+      MyStdMultiMap tmpstdmultimap2;
+      boostmap.swap(tmpboostemap2);
+      stdmap.swap(tmpstdmap2);
+      boostmultimap.swap(tmpboostemultimap2);
+      stdmultimap.swap(tmpstdmultimap2);
+      boostmap.swap(tmpboostemap2);
+      stdmap.swap(tmpstdmap2);
+      boostmultimap.swap(tmpboostemultimap2);
+      stdmultimap.swap(tmpstdmultimap2);
+      if(!CheckEqualPairContainers(boostmap, stdmap)) return 1;
+      if(!CheckEqualPairContainers(boostmultimap, stdmultimap)) return 1;
+   }
+   return 0;
+}
+
+template<class MyBoostMap
+        , class MyStdMap
+        , class MyBoostMultiMap
+        , class MyStdMultiMap>
+int map_test_erase(MyBoostMap &boostmap, MyStdMap &stdmap, MyBoostMultiMap &boostmultimap, MyStdMultiMap &stdmultimap)
+{
+   typedef typename MyBoostMap::key_type    IntType;
+   typedef dtl::pair<IntType, IntType>         IntPairType;
+   typedef typename MyStdMap::value_type  StdPairType;
+
+   //Insertion from other container
+   //Initialize values
+   {
+      //This is really nasty, but we have no other simple choice
+      IntPairType aux_vect[MaxElem];
+      for(int i = 0; i < MaxElem; ++i){
+         IntType i1(-1);
+         IntType i2(-1);
+         new(&aux_vect[i])IntPairType(boost::move(i1), boost::move(i2));
+      }
+      IntPairType aux_vect3[MaxElem];
+      for(int i = 0; i < MaxElem; ++i){
+         IntType i1(-1);
+         IntType i2(-1);
+         new(&aux_vect3[i])IntPairType(boost::move(i1), boost::move(i2));
+      }
+
+      boostmap.insert(boost::make_move_iterator(&aux_vect[0]), boost::make_move_iterator(&aux_vect[0] + MaxElem));
+      boostmultimap.insert(boost::make_move_iterator(&aux_vect3[0]), boost::make_move_iterator(&aux_vect3[0] + MaxElem));
+      for(int i = 0; i != MaxElem; ++i){
+         StdPairType stdpairtype(-1, -1);
+         stdmap.insert(stdpairtype);
+         stdmultimap.insert(stdpairtype);
+      }
+      if(!CheckEqualPairContainers(boostmap, stdmap)) return 1;
+      if(!CheckEqualPairContainers(boostmultimap, stdmultimap)) return 1;
+
+      for(int i = 0, j = static_cast<int>(boostmap.size()); i < j; ++i){
+         IntType k(i);
+         boostmap.erase(k);
+         stdmap.erase(i);
+         boostmultimap.erase(k);
+         stdmultimap.erase(i);
+      }
+      if(!CheckEqualPairContainers(boostmap, stdmap)) return 1;
+      if(!CheckEqualPairContainers(boostmultimap, stdmultimap)) return 1;
+   }
+   {
+      IntPairType aux_vect[MaxElem];
+      for(int i = 0; i < MaxElem; ++i){
+         IntType i1(-1);
+         IntType i2(-1);
+         new(&aux_vect[i])IntPairType(boost::move(i1), boost::move(i2));
+      }
+
+      IntPairType aux_vect3[MaxElem];
+      for(int i = 0; i < MaxElem; ++i){
+         IntType i1(-1);
+         IntType i2(-1);
+         new(&aux_vect3[i])IntPairType(boost::move(i1), boost::move(i2));
+      }
+
+      IntPairType aux_vect4[MaxElem];
+      for(int i = 0; i < MaxElem; ++i){
+         IntType i1(-1);
+         IntType i2(-1);
+         new(&aux_vect4[i])IntPairType(boost::move(i1), boost::move(i2));
+      }
+
+      IntPairType aux_vect5[MaxElem];
+      for(int i = 0; i < MaxElem; ++i){
+         IntType i1(-1);
+         IntType i2(-1);
+         new(&aux_vect5[i])IntPairType(boost::move(i1), boost::move(i2));
+      }
+
+      boostmap.insert(boost::make_move_iterator(&aux_vect[0]), boost::make_move_iterator(&aux_vect[0] + MaxElem));
+      boostmap.insert(boost::make_move_iterator(&aux_vect3[0]), boost::make_move_iterator(&aux_vect3[0] + MaxElem));
+      boostmultimap.insert(boost::make_move_iterator(&aux_vect4[0]), boost::make_move_iterator(aux_vect4 + MaxElem));
+      boostmultimap.insert(boost::make_move_iterator(&aux_vect5[0]), boost::make_move_iterator(aux_vect5 + MaxElem));
+
+      for(int i = 0; i != MaxElem; ++i){
+         StdPairType stdpairtype(-1, -1);
+         stdmap.insert(stdpairtype);
+         stdmultimap.insert(stdpairtype);
+         stdmap.insert(stdpairtype);
+         stdmultimap.insert(stdpairtype);
+      }
+      if(!CheckEqualPairContainers(boostmap, stdmap)) return 1;
+      if(!CheckEqualPairContainers(boostmultimap, stdmultimap)) return 1;
+
+      boostmap.erase(boostmap.begin()->first);
+      stdmap.erase(stdmap.begin()->first);
+      boostmultimap.erase(boostmultimap.begin()->first);
+      stdmultimap.erase(stdmultimap.begin()->first);
+      if(!CheckEqualPairContainers(boostmap, stdmap)) return 1;
+      if(!CheckEqualPairContainers(boostmultimap, stdmultimap)) return 1;
+   }
+   return 0;
+}
+
+template<class MyBoostMap
+        , class MyStdMap
+        , class MyBoostMultiMap
+        , class MyStdMultiMap>
+int map_test_insert2(MyBoostMap &boostmap, MyStdMap &stdmap, MyBoostMultiMap &boostmultimap, MyStdMultiMap &stdmultimap)
+{
+   typedef typename MyBoostMap::key_type    IntType;
+   typedef dtl::pair<IntType, IntType>         IntPairType;
+   typedef typename MyStdMap::value_type  StdPairType;
+
+   //This is really nasty, but we have no other simple choice
+   IntPairType aux_vect[MaxElem];
+   for(int i = 0; i < MaxElem; ++i){
+      IntType i1(i);
+      IntType i2(i);
+      new(&aux_vect[i])IntPairType(boost::move(i1), boost::move(i2));
+   }
+   IntPairType aux_vect3[MaxElem];
+   for(int i = 0; i < MaxElem; ++i){
+      IntType i1(i);
+      IntType i2(i);
+      new(&aux_vect3[i])IntPairType(boost::move(i1), boost::move(i2));
+   }
+
+   for(int i = 0; i < MaxElem; ++i){
+      boostmap.insert(boost::move(aux_vect[i]));
+      stdmap.insert(StdPairType(i, i));
+      boostmultimap.insert(boost::move(aux_vect3[i]));
+      stdmultimap.insert(StdPairType(i, i));
+   }
+
+   if(!CheckEqualPairContainers(boostmap, stdmap)) return 1;
+   if(!CheckEqualPairContainers(boostmultimap, stdmultimap)) return 1;
+
+   for(int i = 0; i < MaxElem; ++i){
+      IntPairType intpair;
+      {
+         IntType i1(i);
+         IntType i2(i);
+         new(&intpair)IntPairType(boost::move(i1), boost::move(i2));
+      }
+      boostmap.insert(boostmap.begin(), boost::move(intpair));
+      stdmap.insert(stdmap.begin(), StdPairType(i, i));
+      //PrintContainers(boostmap, stdmap);
+      {
+         IntType i1(i);
+         IntType i2(i);
+         new(&intpair)IntPairType(boost::move(i1), boost::move(i2));
+      }
+      boostmultimap.insert(boostmultimap.begin(), boost::move(intpair));
+      stdmultimap.insert(stdmultimap.begin(), StdPairType(i, i));
+      //PrintContainers(boostmultimap, stdmultimap);
+      if(!CheckEqualPairContainers(boostmap, stdmap))
+         return 1;
+      if(!CheckEqualPairContainers(boostmultimap, stdmultimap))
+         return 1;
+      {
+         IntType i1(i);
+         IntType i2(i);
+         new(&intpair)IntPairType(boost::move(i1), boost::move(i2));
+      }
+      boostmap.insert(boostmap.end(), boost::move(intpair));
+      stdmap.insert(stdmap.end(), StdPairType(i, i));
+      {
+         IntType i1(i);
+         IntType i2(i);
+         new(&intpair)IntPairType(boost::move(i1), boost::move(i2));
+      }
+      boostmultimap.insert(boostmultimap.end(), boost::move(intpair));
+      stdmultimap.insert(stdmultimap.end(), StdPairType(i, i));
+      if(!CheckEqualPairContainers(boostmap, stdmap))
+         return 1;
+      if(!CheckEqualPairContainers(boostmultimap, stdmultimap))
+         return 1;
+      {
+         IntType i1(i);
+         IntType i2(i);
+         new(&intpair)IntPairType(boost::move(i1), boost::move(i2));
+      }
+      IntType k(i);
+      boostmap.insert(boostmap.lower_bound(k), boost::move(intpair));
+      stdmap.insert(stdmap.lower_bound(i), StdPairType(i, i));
+      //PrintContainers(boostmap, stdmap);
+      {
+         IntType i1(i);
+         IntType i2(i);
+         new(&intpair)IntPairType(boost::move(i1), boost::move(i2));
+      }
+      {
+         IntType i1(i);
+         boostmultimap.insert(boostmultimap.lower_bound(boost::move(i1)), boost::move(intpair));
+         stdmultimap.insert(stdmultimap.lower_bound(i), StdPairType(i, i));
+      }
+
+      //PrintContainers(boostmultimap, stdmultimap);
+      if(!CheckEqualPairContainers(boostmap, stdmap))
+         return 1;
+      if(!CheckEqualPairContainers(boostmultimap, stdmultimap))
+         return 1;
+      {  //Check equal_range
+         std::pair<typename MyBoostMultiMap::iterator, typename MyBoostMultiMap::iterator> bret =
+            boostmultimap.equal_range(boostmultimap.begin()->first);
+
+         std::pair<typename MyStdMultiMap::iterator, typename MyStdMultiMap::iterator>   sret =
+            stdmultimap.equal_range(stdmultimap.begin()->first);
+
+         if( boost::container::iterator_distance(bret.first, bret.second) !=
+               boost::container::iterator_distance(sret.first, sret.second) ){
+            return 1;
+         }
+      }
+      {
+         IntType i1(i);
+         boostmap.insert(boostmap.upper_bound(boost::move(i1)), boost::move(intpair));
+         stdmap.insert(stdmap.upper_bound(i), StdPairType(i, i));
+      }
+      //PrintContainers(boostmap, stdmap);
+      {
+         IntType i1(i);
+         IntType i2(i);
+         new(&intpair)IntPairType(boost::move(i1), boost::move(i2));
+      }
+      {
+         IntType i1(i);
+         boostmultimap.insert(boostmultimap.upper_bound(boost::move(i1)), boost::move(intpair));
+         stdmultimap.insert(stdmultimap.upper_bound(i), StdPairType(i, i));
+      }
+      //PrintContainers(boostmultimap, stdmultimap);
+      if(!CheckEqualPairContainers(boostmap, stdmap))
+         return 1;
+      if(!CheckEqualPairContainers(boostmultimap, stdmultimap))
+         return 1;
+
+      map_test_rebalanceable(boostmap
+         , dtl::bool_<has_member_rebalance<MyBoostMap>::value>());
+      if(!CheckEqualContainers(boostmap, stdmap)){
+         std::cout << "Error in boostmap.rebalance()" << std::endl;
+         return 1;
+      }
+      map_test_rebalanceable(boostmultimap
+         , dtl::bool_<has_member_rebalance<MyBoostMap>::value>());
+      if(!CheckEqualContainers(boostmultimap, stdmultimap)){
+         std::cout << "Error in boostmultimap.rebalance()" << std::endl;
+         return 1;
+      }
+   }
+   return 0;
+}
+
+
+template<class MyBoostMap
+        , class MyStdMap
+        , class MyBoostMultiMap
+        , class MyStdMultiMap>
+int map_test_search(MyBoostMap &boostmap, MyStdMap &stdmap, MyBoostMultiMap &boostmultimap, MyStdMultiMap &stdmultimap)
+{
+   typedef typename MyBoostMap::key_type    IntType;
+   typedef dtl::pair<IntType, IntType>         IntPairType;
+
+   //Compare count/contains with std containers
+   for(int i = 0; i < MaxElem; ++i){
+      IntType k(i);
+      if(boostmap.count(k) != stdmap.count(i)){
+         return -1;
+      }
+
+      if(boostmap.contains(k) != (stdmap.find(i) != stdmap.end())){
+         return -1;
+      }
+
+      if(boostmultimap.count(k) != stdmultimap.count(i)){
+         return -1;
+      }
+
+      if(boostmultimap.contains(k) != (stdmultimap.find(i) != stdmultimap.end())){
+         return -1;
+      }
+   }
+
+   {
+      //Now do count exercise
+      boostmap.erase(boostmap.begin(), boostmap.end());
+      boostmultimap.erase(boostmultimap.begin(), boostmultimap.end());
+      boostmap.clear();
+      boostmultimap.clear();
+
+      for(int j = 0; j < 3; ++j)
+      for(int i = 0; i < 100; ++i){
+         IntPairType intpair;
+         {
+         IntType i1(i), i2(i);
+         new(&intpair)IntPairType(boost::move(i1), boost::move(i2));
+         }
+         boostmap.insert(boost::move(intpair));
+         {
+            IntType i1(i), i2(i);
+            new(&intpair)IntPairType(boost::move(i1), boost::move(i2));
+         }
+         boostmultimap.insert(boost::move(intpair));
+         IntType k(i);
+         if(boostmap.count(k) != typename MyBoostMultiMap::size_type(1))
+            return 1;
+         if(boostmultimap.count(k) != typename MyBoostMultiMap::size_type(j+1))
+            return 1;
+      }
+   }
+
+   return 0;
+}
+
+template<class MyBoostMap
+        , class MyStdMap
+        , class MyBoostMultiMap
+        , class MyStdMultiMap>
+int map_test_indexing(MyBoostMap &boostmap, MyStdMap &stdmap, MyBoostMultiMap &boostmultimap, MyStdMultiMap &stdmultimap)
+{
+   typedef typename MyBoostMap::key_type    IntType;
+   typedef dtl::pair<IntType, IntType>         IntPairType;
+
+   {  //operator[] test
+      boostmap.clear();
+      boostmultimap.clear();
+      stdmap.clear();
+      stdmultimap.clear();
+
+      IntPairType aux_vect[MaxElem];
+      for(int i = 0; i < MaxElem; ++i){
+         IntType i1(i);
+         IntType i2(i);
+         new(&aux_vect[i])IntPairType(boost::move(i1), boost::move(i2));
+      }
+
+      for(int i = 0; i < MaxElem; ++i){
+         boostmap[boost::move(aux_vect[i].first)] = boost::move(aux_vect[i].second);
+         stdmap[i] = i;
+      }
+
+      if(!CheckEqualPairContainers(boostmap, stdmap)) return 1;
+      if(!CheckEqualPairContainers(boostmultimap, stdmultimap)) return 1;
+   }
+   return 0;
+}
+
+template< class MyBoostMap, class StdMap, class MaybeMove>
+int map_test_insert_or_assign_impl()
+{
+   typedef typename MyBoostMap::key_type     IntType;
+   typedef dtl::pair<IntType, IntType>       IntPairType;
+   typedef typename MyBoostMap::iterator     Biterator;
+   typedef std::pair<Biterator, bool>        Bpair;
+
+   MaybeMove maybe_move;
+
+   {  //insert_or_assign test
+      MyBoostMap boostmap;
+      StdMap stdmap;
+      IntPairType aux_vect[MaxElem];
+      for(int i = 0; i < MaxElem; ++i){
+         IntType i1(i);
+         IntType i2(MaxElem-i);
+         new(&aux_vect[i])IntPairType(maybe_move(i1), maybe_move(i2));
+      }
+
+      IntPairType aux_vect2[MaxElem];
+      for(int i = 0; i < MaxElem; ++i){
+         IntType i1(i);
+         IntType i2(i);
+         new(&aux_vect2[i])IntPairType(maybe_move(i1), maybe_move(i2));
+      }
+
+      for(int i = 0; i < MaxElem; ++i){
+         Bpair r = boostmap.insert_or_assign(maybe_move(aux_vect[i].first), maybe_move(aux_vect[i].second));
+         stdmap[i] = MaxElem-i;
+         if(!r.second)
+            return 1;
+         const IntType key(i);
+         if(r.first->first != key)
+            return 1;
+         const IntType mapped(MaxElem-i);
+         if(r.first->second != mapped)
+            return 1;
+      }
+
+      if(!CheckEqualPairContainers(boostmap, stdmap)) return 1;
+
+      for(int i = 0; i < MaxElem; ++i){
+         Bpair r = boostmap.insert_or_assign(maybe_move(aux_vect2[i].first), maybe_move(aux_vect2[i].second));
+         stdmap[i] = i;
+         if(r.second)
+            return 1;
+         const IntType key(i);
+         if(r.first->first != key)
+            return 1;
+         const IntType mapped(i);
+         if(r.first->second != mapped)
+            return 1;
+      }
+
+      if(!CheckEqualPairContainers(boostmap, stdmap)) return 1;
+   }
+   {  //insert_or_assign test with hint
+      MyBoostMap boostmap;
+      StdMap stdmap;
+      IntPairType aux_vect[MaxElem];
+      for(int i = 0; i < MaxElem; ++i){
+         IntType i1(i);
+         IntType i2(MaxElem-i);
+         new(&aux_vect[i])IntPairType(maybe_move(i1), maybe_move(i2));
+      }
+
+      IntPairType aux_vect2[MaxElem];
+      for(int i = 0; i < MaxElem; ++i){
+         IntType i1(i);
+         IntType i2(i);
+         new(&aux_vect2[i])IntPairType(maybe_move(i1), maybe_move(i2));
+      }
+
+      for(int i = 0; i < MaxElem; ++i){
+         Biterator r = boostmap.insert_or_assign(boostmap.end(), maybe_move(aux_vect[i].first), maybe_move(aux_vect[i].second));
+         stdmap[i] = MaxElem-i;
+         const IntType key(i);
+         if(r->first != key)
+            return 1;
+         const IntType mapped(MaxElem-i);
+         if(r->second != mapped)
+            return 1;
+      }
+
+      if(!CheckEqualPairContainers(boostmap, stdmap)) return 1;
+
+      for(int i = 0; i < MaxElem; ++i){
+         Biterator r = boostmap.insert_or_assign(boostmap.end(), maybe_move(aux_vect2[i].first), maybe_move(aux_vect2[i].second));
+         stdmap[i] = i;
+         const IntType key(i);
+         if(r->first != key)
+            return 1;
+         const IntType mapped(i);
+         if(r->second != mapped)
+            return 1;
+      }
+
+      if(!CheckEqualPairContainers(boostmap, stdmap)) return 1;
+   }
+   return 0;
+}
+
+template< class MyBoostMap, class StdMap>
+int map_test_insert_or_assign(dtl::bool_<false> )//noncopyable
+{
+   return map_test_insert_or_assign_impl<MyBoostMap, StdMap, move_op>();
+}
+
+template< class MyBoostMap, class StdMap>
+int map_test_insert_or_assign(dtl::bool_<true> )//copyable
+{
+   int r = map_test_insert_or_assign_impl<MyBoostMap, StdMap, const_ref_op>();
+   if (r)
+      r = map_test_insert_or_assign_impl<MyBoostMap, StdMap, move_op>();
+   return r;
+}
+
+template< class MyBoostMap
+        , class MyStdMap
+        , class MyBoostMultiMap
+        , class MyStdMultiMap>
+int map_test_try_emplace(MyBoostMap &boostmap, MyStdMap &stdmap, MyBoostMultiMap &boostmultimap, MyStdMultiMap &stdmultimap)
+{
+   typedef typename MyBoostMap::key_type    IntType;
+   typedef dtl::pair<IntType, IntType>         IntPairType;
+
+   {  //try_emplace
+      boostmap.clear();
+      boostmultimap.clear();
+      stdmap.clear();
+      stdmultimap.clear();
+
+      IntPairType aux_vect[MaxElem];
+      for(int i = 0; i < MaxElem; ++i){
+         IntType i1(i);
+         IntType i2(i);
+         new(&aux_vect[i])IntPairType(boost::move(i1), boost::move(i2));
+      }
+
+      IntPairType aux_vect2[MaxElem];
+      for(int i = 0; i < MaxElem; ++i){
+         IntType i1(i);
+         IntType i2(MaxElem-i);
+         new(&aux_vect2[i])IntPairType(boost::move(i1), boost::move(i2));
+      }
+
+      typedef typename MyBoostMap::iterator iterator;
+      for(int i = 0; i < MaxElem; ++i){
+         iterator it;
+         if(i&1){
+            std::pair<typename MyBoostMap::iterator, bool> ret =
+               boostmap.try_emplace(boost::move(aux_vect[i].first), boost::move(aux_vect[i].second));
+            if(!ret.second)
+               return 1;
+            it = ret.first;
+         }
+         else{
+            it = boostmap.try_emplace
+               (boostmap.upper_bound(aux_vect[i].first), boost::move(aux_vect[i].first), boost::move(aux_vect[i].second));
+         }
+         if(boostmap.end() == it || it->first != aux_vect2[i].first || it->second != aux_vect2[i].first){
+            return 1;
+         }
+         stdmap[i] = i;
+      }
+
+      if(!CheckEqualPairContainers(boostmap, stdmap)) return 1;
+      if(!CheckEqualPairContainers(boostmultimap, stdmultimap)) return 1;
+
+      for(int i = 0; i < MaxElem; ++i){
+         iterator it;
+         iterator itex = boostmap.find(aux_vect2[i].first);
+         if(itex == boostmap.end())
+            return 1;
+         if(i&1){
+            std::pair<typename MyBoostMap::iterator, bool> ret =
+               boostmap.try_emplace(boost::move(aux_vect2[i].first), boost::move(aux_vect2[i].second));
+            if(ret.second)
+               return 1;
+            it = ret.first;
+         }
+         else{
+            it = boostmap.try_emplace
+               (boostmap.upper_bound(aux_vect2[i].first), boost::move(aux_vect2[i].first), boost::move(aux_vect2[i].second));
+         }
+         const IntType test_int(i);
+         if(boostmap.end() == it || it != itex || it->second != test_int){
+            return 1;
+         }
+      }
+
+      if(!CheckEqualPairContainers(boostmap, stdmap)) return 1;
+      if(!CheckEqualPairContainers(boostmultimap, stdmultimap)) return 1;
+   }
+   return 0;
+}
+
+
+template< class MyBoostMap
+        , class MyStdMap
+        , class MyBoostMultiMap
+        , class MyStdMultiMap>
+int map_test_merge(MyBoostMap &boostmap, MyStdMap &stdmap, MyBoostMultiMap &boostmultimap, MyStdMultiMap &stdmultimap)
+{
+   typedef typename MyBoostMap::key_type    IntType;
+   typedef dtl::pair<IntType, IntType>         IntPairType;
+   typedef typename MyStdMap::value_type  StdPairType;
+   
+   {  //merge
+      ::boost::movelib::unique_ptr<MyBoostMap> const pboostmap2 = ::boost::movelib::make_unique<MyBoostMap>();
+      ::boost::movelib::unique_ptr<MyBoostMultiMap> const pboostmultimap2 = ::boost::movelib::make_unique<MyBoostMultiMap>();
+
+      MyBoostMap &boostmap2 = *pboostmap2;
+      MyBoostMultiMap &boostmultimap2 = *pboostmultimap2;
+
+      boostmap.clear();
+      boostmap2.clear();
+      boostmultimap.clear();
+      boostmultimap2.clear();
+      stdmap.clear();
+      stdmultimap.clear();
+
+      {
+         IntPairType aux_vect[MaxElem];
+         for(int i = 0; i < MaxElem; ++i){
+            IntType i1(i);
+            IntType i2(i);
+            new(&aux_vect[i])IntPairType(boost::move(i1), boost::move(i2));
+         }
+
+         IntPairType aux_vect2[MaxElem];
+         for(int i = 0; i < MaxElem; ++i){
+            IntType i1(MaxElem/2+i);
+            IntType i2(MaxElem-i);
+            new(&aux_vect2[i])IntPairType(boost::move(i1), boost::move(i2));
+         }
+         IntPairType aux_vect3[MaxElem];
+         for(int i = 0; i < MaxElem; ++i){
+            IntType i1(MaxElem*2/2+i);
+            IntType i2(MaxElem*2+i);
+            new(&aux_vect3[i])IntPairType(boost::move(i1), boost::move(i2));
+         }
+         boostmap.insert(boost::make_move_iterator(&aux_vect[0]), boost::make_move_iterator(&aux_vect[0] + MaxElem));
+         boostmap2.insert(boost::make_move_iterator(&aux_vect2[0]), boost::make_move_iterator(&aux_vect2[0] + MaxElem));
+         boostmultimap2.insert(boost::make_move_iterator(&aux_vect3[0]), boost::make_move_iterator(&aux_vect3[0] + MaxElem));
+      }
+      for(int i = 0; i < MaxElem; ++i){
+         stdmap.insert(StdPairType(i, i));
+      }
+      for(int i = 0; i < MaxElem; ++i){
+         stdmap.insert(StdPairType(MaxElem/2+i, MaxElem-i));
+      }
+
+      boostmap.merge(boost::move(boostmap2));
+      if(!CheckEqualPairContainers(boostmap, stdmap)) return 1;
+
+      for(int i = 0; i < MaxElem; ++i){
+         stdmap.insert(StdPairType(MaxElem*2/2+i, MaxElem*2+i));
+      }
+
+      boostmap.merge(boost::move(boostmultimap2));
+      if(!CheckEqualPairContainers(boostmap, stdmap)) return 1;
+
+      boostmap.clear();
+      boostmap2.clear();
+      boostmultimap.clear();
+      boostmultimap2.clear();
+      stdmap.clear();
+      stdmultimap.clear();
+      {
+         IntPairType aux_vect[MaxElem];
+         for(int i = 0; i < MaxElem; ++i){
+            IntType i1(i);
+            IntType i2(i);
+            new(&aux_vect[i])IntPairType(boost::move(i1), boost::move(i2));
+         }
+
+         IntPairType aux_vect2[MaxElem];
+         for(int i = 0; i < MaxElem; ++i){
+            IntType i1(MaxElem/2+i);
+            IntType i2(MaxElem-i);
+            new(&aux_vect2[i])IntPairType(boost::move(i1), boost::move(i2));
+         }
+         IntPairType aux_vect3[MaxElem];
+         for(int i = 0; i < MaxElem; ++i){
+            IntType i1(MaxElem*2/2+i);
+            IntType i2(MaxElem*2+i);
+            new(&aux_vect3[i])IntPairType(boost::move(i1), boost::move(i2));
+         }
+         boostmultimap.insert(boost::make_move_iterator(&aux_vect[0]), boost::make_move_iterator(&aux_vect[0] + MaxElem));
+         boostmultimap2.insert(boost::make_move_iterator(&aux_vect2[0]), boost::make_move_iterator(&aux_vect2[0] + MaxElem));
+         boostmap2.insert(boost::make_move_iterator(&aux_vect3[0]), boost::make_move_iterator(&aux_vect3[0] + MaxElem));
+      }
+      for(int i = 0; i < MaxElem; ++i){
+         stdmultimap.insert(StdPairType(i, i));
+      }
+      for(int i = 0; i < MaxElem; ++i){
+         stdmultimap.insert(StdPairType(MaxElem/2+i, MaxElem-i));
+      }
+      boostmultimap.merge(boostmultimap2);
+      if(!CheckEqualPairContainers(boostmultimap, stdmultimap)) return 1;
+
+      for(int i = 0; i < MaxElem; ++i){
+         stdmultimap.insert(StdPairType(MaxElem*2/2+i, MaxElem*2+i));
+      }
+
+      boostmultimap.merge(boostmap2);
+      if(!CheckEqualPairContainers(boostmultimap, stdmultimap)) return 1;
+   }
+   return 0;
+}
+
+
+template<class MyBoostMap
+        ,class MyStdMap
+        ,class MyBoostMultiMap
+        ,class MyStdMultiMap>
+int map_test()
+{
+   typedef typename MyBoostMap::key_type    IntType;
+
+   if(map_test_range<MyBoostMap, MyStdMap, MyBoostMultiMap, MyStdMultiMap>())
+      return 1;
+
+   ::boost::movelib::unique_ptr<MyBoostMap> const pboostmap = ::boost::movelib::make_unique<MyBoostMap>();
+   ::boost::movelib::unique_ptr<MyStdMap> const pstdmap = ::boost::movelib::make_unique<MyStdMap>();
+   ::boost::movelib::unique_ptr<MyBoostMultiMap> const pboostmultimap = ::boost::movelib::make_unique<MyBoostMultiMap>();
+   ::boost::movelib::unique_ptr<MyStdMultiMap> const pstdmultimap = ::boost::movelib::make_unique<MyStdMultiMap>();
+   MyBoostMap &boostmap = *pboostmap;
+   MyStdMap   &stdmap   = *pstdmap;
+   MyBoostMultiMap &boostmultimap = *pboostmultimap;
+   MyStdMultiMap   &stdmultimap   = *pstdmultimap;
+   typedef dtl::bool_<boost::container::test::is_copyable<IntType>::value> copyable_t;
+
+   if (map_test_step(boostmap, stdmap, boostmultimap, stdmultimap))
+      return 1;
+
+   if (map_test_insert(boostmap, stdmap, boostmultimap, stdmultimap))
+      return 1;
+
+   if (map_test_erase(boostmap, stdmap, boostmultimap, stdmultimap))
+      return 1;
+
+   if (map_test_insert2(boostmap, stdmap, boostmultimap, stdmultimap))
+      return 1;
+
+   if (map_test_search(boostmap, stdmap, boostmultimap, stdmultimap))
+      return 1;
+
+   if (map_test_indexing(boostmap, stdmap, boostmultimap, stdmultimap))
+      return 1;
+
+   if (map_test_try_emplace(boostmap, stdmap, boostmultimap, stdmultimap))
+      return 1;
+
+   if (map_test_merge(boostmap, stdmap, boostmultimap, stdmultimap))
+      return 1;
+
+   if (map_test_insert_or_assign<MyBoostMap, MyStdMap>(copyable_t()))
+      return 1;
+
+   if(map_test_copyable<MyBoostMap, MyStdMap, MyBoostMultiMap, MyStdMultiMap>(copyable_t()))
+      return 1;
+   return 0;
+}
+
+template<typename MapType>
+bool test_map_support_for_initialization_list_for()
+{
+#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
+   const std::initializer_list<std::pair<typename MapType::value_type::first_type, typename MapType::mapped_type>> il
+      = { std::make_pair(1, 2), std::make_pair(3, 4) };
+
+   const MapType expected_map(il.begin(), il.end());
+   {
+      const MapType sil = il;
+      if (sil != expected_map)
+         return false;
+
+      MapType sila(il, typename MapType::allocator_type());
+      if (sila != expected_map)
+         return false;
+
+      MapType silca(il, typename MapType::key_compare(), typename MapType::allocator_type());
+      if (silca != expected_map)
+         return false;
+
+      const MapType sil_ordered(ordered_unique_range, il);
+      if (sil_ordered != expected_map)
+         return false;
+
+      MapType sil_assign = { std::make_pair(99, 100) };
+      sil_assign = il;
+      if (sil_assign != expected_map)
+         return false;
+   }
+   {
+      MapType sil;
+      sil.insert(il);
+      if (sil != expected_map)
+         return false;
+   }
+   return true;
+#endif
+   return true;
+}
+
+template<typename MapType, typename MultimapType>
+bool instantiate_constructors()
+{
+   {
+      typedef typename MapType::value_type value_type;
+      typename MapType::key_compare comp;
+      typename MapType::allocator_type a;
+      value_type value;
+      {
+         MapType s0;
+         MapType s1(comp);
+         MapType s2(a);
+         MapType s3(comp, a);
+      }
+      {
+         MapType s0(&value, &value);
+         MapType s1(&value, &value ,comp);
+         MapType s2(&value, &value ,a);
+         MapType s3(&value, &value ,comp, a);
+      }
+      #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
+      {
+         std::initializer_list<value_type> il;
+         MapType s0(il);
+         MapType s1(il, comp);
+         MapType s2(il, a);
+         MapType s3(il, comp, a);
+      }
+      {
+         std::initializer_list<value_type> il;
+         MapType s0(ordered_unique_range, il);
+         MapType s1(ordered_unique_range, il, comp);
+         MapType s3(ordered_unique_range, il, comp, a);
+      }
+      #endif
+      {
+         MapType s0(ordered_unique_range, &value, &value);
+         MapType s1(ordered_unique_range, &value, &value ,comp);
+         MapType s2(ordered_unique_range, &value, &value ,comp, a);
+      }
+   }
+
+   {
+      typedef typename MultimapType::value_type value_type;
+      typename MultimapType::key_compare comp;
+      typename MultimapType::allocator_type a;
+      value_type value;
+      {
+         MultimapType s0;
+         MultimapType s1(comp);
+         MultimapType s2(a);
+         MultimapType s3(comp, a);
+      }
+      {
+         MultimapType s0(&value, &value);
+         MultimapType s1(&value, &value ,comp);
+         MultimapType s2(&value, &value ,a);
+         MultimapType s3(&value, &value ,comp, a);
+      }
+      #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
+      {
+         std::initializer_list<value_type> il;
+         MultimapType s0(il);
+         MultimapType s1(il, comp);
+         MultimapType s2(il, a);
+         MultimapType s3(il, comp, a);
+      }
+      {
+         std::initializer_list<value_type> il;
+         MultimapType s0(ordered_range, il);
+         MultimapType s1(ordered_range, il, comp);
+         MultimapType s3(ordered_range, il, comp, a);
+      }
+      #endif
+      {
+         MultimapType s0(ordered_range, &value, &value);
+         MultimapType s1(ordered_range, &value, &value ,comp);
+         MultimapType s2(ordered_range, &value, &value ,comp, a);
+      }
+   }
+   return true;
+}
+
+}  //namespace test{
+}  //namespace container {
+}  //namespace boost{
+
+#include <boost/container/detail/config_end.hpp>
+
+#endif   //#ifndef BOOST_CONTAINER_TEST_MAP_TEST_HEADER
diff --git a/src/boost/libs/container/test/memory_resource_logger.hpp b/src/boost/libs/container/test/memory_resource_logger.hpp
new file mode 100644
index 000000000..e8bc405b8
--- /dev/null
+++ b/src/boost/libs/container/test/memory_resource_logger.hpp
@@ -0,0 +1,86 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2015-2015. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/container for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#ifndef BOOST_CONTAINER_TEST_MEMORY_RESOURCE_TESTER_HPP
+#define BOOST_CONTAINER_TEST_MEMORY_RESOURCE_TESTER_HPP
+
+#include <boost/container/pmr/memory_resource.hpp>
+#include <boost/container/vector.hpp>
+#include <cstdlib>
+
+class memory_resource_logger
+   : public boost::container::pmr::memory_resource
+{
+   public:
+   struct allocation_info
+   {
+      char *address;
+      std::size_t bytes;
+      std::size_t alignment;
+   };
+
+   boost::container::vector<allocation_info> m_info;
+   unsigned m_mismatches;
+
+   explicit memory_resource_logger()
+      : m_info()
+      , m_mismatches()
+   {}
+
+   virtual ~memory_resource_logger()
+   {  this->reset();  }
+
+   virtual void* do_allocate(std::size_t bytes, std::size_t alignment)
+   {
+      char *addr =(char*)std::malloc(bytes);
+      if(!addr){
+         throw std::bad_alloc();
+      }
+      allocation_info info;
+      info.address   = addr;
+      info.bytes     = bytes;
+      info.alignment = alignment;
+      m_info.push_back(info);
+      return addr;
+   }
+
+   virtual void do_deallocate(void* p, std::size_t bytes, std::size_t alignment)
+   {
+      std::size_t i = 0, max = m_info.size();
+      while(i != max && m_info[i].address != p){
+         ++i;
+      }
+      if(i == max){
+         ++m_mismatches;
+      }
+      else{
+         const allocation_info &info = m_info[i];
+         m_mismatches += info.bytes != bytes || info.alignment != alignment;
+         std::free(p);
+         m_info.erase(m_info.nth(i));
+      }
+   }
+
+   virtual bool do_is_equal(const boost::container::pmr::memory_resource& other) const BOOST_NOEXCEPT
+   {
+      return static_cast<const memory_resource *>(this) == &other;
+   }
+
+   void reset()
+   {
+      while(!m_info.empty()){
+         std::free(m_info.back().address);
+         m_info.pop_back();
+      }
+      m_mismatches = 0u;
+   }
+};
+
+#endif   //#ifndef BOOST_CONTAINER_TEST_MEMORY_RESOURCE_TESTER_HPP
diff --git a/src/boost/libs/container/test/memory_resource_test.cpp b/src/boost/libs/container/test/memory_resource_test.cpp
new file mode 100644
index 000000000..4c4cb511b
--- /dev/null
+++ b/src/boost/libs/container/test/memory_resource_test.cpp
@@ -0,0 +1,135 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2015-2015. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/container for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+#include <boost/container/pmr/memory_resource.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <boost/core/no_exceptions_support.hpp>
+#include "derived_from_memory_resource.hpp"
+
+#include <cstdlib>
+
+using namespace boost::container;
+using namespace boost::container::pmr;
+
+void test_allocate()
+{
+   derived_from_memory_resource d;
+   memory_resource &mr = d;
+
+   d.reset();
+   BOOST_TEST(d.do_allocate_called == false);
+   BOOST_TEST(d.do_allocate_bytes == 0);
+   BOOST_TEST(d.do_allocate_alignment == 0);
+
+   mr.allocate(2, 4);
+   BOOST_TEST(d.do_allocate_called == true);
+   BOOST_TEST(d.do_allocate_bytes == 2);
+   BOOST_TEST(d.do_allocate_alignment == 4);
+}
+
+void test_deallocate()
+{
+   derived_from_memory_resource d;
+   memory_resource &mr = d;
+
+   d.reset();
+   BOOST_TEST(d.do_deallocate_called == false);
+   BOOST_TEST(d.do_deallocate_p == 0);
+   BOOST_TEST(d.do_allocate_bytes == 0);
+   BOOST_TEST(d.do_allocate_alignment == 0);
+
+   mr.deallocate(&d, 2, 4);
+   BOOST_TEST(d.do_deallocate_called == true);
+   BOOST_TEST(d.do_deallocate_p == &d);
+   BOOST_TEST(d.do_deallocate_bytes == 2);
+   BOOST_TEST(d.do_deallocate_alignment == 4);
+}
+
+void test_destructor()
+{
+   {
+   derived_from_memory_resource d;
+   d.reset();
+   BOOST_TEST(derived_from_memory_resource::destructor_called == false);
+   }
+   BOOST_TEST(derived_from_memory_resource::destructor_called == true);
+}
+
+void test_is_equal()
+{
+   derived_from_memory_resource d;
+   memory_resource &mr = d;
+
+   d.reset();
+   BOOST_TEST(d.do_is_equal_called == false);
+   BOOST_TEST(d.do_is_equal_other == 0);
+
+   mr.is_equal(d);
+   BOOST_TEST(d.do_is_equal_called == true);
+   BOOST_TEST(d.do_is_equal_other == &d);
+}
+
+void test_equality_operator()
+{
+   derived_from_memory_resource d;
+   memory_resource &mr = d;
+
+   d.reset();
+   BOOST_TEST(d.do_is_equal_called == false);
+   BOOST_TEST(d.do_is_equal_other == 0);
+
+   //equal addresses are shorcircuited
+   BOOST_TEST((mr == mr) == true);
+   BOOST_TEST(d.do_is_equal_called == false);
+   BOOST_TEST(d.do_is_equal_other == 0);
+
+   //unequal addresses are dispatched to is_equal which in turn calls do_is_equal
+   derived_from_memory_resource d2(1);
+   d.reset();
+   d2.reset();
+   memory_resource &mr2 = d2;
+   BOOST_TEST((mr == mr2) == false);
+   BOOST_TEST(d.do_is_equal_called == true);
+   BOOST_TEST(d.do_is_equal_other == &d2);
+}
+
+void test_inequality_operator()
+{
+   derived_from_memory_resource d;
+   memory_resource &mr = d;
+
+   d.reset();
+   BOOST_TEST(d.do_is_equal_called == false);
+   BOOST_TEST(d.do_is_equal_other == 0);
+
+   //equal addresses are shorcircuited
+   BOOST_TEST((mr != mr) == false);
+   BOOST_TEST(d.do_is_equal_called == false);
+   BOOST_TEST(d.do_is_equal_other == 0);
+
+   //unequal addresses are dispatched to is_equal which in turn calls do_is_equal
+   derived_from_memory_resource d2(1);
+   d.reset();
+   d2.reset();
+   memory_resource &mr2 = d2;
+   BOOST_TEST((mr != mr2) == true);
+   BOOST_TEST(d.do_is_equal_called == true);
+   BOOST_TEST(d.do_is_equal_other == &d2);
+}
+
+int main()
+{
+   test_destructor();
+   test_allocate();
+   test_deallocate();
+   test_is_equal();
+   test_equality_operator();
+   test_inequality_operator();
+   return ::boost::report_errors();
+}
diff --git a/src/boost/libs/container/test/monotonic_buffer_resource_test.cpp b/src/boost/libs/container/test/monotonic_buffer_resource_test.cpp
new file mode 100644
index 000000000..4923e2460
--- /dev/null
+++ b/src/boost/libs/container/test/monotonic_buffer_resource_test.cpp
@@ -0,0 +1,483 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2015-2015. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/container for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#include <boost/container/pmr/monotonic_buffer_resource.hpp>
+#include <boost/container/pmr/global_resource.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include "derived_from_memory_resource.hpp"
+#include "memory_resource_logger.hpp"
+
+using namespace boost::container::pmr;
+
+static const std::size_t AllocCount = 32u;
+
+namespace test_block_chain{
+
+//explicit block_slist(memory_resource &upstream_rsrc)
+void test_constructor()
+{
+   memory_resource_logger mrl;
+   block_slist bc(mrl);
+   //Resource stored
+   BOOST_TEST(&bc.upstream_resource() == &mrl);
+   //No allocation performed
+   BOOST_TEST(mrl.m_info.size() == 0u);
+}
+
+//void *allocate(std::size_t size)
+void test_allocate()
+{
+   memory_resource_logger mrl;
+   block_slist bc(mrl);
+
+   for(unsigned i = 0; i != unsigned(AllocCount); ++i){
+      //Allocate and trace data
+      const std::size_t alloc    = i+1;
+      char *const addr           = (char*)bc.allocate(alloc);
+      //Should have allocated a new entry
+      BOOST_TEST(mrl.m_info.size() == (i+1));
+      //Requested size must be bigger to include metadata
+      BOOST_TEST(mrl.m_info[i].bytes > alloc);
+      BOOST_TEST(mrl.m_info[i].alignment == memory_resource::max_align);
+      //Returned address should be between the allocated buffer
+      BOOST_TEST(mrl.m_info[i].address < addr);
+      BOOST_TEST(addr < (mrl.m_info[i].address + mrl.m_info[i].bytes));
+      //Allocate size should include all requested size
+      BOOST_TEST((addr + alloc) <= (mrl.m_info[i].address + mrl.m_info[i].bytes));
+      //Allocation must be max-aligned
+      BOOST_TEST((std::size_t(addr) % memory_resource::max_align) == 0);
+   }
+}
+
+//void release() BOOST_NOEXCEPT
+void test_release()
+{
+   memory_resource_logger mrl;
+   block_slist bc(mrl);
+
+   //Allocate and trace data
+   char *bufs[AllocCount];
+   for(unsigned i = 0; i != unsigned(AllocCount); ++i){
+      bufs[i]                    = (char*)bc.allocate(i+1);
+   }
+   (void)bufs;
+   //Should have allocated a new entry
+   BOOST_TEST(mrl.m_info.size() == AllocCount);
+
+   //Now release and check all allocations match deallocations
+   bc.release();
+   BOOST_TEST(mrl.m_mismatches == 0);
+   BOOST_TEST(mrl.m_info.size() == 0u);
+}
+
+//memory_resource* upstream_resource()
+void test_memory_resource()
+{
+   derived_from_memory_resource d;
+   block_slist bc(d);
+   //Resource stored
+   BOOST_TEST(&bc.upstream_resource() == &d);
+}
+
+//~block_slist()   {  this->release();  }
+void test_destructor()
+{
+   memory_resource_logger mrl;
+   {
+      block_slist bc(mrl);
+
+      //Allocate and trace data
+      char *bufs[AllocCount];
+      for(unsigned i = 0; i != unsigned(AllocCount); ++i){
+         bufs[i] = (char*)bc.allocate(i+1);
+      }
+      (void)bufs;
+      //Should have allocated a new entry
+      BOOST_TEST(mrl.m_info.size() == AllocCount);
+
+      //Destructor should release all memory
+   }
+   BOOST_TEST(mrl.m_mismatches == 0);
+   BOOST_TEST(mrl.m_info.size() == 0u);
+}
+
+}  //namespace test_block_chain {
+
+void test_resource_constructor()
+{
+   //First constructor, null resource
+   {
+      memory_resource_logger mrl;
+      BOOST_TEST(mrl.m_info.size() == 0u);
+      set_default_resource(&mrl);
+      monotonic_buffer_resource m;
+      //test postconditions
+      BOOST_TEST(m.upstream_resource() == get_default_resource());
+      //test it does not allocate any memory
+      BOOST_TEST(mrl.m_info.size() == 0u);
+      set_default_resource(0);
+   }
+   //First constructor, non-null resource
+   {
+      derived_from_memory_resource dmr;
+      dmr.reset();
+      monotonic_buffer_resource m(&dmr);
+      //test postconditions
+      BOOST_TEST(m.upstream_resource() == &dmr);
+      BOOST_TEST(m.next_buffer_size() == monotonic_buffer_resource::initial_next_buffer_size);
+      BOOST_TEST(m.current_buffer() == 0);
+      //test it does not allocate any memory
+      BOOST_TEST(dmr.do_allocate_called == false);
+   }
+}
+
+void test_initial_size_constructor()
+{
+   //Second constructor, null resource
+   const std::size_t initial_size = monotonic_buffer_resource::initial_next_buffer_size*2;
+   {
+      memory_resource_logger mrl;
+      BOOST_TEST(mrl.m_info.size() == 0u);
+      set_default_resource(&mrl);
+      monotonic_buffer_resource m(initial_size);
+      //test postconditions
+      BOOST_TEST(m.upstream_resource() == get_default_resource());
+      BOOST_TEST(m.next_buffer_size() >= initial_size);
+      BOOST_TEST(m.current_buffer() == 0);
+      //test it does not allocate any memory
+      BOOST_TEST(mrl.m_info.size() == 0u);
+      set_default_resource(0);
+   }
+   //Second constructor, non-null resource
+   {
+      derived_from_memory_resource dmr;
+      dmr.reset();
+      monotonic_buffer_resource m(initial_size, &dmr);
+      //test postconditions
+      BOOST_TEST(m.upstream_resource() == &dmr);
+      BOOST_TEST(m.next_buffer_size() >= initial_size);
+      BOOST_TEST(m.current_buffer() == 0);
+      //test it does not allocate any memory
+      BOOST_TEST(dmr.do_allocate_called == false);
+   }
+}
+
+void test_buffer_constructor()
+{
+   const std::size_t BufSz = monotonic_buffer_resource::initial_next_buffer_size*2;
+   unsigned char buf[BufSz];
+   //Third constructor, null resource
+   {
+      memory_resource_logger mrl;
+      BOOST_TEST(mrl.m_info.size() == 0u);
+      set_default_resource(&mrl);
+      monotonic_buffer_resource m(buf, BufSz);
+      //test postconditions
+      BOOST_TEST(m.upstream_resource() == get_default_resource());
+      BOOST_TEST(m.next_buffer_size() >= BufSz*2);
+      BOOST_TEST(m.current_buffer() == buf);
+      //test it does not allocate any memory
+      BOOST_TEST(mrl.m_info.size() == 0u);
+      set_default_resource(0);
+   }
+   //Third constructor, non-null resource
+   {
+      derived_from_memory_resource dmr;
+      dmr.reset();
+      monotonic_buffer_resource m(buf, sizeof(buf), &dmr);
+      //test postconditions
+      BOOST_TEST(m.upstream_resource() == &dmr);
+      BOOST_TEST(m.next_buffer_size() >= sizeof(buf)*2);
+      BOOST_TEST(m.current_buffer() == buf);
+      //test it does not allocate any memory
+      BOOST_TEST(dmr.do_allocate_called == false);
+   }
+   //Check for empty buffers
+   {
+      monotonic_buffer_resource m(buf, 0);
+      BOOST_TEST(m.upstream_resource() == get_default_resource());
+      BOOST_TEST(m.next_buffer_size() > 1);
+      BOOST_TEST(m.current_buffer() == buf);
+   }
+}
+
+struct derived_from_monotonic_buffer_resource
+   : public monotonic_buffer_resource
+{
+   explicit derived_from_monotonic_buffer_resource(memory_resource *p)
+      : monotonic_buffer_resource(p)
+   {}
+
+   explicit derived_from_monotonic_buffer_resource(std::size_t initial_size, memory_resource* upstream)
+      : monotonic_buffer_resource(initial_size, upstream)
+   {}
+
+   explicit derived_from_monotonic_buffer_resource(void* buffer, std::size_t buffer_size, memory_resource* upstream)
+      : monotonic_buffer_resource(buffer, buffer_size, upstream)
+   {}
+
+   using monotonic_buffer_resource::do_allocate;
+   using monotonic_buffer_resource::do_deallocate;
+   using monotonic_buffer_resource::do_is_equal;
+};
+
+void test_upstream_resource()
+{
+   //Allocate buffer first to avoid stack-use-after-scope in monotonic_buffer_resource's destructor
+   const std::size_t BufSz = monotonic_buffer_resource::initial_next_buffer_size;
+   boost::move_detail::aligned_storage<BufSz+block_slist::header_size>::type buf;
+   //Test stores the resource and uses it to allocate memory
+   derived_from_memory_resource dmr;
+   dmr.reset();
+   derived_from_monotonic_buffer_resource dmbr(&dmr);
+   //Resource must be stored and initial values given (no current buffer)
+   BOOST_TEST(dmbr.upstream_resource() == &dmr);
+   BOOST_TEST(dmbr.next_buffer_size() == monotonic_buffer_resource::initial_next_buffer_size);
+   BOOST_TEST(dmbr.current_buffer() == 0);
+   //Test it does not allocate any memory
+   BOOST_TEST(dmr.do_allocate_called == false);
+   //Now stub buffer storage it as the return buffer
+   //for "derived_from_memory_resource":
+   dmr.do_allocate_return = &buf;
+   //Test that allocation uses the upstream_resource()
+   void *addr = dmbr.do_allocate(1u, 1u);
+   //Test returns stubbed memory with the internal initial size plus metadata size
+   BOOST_TEST(addr > (char*)&buf);
+   BOOST_TEST(addr < (char*)(&buf+1));
+   BOOST_TEST(dmr.do_allocate_called == true);
+   BOOST_TEST(dmr.do_allocate_bytes > BufSz);
+   //Alignment for the resource must be max_align
+   BOOST_TEST(dmr.do_allocate_alignment == memory_resource::max_align);
+}
+
+void test_do_allocate()
+{
+   memory_resource_logger mrl;
+   {
+      std::size_t remaining_storage = 0u;
+      derived_from_monotonic_buffer_resource dmbr(&mrl);
+      //First test, no buffer
+      {
+         dmbr.do_allocate(1, 1);
+         //It should allocate initial size
+         BOOST_TEST(mrl.m_info.size() == 1u);
+         //... which requests the initial size plus the header size to the allcoator
+         BOOST_TEST(mrl.m_info[0].bytes == monotonic_buffer_resource::initial_next_buffer_size+block_slist::header_size);
+         std::size_t remaining = dmbr.remaining_storage(1u);
+         //Remaining storage should be one less than initial, as we requested 1 byte with minimal alignment
+         BOOST_TEST(remaining == monotonic_buffer_resource::initial_next_buffer_size-1u);
+         remaining_storage = remaining;
+      }
+      //Now ask for more internal storage with misaligned current buffer
+      {
+         //Test wasted space
+         std::size_t wasted_due_to_alignment;
+         dmbr.remaining_storage(4u, wasted_due_to_alignment);
+         BOOST_TEST(wasted_due_to_alignment == 3u);
+         dmbr.do_allocate(4, 4);
+         //It should not have allocated
+         BOOST_TEST(mrl.m_info.size() == 1u);
+         std::size_t remaining = dmbr.remaining_storage(1u);
+         //We wasted some bytes due to alignment plus 4 bytes of real storage
+         BOOST_TEST(remaining == remaining_storage - 4 - wasted_due_to_alignment);
+         remaining_storage = remaining;
+      }
+      //Now request the same alignment to test no storage is wasted
+      {
+         std::size_t wasted_due_to_alignment;
+         std::size_t remaining = dmbr.remaining_storage(1u, wasted_due_to_alignment);
+         BOOST_TEST(mrl.m_info.size() == 1u);
+         dmbr.do_allocate(4, 4);
+         //It should not have allocated
+         BOOST_TEST(mrl.m_info.size() == 1u);
+         remaining = dmbr.remaining_storage(1u);
+         //We wasted no bytes due to alignment plus 4 bytes of real storage
+         BOOST_TEST(remaining == remaining_storage - 4u);
+         remaining_storage = remaining;
+      }
+      //Now exhaust the remaining storage with 2 byte alignment (the last allocation
+      //was 4 bytes with 4 byte alignment) so it should be already 2-byte aligned.
+      {
+         dmbr.do_allocate(remaining_storage, 2);
+         std::size_t wasted_due_to_alignment;
+         std::size_t remaining = dmbr.remaining_storage(1u, wasted_due_to_alignment);
+         BOOST_TEST(wasted_due_to_alignment == 0u);
+         BOOST_TEST(remaining == 0u);
+         //It should not have allocated
+         BOOST_TEST(mrl.m_info.size() == 1u);
+         remaining_storage = 0u;
+      }
+      //The next allocation should trigger the upstream resource, even with a 1 byte
+      //allocation.
+      {
+         dmbr.do_allocate(1u, 1u);
+         BOOST_TEST(mrl.m_info.size() == 2u);
+         //The next allocation should be geometrically bigger.
+         BOOST_TEST(mrl.m_info[1].bytes == 2*monotonic_buffer_resource::initial_next_buffer_size+block_slist::header_size);
+         std::size_t wasted_due_to_alignment;
+         //For a 2 byte alignment one byte will be wasted from the previous 1 byte allocation
+         std::size_t remaining = dmbr.remaining_storage(2u, wasted_due_to_alignment);
+         BOOST_TEST(wasted_due_to_alignment == 1u);
+         BOOST_TEST(remaining == (mrl.m_info[1].bytes - 1u  - wasted_due_to_alignment - block_slist::header_size));
+         //It should not have allocated
+         remaining_storage = dmbr.remaining_storage(1u);
+      }
+      //Now try a bigger than next allocation and see if next_buffer_size is doubled.
+      {
+         std::size_t next_alloc = 5*monotonic_buffer_resource::initial_next_buffer_size;
+         dmbr.do_allocate(next_alloc, 1u);
+         BOOST_TEST(mrl.m_info.size() == 3u);
+         //The next allocation should be geometrically bigger.
+         BOOST_TEST(mrl.m_info[2].bytes == 8*monotonic_buffer_resource::initial_next_buffer_size+block_slist::header_size);
+         remaining_storage = dmbr.remaining_storage(1u);
+      }
+   }
+   //derived_from_monotonic_buffer_resource dmbr(&mrl) is destroyed
+   BOOST_TEST(mrl.m_mismatches == 0u);
+   BOOST_TEST(mrl.m_info.size() == 0u);
+
+   //Now use a local buffer
+   {
+      boost::move_detail::aligned_storage
+         <monotonic_buffer_resource::initial_next_buffer_size>::type buf;
+      //Supply an external buffer
+      derived_from_monotonic_buffer_resource dmbr(&buf, sizeof(buf), &mrl);
+      BOOST_TEST(dmbr.remaining_storage(1u) == sizeof(buf));
+      //Allocate all remaining storage
+      dmbr.do_allocate(dmbr.remaining_storage(1u), 1u);
+      //No new allocation should have occurred
+      BOOST_TEST(mrl.m_info.size() == 0u);
+      BOOST_TEST(dmbr.remaining_storage(1u) == 0u);
+   }
+   BOOST_TEST(mrl.m_mismatches == 0u);
+   BOOST_TEST(mrl.m_info.size() == 0u);
+}
+
+void test_do_deallocate()
+{
+   memory_resource_logger mrl;
+   const std::size_t initial_size = 1u;
+   {
+      derived_from_monotonic_buffer_resource dmbr(initial_size, &mrl);
+      //First test, no buffer
+      const unsigned iterations = 8;
+      char *bufs[iterations];
+      std::size_t sizes[iterations];
+      //Test each iteration allocates memory
+      for(unsigned i = 0; i != iterations; ++i)
+      {
+         sizes[i] = dmbr.remaining_storage()+1;
+         bufs[i]  = (char*)dmbr.do_allocate(sizes[i], 1);
+         BOOST_TEST(mrl.m_info.size() == (i+1));
+      }
+      std::size_t remaining = dmbr.remaining_storage();
+      //Test do_deallocate does not release any storage
+      for(unsigned i = 0; i != iterations; ++i)
+      {
+         dmbr.do_deallocate(bufs[i], sizes[i], 1u);
+         BOOST_TEST(mrl.m_info.size() == iterations);
+         BOOST_TEST(remaining == dmbr.remaining_storage());
+         BOOST_TEST(mrl.m_mismatches == 0u);
+      }
+   }
+}
+
+void test_do_is_equal()
+{
+   //! <b>Returns</b>:
+   //!   `this == dynamic_cast<const monotonic_buffer_resource*>(&other)`.
+   memory_resource_logger mrl;
+   derived_from_monotonic_buffer_resource dmbr(&mrl);
+   derived_from_monotonic_buffer_resource dmbr2(&mrl);
+   BOOST_TEST(true == dmbr.do_is_equal(dmbr));
+   BOOST_TEST(false == dmbr.do_is_equal(dmbr2));
+   //A different type should be always different
+   derived_from_memory_resource dmr;
+   BOOST_TEST(false == dmbr.do_is_equal(dmr));
+}
+
+void test_release()
+{
+   {
+      memory_resource_logger mrl;
+      const std::size_t initial_size = 1u;
+      derived_from_monotonic_buffer_resource dmbr(initial_size, &mrl);
+      //First test, no buffer
+      const unsigned iterations = 8;
+      //Test each iteration allocates memory
+      for(unsigned i = 0; i != iterations; ++i)
+      {
+         dmbr.do_allocate(dmbr.remaining_storage()+1, 1);
+         BOOST_TEST(mrl.m_info.size() == (i+1));
+      }
+      //Release and check memory was released
+      dmbr.release();
+      BOOST_TEST(mrl.m_mismatches == 0u);
+      BOOST_TEST(mrl.m_info.size() == 0u);
+   }
+   //Now use a local buffer
+   {
+      boost::move_detail::aligned_storage
+         <monotonic_buffer_resource::initial_next_buffer_size>::type buf;
+      //Supply an external buffer
+      monotonic_buffer_resource monr(&buf, sizeof(buf));
+      memory_resource &mr = monr;
+      BOOST_TEST(monr.remaining_storage(1u) == sizeof(buf));
+      //Allocate all remaining storage
+      mr.allocate(monr.remaining_storage(1u), 1u);
+      BOOST_TEST(monr.current_buffer() == ((char*)&buf + sizeof(buf)));
+      //No new allocation should have occurred
+      BOOST_TEST(monr.remaining_storage(1u) == 0u);
+      //Release and check memory was released and the original buffer is back
+      monr.release();
+      BOOST_TEST(monr.remaining_storage(1u) == sizeof(buf));
+      BOOST_TEST(monr.current_buffer() == &buf);
+   }
+}
+
+void test_destructor()
+{
+   memory_resource_logger mrl;
+   const std::size_t initial_size = 1u;
+   {
+      derived_from_monotonic_buffer_resource dmbr(initial_size, &mrl);
+      //First test, no buffer
+      const unsigned iterations = 8;
+      //Test each iteration allocates memory
+      for(unsigned i = 0; i != iterations; ++i)
+      {
+         dmbr.do_allocate(dmbr.remaining_storage()+1, 1);
+         BOOST_TEST(mrl.m_info.size() == (i+1));
+      }
+   }  //dmbr is destroyed, memory should be released
+   BOOST_TEST(mrl.m_mismatches == 0u);
+   BOOST_TEST(mrl.m_info.size() == 0u);
+}
+
+int main()
+{
+   test_block_chain::test_constructor();
+   test_block_chain::test_allocate();
+   test_block_chain::test_release();
+   test_block_chain::test_memory_resource();
+   test_block_chain::test_destructor();
+
+   test_resource_constructor();
+   test_initial_size_constructor();
+   test_buffer_constructor();
+
+   test_upstream_resource();
+   test_do_allocate();
+   test_do_deallocate();
+   test_do_is_equal();
+   test_release();
+   test_destructor();
+   return ::boost::report_errors();
+}
diff --git a/src/boost/libs/container/test/movable_int.hpp b/src/boost/libs/container/test/movable_int.hpp
new file mode 100644
index 000000000..c38146ecf
--- /dev/null
+++ b/src/boost/libs/container/test/movable_int.hpp
@@ -0,0 +1,437 @@
+///////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2006. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/container for documentation.
+//
+///////////////////////////////////////////////////////////////////////////
+
+#ifndef BOOST_CONTAINER_TEST_MOVABLE_INT_HEADER
+#define BOOST_CONTAINER_TEST_MOVABLE_INT_HEADER
+
+#include <boost/container/detail/config_begin.hpp>
+#include <boost/container/detail/workaround.hpp>
+#include <boost/move/utility_core.hpp>
+#include <ostream>
+#include <climits>
+#include <boost/assert.hpp>
+
+namespace boost {
+namespace container {
+namespace test {
+
+template<class T>
+struct is_copyable;
+
+template<>
+struct is_copyable<int>
+{
+   static const bool value = true;
+};
+
+
+class movable_int
+{
+   BOOST_MOVABLE_BUT_NOT_COPYABLE(movable_int)
+
+   public:
+
+   static unsigned int count;
+
+   movable_int()
+      :  m_int(0)
+   { ++count;  }
+
+   explicit movable_int(int a)
+      :  m_int(a)
+   {
+      //Disallow INT_MIN
+      BOOST_ASSERT(this->m_int != INT_MIN);
+      ++count;
+   }
+
+   movable_int(BOOST_RV_REF(movable_int) mmi)
+      :  m_int(mmi.m_int)
+   {  mmi.m_int = 0; ++count; }
+
+   movable_int & operator= (BOOST_RV_REF(movable_int) mmi)
+   {  this->m_int = mmi.m_int;   mmi.m_int = 0; return *this;  }
+
+   movable_int & operator= (int i)
+   {  this->m_int = i;  BOOST_ASSERT(this->m_int != INT_MIN); return *this;  }
+
+   ~movable_int()
+   {
+      //Double destructor called
+      BOOST_ASSERT(this->m_int != INT_MIN);
+      this->m_int = INT_MIN;
+      --count;
+   }
+
+   friend bool operator ==(const movable_int &l, const movable_int &r)
+   {  return l.m_int == r.m_int;   }
+
+   friend bool operator !=(const movable_int &l, const movable_int &r)
+   {  return l.m_int != r.m_int;   }
+
+   friend bool operator <(const movable_int &l, const movable_int &r)
+   {  return l.m_int < r.m_int;   }
+
+   friend bool operator <=(const movable_int &l, const movable_int &r)
+   {  return l.m_int <= r.m_int;   }
+
+   friend bool operator >=(const movable_int &l, const movable_int &r)
+   {  return l.m_int >= r.m_int;   }
+
+   friend bool operator >(const movable_int &l, const movable_int &r)
+   {  return l.m_int > r.m_int;   }
+
+   int get_int() const
+   {  return m_int;  }
+
+   friend bool operator==(const movable_int &l, int r)
+   {  return l.get_int() == r;   }
+
+   friend bool operator==(int l, const movable_int &r)
+   {  return l == r.get_int();   }
+
+   friend bool operator<(const movable_int &l, int r)
+   {  return l.get_int() < r;   }
+
+   friend bool operator<(int l, const movable_int &r)
+   {  return l < r.get_int();   }
+
+   friend std::size_t hash_value(const movable_int &v)
+   {  return (std::size_t)v.get_int(); }
+
+   private:
+   int m_int;
+};
+
+unsigned int movable_int::count = 0;
+
+inline movable_int produce_movable_int()
+{  return movable_int();  }
+
+template<class E, class T>
+std::basic_ostream<E, T> & operator<<
+   (std::basic_ostream<E, T> & os, movable_int const & p)
+
+{
+    os << p.get_int();
+    return os;
+}
+
+template<>
+struct is_copyable<movable_int>
+{
+   static const bool value = false;
+};
+
+class movable_and_copyable_int
+{
+   BOOST_COPYABLE_AND_MOVABLE(movable_and_copyable_int)
+
+   public:
+
+   static unsigned int count;
+
+   movable_and_copyable_int()
+      :  m_int(0)
+   { ++count; }
+
+   explicit movable_and_copyable_int(int a)
+      :  m_int(a)
+   {
+      //Disallow INT_MIN
+      BOOST_ASSERT(this->m_int != INT_MIN);
+      ++count;
+   }
+
+   movable_and_copyable_int(const movable_and_copyable_int& mmi)
+      :  m_int(mmi.m_int)
+   {  ++count; }
+
+   movable_and_copyable_int(BOOST_RV_REF(movable_and_copyable_int) mmi)
+      :  m_int(mmi.m_int)
+   {  mmi.m_int = 0; ++count; }
+
+   ~movable_and_copyable_int()
+   {
+      //Double destructor called
+      BOOST_ASSERT(this->m_int != INT_MIN);
+      this->m_int = INT_MIN;
+      --count;
+   }
+
+   movable_and_copyable_int &operator= (BOOST_COPY_ASSIGN_REF(movable_and_copyable_int) mi)
+   {  this->m_int = mi.m_int;    return *this;  }
+
+   movable_and_copyable_int & operator= (BOOST_RV_REF(movable_and_copyable_int) mmi)
+   {  this->m_int = mmi.m_int;   mmi.m_int = 0;    return *this;  }
+
+   movable_and_copyable_int & operator= (int i)
+   {  this->m_int = i;  BOOST_ASSERT(this->m_int != INT_MIN); return *this;  }
+
+   friend bool operator ==(const movable_and_copyable_int &l, const movable_and_copyable_int &r)
+   {  return l.m_int == r.m_int;   }
+
+   friend bool operator !=(const movable_and_copyable_int &l, const movable_and_copyable_int &r)
+   {  return l.m_int != r.m_int;   }
+
+   friend bool operator <(const movable_and_copyable_int &l, const movable_and_copyable_int &r)
+   {  return l.m_int < r.m_int;   }
+
+   friend bool operator <=(const movable_and_copyable_int &l, const movable_and_copyable_int &r)
+   {  return l.m_int <= r.m_int;   }
+
+   friend bool operator >=(const movable_and_copyable_int &l, const movable_and_copyable_int &r)
+   {  return l.m_int >= r.m_int;   }
+
+   friend bool operator >(const movable_and_copyable_int &l, const movable_and_copyable_int &r)
+   {  return l.m_int > r.m_int;   }
+
+   int get_int() const
+   {  return m_int;  }
+
+   friend bool operator==(const movable_and_copyable_int &l, int r)
+   {  return l.get_int() == r;   }
+
+   friend bool operator==(int l, const movable_and_copyable_int &r)
+   {  return l == r.get_int();   }
+
+   friend bool operator<(const movable_and_copyable_int &l, int r)
+   {  return l.get_int() < r;   }
+
+   friend bool operator<(int l, const movable_and_copyable_int &r)
+   {  return l < r.get_int();   }
+
+   friend std::size_t hash_value(const movable_and_copyable_int &v)
+   {  return (std::size_t)v.get_int(); }
+
+   private:
+   int m_int;
+};
+
+unsigned int movable_and_copyable_int::count = 0;
+
+inline movable_and_copyable_int produce_movable_and_copyable_int()
+{  return movable_and_copyable_int();  }
+
+template<class E, class T>
+std::basic_ostream<E, T> & operator<<
+   (std::basic_ostream<E, T> & os, movable_and_copyable_int const & p)
+
+{
+    os << p.get_int();
+    return os;
+}
+
+template<>
+struct is_copyable<movable_and_copyable_int>
+{
+   static const bool value = true;
+};
+
+class copyable_int
+{
+   public:
+
+   static unsigned int count;
+
+   copyable_int()
+      :  m_int(0)
+   { ++count; }
+
+   explicit copyable_int(int a)
+      :  m_int(a)
+   {
+      //Disallow INT_MIN
+      BOOST_ASSERT(this->m_int != INT_MIN);
+      ++count;
+   }
+
+   copyable_int(const copyable_int& mmi)
+      :  m_int(mmi.m_int)
+   { ++count; }
+
+   copyable_int & operator= (int i)
+   {  this->m_int = i;  BOOST_ASSERT(this->m_int != INT_MIN); return *this;  }
+
+   copyable_int & operator= (const copyable_int &ci)
+   {  this->m_int = ci.m_int;  BOOST_ASSERT(this->m_int != INT_MIN); return *this;  }
+
+   ~copyable_int()
+   {
+      //Double destructor called
+      BOOST_ASSERT(this->m_int != INT_MIN);
+      this->m_int = INT_MIN;
+      --count;
+   }
+
+   friend bool operator ==(const copyable_int &l, const copyable_int &r)
+   {  return l.m_int == r.m_int;   }
+
+   friend bool operator !=(const copyable_int &l, const copyable_int &r)
+   {  return l.m_int != r.m_int;   }
+
+   friend bool operator <(const copyable_int &l, const copyable_int &r)
+   {  return l.m_int < r.m_int;   }
+
+   friend bool operator <=(const copyable_int &l, const copyable_int &r)
+   {  return l.m_int <= r.m_int;   }
+
+   friend bool operator >=(const copyable_int &l, const copyable_int &r)
+   {  return l.m_int >= r.m_int;   }
+
+   friend bool operator >(const copyable_int &l, const copyable_int &r)
+   {  return l.m_int > r.m_int;   }
+
+   int get_int() const
+   {  return m_int;  }
+
+   friend bool operator==(const copyable_int &l, int r)
+   {  return l.get_int() == r;   }
+
+   friend bool operator==(int l, const copyable_int &r)
+   {  return l == r.get_int();   }
+
+   friend bool operator<(const copyable_int &l, int r)
+   {  return l.get_int() < r;   }
+
+   friend bool operator<(int l, const copyable_int &r)
+   {  return l < r.get_int();   }
+
+   friend std::size_t hash_value(const copyable_int &v)
+   {  return (std::size_t)v.get_int(); }
+
+   private:
+   int m_int;
+};
+
+unsigned int copyable_int::count = 0;
+
+inline copyable_int produce_copyable_int()
+{  return copyable_int();  }
+
+template<class E, class T>
+std::basic_ostream<E, T> & operator<<
+   (std::basic_ostream<E, T> & os, copyable_int const & p)
+
+{
+    os << p.get_int();
+    return os;
+}
+
+template<>
+struct is_copyable<copyable_int>
+{
+   static const bool value = true;
+};
+
+class non_copymovable_int
+{
+   non_copymovable_int(const non_copymovable_int& mmi);
+   non_copymovable_int & operator= (const non_copymovable_int &mi);
+
+   public:
+
+   static unsigned int count;
+
+   non_copymovable_int()
+      :  m_int(0)
+   { ++count; }
+
+   explicit non_copymovable_int(int a)
+      :  m_int(a)
+   { ++count; }
+
+   ~non_copymovable_int()
+   {  m_int = 0;  --count; }
+
+   bool operator ==(const non_copymovable_int &mi) const
+   {  return this->m_int == mi.m_int;   }
+
+   bool operator !=(const non_copymovable_int &mi) const
+   {  return this->m_int != mi.m_int;   }
+
+   bool operator <(const non_copymovable_int &mi) const
+   {  return this->m_int < mi.m_int;   }
+
+   bool operator <=(const non_copymovable_int &mi) const
+   {  return this->m_int <= mi.m_int;   }
+
+   bool operator >=(const non_copymovable_int &mi) const
+   {  return this->m_int >= mi.m_int;   }
+
+   bool operator >(const non_copymovable_int &mi) const
+   {  return this->m_int > mi.m_int;   }
+
+   int get_int() const
+   {  return m_int;  }
+
+   friend bool operator==(const non_copymovable_int &l, int r)
+   {  return l.get_int() == r;   }
+
+   friend bool operator==(int l, const non_copymovable_int &r)
+   {  return l == r.get_int();   }
+
+   friend bool operator<(const non_copymovable_int &l, int r)
+   {  return l.get_int() < r;   }
+
+   friend bool operator<(int l, const non_copymovable_int &r)
+   {  return l < r.get_int();   }
+
+   friend std::size_t hash_value(const non_copymovable_int &v)
+   {  return (std::size_t)v.get_int(); }
+
+   private:
+   int m_int;
+};
+
+unsigned int non_copymovable_int::count = 0;
+
+template<class T>
+struct life_count
+{
+   static unsigned check(unsigned) {  return true;   }
+};
+
+template<>
+struct life_count< movable_int >
+{
+   static unsigned check(unsigned c)
+   {  return c == movable_int::count;   }
+};
+
+template<>
+struct life_count< copyable_int >
+{
+   static unsigned check(unsigned c)
+   {  return c == copyable_int::count;   }
+};
+
+template<>
+struct life_count< movable_and_copyable_int >
+{
+   static unsigned check(unsigned c)
+   {  return c == movable_and_copyable_int::count;   }
+};
+
+template<>
+struct life_count< non_copymovable_int >
+{
+   static unsigned check(unsigned c)
+   {  return c == non_copymovable_int::count;   }
+};
+
+
+}  //namespace test {
+}  //namespace container {
+}  //namespace boost {
+
+#include <boost/container/detail/config_end.hpp>
+
+#endif   //#ifndef BOOST_CONTAINER_TEST_MOVABLE_INT_HEADER
diff --git a/src/boost/libs/container/test/node_handle_test.cpp b/src/boost/libs/container/test/node_handle_test.cpp
new file mode 100644
index 000000000..3c2637946
--- /dev/null
+++ b/src/boost/libs/container/test/node_handle_test.cpp
@@ -0,0 +1,633 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2016-2016. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/container for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+#include <boost/core/lightweight_test.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/container/node_handle.hpp>
+#include <boost/container/new_allocator.hpp>
+#include <boost/move/utility_core.hpp>
+#include <boost/move/adl_move_swap.hpp>
+#include <boost/container/detail/pair_key_mapped_of_value.hpp>
+
+using namespace ::boost::container;
+
+enum EAllocState
+{
+   DefaultConstructed,
+   MoveConstructed,
+   MoveAssigned,
+   CopyConstructed,
+   CopyAssigned,
+   Swapped,
+   Destructed
+};
+
+template<class Node>
+class trace_allocator
+   : public new_allocator<Node>
+{
+   BOOST_COPYABLE_AND_MOVABLE(trace_allocator)
+
+   typedef new_allocator<Node> base_t;
+
+   public:
+
+   struct propagate_on_container_move_assignment
+   {
+      static const bool value = true;
+   };
+
+   struct propagate_on_container_swap
+   {
+      static const bool value = true;
+   };
+
+   //!Obtains an new_allocator that allocates
+   //!objects of type T2
+   template<class T2>
+   struct rebind
+   {
+      typedef trace_allocator<T2> other;
+   };
+
+   explicit trace_allocator(unsigned value = 999)
+      : m_state(DefaultConstructed), m_value(value)
+   {
+      ++count;
+   }
+
+   trace_allocator(BOOST_RV_REF(trace_allocator) other)
+      : base_t(boost::move(BOOST_MOVE_BASE(base_t, other))), m_state(MoveConstructed), m_value(other.m_value)
+   {
+      ++count;
+   }
+
+   trace_allocator(const trace_allocator &other)
+      : base_t(other), m_state(CopyConstructed), m_value(other.m_value)
+   {
+      ++count;
+   }
+
+   trace_allocator & operator=(BOOST_RV_REF(trace_allocator) other)
+   {
+      m_value = other.m_value;
+      m_state = MoveAssigned;
+      return *this;
+   }
+
+   template<class OtherNode>
+   trace_allocator(const trace_allocator<OtherNode> &other)
+      : m_state(CopyConstructed), m_value(other.m_value)
+   {
+      ++count;
+   }
+
+   template<class OtherNode>
+   trace_allocator & operator=(BOOST_COPY_ASSIGN_REF(trace_allocator<OtherNode>) other)
+   {
+      m_value = other.m_value;
+      m_state = CopyAssigned;
+      return *this;
+   }
+
+   ~trace_allocator()
+   {
+      m_value = 0u-1u;
+      m_state = Destructed;
+      --count;
+   }
+
+   void swap(trace_allocator &other)
+   {
+      boost::adl_move_swap(m_value, other.m_value);
+      m_state = other.m_state = Swapped;
+   }
+
+   friend void swap(trace_allocator &left, trace_allocator &right)
+   {
+      left.swap(right);
+   }
+
+   EAllocState m_state;
+   unsigned m_value;
+
+   static unsigned int count;
+
+   static void reset_count()
+   {  count = 0;  }
+};
+
+template<class Node>
+unsigned int trace_allocator<Node>::count = 0;
+
+template<class T>
+struct node
+{
+   typedef T value_type;
+   value_type value;
+
+         value_type &get_data()       {  return value; }
+   const value_type &get_data() const {  return value; }
+
+   node()
+   {
+      ++count;
+   }
+
+   ~node()
+   {
+      --count;
+   }
+
+   static unsigned int count;
+
+   static void reset_count()
+   {  count = 0;  }
+};
+
+template<class T1, class T2>
+struct value
+{
+   T1 first;
+   T2 second;
+};
+
+template<class T>
+unsigned int node<T>::count = 0;
+
+
+//Common types
+typedef value<int, unsigned> test_pair;
+typedef pair_key_mapped_of_value<int, unsigned> key_mapped_t;
+typedef node<test_pair> node_t;
+typedef trace_allocator< node_t > node_alloc_t;
+typedef node_handle<node_alloc_t, void>         node_handle_set_t;
+typedef node_handle<node_alloc_t, key_mapped_t> node_handle_map_t;
+typedef allocator_traits<node_alloc_t>::portable_rebind_alloc<test_pair>::type value_allocator_type;
+
+void test_types()
+{
+   //set
+   BOOST_STATIC_ASSERT(( dtl::is_same<node_handle_set_t::value_type, test_pair>::value ));
+   BOOST_STATIC_ASSERT(( dtl::is_same<node_handle_set_t::key_type, test_pair>::value ));
+   BOOST_STATIC_ASSERT(( dtl::is_same<node_handle_set_t::mapped_type, test_pair>::value ));
+   BOOST_STATIC_ASSERT(( dtl::is_same<node_handle_set_t::allocator_type, value_allocator_type>::value ));
+
+   //map
+   BOOST_STATIC_ASSERT(( dtl::is_same<node_handle_map_t::value_type, test_pair>::value ));
+   BOOST_STATIC_ASSERT(( dtl::is_same<node_handle_map_t::key_type, int>::value ));
+   BOOST_STATIC_ASSERT(( dtl::is_same<node_handle_map_t::mapped_type, unsigned>::value ));
+   BOOST_STATIC_ASSERT(( dtl::is_same<node_handle_map_t::allocator_type, value_allocator_type>::value ));
+}
+
+void test_default_constructor()
+{
+   node_alloc_t::reset_count();
+   {
+      node_handle_set_t nh;
+      BOOST_TEST(node_alloc_t::count == 0);
+   }
+   BOOST_TEST(node_alloc_t::count == 0);
+}
+
+void test_arg_constructor()
+{
+   //With non-null pointer
+   node_alloc_t::reset_count();
+   node_t::reset_count();
+   {
+      const node_alloc_t al;
+      BOOST_TEST(node_alloc_t::count == 1);
+      {
+         node_handle_set_t nh(new node_t, al);
+         BOOST_TEST(node_t::count == 1);
+         BOOST_TEST(node_alloc_t::count == 2);
+      }
+      BOOST_TEST(node_alloc_t::count == 1);
+   }
+   BOOST_TEST(node_t::count == 0);
+   BOOST_TEST(node_alloc_t::count == 0);
+
+   //With null pointer
+   node_alloc_t::reset_count();
+   node_t::reset_count();
+   {
+      const node_alloc_t al;
+      BOOST_TEST(node_alloc_t::count == 1);
+      {
+         node_handle_set_t nh(0, al);
+         BOOST_TEST(node_t::count == 0);
+         BOOST_TEST(node_alloc_t::count == 1);
+      }
+      BOOST_TEST(node_alloc_t::count == 1);
+      BOOST_TEST(node_t::count == 0);
+   }
+   BOOST_TEST(node_alloc_t::count == 0);
+}
+
+void test_move_constructor()
+{
+   //With non-null pointer
+   node_alloc_t::reset_count();
+   node_t::reset_count();
+   {
+      const node_alloc_t al;
+      BOOST_TEST(node_alloc_t::count == 1);
+      {
+         node_t *const from_ptr = new node_t;
+         node_handle_set_t nh(from_ptr, al);
+         BOOST_TEST(node_t::count == 1);
+         BOOST_TEST(node_alloc_t::count == 2);
+         {
+            node_handle_set_t nh2(boost::move(nh));
+            BOOST_TEST(nh.empty());
+            BOOST_TEST(!nh2.empty());
+            BOOST_TEST(nh2.get() == from_ptr);
+            BOOST_TEST(nh2.node_alloc().m_state == MoveConstructed);
+            BOOST_TEST(node_t::count == 1);
+            BOOST_TEST(node_alloc_t::count == 2);
+         }
+         BOOST_TEST(node_t::count == 0);
+         BOOST_TEST(node_alloc_t::count == 1);
+      }
+      BOOST_TEST(node_alloc_t::count == 1);
+   }
+   BOOST_TEST(node_t::count == 0);
+   BOOST_TEST(node_alloc_t::count == 0);
+
+   //With null pointer
+   node_alloc_t::reset_count();
+   node_t::reset_count();
+   {
+      const node_alloc_t al;
+      BOOST_TEST(node_alloc_t::count == 1);
+      {
+         node_handle_set_t nh;
+         {
+            node_handle_set_t nh2(boost::move(nh));
+            BOOST_TEST(nh.empty());
+            BOOST_TEST(nh2.empty());
+            BOOST_TEST(node_alloc_t::count == 1);
+         }
+         BOOST_TEST(node_t::count == 0);
+         BOOST_TEST(node_alloc_t::count == 1);
+      }
+      BOOST_TEST(node_alloc_t::count == 1);
+   }
+   BOOST_TEST(node_t::count == 0);
+   BOOST_TEST(node_alloc_t::count == 0);
+}
+
+void test_related_constructor()
+{
+   //With non-null pointer
+   node_alloc_t::reset_count();
+   node_t::reset_count();
+   {
+      const node_alloc_t al;
+      BOOST_TEST(node_alloc_t::count == 1);
+      {
+         node_t *const from_ptr = new node_t;
+         node_handle_map_t nh(from_ptr, al);
+         BOOST_TEST(node_t::count == 1);
+         BOOST_TEST(node_alloc_t::count == 2);
+         {
+            node_handle_set_t nh2(boost::move(nh));
+            BOOST_TEST(nh.empty());
+            BOOST_TEST(!nh2.empty());
+            BOOST_TEST(nh2.get() == from_ptr);
+            BOOST_TEST(nh2.node_alloc().m_state == MoveConstructed);
+            BOOST_TEST(node_t::count == 1);
+            BOOST_TEST(node_alloc_t::count == 2);
+         }
+         BOOST_TEST(node_t::count == 0);
+         BOOST_TEST(node_alloc_t::count == 1);
+      }
+      BOOST_TEST(node_alloc_t::count == 1);
+   }
+   BOOST_TEST(node_t::count == 0);
+   BOOST_TEST(node_alloc_t::count == 0);
+
+   //With null pointer
+   node_alloc_t::reset_count();
+   node_t::reset_count();
+   {
+      const node_alloc_t al;
+      BOOST_TEST(node_alloc_t::count == 1);
+      {
+         node_handle_set_t nh;
+         {
+            node_handle_map_t nh2(boost::move(nh));
+            BOOST_TEST(nh.empty());
+            BOOST_TEST(nh2.empty());
+            BOOST_TEST(node_alloc_t::count == 1);
+         }
+         BOOST_TEST(node_t::count == 0);
+         BOOST_TEST(node_alloc_t::count == 1);
+      }
+      BOOST_TEST(node_alloc_t::count == 1);
+   }
+   BOOST_TEST(node_t::count == 0);
+   BOOST_TEST(node_alloc_t::count == 0);
+}
+
+void test_move_assignment()
+{
+   //empty = full
+   {
+      node_alloc_t::reset_count();
+      node_t::reset_count();
+      node_t *const from_ptr = new node_t;
+      node_handle_set_t nh_from(from_ptr, node_alloc_t());
+      BOOST_TEST(node_t::count == 1);
+      BOOST_TEST(node_alloc_t::count == 1);
+
+      node_handle_set_t nh_to;
+      BOOST_TEST(nh_to.empty());
+      BOOST_TEST(node_t::count == 1);
+      BOOST_TEST(node_alloc_t::count == 1);
+
+      nh_to = boost::move(nh_from);
+
+      BOOST_TEST(nh_from.empty());
+      BOOST_TEST(!nh_to.empty());
+      BOOST_TEST(nh_to.get() == from_ptr);
+      BOOST_TEST(nh_to.node_alloc().m_state == MoveConstructed);
+      BOOST_TEST(node_t::count == 1);
+      BOOST_TEST(node_alloc_t::count == 1);
+   }
+
+   //empty = empty
+   {
+      node_alloc_t::reset_count();
+      node_t::reset_count();
+
+      node_handle_set_t nh_from;
+      BOOST_TEST(nh_from.empty());
+      BOOST_TEST(node_t::count == 0);
+      BOOST_TEST(node_alloc_t::count == 0);
+
+      node_handle_set_t nh_to;
+      BOOST_TEST(nh_to.empty());
+      BOOST_TEST(node_t::count == 0);
+      BOOST_TEST(node_alloc_t::count == 0);
+
+      nh_to = boost::move(nh_from);
+
+      BOOST_TEST(nh_from.empty());
+      BOOST_TEST(nh_to.empty());
+      BOOST_TEST(node_t::count == 0);
+      BOOST_TEST(node_alloc_t::count == 0);
+   }
+
+   //full = empty
+   {
+      node_alloc_t::reset_count();
+      node_t::reset_count();
+
+      node_handle_set_t nh_from;
+      BOOST_TEST(nh_from.empty());
+      BOOST_TEST(node_t::count == 0);
+      BOOST_TEST(node_alloc_t::count == 0);
+
+      node_handle_set_t nh_to(new node_t, node_alloc_t());
+      BOOST_TEST(node_t::count == 1);
+      BOOST_TEST(node_alloc_t::count == 1);
+
+      nh_to = boost::move(nh_from);
+
+      BOOST_TEST(nh_from.empty());
+      BOOST_TEST(nh_to.empty());
+      BOOST_TEST(node_t::count == 0);
+      BOOST_TEST(node_alloc_t::count == 0);
+   }
+
+   //full = full
+   {
+      node_alloc_t::reset_count();
+      node_t::reset_count();
+
+      node_t *const from_ptr = new node_t;
+      node_handle_set_t nh_from(from_ptr, node_alloc_t());
+      BOOST_TEST(node_t::count == 1);
+      BOOST_TEST(node_alloc_t::count == 1);
+
+      node_handle_set_t nh_to(new node_t, node_alloc_t());
+      BOOST_TEST(node_t::count == 2);
+      BOOST_TEST(node_alloc_t::count == 2);
+
+      nh_to = boost::move(nh_from);
+
+      BOOST_TEST(nh_from.empty());
+      BOOST_TEST(!nh_to.empty());
+      BOOST_TEST(nh_to.get() == from_ptr);
+      BOOST_TEST(nh_to.node_alloc().m_state == MoveAssigned);
+      BOOST_TEST(node_t::count == 1);
+      BOOST_TEST(node_alloc_t::count == 1);
+   }
+}
+
+void test_value_key_mapped()
+{
+   //value()
+   {
+      node_t *from_ptr = new node_t;
+      const node_handle_set_t nh_from(from_ptr, node_alloc_t());
+      from_ptr->value.first  = -99;
+      from_ptr->value.second =  99;
+      BOOST_TEST(nh_from.value().first  == -99);
+      BOOST_TEST(nh_from.value().second ==  99);
+   }
+   //key()/mapped()
+   {
+      node_t *from_ptr = new node_t;
+      const node_handle_map_t nh_from(from_ptr, node_alloc_t());
+      from_ptr->value.first  = -98;
+      from_ptr->value.second =  98;
+      BOOST_TEST(nh_from.key()    == -98);
+      BOOST_TEST(nh_from.mapped() ==  98);
+   }
+}
+
+void test_get_allocator()
+{
+   const node_handle_set_t nh(new node_t, node_alloc_t(888));
+   allocator_traits<node_alloc_t>::portable_rebind_alloc<test_pair>::type a = nh.get_allocator();
+   BOOST_TEST(a.m_value == 888);
+}
+
+void test_bool_conversion_empty()
+{
+   const node_handle_set_t nh(new node_t, node_alloc_t(777));
+   const node_handle_set_t nh_null;
+   BOOST_TEST(nh && !nh_null);
+   BOOST_TEST(!(!nh || nh_null));
+   BOOST_TEST(!nh.empty() && nh_null.empty());
+   BOOST_TEST(!(nh.empty() || !nh_null.empty()));
+}
+
+void test_swap()
+{
+   //empty.swap(full)
+   {
+      node_alloc_t::reset_count();
+      node_t::reset_count();
+      node_t *const from_ptr = new node_t;
+      node_handle_set_t nh_from(from_ptr, node_alloc_t());
+      BOOST_TEST(node_t::count == 1);
+      BOOST_TEST(node_alloc_t::count == 1);
+
+      node_handle_set_t nh_to;
+      BOOST_TEST(nh_to.empty());
+      BOOST_TEST(node_t::count == 1);
+      BOOST_TEST(node_alloc_t::count == 1);
+
+      nh_to.swap(nh_from);
+
+      BOOST_TEST(nh_from.empty());
+      BOOST_TEST(!nh_to.empty());
+      BOOST_TEST(nh_to.get() == from_ptr);
+      BOOST_TEST(nh_to.node_alloc().m_state == MoveConstructed);
+      BOOST_TEST(node_t::count == 1);
+      BOOST_TEST(node_alloc_t::count == 1);
+   }
+
+   //empty.swap(empty)
+   {
+      node_alloc_t::reset_count();
+      node_t::reset_count();
+
+      node_handle_set_t nh_from;
+      BOOST_TEST(nh_from.empty());
+      BOOST_TEST(node_t::count == 0);
+      BOOST_TEST(node_alloc_t::count == 0);
+
+      node_handle_set_t nh_to;
+      BOOST_TEST(nh_to.empty());
+      BOOST_TEST(node_t::count == 0);
+      BOOST_TEST(node_alloc_t::count == 0);
+
+      nh_to.swap(nh_from);
+
+      BOOST_TEST(nh_from.empty());
+      BOOST_TEST(nh_to.empty());
+      BOOST_TEST(node_t::count == 0);
+      BOOST_TEST(node_alloc_t::count == 0);
+   }
+
+   //full.swap(empty)
+   {
+      node_alloc_t::reset_count();
+      node_t::reset_count();
+
+      node_handle_set_t nh_from;
+      BOOST_TEST(nh_from.empty());
+      BOOST_TEST(node_t::count == 0);
+      BOOST_TEST(node_alloc_t::count == 0);
+
+      node_t *const to_ptr = new node_t;
+      node_handle_set_t nh_to(to_ptr, node_alloc_t());
+      BOOST_TEST(node_t::count == 1);
+      BOOST_TEST(node_alloc_t::count == 1);
+
+      nh_to.swap(nh_from);
+
+      BOOST_TEST(!nh_from.empty());
+      BOOST_TEST(nh_from.node_alloc().m_state == MoveConstructed);
+      BOOST_TEST(nh_from.get() == to_ptr);
+      BOOST_TEST(nh_to.empty());
+
+      BOOST_TEST(node_t::count == 1);
+      BOOST_TEST(node_alloc_t::count == 1);
+   }
+
+   //full.swap(full)
+   {
+      node_alloc_t::reset_count();
+      node_t::reset_count();
+
+      node_t *const from_ptr = new node_t;
+      node_handle_set_t nh_from(from_ptr, node_alloc_t());
+      BOOST_TEST(node_t::count == 1);
+      BOOST_TEST(node_alloc_t::count == 1);
+
+      node_t *const to_ptr = new node_t;
+      node_handle_set_t nh_to(to_ptr, node_alloc_t());
+      BOOST_TEST(node_t::count == 2);
+      BOOST_TEST(node_alloc_t::count == 2);
+
+      nh_to.swap(nh_from);
+
+      BOOST_TEST(!nh_from.empty());
+      BOOST_TEST(nh_from.get() == to_ptr);
+      BOOST_TEST(nh_from.node_alloc().m_state == Swapped);
+
+      BOOST_TEST(!nh_to.empty());
+      BOOST_TEST(nh_to.get() == from_ptr);
+      BOOST_TEST(nh_to.node_alloc().m_state == Swapped);
+
+      BOOST_TEST(node_t::count == 2);
+      BOOST_TEST(node_alloc_t::count == 2);
+   }
+}
+
+void test_get_release()
+{
+   //get()
+   {
+      node_alloc_t::reset_count();
+      node_t::reset_count();
+
+      node_t *const ptr = new node_t;
+      const node_handle_set_t nh(ptr, node_alloc_t());
+      BOOST_TEST(node_t::count == 1);
+      BOOST_TEST(node_alloc_t::count == 1);
+
+      BOOST_TEST(nh.get() == ptr);
+      BOOST_TEST(!nh.empty());
+      BOOST_TEST(node_t::count == 1);
+      BOOST_TEST(node_alloc_t::count == 1);
+   }
+   BOOST_TEST(node_t::count == 0);
+   BOOST_TEST(node_alloc_t::count == 0);
+
+   //release()
+   {
+      node_alloc_t::reset_count();
+      node_t::reset_count();
+
+      node_t *const ptr = new node_t;
+      node_handle_set_t nh(ptr, node_alloc_t());
+      BOOST_TEST(node_t::count == 1);
+      BOOST_TEST(node_alloc_t::count == 1);
+
+      BOOST_TEST(nh.release() == ptr);
+      BOOST_TEST(nh.empty());
+      BOOST_TEST(node_t::count == 1);
+      BOOST_TEST(node_alloc_t::count == 0);
+      delete ptr;
+   }
+   BOOST_TEST(node_t::count == 0);
+}
+
+int main()
+{
+   test_types();
+   test_default_constructor();
+   test_arg_constructor();
+   test_move_constructor();
+   test_related_constructor();
+   test_move_assignment();
+   test_value_key_mapped();
+   test_get_allocator();
+   test_bool_conversion_empty();
+   test_swap();
+   test_get_release();
+   return ::boost::report_errors();
+}
diff --git a/src/boost/libs/container/test/null_iterators_test.cpp b/src/boost/libs/container/test/null_iterators_test.cpp
new file mode 100644
index 000000000..f081dbe0e
--- /dev/null
+++ b/src/boost/libs/container/test/null_iterators_test.cpp
@@ -0,0 +1,96 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2014-2014. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/container for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#include <boost/container/vector.hpp>
+#include <boost/container/deque.hpp>
+#include <boost/container/stable_vector.hpp>
+#include <boost/container/static_vector.hpp>
+#include <boost/container/string.hpp>
+#include <boost/container/list.hpp>
+#include <boost/container/slist.hpp>
+#include <boost/container/map.hpp>
+#include <boost/container/set.hpp>
+#include <boost/container/flat_set.hpp>
+#include <boost/container/flat_map.hpp>
+#include <boost/intrusive/detail/mpl.hpp>
+
+#include <boost/core/lightweight_test.hpp>
+#include <boost/static_assert.hpp>
+#include <cstring>
+#include <new>
+
+using namespace boost::container;
+
+typedef boost::container::dtl::aligned_storage<sizeof(void*)*4>::type buffer_t;
+
+static buffer_t buffer_0x00;
+static buffer_t buffer_0xFF;
+
+template<class Iterator>
+const Iterator &on_0x00_buffer()
+{
+   BOOST_STATIC_ASSERT(sizeof(buffer_t) >= sizeof(Iterator));
+   return * ::new(std::memset(&buffer_0x00, 0x00, sizeof(buffer_0x00))) Iterator();
+}
+
+template<class Iterator>
+const Iterator &on_0xFF_buffer()
+{
+   BOOST_STATIC_ASSERT(sizeof(buffer_t) >= sizeof(Iterator));
+   return * ::new(std::memset(&buffer_0xFF, 0xFF, sizeof(buffer_0xFF))) Iterator();
+}
+
+namespace boost {
+namespace container {
+namespace test {
+
+BOOST_INTRUSIVE_INSTANTIATE_DEFAULT_TYPE_TMPLT(reverse_iterator)
+BOOST_INTRUSIVE_INSTANTIATE_DEFAULT_TYPE_TMPLT(const_reverse_iterator)
+
+}}}   //namespace boost::container::test {
+
+template<class Container>
+void check_null_iterators()
+{
+   typedef typename Container::iterator               iterator;
+   typedef typename Container::const_iterator         const_iterator;
+   typedef BOOST_INTRUSIVE_OBTAIN_TYPE_WITH_DEFAULT
+      (boost::container::test::, Container
+      ,reverse_iterator, iterator)                    reverse_iterator;
+   typedef BOOST_INTRUSIVE_OBTAIN_TYPE_WITH_DEFAULT
+      (boost::container::test::, Container
+      ,const_reverse_iterator, const_iterator)        const_reverse_iterator;
+
+   BOOST_TEST(on_0xFF_buffer<iterator>()               == on_0x00_buffer<iterator>());
+   BOOST_TEST(on_0xFF_buffer<const_iterator>()         == on_0x00_buffer<const_iterator>());
+   BOOST_TEST(on_0xFF_buffer<reverse_iterator>()       == on_0x00_buffer<reverse_iterator>());
+   BOOST_TEST(on_0xFF_buffer<const_reverse_iterator>() == on_0x00_buffer<const_reverse_iterator>());
+}
+
+int main()
+{
+   check_null_iterators< vector<int> >();
+   check_null_iterators< deque<int> >();
+   check_null_iterators< stable_vector<int> >();
+   check_null_iterators< static_vector<int, 1> >();
+   check_null_iterators< string >();
+   check_null_iterators< list<int> >();
+   check_null_iterators< slist<int> >();
+   check_null_iterators< map<int, int> >();
+   check_null_iterators< multimap<int, int> >();
+   check_null_iterators< set<int> >();
+   check_null_iterators< multiset<int> >();
+   check_null_iterators< flat_set<int> >();
+   check_null_iterators< flat_multiset<int> >();
+   check_null_iterators< flat_map<int, int> >();
+   check_null_iterators< flat_multimap<int, int> >();
+
+   return boost::report_errors();
+}
diff --git a/src/boost/libs/container/test/pair_test.cpp b/src/boost/libs/container/test/pair_test.cpp
new file mode 100644
index 000000000..5ead7a450
--- /dev/null
+++ b/src/boost/libs/container/test/pair_test.cpp
@@ -0,0 +1,156 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2011-2013. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/container for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+#include <boost/container/detail/config_begin.hpp>
+#include <boost/container/detail/pair.hpp>
+#include "movable_int.hpp"
+#include "emplace_test.hpp"
+#include<boost/move/utility_core.hpp>
+#include<boost/move/detail/fwd_macros.hpp>
+#include<boost/core/lightweight_test.hpp>
+
+//non_copymovable_int
+//copyable_int
+//movable_int
+//movable_and_copyable_int
+
+
+#include <boost/tuple/tuple.hpp>
+
+#if !defined(BOOST_NO_CXX11_HDR_TUPLE) || (defined(BOOST_MSVC) && (BOOST_MSVC == 1700 || BOOST_MSVC == 1600))
+#define BOOST_CONTAINER_PAIR_TEST_HAS_HEADER_TUPLE
+#endif
+
+#if defined(BOOST_CONTAINER_PAIR_TEST_HAS_HEADER_TUPLE)
+#include <tuple>
+#endif
+
+using namespace ::boost::container;
+
+int main ()
+{
+   {
+      dtl::pair<test::non_copymovable_int, test::non_copymovable_int> p1;
+      dtl::pair<test::copyable_int, test::copyable_int> p2;
+      dtl::pair<test::movable_int, test::movable_int> p3;
+      dtl::pair<test::movable_and_copyable_int, test::movable_and_copyable_int> p4;
+   }
+   {  //Constructible from two values
+      dtl::pair<test::non_copymovable_int, test::non_copymovable_int> p1(1, 2);
+      dtl::pair<test::copyable_int, test::copyable_int> p2(1, 2);
+      dtl::pair<test::movable_int, test::movable_int> p3(1, 2);
+      dtl::pair<test::movable_and_copyable_int, test::movable_and_copyable_int> p4(1, 2);
+   }
+
+   {  //Constructible from internal types
+      dtl::pair<test::copyable_int, test::copyable_int> p2(test::copyable_int(1), test::copyable_int(2));
+      {
+         test::movable_int a(1), b(2);
+         dtl::pair<test::movable_int, test::movable_int> p3(::boost::move(a), ::boost::move(b));
+      }
+      {
+         test::movable_and_copyable_int a(1), b(2);
+         dtl::pair<test::movable_and_copyable_int, test::movable_and_copyable_int> p4(::boost::move(a), ::boost::move(b));
+      }
+   }
+   {  //piecewise construct from boost tuple
+      using namespace boost::tuples;
+      {
+         boost::container::dtl::pair<int, float> p(piecewise_construct, tuple<>(), tuple<>());
+         BOOST_TEST(p.first == 0);
+         BOOST_TEST(p.second == 0.f);
+      }
+      {
+         boost::container::dtl::pair<int, float> p(piecewise_construct, tuple<>(), tuple<float>(2.f));
+         BOOST_TEST(p.first == 0);
+         BOOST_TEST(p.second == 2.f);
+      }
+      {
+         boost::container::dtl::pair<int, float> p(piecewise_construct, tuple<int>(2), tuple<float>(1.f));
+         BOOST_TEST(p.first == 2);
+         BOOST_TEST(p.second == 1.f);
+      }
+      {
+         boost::container::dtl::pair
+            < boost::container::dtl::pair<int, float>
+            , boost::container::dtl::pair<double, char>
+            > p(piecewise_construct, tuple<int, float>(3, 4.f), tuple<double, char>(8.,'a'));
+         BOOST_TEST(p.first.first   == 3);
+         BOOST_TEST(p.first.second  == 4.f);
+         BOOST_TEST(p.second.first  == 8.);
+         BOOST_TEST(p.second.second == 'a');
+      }
+      {
+         boost::container::dtl::pair
+            < tuple<int, float, double>
+            , char
+            > p(piecewise_construct, tuple<int, float, double>(3, 16.f, 32.), tuple<char>('b'));
+         BOOST_TEST(p.first.get<0>() == 3);
+         BOOST_TEST(p.first.get<1>() == 16.f);
+         BOOST_TEST(p.first.get<2>() == 32.);
+         BOOST_TEST(p.second == 'b');
+      }
+   }
+   #if defined(BOOST_CONTAINER_PAIR_TEST_HAS_HEADER_TUPLE)
+   {  //piecewise construct from std tuple
+      using std::tuple;
+      {
+         boost::container::dtl::pair<int, float> p(piecewise_construct, tuple<>(), tuple<>());
+         BOOST_TEST(p.first == 0);
+         BOOST_TEST(p.second == 0.f);
+      }
+      {
+         boost::container::dtl::pair<int, float> p(piecewise_construct, tuple<>(), tuple<float>(2.f));
+         BOOST_TEST(p.first == 0);
+         BOOST_TEST(p.second == 2.f);
+      }
+      {
+         boost::container::dtl::pair<int, float> p(piecewise_construct, tuple<int>(2), tuple<float>(1.f));
+         BOOST_TEST(p.first == 2);
+         BOOST_TEST(p.second == 1.f);
+      }
+      {
+         boost::container::dtl::pair
+            < boost::container::dtl::pair<int, float>
+            , boost::container::dtl::pair<double, char>
+            > p(piecewise_construct, tuple<int, float>(3, 4.f), tuple<double, char>(8.,'a'));
+         BOOST_TEST(p.first.first   == 3);
+         BOOST_TEST(p.first.second  == 4.f);
+         BOOST_TEST(p.second.first  == 8.);
+         BOOST_TEST(p.second.second == 'a');
+      }
+      {
+         boost::container::dtl::pair
+            < tuple<int, float, double>
+            , char
+            > p(piecewise_construct, tuple<int, float, double>(3, 16.f, 32.), tuple<char>('b'));
+         BOOST_TEST(std::get<0>(p.first) == 3);
+         BOOST_TEST(std::get<1>(p.first) == 16.f);
+         BOOST_TEST(std::get<2>(p.first) == 32.);
+         BOOST_TEST(p.second == 'b');
+      }
+      #if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+      typedef dtl::pair<test::movable_int, test::movable_int> movable_pair_t;
+      typedef dtl::pair<movable_pair_t, movable_pair_t> movable_pair_pair_t;
+      test::movable_int a(1), b(2), c(3), d(4);
+      movable_pair_pair_t p( piecewise_construct
+                           , dtl::forward_as_tuple_impl(boost::move(a), boost::move(b))
+                           , dtl::forward_as_tuple_impl(boost::move(c), boost::move(d))
+                           );
+      BOOST_TEST(p.first.first   == 1);
+      BOOST_TEST(p.first.second  == 2);
+      BOOST_TEST(p.second.first  == 3);
+      BOOST_TEST(p.second.second == 4);
+      #endif
+   }
+   #endif   //#!defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) && !defined(BOOST_NO_CXX11_HDR_TUPLE)
+   return ::boost::report_errors();
+}
+
+#include <boost/container/detail/config_end.hpp>
diff --git a/src/boost/libs/container/test/pmr_deque_test.cpp b/src/boost/libs/container/test/pmr_deque_test.cpp
new file mode 100644
index 000000000..15c67e2a6
--- /dev/null
+++ b/src/boost/libs/container/test/pmr_deque_test.cpp
@@ -0,0 +1,26 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2015-2015. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/container for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#include <boost/container/pmr/deque.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/container/detail/type_traits.hpp>
+
+int main()
+{
+   using namespace boost::container;
+   using boost::container::dtl::is_same;
+
+   typedef deque<int, pmr::polymorphic_allocator<int> > intcontainer_t;
+   BOOST_STATIC_ASSERT(( is_same<intcontainer_t, pmr::deque_of<int>::type >::value ));
+   #if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
+      BOOST_STATIC_ASSERT(( is_same<intcontainer_t, pmr::deque<int> >::value ));
+   #endif
+   return 0;
+}
diff --git a/src/boost/libs/container/test/pmr_flat_map_test.cpp b/src/boost/libs/container/test/pmr_flat_map_test.cpp
new file mode 100644
index 000000000..f98e497bf
--- /dev/null
+++ b/src/boost/libs/container/test/pmr_flat_map_test.cpp
@@ -0,0 +1,26 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2015-2015. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/container for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#include <boost/container/pmr/flat_map.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/container/detail/type_traits.hpp>
+
+int main()
+{
+   using namespace boost::container;
+   using boost::container::dtl::is_same;
+
+   typedef flat_map<int, float, std::less<int>, pmr::polymorphic_allocator<std::pair<int, float> > > intcontainer_t;
+   BOOST_STATIC_ASSERT(( is_same<intcontainer_t, pmr::flat_map_of<int, float>::type >::value ));
+   #if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
+      BOOST_STATIC_ASSERT(( is_same<intcontainer_t, pmr::flat_map<int, float> >::value ));
+   #endif
+   return 0;
+}
diff --git a/src/boost/libs/container/test/pmr_flat_set_test.cpp b/src/boost/libs/container/test/pmr_flat_set_test.cpp
new file mode 100644
index 000000000..5c9efe1a7
--- /dev/null
+++ b/src/boost/libs/container/test/pmr_flat_set_test.cpp
@@ -0,0 +1,26 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2015-2015. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/container for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#include <boost/container/pmr/flat_set.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/container/detail/type_traits.hpp>
+
+int main()
+{
+   using namespace boost::container;
+   using boost::container::dtl::is_same;
+
+   typedef flat_set<int, std::less<int>, pmr::polymorphic_allocator<int> > intcontainer_t;
+   BOOST_STATIC_ASSERT(( is_same<intcontainer_t, pmr::flat_set_of<int>::type >::value ));
+   #if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
+      BOOST_STATIC_ASSERT(( is_same<intcontainer_t, pmr::flat_set<int> >::value ));
+   #endif
+   return 0;
+}
diff --git a/src/boost/libs/container/test/pmr_list_test.cpp b/src/boost/libs/container/test/pmr_list_test.cpp
new file mode 100644
index 000000000..794ccf524
--- /dev/null
+++ b/src/boost/libs/container/test/pmr_list_test.cpp
@@ -0,0 +1,26 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2015-2015. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/container for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#include <boost/container/pmr/list.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/container/detail/type_traits.hpp>
+
+int main()
+{
+   using namespace boost::container;
+   using boost::container::dtl::is_same;
+
+   typedef list<int, pmr::polymorphic_allocator<int> > intcontainer_t;
+   BOOST_STATIC_ASSERT(( is_same<intcontainer_t, pmr::list_of<int>::type >::value ));
+   #if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
+      BOOST_STATIC_ASSERT(( is_same<intcontainer_t, pmr::list<int> >::value ));
+   #endif
+   return 0;
+}
diff --git a/src/boost/libs/container/test/pmr_map_test.cpp b/src/boost/libs/container/test/pmr_map_test.cpp
new file mode 100644
index 000000000..5db3f1091
--- /dev/null
+++ b/src/boost/libs/container/test/pmr_map_test.cpp
@@ -0,0 +1,26 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2015-2015. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/container for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#include <boost/container/pmr/map.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/container/detail/type_traits.hpp>
+
+int main()
+{
+   using namespace boost::container;
+   using boost::container::dtl::is_same;
+
+   typedef map<int, float, std::less<int>, pmr::polymorphic_allocator<std::pair<const int, float> > > intcontainer_t;
+   BOOST_STATIC_ASSERT(( is_same<intcontainer_t, pmr::map_of<int, float>::type >::value ));
+   #if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
+      BOOST_STATIC_ASSERT(( is_same<intcontainer_t, pmr::map<int, float> >::value ));
+   #endif
+   return 0;
+}
diff --git a/src/boost/libs/container/test/pmr_set_test.cpp b/src/boost/libs/container/test/pmr_set_test.cpp
new file mode 100644
index 000000000..3093fd434
--- /dev/null
+++ b/src/boost/libs/container/test/pmr_set_test.cpp
@@ -0,0 +1,26 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2015-2015. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/container for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#include <boost/container/pmr/set.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/container/detail/type_traits.hpp>
+
+int main()
+{
+   using namespace boost::container;
+   using boost::container::dtl::is_same;
+
+   typedef set<int, std::less<int>, pmr::polymorphic_allocator<int> > intcontainer_t;
+   BOOST_STATIC_ASSERT(( is_same<intcontainer_t, pmr::set_of<int>::type >::value ));
+   #if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
+      BOOST_STATIC_ASSERT(( is_same<intcontainer_t, pmr::set<int> >::value ));
+   #endif
+   return 0;
+}
diff --git a/src/boost/libs/container/test/pmr_slist_test.cpp b/src/boost/libs/container/test/pmr_slist_test.cpp
new file mode 100644
index 000000000..ed4b5ae9c
--- /dev/null
+++ b/src/boost/libs/container/test/pmr_slist_test.cpp
@@ -0,0 +1,26 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2015-2015. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/container for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#include <boost/container/slist.hpp>
+
+struct empty
+{
+   friend bool operator == (const empty &, const empty &){ return true; }
+   friend bool operator <  (const empty &, const empty &){ return true; }
+};
+
+template class ::boost::container::slist<empty>;
+
+int main()
+{
+   ::boost::container::slist<empty> dummy;
+   (void)dummy;
+   return 0;
+}
diff --git a/src/boost/libs/container/test/pmr_small_vector_test.cpp b/src/boost/libs/container/test/pmr_small_vector_test.cpp
new file mode 100644
index 000000000..334588da3
--- /dev/null
+++ b/src/boost/libs/container/test/pmr_small_vector_test.cpp
@@ -0,0 +1,26 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2015-2015. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/container for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#include <boost/container/pmr/small_vector.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/container/detail/type_traits.hpp>
+
+int main()
+{
+   using namespace boost::container;
+   using boost::container::dtl::is_same;
+
+   typedef small_vector<int, 2, pmr::polymorphic_allocator<int> > intcontainer_t;
+   BOOST_STATIC_ASSERT(( is_same<intcontainer_t, pmr::small_vector_of<int, 2>::type >::value ));
+   #if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
+      BOOST_STATIC_ASSERT(( is_same<intcontainer_t, pmr::small_vector<int, 2> >::value ));
+   #endif
+   return 0;
+}
diff --git a/src/boost/libs/container/test/pmr_stable_vector_test.cpp b/src/boost/libs/container/test/pmr_stable_vector_test.cpp
new file mode 100644
index 000000000..246f071c3
--- /dev/null
+++ b/src/boost/libs/container/test/pmr_stable_vector_test.cpp
@@ -0,0 +1,26 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2015-2015. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/container for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#include <boost/container/pmr/stable_vector.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/container/detail/type_traits.hpp>
+
+int main()
+{
+   using namespace boost::container;
+   using boost::container::dtl::is_same;
+
+   typedef stable_vector<int, pmr::polymorphic_allocator<int> > intcontainer_t;
+   BOOST_STATIC_ASSERT(( is_same<intcontainer_t, pmr::stable_vector_of<int>::type >::value ));
+   #if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
+      BOOST_STATIC_ASSERT(( is_same<intcontainer_t, pmr::stable_vector<int> >::value ));
+   #endif
+   return 0;
+}
diff --git a/src/boost/libs/container/test/pmr_static_vector_test.cpp b/src/boost/libs/container/test/pmr_static_vector_test.cpp
new file mode 100644
index 000000000..6681f7cd2
--- /dev/null
+++ b/src/boost/libs/container/test/pmr_static_vector_test.cpp
@@ -0,0 +1,26 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2015-2015. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/container for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#include <boost/container/static_vector.hpp>
+
+struct empty
+{
+   friend bool operator == (const empty &, const empty &){ return true; }
+   friend bool operator <  (const empty &, const empty &){ return true; }
+};
+
+template class ::boost::container::static_vector<empty, 2>;
+
+int main()
+{
+   ::boost::container::static_vector<empty, 2> dummy;
+   (void)dummy;
+   return 0;
+}
diff --git a/src/boost/libs/container/test/pmr_string_test.cpp b/src/boost/libs/container/test/pmr_string_test.cpp
new file mode 100644
index 000000000..c8d81a5ba
--- /dev/null
+++ b/src/boost/libs/container/test/pmr_string_test.cpp
@@ -0,0 +1,31 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2015-2015. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/container for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#include <boost/container/pmr/string.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/container/detail/type_traits.hpp>
+
+int main()
+{
+   using namespace boost::container;
+   using boost::container::dtl::is_same;
+
+   typedef basic_string<char, std::char_traits<char>, pmr::polymorphic_allocator<char> > string_t;
+   typedef basic_string<wchar_t, std::char_traits<wchar_t>, pmr::polymorphic_allocator<wchar_t> > wstring_t;
+   BOOST_STATIC_ASSERT(( is_same<string_t, pmr::string>::value ));
+   BOOST_STATIC_ASSERT(( is_same<string_t, pmr::basic_string_of<char>::type>::value ));
+   BOOST_STATIC_ASSERT(( is_same<wstring_t, pmr::wstring>::value ));
+   BOOST_STATIC_ASSERT(( is_same<wstring_t, pmr::basic_string_of<wchar_t>::type>::value ));
+   #if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
+      BOOST_STATIC_ASSERT(( is_same<string_t, pmr::string >::value ));
+      BOOST_STATIC_ASSERT(( is_same<wstring_t, pmr::wstring >::value ));
+   #endif
+   return 0;
+}
diff --git a/src/boost/libs/container/test/pmr_vector_test.cpp b/src/boost/libs/container/test/pmr_vector_test.cpp
new file mode 100644
index 000000000..293291ce0
--- /dev/null
+++ b/src/boost/libs/container/test/pmr_vector_test.cpp
@@ -0,0 +1,26 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2015-2015. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/container for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#include <boost/container/pmr/vector.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/container/detail/type_traits.hpp>
+
+int main()
+{
+   using namespace boost::container;
+   using boost::container::dtl::is_same;
+
+   typedef vector<int, pmr::polymorphic_allocator<int> > intcontainer_t;
+   BOOST_STATIC_ASSERT(( is_same<intcontainer_t, pmr::vector_of<int>::type >::value ));
+   #if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
+      BOOST_STATIC_ASSERT(( is_same<intcontainer_t, pmr::vector<int> >::value ));
+   #endif
+   return 0;
+}
diff --git a/src/boost/libs/container/test/polymorphic_allocator_test.cpp b/src/boost/libs/container/test/polymorphic_allocator_test.cpp
new file mode 100644
index 000000000..10899cac1
--- /dev/null
+++ b/src/boost/libs/container/test/polymorphic_allocator_test.cpp
@@ -0,0 +1,198 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2015-2015. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/container for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+#include <boost/container/pmr/polymorphic_allocator.hpp>
+#include <boost/container/pmr/global_resource.hpp>
+#include <boost/core/lightweight_test.hpp>
+
+#include "derived_from_memory_resource.hpp"
+#include "propagation_test_allocator.hpp"
+
+using namespace boost::container::pmr;
+using namespace boost::container;
+
+void test_default_constructor()
+{
+   polymorphic_allocator<int> a;
+   BOOST_TEST(a.resource() == get_default_resource());
+}
+
+void test_resource_constructor()
+{
+   polymorphic_allocator<int> a(0);
+   BOOST_TEST(a.resource() == get_default_resource());
+
+   derived_from_memory_resource d;
+   polymorphic_allocator<int> b(&d);
+   BOOST_TEST(&d == b.resource());
+}
+
+void test_copy_constructor()
+{
+   derived_from_memory_resource d;
+   polymorphic_allocator<int> b(&d);
+   polymorphic_allocator<int> c(b);
+   BOOST_TEST(b.resource() == c.resource());
+}
+
+void test_copy_assignment()
+{
+   derived_from_memory_resource d;
+   polymorphic_allocator<int> b(&d);
+   polymorphic_allocator<int> c;
+   BOOST_TEST(c.resource() == get_default_resource());
+   c = b;
+   BOOST_TEST(c.resource() == b.resource());
+}
+
+void test_allocate()
+{
+   int dummy;
+   derived_from_memory_resource d;
+   polymorphic_allocator<int> p(&d);
+   d.reset();
+   d.do_allocate_return = &dummy;
+   p.allocate(2);
+   BOOST_TEST(d.do_allocate_called == true);
+   BOOST_TEST(d.do_allocate_return == &dummy);
+   //It shall allocate 2*sizeof(int), alignment_of<int>
+   BOOST_TEST(d.do_allocate_bytes == 2*sizeof(int));
+   BOOST_TEST(d.do_allocate_alignment == dtl::alignment_of<int>::value);
+}
+
+void test_deallocate()
+{
+   int dummy;
+   derived_from_memory_resource d;
+   polymorphic_allocator<int> p(&d);
+   d.reset();
+   p.deallocate(&dummy, 3);
+   BOOST_TEST(d.do_deallocate_called == true);
+   //It shall deallocate 2*sizeof(int), alignment_of<int>
+   BOOST_TEST(d.do_deallocate_p == &dummy);
+   BOOST_TEST(d.do_deallocate_bytes == 3*sizeof(int));
+   BOOST_TEST(d.do_deallocate_alignment == dtl::alignment_of<int>::value);
+}
+
+void test_construct()
+{
+   //0 arg
+   {
+      typedef allocator_argument_tester<NotUsesAllocator, 0> value_type;
+      value_type value;
+      value.~value_type();
+      polymorphic_allocator<int> pa;
+      pa.construct(&value);
+      BOOST_TEST(value.construction_type == NotUsesAllocator);
+      BOOST_TEST(value.value == 0);
+      value.~value_type();
+   }
+   {
+      typedef allocator_argument_tester<ErasedTypePrefix, 0> value_type;
+      value_type value;
+      value.~value_type();
+      polymorphic_allocator<int> pa;
+      pa.construct(&value);
+      BOOST_TEST(value.construction_type == ConstructiblePrefix);
+      BOOST_TEST(value.value == 0);
+      value.~value_type();
+   }
+   {
+      typedef allocator_argument_tester<ErasedTypeSuffix, 0> value_type;
+      value_type value;
+      value.~value_type();
+      polymorphic_allocator<int> pa;
+      pa.construct(&value);
+      BOOST_TEST(value.construction_type == ConstructibleSuffix);
+      BOOST_TEST(value.value == 0);
+      value.~value_type();
+   }
+   //1 arg
+   {
+      typedef allocator_argument_tester<NotUsesAllocator, 0> value_type;
+      value_type value;
+      value.~value_type();
+      polymorphic_allocator<int> pa;
+      pa.construct(&value, 2);
+      BOOST_TEST(value.construction_type == NotUsesAllocator);
+      BOOST_TEST(value.value == 2);
+      value.~value_type();
+   }
+   {
+      typedef allocator_argument_tester<ErasedTypePrefix, 0> value_type;
+      value_type value;
+      value.~value_type();
+      polymorphic_allocator<int> pa;
+      pa.construct(&value, 3);
+      BOOST_TEST(value.construction_type == ConstructiblePrefix);
+      BOOST_TEST(value.value == 3);
+      value.~value_type();
+   }
+   {
+      typedef allocator_argument_tester<ErasedTypeSuffix, 0> value_type;
+      value_type value;
+      value.~value_type();
+      polymorphic_allocator<int> pa;
+      pa.construct(&value, 4);
+      BOOST_TEST(value.construction_type == ConstructibleSuffix);
+      BOOST_TEST(value.value == 4);
+      value.~value_type();
+   }
+}
+
+struct char_holder
+{
+   char m_char;
+   ~char_holder()
+   {  destructor_called = true;  }
+   static bool destructor_called;
+};
+
+bool char_holder::destructor_called = false;
+
+void test_destroy()
+{
+   char_holder ch;
+   polymorphic_allocator<int> p;
+   BOOST_TEST(char_holder::destructor_called == false);
+   p.destroy(&ch);
+   BOOST_TEST(char_holder::destructor_called == true);
+}
+
+void test_select_on_container_copy_construction()
+{
+   //select_on_container_copy_construction shall return
+   //a default constructed polymorphic_allocator
+   //which uses the default resource.
+   derived_from_memory_resource d;
+   polymorphic_allocator<int> p(&d);
+   BOOST_TEST(get_default_resource() == p.select_on_container_copy_construction().resource());
+}
+
+void test_resource()
+{
+   derived_from_memory_resource d;
+   polymorphic_allocator<int> p(&d);
+   BOOST_TEST(&d == p.resource());
+}
+
+int main()
+{
+   test_default_constructor();
+   test_resource_constructor();
+   test_copy_constructor();
+   test_copy_assignment();
+   test_allocate();
+   test_deallocate();
+   test_construct();
+   test_destroy();
+   test_select_on_container_copy_construction();
+   test_resource();
+   return ::boost::report_errors();
+}
diff --git a/src/boost/libs/container/test/pool_resource_test.hpp b/src/boost/libs/container/test/pool_resource_test.hpp
new file mode 100644
index 000000000..110274e32
--- /dev/null
+++ b/src/boost/libs/container/test/pool_resource_test.hpp
@@ -0,0 +1,493 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2015-2015. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/container for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#include <boost/container/pmr/global_resource.hpp>
+#include <boost/core/lightweight_test.hpp>
+
+#include <boost/intrusive/detail/math.hpp>
+
+#include "derived_from_memory_resource.hpp"
+#include "memory_resource_logger.hpp"
+
+using namespace boost::container::pmr;
+
+template<class PoolResource>
+struct derived_from_pool_resource
+   : public PoolResource
+{
+   derived_from_pool_resource(const pool_options& opts, memory_resource* upstream)
+      : PoolResource(opts, upstream)
+   {}
+
+   explicit derived_from_pool_resource(memory_resource *p)
+      : PoolResource(p)
+   {}
+
+   explicit derived_from_pool_resource(const pool_options &opts)
+      : PoolResource(opts)
+   {}
+
+   derived_from_pool_resource()
+      : PoolResource()
+   {}
+
+   using PoolResource::do_allocate;
+   using PoolResource::do_deallocate;
+   using PoolResource::do_is_equal;
+};
+
+template<class PoolResource>
+void test_default_constructor()
+{
+   //With default options/resource
+   {
+      derived_from_memory_resource dmr;
+      dmr.reset();
+      PoolResource m;
+      //test postconditions
+      BOOST_TEST(m.upstream_resource() == get_default_resource());
+      BOOST_TEST(m.options().max_blocks_per_chunk == pool_options_default_max_blocks_per_chunk);
+      BOOST_TEST(m.options().largest_required_pool_block == pool_options_default_largest_required_pool_block);
+      //test it does not allocate any memory
+      BOOST_TEST(dmr.do_allocate_called == false);
+   }
+}
+
+template<class PoolResource>
+void test_upstream_constructor()
+{
+   //With a resource, default options
+   {
+      derived_from_memory_resource dmr;
+      dmr.reset();
+      PoolResource m(&dmr);
+      //test postconditions
+      BOOST_TEST(m.upstream_resource() == &dmr);
+      BOOST_TEST(m.options().max_blocks_per_chunk == pool_options_default_max_blocks_per_chunk);
+      BOOST_TEST(m.options().largest_required_pool_block == pool_options_default_largest_required_pool_block);
+      //test it does not allocate any memory
+      BOOST_TEST(dmr.do_allocate_called == false);
+   }
+}
+
+template<class PoolResource>
+void test_options_constructor()
+{
+   //Default options
+   {
+      memory_resource_logger mrl;
+      BOOST_TEST(mrl.m_info.size() == 0u);
+      set_default_resource(&mrl);
+      pool_options opts;
+      PoolResource m(opts);
+      //test postconditions
+      BOOST_TEST(m.upstream_resource() == get_default_resource());
+      BOOST_TEST(m.options().max_blocks_per_chunk == pool_options_default_max_blocks_per_chunk);
+      BOOST_TEST(m.options().largest_required_pool_block == pool_options_default_largest_required_pool_block);
+      //test it does not allocate any memory
+      BOOST_TEST(mrl.m_info.size() == 0u);
+   }
+   //Too large option values
+   {
+      memory_resource_logger mrl;
+      BOOST_TEST(mrl.m_info.size() == 0u);
+      set_default_resource(&mrl);
+      pool_options opts;
+      opts.max_blocks_per_chunk = pool_options_default_max_blocks_per_chunk+1;
+      opts.largest_required_pool_block = pool_options_default_largest_required_pool_block+1;
+      PoolResource m(opts);
+      //test postconditions
+      BOOST_TEST(m.upstream_resource() == get_default_resource());
+      BOOST_TEST(m.options().max_blocks_per_chunk == pool_options_default_max_blocks_per_chunk);
+      BOOST_TEST(m.options().largest_required_pool_block == pool_options_default_largest_required_pool_block);
+      //test it does not allocate any memory
+      BOOST_TEST(mrl.m_info.size() == 0u);
+   }
+   //Too small option values
+   {
+      memory_resource_logger mrl;
+      BOOST_TEST(mrl.m_info.size() == 0u);
+      set_default_resource(&mrl);
+      pool_options opts;
+      opts.largest_required_pool_block = pool_options_minimum_largest_required_pool_block-1u;
+      PoolResource m(opts);
+      //test postconditions
+      BOOST_TEST(m.upstream_resource() == get_default_resource());
+      BOOST_TEST(m.options().max_blocks_per_chunk == pool_options_default_max_blocks_per_chunk);
+      BOOST_TEST(m.options().largest_required_pool_block == pool_options_minimum_largest_required_pool_block);
+      //test it does not allocate any memory
+      BOOST_TEST(mrl.m_info.size() == 0u);
+   }
+   //In range option values
+   {
+      memory_resource_logger mrl;
+      BOOST_TEST(mrl.m_info.size() == 0u);
+      set_default_resource(&mrl);
+      pool_options opts;
+      opts.max_blocks_per_chunk = pool_options_default_max_blocks_per_chunk;
+      opts.largest_required_pool_block = pool_options_minimum_largest_required_pool_block;
+      PoolResource m(opts);
+      //test postconditions
+      BOOST_TEST(m.upstream_resource() == get_default_resource());
+      BOOST_TEST(m.options().max_blocks_per_chunk == pool_options_default_max_blocks_per_chunk);
+      BOOST_TEST(m.options().largest_required_pool_block == pool_options_minimum_largest_required_pool_block);
+      //test it does not allocate any memory
+      BOOST_TEST(mrl.m_info.size() == 0u);
+   }
+}
+
+template<class PoolResource>
+void test_options_upstream_constructor()
+{
+   //Default options
+   {
+      derived_from_memory_resource dmr;
+      dmr.reset();
+      pool_options opts;
+      PoolResource m(opts, &dmr);
+      //test postconditions
+      BOOST_TEST(m.upstream_resource() == &dmr);
+      BOOST_TEST(m.options().max_blocks_per_chunk == pool_options_default_max_blocks_per_chunk);
+      BOOST_TEST(m.options().largest_required_pool_block == pool_options_default_largest_required_pool_block);
+      //test it does not allocate any memory
+      BOOST_TEST(dmr.do_allocate_called == false);
+   }
+   //Too large option values
+   {
+      derived_from_memory_resource dmr;
+      dmr.reset();
+      pool_options opts;
+      opts.max_blocks_per_chunk = pool_options_default_max_blocks_per_chunk+1;
+      opts.largest_required_pool_block = pool_options_default_largest_required_pool_block+1;
+      PoolResource m(opts, &dmr);
+      //test postconditions
+      BOOST_TEST(m.upstream_resource() == &dmr);
+      BOOST_TEST(m.options().max_blocks_per_chunk == pool_options_default_max_blocks_per_chunk);
+      BOOST_TEST(m.options().largest_required_pool_block == pool_options_default_largest_required_pool_block);
+      //test it does not allocate any memory
+      BOOST_TEST(dmr.do_allocate_called == false);
+   }
+   //Too small option values
+   {
+      derived_from_memory_resource dmr;
+      dmr.reset();
+      pool_options opts;
+      opts.largest_required_pool_block = pool_options_minimum_largest_required_pool_block-1u;
+      PoolResource m(opts, &dmr);
+      //test postconditions
+      BOOST_TEST(m.upstream_resource() == &dmr);
+      BOOST_TEST(m.options().max_blocks_per_chunk == pool_options_default_max_blocks_per_chunk);
+      BOOST_TEST(m.options().largest_required_pool_block == pool_options_minimum_largest_required_pool_block);
+      //test it does not allocate any memory
+      BOOST_TEST(dmr.do_allocate_called == false);
+   }
+   //In range option values
+   {
+      derived_from_memory_resource dmr;
+      dmr.reset();
+      pool_options opts;
+      opts.max_blocks_per_chunk = pool_options_default_max_blocks_per_chunk;
+      opts.largest_required_pool_block = pool_options_minimum_largest_required_pool_block;
+      PoolResource m(opts, &dmr);
+      //test postconditions
+      BOOST_TEST(m.upstream_resource() == &dmr);
+      //max blocks is unchanged in this implementation
+      BOOST_TEST(m.options().max_blocks_per_chunk == pool_options_default_max_blocks_per_chunk);
+      //largest block is rounded to pow2
+      BOOST_TEST(m.options().largest_required_pool_block == bi::detail::ceil_pow2(opts.largest_required_pool_block));
+      //test it does not allocate any memory
+      BOOST_TEST(dmr.do_allocate_called == false);
+   }
+}
+
+template<class PoolResource>
+void test_options()
+{
+   //In range option values
+   {
+      derived_from_memory_resource dmr;
+      dmr.reset();
+      pool_options opts;
+      opts.max_blocks_per_chunk = pool_options_default_max_blocks_per_chunk/2u;
+      opts.largest_required_pool_block = (pool_options_default_largest_required_pool_block
+         - pool_options_minimum_largest_required_pool_block) | std::size_t(1); //guaranteed to be non power of 2.
+      PoolResource m(opts, &dmr);
+      //test postconditions
+      BOOST_TEST(m.upstream_resource() == &dmr);
+      //max blocks is unchanged in this implementation
+      BOOST_TEST(m.options().max_blocks_per_chunk == opts.max_blocks_per_chunk);
+      //largest block is rounded to pow2
+      BOOST_TEST(m.options().largest_required_pool_block == bi::detail::ceil_pow2(opts.largest_required_pool_block));
+      //test it does not allocate any memory
+      BOOST_TEST(dmr.do_allocate_called == false);
+   }
+}
+
+template<class PoolResource>
+void test_do_allocate_deallocate()
+{
+   memory_resource_logger mrl;
+   {
+      derived_from_pool_resource<PoolResource> dmbr(&mrl);
+      {
+         //First block from pool 0
+         dmbr.do_allocate(1, 1);
+         //It should allocate the pool array plus an initial block
+         BOOST_TEST(mrl.m_info.size() == 2u);
+         //Second block from pool 0
+         dmbr.do_allocate(1, 1);
+         //It should allocate again (with 2 chunks per block)
+         BOOST_TEST(mrl.m_info.size() == 3u);
+         //Third block from pool 0
+         dmbr.do_allocate(1, 1);
+         //It should NOT allocate again (previous was a 2 block chunk)
+         BOOST_TEST(mrl.m_info.size() == 3u);
+      }
+   }
+   BOOST_TEST(mrl.m_mismatches == 0u);
+   BOOST_TEST(mrl.m_info.size() == 0u);
+
+   //Allocate and deallocate from the same chunk to test block caching
+   {
+      derived_from_pool_resource<PoolResource> dmbr(&mrl);
+      {
+         //First block from pool 0
+         void *p = dmbr.do_allocate(1, 1);
+         //It should allocate the pool array plus an initial block
+         BOOST_TEST(mrl.m_info.size() == 2u);
+         //No cached, as initial blocks per chunk is 1
+         BOOST_TEST(dmbr.pool_cached_blocks(0u) == 0u);
+         //Deallocate and allocate again
+         dmbr.do_deallocate(p, 1, 1);
+         //Cached
+         BOOST_TEST(dmbr.pool_cached_blocks(0u) == 1u);
+         p = dmbr.do_allocate(1, 1);
+         //Reused
+         BOOST_TEST(dmbr.pool_cached_blocks(0u) == 0u);
+         //It should have NOT allocated (block reuse)
+         BOOST_TEST(mrl.m_info.size() == 2u);
+
+         //Allocate again 2 times (a 2 block chunk is exhausted)
+         void *p2 = dmbr.do_allocate(1, 1);
+         //1 left cached
+         BOOST_TEST(dmbr.pool_cached_blocks(0u) == 1u);
+         void *p3 = dmbr.do_allocate(1, 1);
+         //Cache exhausted
+         BOOST_TEST(dmbr.pool_cached_blocks(0u) == 0u);
+         //Single chunk allocation happened
+         BOOST_TEST(mrl.m_info.size() == 3u);
+
+         //Now deallocate all (no memory is freed, all cached)
+         dmbr.do_deallocate(p2, 1, 1);
+         dmbr.do_deallocate(p3, 1, 1);
+         dmbr.do_deallocate(p, 1, 1);
+         BOOST_TEST(dmbr.pool_cached_blocks(0u) == 3u);
+         BOOST_TEST(mrl.m_info.size() == 3u);
+      }
+   }
+   BOOST_TEST(mrl.m_mismatches == 0u);
+   BOOST_TEST(mrl.m_info.size() == 0u);
+
+   //Now test max block per chunk
+   {
+      pool_options opts;
+      //so after max_blocks_per_chunk*2-1 allocations, all new chunks must hold max_blocks_per_chunk blocks
+      opts.max_blocks_per_chunk = 32u; 
+      derived_from_pool_resource<PoolResource> dmbr(opts, &mrl);
+      {
+         std::size_t loops = opts.max_blocks_per_chunk*2-1u;
+         while(loops--){
+            dmbr.do_allocate(1, 1);
+         }
+         //pool array + log2(max_blocks_per_chunk)+1 chunks (sizes [1, 2, 4, ...])
+         const std::size_t num_chunks = bi::detail::floor_log2(opts.max_blocks_per_chunk)+1u;
+         BOOST_TEST(mrl.m_info.size() == 1u + num_chunks);
+         //Next allocation should allocate max_blocks_per_chunk blocks in a chunk so max_blocks_per_chunk-1 should remain free
+         dmbr.do_allocate(1, 1);
+         BOOST_TEST(mrl.m_info.size() == 1u + num_chunks + 1u);
+         BOOST_TEST(dmbr.pool_cached_blocks(0u) == (opts.max_blocks_per_chunk-1u));
+         //Exhaust the chunk and allocate a new one, test max_blocks_per_chunk is not passed again
+         loops = opts.max_blocks_per_chunk;
+         while(loops--){
+            dmbr.do_allocate(1, 1);
+         }
+         BOOST_TEST(mrl.m_info.size() == 1u + num_chunks + 2u);
+         BOOST_TEST(dmbr.pool_cached_blocks(0u) == (opts.max_blocks_per_chunk-1u));
+      }
+   }
+   BOOST_TEST(mrl.m_mismatches == 0u);
+   BOOST_TEST(mrl.m_info.size() == 0u);
+
+   //Now test max block per chunk
+   {
+      pool_options opts;
+      //so after max_blocks_per_chunk*2-1 allocations, all new chunks must hold max_blocks_per_chunk blocks
+      opts.max_blocks_per_chunk = 32u; 
+      derived_from_pool_resource<PoolResource> dmbr(opts, &mrl);
+      {
+         std::size_t loops = opts.max_blocks_per_chunk*2-1u;
+         while(loops--){
+            dmbr.do_allocate(1, 1);
+         }
+         //pool array + log2(max_blocks_per_chunk)+1 chunks (sizes [1, 2, 4, ...])
+         BOOST_TEST(dmbr.pool_next_blocks_per_chunk(0u) == opts.max_blocks_per_chunk);
+         const std::size_t num_chunks = bi::detail::floor_log2(opts.max_blocks_per_chunk)+1u;
+         BOOST_TEST(mrl.m_info.size() == 1u + num_chunks);
+         //Next allocation should allocate max_blocks_per_chunk blocks in a chunk so max_blocks_per_chunk-1 should remain free
+         dmbr.do_allocate(1, 1);
+         BOOST_TEST(dmbr.pool_next_blocks_per_chunk(0u) == opts.max_blocks_per_chunk);
+         BOOST_TEST(mrl.m_info.size() == 1u + num_chunks + 1u);
+         BOOST_TEST(dmbr.pool_cached_blocks(0u) == (opts.max_blocks_per_chunk-1u));
+      }
+   }
+   BOOST_TEST(mrl.m_mismatches == 0u);
+   BOOST_TEST(mrl.m_info.size() == 0u);
+
+   //Now test different pool sizes
+   {
+      pool_options opts;
+      //so after max_blocks_per_chunk*2-1 allocations, all new chunks must hold max_blocks_per_chunk blocks
+      opts.max_blocks_per_chunk = 1u; 
+      derived_from_pool_resource<PoolResource> dmbr(opts, &mrl);
+      const pool_options &final_opts = dmbr.options();
+
+      //Force pool creation
+      dmbr.do_deallocate(dmbr.do_allocate(1, 1), 1, 1);
+      //pool array plus first pool's chunk allocation
+      BOOST_TEST(mrl.m_info.size() == 2u);
+      //pool count must be:
+      // log2(the maximum block) - log2(the minimum block) + 1. Example if minimum block is 8, and maximum 32:
+      // log(32) - log2(8) + 1u = 3 pools (block sizes: 8, 16, and 32)
+      const std::size_t minimum_size = dmbr.pool_block(0u);
+      const std::size_t maximum_size = final_opts.largest_required_pool_block;
+      BOOST_TEST(dmbr.pool_count() == (1u + bi::detail::floor_log2(maximum_size) - bi::detail::floor_log2(minimum_size)));
+      for(std::size_t i = 0, s = minimum_size, max = dmbr.pool_count(); i != max; ++i, s*=2){
+         //Except in the first pool, each cache should be empty
+         BOOST_TEST(dmbr.pool_cached_blocks(i) == std::size_t(i == 0));
+         dmbr.do_deallocate(dmbr.do_allocate(s/2+1, 1), s/2+1, 1);
+         dmbr.do_deallocate(dmbr.do_allocate(s-1, 1), s-1, 1);
+         dmbr.do_deallocate(dmbr.do_allocate(s, 1), s, 1);
+         //pool array plus each previous chunk allocation
+         BOOST_TEST(mrl.m_info.size() == (1u + i + 1u));
+         //as we limited max_blocks_per_chunk to 1, no cached blocks should be available except one
+         BOOST_TEST(dmbr.pool_cached_blocks(i) == 1u);
+      }
+      //Now test out of maximum values, which should go directly to upstream
+      //it should be directly deallocated.
+      void *p = dmbr.do_allocate(maximum_size+1, 1);
+      BOOST_TEST(mrl.m_info.size() == (1u + dmbr.pool_count() + 1u));
+      dmbr.do_deallocate(p, maximum_size+1, 1);
+      BOOST_TEST(mrl.m_info.size() == (1u + dmbr.pool_count()));
+   }
+   BOOST_TEST(mrl.m_mismatches == 0u);
+   BOOST_TEST(mrl.m_info.size() == 0u);
+}
+
+template<class PoolResource>
+void test_do_is_equal()
+{
+   //`this == dynamic_cast<const PoolResource*>(&other)`.
+   memory_resource_logger mrl;
+   derived_from_pool_resource<PoolResource> dmbr(&mrl);
+   derived_from_pool_resource<PoolResource> dmbr2(&mrl);
+   BOOST_TEST(true == dmbr.do_is_equal(dmbr));
+   BOOST_TEST(false == dmbr.do_is_equal(dmbr2));
+   //A different type should be always different
+   derived_from_memory_resource dmr;
+   BOOST_TEST(false == dmbr.do_is_equal(dmr));
+}
+
+template<class PoolResource>
+void test_release()
+{
+   memory_resource_logger mrl;
+   {
+      pool_options opts;
+      //so after max_blocks_per_chunk*2-1 allocations, all new chunks must hold max_blocks_per_chunk blocks
+      opts.max_blocks_per_chunk = 4u; 
+      derived_from_pool_resource<PoolResource> dmbr(opts, &mrl);
+      const pool_options &final_opts = dmbr.options();
+      const std::size_t minimum_size = dmbr.pool_block(0u);
+      const std::size_t maximum_size = final_opts.largest_required_pool_block;
+      const std::size_t pool_count = 1u + bi::detail::floor_log2(maximum_size) - bi::detail::floor_log2(minimum_size);
+
+      std::size_t expected_memory_allocs = 0;
+      for(std::size_t i = 0, imax = pool_count, s = minimum_size; i != imax; s*=2, ++i){
+         for(std::size_t j = 0, j_max = opts.max_blocks_per_chunk*2u-1u; j != j_max; ++j){
+            dmbr.do_allocate(s, 1);
+         }
+         //One due to the pool array, and for each pool, log2(max_blocks_per_chunk)+1 allocations
+         expected_memory_allocs = 1 + (bid::floor_log2(opts.max_blocks_per_chunk) + 1u)*(i+1);
+         //pool array plus each previous chunk allocation
+         BOOST_TEST(mrl.m_info.size() == expected_memory_allocs);
+      }
+      //Now with out-of-pool sizes
+      for(std::size_t j = 0, j_max = opts.max_blocks_per_chunk*2u-1u; j != j_max; ++j){
+         dmbr.do_allocate(maximum_size+1, 1);
+         BOOST_TEST(mrl.m_info.size() == ++expected_memory_allocs);
+      }
+      //Now release memory and check all memory allocated through do_allocate was deallocated to upstream      
+      dmbr.release();
+      BOOST_TEST(mrl.m_info.size() == 1u);
+   }
+   BOOST_TEST(mrl.m_mismatches == 0u);
+   BOOST_TEST(mrl.m_info.size() == 0u);
+}
+
+template<class PoolResource>
+void test_destructor()
+{
+   memory_resource_logger mrl;
+   {
+      pool_options opts;
+      //so after max_blocks_per_chunk*2-1 allocations, all new chunks must hold max_blocks_per_chunk blocks
+      opts.max_blocks_per_chunk = 4u; 
+      derived_from_pool_resource<PoolResource> dmbr(opts, &mrl);
+      const pool_options &final_opts = dmbr.options();
+      const std::size_t minimum_size = dmbr.pool_block(0u);
+      const std::size_t maximum_size = final_opts.largest_required_pool_block;
+      const std::size_t pool_count = 1u + bi::detail::floor_log2(maximum_size) - bi::detail::floor_log2(minimum_size);
+
+      std::size_t expected_memory_allocs = 0;
+      for(std::size_t i = 0, imax = pool_count, s = minimum_size; i != imax; s*=2, ++i){
+         for(std::size_t j = 0, j_max = opts.max_blocks_per_chunk*2u-1u; j != j_max; ++j){
+            dmbr.do_allocate(s, 1);
+         }
+         //One due to the pool array, and for each pool, log2(max_blocks_per_chunk)+1 allocations
+         expected_memory_allocs = 1 + (bid::floor_log2(opts.max_blocks_per_chunk) + 1u)*(i+1);
+         //pool array plus each previous chunk allocation
+         BOOST_TEST(mrl.m_info.size() == expected_memory_allocs);
+      }
+      //Now with out-of-pool sizes
+      for(std::size_t j = 0, j_max = opts.max_blocks_per_chunk*2u-1u; j != j_max; ++j){
+         dmbr.do_allocate(maximum_size+1, 1);
+         BOOST_TEST(mrl.m_info.size() == ++expected_memory_allocs);
+      }
+      //Don't release, all memory, including internal allocations, should be automatically
+      //released after the destructor is run
+   }
+   BOOST_TEST(mrl.m_mismatches == 0u);
+   BOOST_TEST(mrl.m_info.size() == 0u);
+}
+
+
+template<class PoolResource>
+void test_pool_resource()
+{
+   test_options_upstream_constructor<PoolResource>();
+   test_default_constructor<PoolResource>();
+   test_upstream_constructor<PoolResource>();
+   test_options_constructor<PoolResource>();
+   test_options<PoolResource>();
+   test_do_allocate_deallocate<PoolResource>();
+   test_do_is_equal<PoolResource>();
+   test_release<PoolResource>();
+   test_destructor<PoolResource>();
+}
diff --git a/src/boost/libs/container/test/print_container.hpp b/src/boost/libs/container/test/print_container.hpp
new file mode 100644
index 000000000..2e49ec60e
--- /dev/null
+++ b/src/boost/libs/container/test/print_container.hpp
@@ -0,0 +1,46 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2004-2013. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/container for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#ifndef BOOST_PRINTCONTAINER_HPP
+#define BOOST_PRINTCONTAINER_HPP
+
+#include <boost/container/detail/config_begin.hpp>
+#include <iostream>
+
+namespace boost{
+namespace container {
+namespace test{
+
+//Function to dump data
+template<class MyBoostCont
+        ,class MyStdCont>
+void PrintContainers(MyBoostCont *boostcont, MyStdCont *stdcont)
+{
+   typename MyBoostCont::iterator itboost = boostcont->begin(), itboostend = boostcont->end();
+   typename MyStdCont::iterator itstd = stdcont->begin(), itstdend = stdcont->end();
+
+   std::cout << "MyBoostCont" << std::endl;
+   for(; itboost != itboostend; ++itboost){
+      std::cout << *itboost << std::endl;
+   }
+   std::cout << "MyStdCont" << std::endl;
+
+   for(; itstd != itstdend; ++itstd){
+      std::cout << *itstd << std::endl;
+   }
+}
+
+}  //namespace test{
+}  //namespace container {
+}  //namespace boost{
+
+#include <boost/container/detail/config_end.hpp>
+
+#endif //#ifndef BOOST_PRINTCONTAINER_HPP
diff --git a/src/boost/libs/container/test/propagate_allocator_test.hpp b/src/boost/libs/container/test/propagate_allocator_test.hpp
new file mode 100644
index 000000000..e3a504818
--- /dev/null
+++ b/src/boost/libs/container/test/propagate_allocator_test.hpp
@@ -0,0 +1,368 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2008. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/container for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+#ifndef BOOST_CONTAINER_PROPAGATE_ALLOCATOR_TEST_HPP
+#define BOOST_CONTAINER_PROPAGATE_ALLOCATOR_TEST_HPP
+
+#include <boost/container/detail/config_begin.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include "dummy_test_allocator.hpp"
+
+#include <iostream>
+
+namespace boost{
+namespace container {
+namespace test{
+
+template<class Selector>
+struct alloc_propagate_base;
+
+template<class T, class Allocator, class Selector>
+class alloc_propagate_wrapper
+   : public alloc_propagate_base<Selector>::template apply<T, Allocator>::type
+{
+   BOOST_COPYABLE_AND_MOVABLE(alloc_propagate_wrapper)
+
+   public:   
+   typedef typename alloc_propagate_base
+      <Selector>::template apply<T, Allocator>::type  Base;
+
+   typedef typename Base::allocator_type  allocator_type;
+   typedef typename Base::value_type      value_type;
+   typedef typename Base::size_type       size_type;
+
+   alloc_propagate_wrapper()
+      : Base()
+   {}
+
+   explicit alloc_propagate_wrapper(const allocator_type &a)
+      : Base(a)
+   {}
+/*
+   //sequence containers only
+   explicit alloc_propagate_wrapper(size_type n, const value_type &v, const allocator_type &a)
+      : Base(n, v, a)
+   {}
+
+   alloc_propagate_wrapper(size_type n, const allocator_type &a)
+      : Base(n, a)
+   {}*/
+
+   template<class Iterator>
+   alloc_propagate_wrapper(Iterator b, Iterator e, const allocator_type &a)
+      : Base(b, e, a)
+   {}
+
+   #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
+   alloc_propagate_wrapper(std::initializer_list<value_type> il, const allocator_type& a)
+      : Base(il, a)
+   {}
+/*
+   //associative containers only
+   alloc_propagate_wrapper(std::initializer_list<value_type> il, const Compare& comp, const allocator_type& a)
+      : Base(il, comp, a)
+   {}*/
+
+   #endif
+
+   alloc_propagate_wrapper(const alloc_propagate_wrapper &x)
+      : Base(x)
+   {}
+
+   alloc_propagate_wrapper(const alloc_propagate_wrapper &x, const allocator_type &a)
+      : Base(x, a)
+   {}
+
+   alloc_propagate_wrapper(BOOST_RV_REF(alloc_propagate_wrapper) x)
+      : Base(boost::move(static_cast<Base&>(x)))
+   {}
+
+   alloc_propagate_wrapper(BOOST_RV_REF(alloc_propagate_wrapper) x, const allocator_type &a)
+      : Base(boost::move(static_cast<Base&>(x)), a)
+   {}
+
+   alloc_propagate_wrapper &operator=(BOOST_COPY_ASSIGN_REF(alloc_propagate_wrapper) x)
+   {  this->Base::operator=((const Base &)x);  return *this; }
+
+   alloc_propagate_wrapper &operator=(BOOST_RV_REF(alloc_propagate_wrapper) x)
+   {  this->Base::operator=(boost::move(static_cast<Base&>(x)));  return *this; }
+
+   void swap(alloc_propagate_wrapper &x)
+   {  this->Base::swap(x);  }
+};
+
+template<class T>
+struct get_real_stored_allocator
+{
+   typedef typename T::stored_allocator_type type;
+};
+
+template<class Container>
+void test_propagate_allocator_allocator_arg();
+
+template<class Selector>
+bool test_propagate_allocator()
+{
+   {
+      typedef propagation_test_allocator<char, true, true, true, true>  AlwaysPropagate;
+      typedef alloc_propagate_wrapper<char, AlwaysPropagate, Selector>  PropagateCont;
+      typedef typename get_real_stored_allocator<typename PropagateCont::Base>::type StoredAllocator;
+      {
+         //////////////////////////////////////////
+         //Test AlwaysPropagate allocator propagation
+         //////////////////////////////////////////
+         
+         //default constructor
+         StoredAllocator::reset_unique_id(111);
+         PropagateCont c;  //stored 112
+         BOOST_TEST (c.get_stored_allocator().id_ == 112);
+         BOOST_TEST (c.get_stored_allocator().ctr_copies_ == 0);
+         BOOST_TEST (c.get_stored_allocator().ctr_moves_ == 0);
+         BOOST_TEST (c.get_stored_allocator().assign_copies_ == 0);
+         BOOST_TEST (c.get_stored_allocator().assign_moves_ == 0);
+         BOOST_TEST (c.get_stored_allocator().swaps_ == 0);
+      }
+      {
+         //copy constructor
+         StoredAllocator::reset_unique_id(222);
+         PropagateCont c; //stored 223
+         BOOST_TEST (c.get_stored_allocator().id_ == 223);
+         //propagate_on_copy_constructor produces copies, moves or RVO (depending on the compiler).
+         //For allocators that copy in select_on_container_copy_construction, at least we must have a copy
+         PropagateCont c2(c); //should propagate 223
+         BOOST_TEST (c2.get_stored_allocator().id_ == 223);
+         BOOST_TEST (c2.get_stored_allocator().ctr_copies_ >= 1);
+         BOOST_TEST (c2.get_stored_allocator().ctr_moves_ >= 0);
+         BOOST_TEST (c2.get_stored_allocator().assign_copies_ == 0);
+         BOOST_TEST (c2.get_stored_allocator().assign_moves_ == 0);
+         BOOST_TEST (c2.get_stored_allocator().swaps_ == 0);
+      }
+      {
+         //move constructor
+         StoredAllocator::reset_unique_id(333);
+         PropagateCont c; //stored 334
+         BOOST_TEST (c.get_stored_allocator().id_ == 334);
+         PropagateCont c2(boost::move(c)); //should propagate 334
+         BOOST_TEST (c2.get_stored_allocator().id_ == 334);
+         BOOST_TEST (c2.get_stored_allocator().ctr_copies_ == 0);
+         BOOST_TEST (c2.get_stored_allocator().ctr_moves_ > 0);
+         BOOST_TEST (c2.get_stored_allocator().assign_copies_ == 0);
+         BOOST_TEST (c2.get_stored_allocator().assign_moves_ == 0);
+         BOOST_TEST (c2.get_stored_allocator().swaps_ == 0);
+      }
+      {
+         //copy assign
+         StoredAllocator::reset_unique_id(444);
+         PropagateCont c; //stored 445
+         BOOST_TEST (c.get_stored_allocator().id_ == 445);
+         PropagateCont c2; //stored 446
+         BOOST_TEST (c2.get_stored_allocator().id_ == 446);
+         c2 = c; //should propagate 445
+         BOOST_TEST (c2.get_stored_allocator().id_ == 445);
+         BOOST_TEST (c2.get_stored_allocator().ctr_copies_ == 0);
+         BOOST_TEST (c2.get_stored_allocator().ctr_moves_  == 0);
+         BOOST_TEST (c2.get_stored_allocator().assign_copies_ == 1);
+         BOOST_TEST (c2.get_stored_allocator().assign_moves_ == 0);
+         BOOST_TEST (c2.get_stored_allocator().swaps_ == 0);
+      }
+      {
+         //move assign
+         StoredAllocator::reset_unique_id(555);
+         PropagateCont c; //stored 556
+         BOOST_TEST (c.get_stored_allocator().id_ == 556);
+         PropagateCont c2; //stored 557
+         BOOST_TEST (c2.get_stored_allocator().id_ == 557);
+         c = boost::move(c2); //should propagate 557
+         BOOST_TEST (c.get_stored_allocator().id_ == 557);
+         BOOST_TEST (c.get_stored_allocator().ctr_copies_    == 0);
+         BOOST_TEST (c.get_stored_allocator().ctr_moves_     == 0);
+         BOOST_TEST (c.get_stored_allocator().assign_copies_ == 0);
+         BOOST_TEST (c.get_stored_allocator().assign_moves_ == 1);
+         BOOST_TEST (c.get_stored_allocator().swaps_ == 0);
+      }
+      {
+         //swap
+         StoredAllocator::reset_unique_id(666);
+         PropagateCont c; //stored 667
+         BOOST_TEST (c.get_stored_allocator().id_ == 667);
+         PropagateCont c2; //stored 668
+         BOOST_TEST (c2.get_stored_allocator().id_ == 668);
+         c.swap(c2);
+         BOOST_TEST (c2.get_stored_allocator().ctr_copies_    == 0);
+         BOOST_TEST (c.get_stored_allocator().ctr_copies_    == 0);
+         BOOST_TEST (c2.get_stored_allocator().ctr_moves_     == 0);
+         BOOST_TEST (c.get_stored_allocator().ctr_moves_     == 0);
+         BOOST_TEST (c2.get_stored_allocator().assign_copies_ == 0);
+         BOOST_TEST (c.get_stored_allocator().assign_copies_ == 0);
+         BOOST_TEST (c2.get_stored_allocator().assign_moves_  == 0);
+         BOOST_TEST (c.get_stored_allocator().assign_moves_  == 0);
+         BOOST_TEST (c2.get_stored_allocator().swaps_  == 1);
+         BOOST_TEST (c.get_stored_allocator().swaps_  == 1);
+      }
+      //And now allocator argument constructors
+      test_propagate_allocator_allocator_arg<PropagateCont>();
+   }
+
+   //////////////////////////////////////////
+   //Test NeverPropagate allocator propagation
+   //////////////////////////////////////////
+   {
+      typedef propagation_test_allocator<char, false, false, false, false> NeverPropagate;
+      typedef alloc_propagate_wrapper<char, NeverPropagate, Selector>      NoPropagateCont;
+      typedef typename get_real_stored_allocator<typename NoPropagateCont::Base>::type StoredAllocator;
+      {
+         //default constructor
+         StoredAllocator::reset_unique_id(111);
+         NoPropagateCont c; //stored 112
+         BOOST_TEST (c.get_stored_allocator().id_ == 112);
+         BOOST_TEST (c.get_stored_allocator().ctr_copies_ == 0);
+         BOOST_TEST (c.get_stored_allocator().ctr_moves_ == 0);
+         BOOST_TEST (c.get_stored_allocator().assign_copies_ == 0);
+         BOOST_TEST (c.get_stored_allocator().assign_moves_ == 0);
+         BOOST_TEST (c.get_stored_allocator().swaps_ == 0);
+      }
+      {
+         //copy constructor
+         //propagate_on_copy_constructor produces copies, moves or RVO (depending on the compiler)
+         //For allocators that don't copy in select_on_container_copy_construction we must have a default
+         //construction
+         StoredAllocator::reset_unique_id(222);
+         NoPropagateCont c; //stored 223
+         BOOST_TEST (c.get_stored_allocator().id_ == 223);
+         NoPropagateCont c2(c); //should NOT propagate 223
+         BOOST_TEST (c2.get_stored_allocator().id_ == 224);
+         BOOST_TEST (c2.get_stored_allocator().ctr_copies_ >= 0);
+         BOOST_TEST (c2.get_stored_allocator().ctr_moves_ >= 0);
+         BOOST_TEST (c2.get_stored_allocator().assign_copies_ == 0);
+         BOOST_TEST (c2.get_stored_allocator().assign_moves_ == 0);
+         BOOST_TEST (c2.get_stored_allocator().swaps_ == 0);
+      }
+      {
+         //move constructor
+         StoredAllocator::reset_unique_id(333);
+         NoPropagateCont c; //stored 334
+         BOOST_TEST (c.get_stored_allocator().id_ == 334);
+         NoPropagateCont c2(boost::move(c)); // should NOT propagate 334
+         BOOST_TEST (c2.get_stored_allocator().ctr_copies_ >= 0);
+         BOOST_TEST (c2.get_stored_allocator().ctr_moves_ >= 0);
+         BOOST_TEST (c2.get_stored_allocator().assign_copies_ == 0);
+         BOOST_TEST (c2.get_stored_allocator().assign_moves_ == 0);
+         BOOST_TEST (c2.get_stored_allocator().swaps_ == 0);
+      }
+      {
+         //copy assign
+         StoredAllocator::reset_unique_id(444);
+         NoPropagateCont c; //stored 445
+         NoPropagateCont c2; //stored 446
+         c2 = c; // should NOT propagate 445
+         BOOST_TEST (c2.get_stored_allocator().id_ == 446);
+         BOOST_TEST (c2.get_stored_allocator().ctr_copies_ == 0);
+         BOOST_TEST (c2.get_stored_allocator().ctr_moves_  == 0);
+         BOOST_TEST (c2.get_stored_allocator().assign_copies_ == 0);
+         BOOST_TEST (c2.get_stored_allocator().assign_moves_ == 0);
+         BOOST_TEST (c2.get_stored_allocator().swaps_ == 0);
+      }
+      {
+         //move assign
+         StoredAllocator::reset_unique_id(555);
+         NoPropagateCont c; //stored 556
+         NoPropagateCont c2; //stored 557
+         c2 = c; // should NOT propagate 556
+         BOOST_TEST (c2.get_stored_allocator().id_ == 557);
+         BOOST_TEST (c2.get_stored_allocator().ctr_copies_ == 0);
+         BOOST_TEST (c2.get_stored_allocator().ctr_moves_  == 0);
+         BOOST_TEST (c2.get_stored_allocator().assign_copies_ == 0);
+         BOOST_TEST (c2.get_stored_allocator().assign_moves_ == 0);
+         BOOST_TEST (c2.get_stored_allocator().swaps_ == 0);
+      }
+      {
+         //swap
+         StoredAllocator::reset_unique_id(666);
+         NoPropagateCont c; //stored 667
+         BOOST_TEST (c.get_stored_allocator().id_ == 667);
+         NoPropagateCont c2; //stored 668
+         BOOST_TEST (c2.get_stored_allocator().id_ == 668);
+         c2.swap(c); // should NOT swap 667 and 668
+         BOOST_TEST (c2.get_stored_allocator().id_ == 668);
+         BOOST_TEST (c2.get_stored_allocator().ctr_copies_ == 0);
+         BOOST_TEST (c2.get_stored_allocator().ctr_moves_  == 0);
+         BOOST_TEST (c2.get_stored_allocator().assign_copies_ == 0);
+         BOOST_TEST (c2.get_stored_allocator().assign_moves_ == 0);
+         BOOST_TEST (c2.get_stored_allocator().swaps_ == 0);
+         BOOST_TEST (c.get_stored_allocator().id_ == 667);
+         BOOST_TEST (c.get_stored_allocator().ctr_copies_ == 0);
+         BOOST_TEST (c.get_stored_allocator().ctr_moves_  == 0);
+         BOOST_TEST (c.get_stored_allocator().assign_copies_ == 0);
+         BOOST_TEST (c.get_stored_allocator().assign_moves_ == 0);
+         BOOST_TEST (c.get_stored_allocator().swaps_ == 0);
+      }
+      //And now allocator argument constructors
+      test_propagate_allocator_allocator_arg<NoPropagateCont>();
+   }
+
+   return report_errors() == 0;
+}
+
+template<class Container>
+void test_propagate_allocator_allocator_arg()
+{
+   typedef typename Container::allocator_type         allocator_type;
+   typedef typename get_real_stored_allocator<typename Container::Base>::type StoredAllocator;
+
+   {  //The allocator must be always propagated
+      //allocator constructor
+      allocator_type::reset_unique_id(111);
+      const allocator_type & a = allocator_type(); //stored 112
+      Container c(a); //should propagate 112
+      BOOST_TEST (c.get_stored_allocator().id_ == 112);
+      BOOST_TEST (c.get_stored_allocator().ctr_copies_ > 0);
+      BOOST_TEST (c.get_stored_allocator().ctr_moves_ == 0);
+      BOOST_TEST (c.get_stored_allocator().assign_copies_ == 0);
+      BOOST_TEST (c.get_stored_allocator().assign_moves_ == 0);
+      BOOST_TEST (c.get_stored_allocator().swaps_ == 0);
+   }
+   {
+      //copy allocator constructor
+      StoredAllocator::reset_unique_id(999);
+      Container c;
+      //stored_allocator_type could be the same type as allocator_type
+      //so reset it again to get a predictable result
+      allocator_type::reset_unique_id(222);
+      Container c2(c, allocator_type()); //should propagate 223
+      BOOST_TEST (c2.get_stored_allocator().id_ == 223);
+      BOOST_TEST (c2.get_stored_allocator().ctr_copies_ > 0);
+      BOOST_TEST (c2.get_stored_allocator().ctr_moves_ == 0);
+      BOOST_TEST (c2.get_stored_allocator().assign_copies_ == 0);
+      BOOST_TEST (c2.get_stored_allocator().assign_moves_ == 0);
+      BOOST_TEST (c2.get_stored_allocator().swaps_ == 0);
+   }
+   {
+      //move allocator constructor
+      StoredAllocator::reset_unique_id(999);
+      Container c;
+      //stored_allocator_type could be the same type as allocator_type
+      //so reset it again to get a predictable result
+      allocator_type::reset_unique_id(333);
+      Container c2(boost::move(c), allocator_type()); //should propagate 334
+      BOOST_TEST (c2.get_stored_allocator().id_ == 334);
+      BOOST_TEST (c2.get_stored_allocator().ctr_copies_ > 0);
+      BOOST_TEST (c2.get_stored_allocator().ctr_moves_ == 0);
+      BOOST_TEST (c2.get_stored_allocator().assign_copies_ == 0);
+      BOOST_TEST (c2.get_stored_allocator().assign_moves_ == 0);
+      BOOST_TEST (c2.get_stored_allocator().swaps_ == 0);
+   }
+}
+
+}  //namespace test{
+}  //namespace container {
+}  //namespace boost{
+
+#include <boost/container/detail/config_end.hpp>
+
+#endif   //#ifndef BOOST_CONTAINER_PROPAGATE_ALLOCATOR_TEST_HPP
diff --git a/src/boost/libs/container/test/propagation_test_allocator.hpp b/src/boost/libs/container/test/propagation_test_allocator.hpp
new file mode 100644
index 000000000..7c8643c55
--- /dev/null
+++ b/src/boost/libs/container/test/propagation_test_allocator.hpp
@@ -0,0 +1,268 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2015-2015. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/container for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#ifndef BOOST_CONTAINER_TEST_ALLOCATOR_ARGUMENT_TESTER_HPP
+#define BOOST_CONTAINER_TEST_ALLOCATOR_ARGUMENT_TESTER_HPP
+
+#include <boost/container/uses_allocator.hpp>
+#include <boost/container/detail/mpl.hpp>
+#include <boost/move/core.hpp>
+#include <boost/container/pmr/polymorphic_allocator.hpp>
+
+
+template<class T, unsigned int Id, bool HasTrueTypes = false>
+class propagation_test_allocator
+{
+   BOOST_COPYABLE_AND_MOVABLE(propagation_test_allocator)
+   public:
+
+   template<class U>
+   struct rebind
+   {
+      typedef propagation_test_allocator<U, Id, HasTrueTypes> other;
+   };
+
+   typedef boost::container::dtl::bool_<HasTrueTypes>  propagate_on_container_copy_assignment;
+   typedef boost::container::dtl::bool_<HasTrueTypes>  propagate_on_container_move_assignment;
+   typedef boost::container::dtl::bool_<HasTrueTypes>  propagate_on_container_swap;
+   typedef boost::container::dtl::bool_<HasTrueTypes>  is_always_equal;
+   typedef T value_type;
+
+   propagation_test_allocator()
+      : m_default_contructed(true), m_move_contructed(false), m_move_assigned(false)
+   {}
+
+   propagation_test_allocator(const propagation_test_allocator&)
+      : m_default_contructed(false), m_move_contructed(false), m_move_assigned(false)
+   {}
+
+   propagation_test_allocator(BOOST_RV_REF(propagation_test_allocator) )
+      : m_default_contructed(false), m_move_contructed(true), m_move_assigned(false)
+   {}
+
+   template<class U>
+   propagation_test_allocator(BOOST_RV_REF_BEG propagation_test_allocator<U, Id, HasTrueTypes> BOOST_RV_REF_END)
+      : m_default_contructed(false), m_move_contructed(true), m_move_assigned(false)
+   {}
+
+   template<class U>
+   propagation_test_allocator(const propagation_test_allocator<U, Id, HasTrueTypes> &)
+   {}
+
+   propagation_test_allocator & operator=(BOOST_COPY_ASSIGN_REF(propagation_test_allocator))
+   {  return *this;  }
+
+   propagation_test_allocator & operator=(BOOST_RV_REF(propagation_test_allocator))
+   {
+      m_move_assigned = true;
+      return *this;
+   }
+
+   std::size_t max_size() const
+   {  return std::size_t(-1);  }
+
+   T* allocate(std::size_t n)
+   {  return (T*)::new char[n*sizeof(T)];  }
+
+   void deallocate(T*p, std::size_t)
+   {  delete []static_cast<char*>(static_cast<void*>(p));  }
+
+   bool m_default_contructed;
+   bool m_move_contructed;
+   bool m_move_assigned;
+};
+
+template <class T1, class T2, unsigned int Id, bool HasTrueTypes>
+bool operator==( const propagation_test_allocator<T1, Id, HasTrueTypes>&
+               , const propagation_test_allocator<T2, Id, HasTrueTypes>&)
+{  return true;   }
+
+template <class T1, class T2, unsigned int Id, bool HasTrueTypes>
+bool operator!=( const propagation_test_allocator<T1, Id, HasTrueTypes>&
+               , const propagation_test_allocator<T2, Id, HasTrueTypes>&)
+{  return false;   }
+
+//This enum lists the construction options
+//for an allocator-aware type
+enum ConstructionTypeEnum
+{
+   ConstructiblePrefix,
+   ConstructibleSuffix,
+   ErasedTypePrefix,
+   ErasedTypeSuffix,
+   NotUsesAllocator
+};
+
+//This base class provices types for
+//the derived class to implement each construction
+//type. If a construction type does not apply
+//the typedef is set to an internal nat
+//so that the class is not constructible from
+//the user arguments.
+template<ConstructionTypeEnum ConstructionType, unsigned int AllocatorTag>
+struct uses_allocator_base;
+
+template<unsigned int AllocatorTag>
+struct uses_allocator_base<ConstructibleSuffix, AllocatorTag>
+{
+   typedef propagation_test_allocator<int, AllocatorTag> allocator_type;
+   typedef allocator_type allocator_constructor_type;
+   struct nat{};
+   typedef nat allocator_arg_type;
+};
+
+template<unsigned int AllocatorTag>
+struct uses_allocator_base<ConstructiblePrefix, AllocatorTag>
+{
+   typedef propagation_test_allocator<int, AllocatorTag> allocator_type;
+   typedef allocator_type allocator_constructor_type;
+   typedef boost::container::allocator_arg_t allocator_arg_type;
+};
+
+template<unsigned int AllocatorTag>
+struct uses_allocator_base<ErasedTypePrefix, AllocatorTag>
+{
+   typedef boost::container::erased_type allocator_type;
+   typedef boost::container::pmr::polymorphic_allocator<int> allocator_constructor_type;
+   typedef boost::container::allocator_arg_t allocator_arg_type;
+};
+
+template<unsigned int AllocatorTag>
+struct uses_allocator_base<ErasedTypeSuffix, AllocatorTag>
+{
+   typedef boost::container::erased_type allocator_type;
+   typedef boost::container::pmr::polymorphic_allocator<int> allocator_constructor_type;
+   struct nat{};
+   typedef nat allocator_arg_type;
+};
+
+template<unsigned int AllocatorTag>
+struct uses_allocator_base<NotUsesAllocator, AllocatorTag>
+{
+   struct nat{};
+   typedef nat allocator_constructor_type;
+   typedef nat allocator_arg_type;
+};
+
+template<ConstructionTypeEnum ConstructionType, unsigned int AllocatorTag>
+struct allocator_argument_tester
+   : uses_allocator_base<ConstructionType, AllocatorTag>
+{
+   private:
+   BOOST_COPYABLE_AND_MOVABLE(allocator_argument_tester)
+
+   public:
+
+   typedef uses_allocator_base<ConstructionType, AllocatorTag> base_type;
+
+   //0 user argument constructors
+   allocator_argument_tester()
+      : construction_type(NotUsesAllocator), value(0)
+   {}
+
+   explicit allocator_argument_tester
+      (typename base_type::allocator_constructor_type)
+      : construction_type(ConstructibleSuffix), value(0)
+   {}
+
+   explicit allocator_argument_tester
+      (typename base_type::allocator_arg_type, typename base_type::allocator_constructor_type)
+      : construction_type(ConstructiblePrefix), value(0)
+   {}
+
+   //1 user argument constructors
+   explicit allocator_argument_tester(int i)
+      : construction_type(NotUsesAllocator), value(i)
+   {}
+
+   allocator_argument_tester
+      (int i, typename base_type::allocator_constructor_type)
+      : construction_type(ConstructibleSuffix), value(i)
+   {}
+
+   allocator_argument_tester
+      ( typename base_type::allocator_arg_type
+      , typename base_type::allocator_constructor_type
+      , int i)
+      : construction_type(ConstructiblePrefix), value(i)
+   {}
+
+   //Copy constructors
+   allocator_argument_tester(const allocator_argument_tester &other)
+      : construction_type(NotUsesAllocator), value(other.value)
+   {}
+
+   allocator_argument_tester( const allocator_argument_tester &other
+                            , typename base_type::allocator_constructor_type)
+      : construction_type(ConstructibleSuffix), value(other.value)
+   {}
+
+   allocator_argument_tester( typename base_type::allocator_arg_type
+                            , typename base_type::allocator_constructor_type
+                            , const allocator_argument_tester &other)
+      : construction_type(ConstructiblePrefix), value(other.value)
+   {}
+
+   //Move constructors
+   allocator_argument_tester(BOOST_RV_REF(allocator_argument_tester) other)
+      : construction_type(NotUsesAllocator), value(other.value)
+   {  other.value = 0;  other.construction_type = NotUsesAllocator;  }
+
+   allocator_argument_tester( BOOST_RV_REF(allocator_argument_tester) other
+                            , typename base_type::allocator_constructor_type)
+      : construction_type(ConstructibleSuffix), value(other.value)
+   {  other.value = 0;  other.construction_type = ConstructibleSuffix;  }
+
+   allocator_argument_tester( typename base_type::allocator_arg_type
+                            , typename base_type::allocator_constructor_type
+                            , BOOST_RV_REF(allocator_argument_tester) other)
+      : construction_type(ConstructiblePrefix), value(other.value)
+   {  other.value = 0;  other.construction_type = ConstructiblePrefix;  }
+
+   ConstructionTypeEnum construction_type;
+   int                  value;
+};
+
+namespace boost {
+namespace container {
+
+template<unsigned int AllocatorTag>
+struct constructible_with_allocator_prefix
+   < ::allocator_argument_tester<ConstructiblePrefix, AllocatorTag> >
+{
+   static const bool value = true;
+};
+
+template<unsigned int AllocatorTag>
+struct constructible_with_allocator_prefix
+   < ::allocator_argument_tester<ErasedTypePrefix, AllocatorTag> >
+{
+   static const bool value = true;
+};
+
+
+template<unsigned int AllocatorTag>
+struct constructible_with_allocator_suffix
+   < ::allocator_argument_tester<ConstructibleSuffix, AllocatorTag> >
+{
+   static const bool value = true;
+};
+
+template<unsigned int AllocatorTag>
+struct constructible_with_allocator_suffix
+   < ::allocator_argument_tester<ErasedTypeSuffix, AllocatorTag> >
+{
+   static const bool value = true;
+};
+
+}  //namespace container {
+}  //namespace boost {
+
+#endif   //BOOST_CONTAINER_TEST_ALLOCATOR_ARGUMENT_TESTER_HPP
diff --git a/src/boost/libs/container/test/resource_adaptor_test.cpp b/src/boost/libs/container/test/resource_adaptor_test.cpp
new file mode 100644
index 000000000..5f8ece297
--- /dev/null
+++ b/src/boost/libs/container/test/resource_adaptor_test.cpp
@@ -0,0 +1,234 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2015-2015. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/container for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+#include <boost/container/pmr/resource_adaptor.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include "propagation_test_allocator.hpp"
+#include "derived_from_memory_resource.hpp"
+#include <boost/container/new_allocator.hpp>
+#include <memory>
+
+using namespace boost::container::pmr;
+
+static const std::size_t max_alignment_value = boost::move_detail::alignment_of<boost::move_detail::max_align_t>::value;
+
+void test_default_constructor()
+{
+   typedef propagation_test_allocator<char, 0> alloc_t;
+   resource_adaptor<alloc_t> ra;
+   BOOST_TEST(ra.get_allocator().m_default_contructed == true);
+}
+
+void test_copy_constructor()
+{
+   typedef propagation_test_allocator<char, 0> alloc_t;
+   resource_adaptor<alloc_t> ra;
+   BOOST_TEST(ra.get_allocator().m_default_contructed == true);
+   resource_adaptor<alloc_t> rb(ra);
+   BOOST_TEST(rb.get_allocator().m_default_contructed == false);
+   BOOST_TEST(rb.get_allocator().m_move_contructed == false);
+}
+
+void test_move_constructor()
+{
+   typedef propagation_test_allocator<char, 0> alloc_t;
+   resource_adaptor<alloc_t> ra;
+   BOOST_TEST(ra.get_allocator().m_default_contructed == true);
+   resource_adaptor<alloc_t> rb(::boost::move(ra));
+   BOOST_TEST(rb.get_allocator().m_default_contructed == false);
+   BOOST_TEST(rb.get_allocator().m_move_contructed == true);
+}
+
+void test_lvalue_alloc_constructor()
+{
+   typedef propagation_test_allocator<char, 0> alloc_t;
+   alloc_t a;
+   resource_adaptor<alloc_t> ra(a);
+   BOOST_TEST(ra.get_allocator().m_default_contructed == false);
+   BOOST_TEST(ra.get_allocator().m_move_contructed == false);
+}
+
+void test_rvalue_alloc_constructor()
+{
+   typedef propagation_test_allocator<char, 0> alloc_t;
+   alloc_t a;
+   resource_adaptor<alloc_t> ra(::boost::move(a));
+   BOOST_TEST(ra.get_allocator().m_default_contructed == false);
+   BOOST_TEST(ra.get_allocator().m_move_contructed == true);
+}
+
+void test_copy_assign()
+{
+   typedef propagation_test_allocator<char, 0> alloc_t;
+   resource_adaptor<alloc_t> ra;
+   BOOST_TEST(ra.get_allocator().m_default_contructed == true);
+   resource_adaptor<alloc_t> rb;
+   BOOST_TEST(ra.get_allocator().m_default_contructed == true);
+   rb = ra;
+   BOOST_TEST(rb.get_allocator().m_move_contructed == false);
+   BOOST_TEST(rb.get_allocator().m_move_assigned == false);
+}
+
+void test_move_assign()
+{
+   typedef propagation_test_allocator<char, 0> alloc_t;
+   resource_adaptor<alloc_t> ra;
+   BOOST_TEST(ra.get_allocator().m_default_contructed == true);
+   resource_adaptor<alloc_t> rb;
+   BOOST_TEST(ra.get_allocator().m_default_contructed == true);
+   rb = ::boost::move(ra);
+   BOOST_TEST(rb.get_allocator().m_move_contructed == false);
+   BOOST_TEST(rb.get_allocator().m_move_assigned == true);
+}
+
+struct stateful
+{
+   public:
+   typedef char value_type;
+
+   template<class U>
+   struct rebind
+   {  typedef stateful other; };
+
+   stateful()
+      : m_u(0u)
+   {}
+
+   char *allocate(std::size_t n)
+   {  allocate_size = n;   return allocate_return;  }
+
+   void deallocate(char *p, std::size_t n)
+   {  deallocate_p = p;    deallocate_size = n; }
+
+   friend bool operator==(const stateful &l, const stateful &r)
+   {  return l.m_u == r.m_u;   }
+
+   friend bool operator!=(const stateful &l, const stateful &r)
+   {  return l.m_u != r.m_u;   }
+
+   public:
+   unsigned m_u;
+   std::size_t allocate_size;
+   char *allocate_return;
+   std::size_t deallocate_size;
+   char *deallocate_p;
+};
+
+void test_get_allocator()
+{
+   stateful a;
+   a.m_u = 999;
+   resource_adaptor<stateful> ra(a);
+   const resource_adaptor<stateful> & cra = ra;
+   BOOST_TEST( ra.get_allocator().m_u == 999);
+   BOOST_TEST(cra.get_allocator().m_u == 999);
+}
+
+typedef resource_adaptor<stateful> stateful_resource_adaptor_t;
+
+struct derived_from_resource_adaptor_stateful
+   : public stateful_resource_adaptor_t
+{
+   public:
+   typedef stateful_resource_adaptor_t base_t;
+   using base_t::do_allocate;
+   using base_t::do_deallocate;
+   using base_t::do_is_equal;
+};
+
+void test_do_allocate_deallocate()
+{
+   {
+      derived_from_resource_adaptor_stateful dra;
+      char dummy = 0;
+      dra.get_allocator().allocate_return = &dummy;
+      void *allocate_ret = dra.do_allocate(998, 1);
+      BOOST_TEST(allocate_ret == &dummy);
+      BOOST_TEST(dra.get_allocator().allocate_size == 998);
+   }
+   {
+      derived_from_resource_adaptor_stateful dra;
+      char dummy = 0;
+      dra.do_deallocate(&dummy, 1234, 1);
+      BOOST_TEST(dra.get_allocator().deallocate_p == &dummy);
+      BOOST_TEST(dra.get_allocator().deallocate_size == 1234);
+   }
+   {
+      //Overaligned allocation
+      derived_from_resource_adaptor_stateful dra;
+      const std::size_t alignment = max_alignment_value*2u;
+      const std::size_t bytes = alignment/2;
+      char dummy[alignment*2u+sizeof(void*)];
+      dra.get_allocator().allocate_return = dummy;
+
+      //First allocate
+      void *allocate_ret = dra.do_allocate(bytes, alignment);
+      BOOST_TEST( (char*)allocate_ret >= (dummy+sizeof(void*)) && (char*)allocate_ret < (dummy + sizeof(dummy)) );
+      BOOST_TEST( (std::size_t(allocate_ret) & (alignment - 1u)) == 0 );
+      BOOST_TEST( dra.get_allocator().allocate_size >= (alignment/2+sizeof(void*)) );
+
+      //Then allocate
+      dra.do_deallocate(allocate_ret, bytes, alignment);
+      BOOST_TEST(dra.get_allocator().deallocate_p == dummy);
+      BOOST_TEST(dra.get_allocator().deallocate_size == dra.get_allocator().allocate_size);
+   }
+   {
+      typedef resource_adaptor< boost::container::new_allocator<int> > new_resource_alloc_t;
+      new_resource_alloc_t ra;
+      boost::container::pmr::memory_resource &mr = ra;
+
+      //new_allocator, low alignment
+      mr.deallocate(mr.allocate(16, 1), 16, 1);
+
+      //new_allocator, high alignment
+      mr.deallocate(mr.allocate(16, max_alignment_value*4u), 16, max_alignment_value*4u);
+   }
+   {
+      typedef resource_adaptor<std ::allocator<int> > new_resource_alloc_t;
+      new_resource_alloc_t ra;
+      boost::container::pmr::memory_resource &mr = ra;
+
+      //std::allocator, low alignment
+      mr.deallocate(mr.allocate(16, 1), 16, 1);
+
+      //std::allocator, high alignment
+      mr.deallocate(mr.allocate(16, max_alignment_value*4u), 16, max_alignment_value*4u);
+   }
+}
+
+void test_do_is_equal()
+{
+   derived_from_resource_adaptor_stateful dra;
+   derived_from_memory_resource dmr;
+   //Different dynamic type must return false
+   BOOST_TEST(dra.do_is_equal(dmr) == false);
+
+   //Same dynamic type with same state must return true
+   derived_from_resource_adaptor_stateful dra2;
+   BOOST_TEST(dra.do_is_equal(dra2) == true);
+
+   //Same dynamic type with different state must return false
+   dra2.get_allocator().m_u = 1234;
+   BOOST_TEST(dra.do_is_equal(dra2) == false);
+}
+
+int main()
+{
+   test_default_constructor();
+   test_copy_constructor();
+   test_move_constructor();
+   test_lvalue_alloc_constructor();
+   test_rvalue_alloc_constructor();
+   test_copy_assign();
+   test_move_assign();
+   test_get_allocator();
+   test_do_allocate_deallocate();
+   test_do_is_equal();
+   return ::boost::report_errors();
+}
diff --git a/src/boost/libs/container/test/scoped_allocator_adaptor_test.cpp b/src/boost/libs/container/test/scoped_allocator_adaptor_test.cpp
new file mode 100644
index 000000000..6a051e279
--- /dev/null
+++ b/src/boost/libs/container/test/scoped_allocator_adaptor_test.cpp
@@ -0,0 +1,1377 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2011-2013. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/container for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+#include <boost/container/detail/config_begin.hpp>
+#include <boost/container/scoped_allocator_fwd.hpp>
+
+// container/detail
+#include <boost/container/detail/mpl.hpp>
+// move
+#include <boost/move/utility_core.hpp>
+#include <boost/move/adl_move_swap.hpp>
+//boost
+#include <boost/tuple/tuple.hpp>
+// std
+#include <memory>
+#include <cstddef>
+
+#if defined(BOOST_CONTAINER_PAIR_TEST_HAS_HEADER_TUPLE)
+#include <tuple>
+#endif
+
+//test
+#include <boost/core/lightweight_test.hpp>
+
+#include "allocator_argument_tester.hpp"
+
+template<unsigned int Type>
+struct tagged_integer
+{};
+
+struct mark_on_destructor
+{
+   mark_on_destructor()
+   {
+      destroyed = false;
+   }
+
+   ~mark_on_destructor()
+   {
+      destroyed = true;
+   }
+
+   static bool destroyed;
+};
+
+bool mark_on_destructor::destroyed = false;
+
+#include <boost/container/scoped_allocator.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/container/vector.hpp>
+#include <boost/container/detail/pair.hpp>
+
+int main()
+{
+   using namespace boost::container;
+
+   typedef propagation_test_allocator<tagged_integer<0>, 0>   OuterAlloc;
+   typedef propagation_test_allocator<tagged_integer<0>, 10>  Outer10IdAlloc;
+   typedef propagation_test_allocator<tagged_integer<9>, 0>   Rebound9OuterAlloc;
+   typedef propagation_test_allocator<tagged_integer<1>, 1>   InnerAlloc1;
+   typedef propagation_test_allocator<tagged_integer<2>, 2>   InnerAlloc2;
+   typedef propagation_test_allocator<tagged_integer<1>, 11>  Inner11IdAlloc1;
+
+   typedef propagation_test_allocator<tagged_integer<0>, 0, false>      OuterAllocFalseHasTrueTypes;
+   typedef propagation_test_allocator<tagged_integer<0>, 0, true>       OuterAllocTrueHasTrueTypes;
+   typedef propagation_test_allocator<tagged_integer<1>, 1, false>      InnerAlloc1FalseHasTrueTypes;
+   typedef propagation_test_allocator<tagged_integer<1>, 1, true>       InnerAlloc1TrueHasTrueTypes;
+   typedef propagation_test_allocator<tagged_integer<2>, 2, false>      InnerAlloc2FalseHasTrueTypes;
+   typedef propagation_test_allocator<tagged_integer<2>, 2, true>       InnerAlloc2TrueHasTrueTypes;
+
+   //
+   typedef scoped_allocator_adaptor< OuterAlloc  >          Scoped0Inner;
+   typedef scoped_allocator_adaptor< OuterAlloc
+                                   , InnerAlloc1 >          Scoped1Inner;
+   typedef scoped_allocator_adaptor< OuterAlloc
+                                   , InnerAlloc1
+                                   , InnerAlloc2 >          Scoped2Inner;
+   typedef scoped_allocator_adaptor
+      < scoped_allocator_adaptor
+         <Outer10IdAlloc>
+      >                                                     ScopedScoped0Inner;
+   typedef scoped_allocator_adaptor
+      < scoped_allocator_adaptor
+         <Outer10IdAlloc, Inner11IdAlloc1>
+      , InnerAlloc1
+      >                                                     ScopedScoped1Inner;
+   typedef scoped_allocator_adaptor< Rebound9OuterAlloc  >  Rebound9Scoped0Inner;
+   typedef scoped_allocator_adaptor< Rebound9OuterAlloc
+                                   , InnerAlloc1 >          Rebound9Scoped1Inner;
+   typedef scoped_allocator_adaptor< Rebound9OuterAlloc
+                                   , InnerAlloc1
+                                   , InnerAlloc2 >          Rebound9Scoped2Inner;
+
+   //outer_allocator_type
+   BOOST_STATIC_ASSERT(( dtl::is_same< OuterAlloc
+                       , Scoped0Inner::outer_allocator_type>::value ));
+   BOOST_STATIC_ASSERT(( dtl::is_same< OuterAlloc
+                       , Scoped1Inner::outer_allocator_type>::value ));
+   BOOST_STATIC_ASSERT(( dtl::is_same< OuterAlloc
+                       , Scoped2Inner::outer_allocator_type>::value ));
+   //value_type
+   BOOST_STATIC_ASSERT(( dtl::is_same< allocator_traits<OuterAlloc>::value_type
+                       , Scoped0Inner::value_type>::value ));
+   BOOST_STATIC_ASSERT(( dtl::is_same< allocator_traits<OuterAlloc>::value_type
+                       , Scoped1Inner::value_type>::value ));
+   BOOST_STATIC_ASSERT(( dtl::is_same< allocator_traits<OuterAlloc>::value_type
+                       , Scoped2Inner::value_type>::value ));
+   //size_type
+   BOOST_STATIC_ASSERT(( dtl::is_same< allocator_traits<OuterAlloc>::size_type
+                       , Scoped0Inner::size_type>::value ));
+   BOOST_STATIC_ASSERT(( dtl::is_same< allocator_traits<OuterAlloc>::size_type
+                       , Scoped1Inner::size_type>::value ));
+   BOOST_STATIC_ASSERT(( dtl::is_same< allocator_traits<OuterAlloc>::size_type
+                       , Scoped2Inner::size_type>::value ));
+
+   //difference_type
+   BOOST_STATIC_ASSERT(( dtl::is_same< allocator_traits<OuterAlloc>::difference_type
+                       , Scoped0Inner::difference_type>::value ));
+   BOOST_STATIC_ASSERT(( dtl::is_same< allocator_traits<OuterAlloc>::difference_type
+                       , Scoped1Inner::difference_type>::value ));
+   BOOST_STATIC_ASSERT(( dtl::is_same< allocator_traits<OuterAlloc>::difference_type
+                       , Scoped2Inner::difference_type>::value ));
+
+   //pointer
+   BOOST_STATIC_ASSERT(( dtl::is_same< allocator_traits<OuterAlloc>::pointer
+                       , Scoped0Inner::pointer>::value ));
+   BOOST_STATIC_ASSERT(( dtl::is_same< allocator_traits<OuterAlloc>::pointer
+                       , Scoped1Inner::pointer>::value ));
+   BOOST_STATIC_ASSERT(( dtl::is_same< allocator_traits<OuterAlloc>::pointer
+                       , Scoped2Inner::pointer>::value ));
+
+   //const_pointer
+   BOOST_STATIC_ASSERT(( dtl::is_same< allocator_traits<OuterAlloc>::const_pointer
+                       , Scoped0Inner::const_pointer>::value ));
+   BOOST_STATIC_ASSERT(( dtl::is_same< allocator_traits<OuterAlloc>::const_pointer
+                       , Scoped1Inner::const_pointer>::value ));
+   BOOST_STATIC_ASSERT(( dtl::is_same< allocator_traits<OuterAlloc>::const_pointer
+                       , Scoped2Inner::const_pointer>::value ));
+
+   //void_pointer
+   BOOST_STATIC_ASSERT(( dtl::is_same< allocator_traits<OuterAlloc>::void_pointer
+                       , Scoped0Inner::void_pointer>::value ));
+   BOOST_STATIC_ASSERT(( dtl::is_same< allocator_traits<OuterAlloc>::void_pointer
+                       , Scoped1Inner::void_pointer>::value ));
+   BOOST_STATIC_ASSERT(( dtl::is_same< allocator_traits<OuterAlloc>::void_pointer
+                       , Scoped2Inner::void_pointer>::value ));
+
+   //const_void_pointer
+   BOOST_STATIC_ASSERT(( dtl::is_same< allocator_traits<OuterAlloc>::const_void_pointer
+                       , Scoped0Inner::const_void_pointer>::value ));
+   BOOST_STATIC_ASSERT(( dtl::is_same< allocator_traits<OuterAlloc>::const_void_pointer
+                       , Scoped1Inner::const_void_pointer>::value ));
+   BOOST_STATIC_ASSERT(( dtl::is_same< allocator_traits<OuterAlloc>::const_void_pointer
+                       , Scoped2Inner::const_void_pointer>::value ));
+
+   //rebind
+   BOOST_STATIC_ASSERT(( dtl::is_same<Scoped0Inner::rebind< tagged_integer<9> >::other
+                       , Rebound9Scoped0Inner >::value ));
+   BOOST_STATIC_ASSERT(( dtl::is_same<Scoped1Inner::rebind< tagged_integer<9> >::other
+                       , Rebound9Scoped1Inner >::value ));
+   BOOST_STATIC_ASSERT(( dtl::is_same<Scoped2Inner::rebind< tagged_integer<9> >::other
+                       , Rebound9Scoped2Inner >::value ));
+
+   //inner_allocator_type
+   BOOST_STATIC_ASSERT(( dtl::is_same< Scoped0Inner
+                       , Scoped0Inner::inner_allocator_type>::value ));
+   BOOST_STATIC_ASSERT(( dtl::is_same< scoped_allocator_adaptor<InnerAlloc1>
+                       , Scoped1Inner::inner_allocator_type>::value ));
+   BOOST_STATIC_ASSERT(( dtl::is_same< scoped_allocator_adaptor<InnerAlloc1, InnerAlloc2>
+                       , Scoped2Inner::inner_allocator_type>::value ));
+
+   {
+      //Propagation test
+      typedef scoped_allocator_adaptor< OuterAllocFalseHasTrueTypes  >  Scoped0InnerF;
+      typedef scoped_allocator_adaptor< OuterAllocTrueHasTrueTypes  >   Scoped0InnerT;
+      typedef scoped_allocator_adaptor< OuterAllocFalseHasTrueTypes
+                                    , InnerAlloc1FalseHasTrueTypes >  Scoped1InnerFF;
+      typedef scoped_allocator_adaptor< OuterAllocFalseHasTrueTypes
+                                    , InnerAlloc1TrueHasTrueTypes >   Scoped1InnerFT;
+      typedef scoped_allocator_adaptor< OuterAllocTrueHasTrueTypes
+                                    , InnerAlloc1FalseHasTrueTypes >  Scoped1InnerTF;
+      typedef scoped_allocator_adaptor< OuterAllocTrueHasTrueTypes
+                                    , InnerAlloc1TrueHasTrueTypes >   Scoped1InnerTT;
+      typedef scoped_allocator_adaptor< OuterAllocFalseHasTrueTypes
+                                    , InnerAlloc1FalseHasTrueTypes
+                                    , InnerAlloc2FalseHasTrueTypes >  Scoped2InnerFFF;
+      typedef scoped_allocator_adaptor< OuterAllocFalseHasTrueTypes
+                                    , InnerAlloc1FalseHasTrueTypes
+                                    , InnerAlloc2TrueHasTrueTypes >  Scoped2InnerFFT;
+      typedef scoped_allocator_adaptor< OuterAllocFalseHasTrueTypes
+                                    , InnerAlloc1TrueHasTrueTypes
+                                    , InnerAlloc2FalseHasTrueTypes >  Scoped2InnerFTF;
+      typedef scoped_allocator_adaptor< OuterAllocFalseHasTrueTypes
+                                    , InnerAlloc1TrueHasTrueTypes
+                                    , InnerAlloc2TrueHasTrueTypes >  Scoped2InnerFTT;
+      typedef scoped_allocator_adaptor< OuterAllocTrueHasTrueTypes
+                                    , InnerAlloc1FalseHasTrueTypes
+                                    , InnerAlloc2FalseHasTrueTypes >  Scoped2InnerTFF;
+      typedef scoped_allocator_adaptor< OuterAllocTrueHasTrueTypes
+                                    , InnerAlloc1FalseHasTrueTypes
+                                    , InnerAlloc2TrueHasTrueTypes >  Scoped2InnerTFT;
+      typedef scoped_allocator_adaptor< OuterAllocTrueHasTrueTypes
+                                    , InnerAlloc1TrueHasTrueTypes
+                                    , InnerAlloc2FalseHasTrueTypes >  Scoped2InnerTTF;
+      typedef scoped_allocator_adaptor< OuterAllocTrueHasTrueTypes
+                                    , InnerAlloc1TrueHasTrueTypes
+                                    , InnerAlloc2TrueHasTrueTypes >  Scoped2InnerTTT;
+
+      //propagate_on_container_copy_assignment
+      //0 inner
+      BOOST_STATIC_ASSERT(( !Scoped0InnerF::propagate_on_container_copy_assignment::value ));
+      BOOST_STATIC_ASSERT((  Scoped0InnerT::propagate_on_container_copy_assignment::value ));
+      //1 inner
+      BOOST_STATIC_ASSERT(( !Scoped1InnerFF::propagate_on_container_copy_assignment::value ));
+      BOOST_STATIC_ASSERT((  Scoped1InnerFT::propagate_on_container_copy_assignment::value ));
+      BOOST_STATIC_ASSERT((  Scoped1InnerTF::propagate_on_container_copy_assignment::value ));
+      BOOST_STATIC_ASSERT((  Scoped1InnerTT::propagate_on_container_copy_assignment::value ));
+      //2 inner
+      BOOST_STATIC_ASSERT(( !Scoped2InnerFFF::propagate_on_container_copy_assignment::value ));
+      BOOST_STATIC_ASSERT((  Scoped2InnerFFT::propagate_on_container_copy_assignment::value ));
+      BOOST_STATIC_ASSERT((  Scoped2InnerFTF::propagate_on_container_copy_assignment::value ));
+      BOOST_STATIC_ASSERT((  Scoped2InnerFTT::propagate_on_container_copy_assignment::value ));
+      BOOST_STATIC_ASSERT((  Scoped2InnerTFF::propagate_on_container_copy_assignment::value ));
+      BOOST_STATIC_ASSERT((  Scoped2InnerTFT::propagate_on_container_copy_assignment::value ));
+      BOOST_STATIC_ASSERT((  Scoped2InnerTTF::propagate_on_container_copy_assignment::value ));
+      BOOST_STATIC_ASSERT((  Scoped2InnerTTT::propagate_on_container_copy_assignment::value ));
+
+      //propagate_on_container_move_assignment
+      //0 inner
+      BOOST_STATIC_ASSERT(( !Scoped0InnerF::propagate_on_container_move_assignment::value ));
+      BOOST_STATIC_ASSERT((  Scoped0InnerT::propagate_on_container_move_assignment::value ));
+      //1 inner
+      BOOST_STATIC_ASSERT(( !Scoped1InnerFF::propagate_on_container_move_assignment::value ));
+      BOOST_STATIC_ASSERT((  Scoped1InnerFT::propagate_on_container_move_assignment::value ));
+      BOOST_STATIC_ASSERT((  Scoped1InnerTF::propagate_on_container_move_assignment::value ));
+      BOOST_STATIC_ASSERT((  Scoped1InnerTT::propagate_on_container_move_assignment::value ));
+      //2 inner
+      BOOST_STATIC_ASSERT(( !Scoped2InnerFFF::propagate_on_container_move_assignment::value ));
+      BOOST_STATIC_ASSERT((  Scoped2InnerFFT::propagate_on_container_move_assignment::value ));
+      BOOST_STATIC_ASSERT((  Scoped2InnerFTF::propagate_on_container_move_assignment::value ));
+      BOOST_STATIC_ASSERT((  Scoped2InnerFTT::propagate_on_container_move_assignment::value ));
+      BOOST_STATIC_ASSERT((  Scoped2InnerTFF::propagate_on_container_move_assignment::value ));
+      BOOST_STATIC_ASSERT((  Scoped2InnerTFT::propagate_on_container_move_assignment::value ));
+      BOOST_STATIC_ASSERT((  Scoped2InnerTTF::propagate_on_container_move_assignment::value ));
+      BOOST_STATIC_ASSERT((  Scoped2InnerTTT::propagate_on_container_move_assignment::value ));
+
+      //propagate_on_container_swap
+      //0 inner
+      BOOST_STATIC_ASSERT(( !Scoped0InnerF::propagate_on_container_swap::value ));
+      BOOST_STATIC_ASSERT((  Scoped0InnerT::propagate_on_container_swap::value ));
+      //1 inner
+      BOOST_STATIC_ASSERT(( !Scoped1InnerFF::propagate_on_container_swap::value ));
+      BOOST_STATIC_ASSERT((  Scoped1InnerFT::propagate_on_container_swap::value ));
+      BOOST_STATIC_ASSERT((  Scoped1InnerTF::propagate_on_container_swap::value ));
+      BOOST_STATIC_ASSERT((  Scoped1InnerTT::propagate_on_container_swap::value ));
+      //2 inner
+      BOOST_STATIC_ASSERT(( !Scoped2InnerFFF::propagate_on_container_swap::value ));
+      BOOST_STATIC_ASSERT((  Scoped2InnerFFT::propagate_on_container_swap::value ));
+      BOOST_STATIC_ASSERT((  Scoped2InnerFTF::propagate_on_container_swap::value ));
+      BOOST_STATIC_ASSERT((  Scoped2InnerFTT::propagate_on_container_swap::value ));
+      BOOST_STATIC_ASSERT((  Scoped2InnerTFF::propagate_on_container_swap::value ));
+      BOOST_STATIC_ASSERT((  Scoped2InnerTFT::propagate_on_container_swap::value ));
+      BOOST_STATIC_ASSERT((  Scoped2InnerTTF::propagate_on_container_swap::value ));
+      BOOST_STATIC_ASSERT((  Scoped2InnerTTT::propagate_on_container_swap::value ));
+      //is_always_equal
+      //0 inner
+      BOOST_STATIC_ASSERT(( !Scoped0InnerF::is_always_equal::value ));
+      BOOST_STATIC_ASSERT((  Scoped0InnerT::is_always_equal::value ));
+      //1 inner
+      BOOST_STATIC_ASSERT(( !Scoped1InnerFF::is_always_equal::value ));
+      BOOST_STATIC_ASSERT(( !Scoped1InnerFT::is_always_equal::value ));
+      BOOST_STATIC_ASSERT(( !Scoped1InnerTF::is_always_equal::value ));
+      BOOST_STATIC_ASSERT((  Scoped1InnerTT::is_always_equal::value ));
+      //2 inner
+      BOOST_STATIC_ASSERT(( !Scoped2InnerFFF::is_always_equal::value ));
+      BOOST_STATIC_ASSERT(( !Scoped2InnerFFT::is_always_equal::value ));
+      BOOST_STATIC_ASSERT(( !Scoped2InnerFTF::is_always_equal::value ));
+      BOOST_STATIC_ASSERT(( !Scoped2InnerFTT::is_always_equal::value ));
+      BOOST_STATIC_ASSERT(( !Scoped2InnerTFF::is_always_equal::value ));
+      BOOST_STATIC_ASSERT(( !Scoped2InnerTFT::is_always_equal::value ));
+      BOOST_STATIC_ASSERT(( !Scoped2InnerTTF::is_always_equal::value ));
+      BOOST_STATIC_ASSERT((  Scoped2InnerTTT::is_always_equal::value ));
+   }
+
+   //Default constructor
+   {
+      Scoped0Inner s0i;
+      Scoped1Inner s1i;
+      //Swap
+      {
+         Scoped0Inner s0i2;
+         Scoped1Inner s1i2;
+         boost::adl_move_swap(s0i, s0i2);
+         boost::adl_move_swap(s1i, s1i2);
+      }
+   }
+
+   //Default constructor
+   {
+      Scoped0Inner s0i;
+      Scoped1Inner s1i;
+   }
+
+   //Copy constructor/assignment
+   {
+      Scoped0Inner s0i;
+      Scoped1Inner s1i;
+      Scoped2Inner s2i;
+
+      Scoped0Inner s0i_b(s0i);
+      Scoped1Inner s1i_b(s1i);
+      Scoped2Inner s2i_b(s2i);
+
+      BOOST_TEST(s0i == s0i_b);
+      BOOST_TEST(s1i == s1i_b);
+      BOOST_TEST(s2i == s2i_b);
+
+      s0i_b = s0i;
+      s1i_b = s1i;
+      s2i_b = s2i;
+
+      BOOST_TEST(s0i == s0i_b);
+      BOOST_TEST(s1i == s1i_b);
+      BOOST_TEST(s2i == s2i_b);
+   }
+
+   //Copy/move constructor/assignment
+   {
+      Scoped0Inner s0i;
+      Scoped1Inner s1i;
+      Scoped2Inner s2i;
+
+      Scoped0Inner s0i_b(::boost::move(s0i));
+      Scoped1Inner s1i_b(::boost::move(s1i));
+      Scoped2Inner s2i_b(::boost::move(s2i));
+
+      BOOST_TEST(s0i_b.outer_allocator().m_move_contructed);
+      BOOST_TEST(s1i_b.outer_allocator().m_move_contructed);
+      BOOST_TEST(s2i_b.outer_allocator().m_move_contructed);
+
+      s0i_b = ::boost::move(s0i);
+      s1i_b = ::boost::move(s1i);
+      s2i_b = ::boost::move(s2i);
+
+      BOOST_TEST(s0i_b.outer_allocator().m_move_assigned);
+      BOOST_TEST(s1i_b.outer_allocator().m_move_assigned);
+      BOOST_TEST(s2i_b.outer_allocator().m_move_assigned);
+   }
+
+   //inner_allocator()
+   {
+      Scoped0Inner s0i;
+      Scoped1Inner s1i;
+      Scoped2Inner s2i;
+      const Scoped0Inner const_s0i;
+      const Scoped1Inner const_s1i;
+      const Scoped2Inner const_s2i;
+
+      Scoped0Inner::inner_allocator_type &s0i_inner =             s0i.inner_allocator();
+      (void)s0i_inner;
+      const Scoped0Inner::inner_allocator_type &const_s0i_inner = const_s0i.inner_allocator();
+      (void)const_s0i_inner;
+      Scoped1Inner::inner_allocator_type &s1i_inner =             s1i.inner_allocator();
+      (void)s1i_inner;
+      const Scoped1Inner::inner_allocator_type &const_s1i_inner = const_s1i.inner_allocator();
+      (void)const_s1i_inner;
+      Scoped2Inner::inner_allocator_type &s2i_inner =             s2i.inner_allocator();
+      (void)s2i_inner;
+      const Scoped2Inner::inner_allocator_type &const_s2i_inner = const_s2i.inner_allocator();
+      (void)const_s2i_inner;
+   }
+
+   //operator==/!=
+   {
+      const Scoped0Inner const_s0i;
+      const Rebound9Scoped0Inner const_rs0i;
+
+      BOOST_TEST(const_s0i == const_s0i);
+      BOOST_TEST(const_rs0i == const_s0i);
+      BOOST_TEST(const_s0i == const_s0i);
+      BOOST_TEST(const_s0i == const_rs0i);
+
+      const Scoped1Inner const_s1i;
+      const Rebound9Scoped1Inner const_rs1i;
+
+      BOOST_TEST(const_s1i == const_s1i);
+      BOOST_TEST(const_rs1i == const_s1i);
+
+      BOOST_TEST(const_s1i == const_s1i);
+      BOOST_TEST(const_s1i == const_rs1i);
+
+      const Scoped2Inner const_s2i;
+      const Rebound9Scoped2Inner const_rs2i;
+
+      BOOST_TEST(const_s2i == const_s2i);
+      BOOST_TEST(const_s2i == const_rs2i);
+
+      BOOST_TEST(const_s2i == const_s2i);
+      BOOST_TEST(const_s2i == const_rs2i);
+   }
+
+   //outer_allocator()
+   {
+      Scoped0Inner s0i;
+      Scoped1Inner s1i;
+      Scoped2Inner s2i;
+      const Scoped0Inner const_s0i;
+      const Scoped1Inner const_s1i;
+      const Scoped2Inner const_s2i;
+
+      Scoped0Inner::outer_allocator_type &s0i_inner =             s0i.outer_allocator();
+      (void)s0i_inner;
+      const Scoped0Inner::outer_allocator_type &const_s0i_inner = const_s0i.outer_allocator();
+      (void)const_s0i_inner;
+      Scoped1Inner::outer_allocator_type &s1i_inner =             s1i.outer_allocator();
+      (void)s1i_inner;
+      const Scoped1Inner::outer_allocator_type &const_s1i_inner = const_s1i.outer_allocator();
+      (void)const_s1i_inner;
+      Scoped2Inner::outer_allocator_type &s2i_inner =             s2i.outer_allocator();
+      (void)s2i_inner;
+      const Scoped2Inner::outer_allocator_type &const_s2i_inner = const_s2i.outer_allocator();
+      (void)const_s2i_inner;
+   }
+
+   //max_size()
+   {
+      const Scoped0Inner const_s0i;
+      const Scoped1Inner const_s1i;
+      const Scoped2Inner const_s2i;
+      const OuterAlloc  const_oa;
+      const InnerAlloc1 const_ia1;
+      const InnerAlloc2 const_ia2;
+
+      BOOST_TEST(const_s0i.max_size() == const_oa.max_size());
+      BOOST_TEST(const_s1i.max_size() == const_oa.max_size());
+
+      BOOST_TEST(const_s2i.max_size() == const_oa.max_size());
+      BOOST_TEST(const_s1i.inner_allocator().max_size() == const_ia1.max_size());
+      BOOST_TEST(const_s2i.inner_allocator().inner_allocator().max_size() == const_ia2.max_size());
+   }
+   //Copy and move operations
+   {
+      //Construction
+      {
+         Scoped0Inner s0i_a, s0i_b(s0i_a), s0i_c(::boost::move(s0i_b));
+         Scoped1Inner s1i_a, s1i_b(s1i_a), s1i_c(::boost::move(s1i_b));
+         Scoped2Inner s2i_a, s2i_b(s2i_a), s2i_c(::boost::move(s2i_b));
+      }
+      //Assignment
+      {
+         Scoped0Inner s0i_a, s0i_b;
+         s0i_a = s0i_b;
+         s0i_a = ::boost::move(s0i_b);
+         Scoped1Inner s1i_a, s1i_b;
+         s1i_a = s1i_b;
+         s1i_a = ::boost::move(s1i_b);
+         Scoped2Inner s2i_a, s2i_b;
+         s2i_a = s2i_b;
+         s2i_a = ::boost::move(s2i_b);
+      }
+
+      OuterAlloc  oa;
+      InnerAlloc1 ia1;
+      InnerAlloc2 ia2;
+      Rebound9OuterAlloc roa;
+      Rebound9Scoped0Inner rs0i;
+      Rebound9Scoped1Inner rs1i;
+      Rebound9Scoped2Inner rs2i;
+
+      //Copy from outer
+      {
+         Scoped0Inner s0i(oa);
+         Scoped1Inner s1i(oa, ia1);
+         Scoped2Inner s2i(oa, ia1, ia2);
+      }
+      //Move from outer
+      {
+         Scoped0Inner s0i(::boost::move(oa));
+         Scoped1Inner s1i(::boost::move(oa), ia1);
+         Scoped2Inner s2i(::boost::move(oa), ia1, ia2);
+      }
+      //Copy from rebound outer
+      {
+         Scoped0Inner s0i(roa);
+         Scoped1Inner s1i(roa, ia1);
+         Scoped2Inner s2i(roa, ia1, ia2);
+      }
+      //Move from rebound outer
+      {
+         Scoped0Inner s0i(::boost::move(roa));
+         Scoped1Inner s1i(::boost::move(roa), ia1);
+         Scoped2Inner s2i(::boost::move(roa), ia1, ia2);
+      }
+      //Copy from rebound scoped
+      {
+         Scoped0Inner s0i(rs0i);
+         Scoped1Inner s1i(rs1i);
+         Scoped2Inner s2i(rs2i);
+      }
+      //Move from rebound scoped
+      {
+         Scoped0Inner s0i(::boost::move(rs0i));
+         Scoped1Inner s1i(::boost::move(rs1i));
+         Scoped2Inner s2i(::boost::move(rs2i));
+      }
+   }
+
+   {
+      vector<int, scoped_allocator_adaptor< propagation_test_allocator<int, 0> > > dummy;
+      dummy.push_back(0);
+   }
+
+   //destroy()
+   {
+      {
+         Scoped0Inner s0i;
+         mark_on_destructor mod;
+         s0i.destroy(&mod);
+         BOOST_TEST(mark_on_destructor::destroyed);
+      }
+
+      {
+         Scoped1Inner s1i;
+         mark_on_destructor mod;
+         s1i.destroy(&mod);
+         BOOST_TEST(mark_on_destructor::destroyed);
+      }
+      {
+         Scoped2Inner s2i;
+         mark_on_destructor mod;
+         s2i.destroy(&mod);
+         BOOST_TEST(mark_on_destructor::destroyed);
+      }
+   }
+
+   //construct
+   {
+      ////////////////////////////////////////////////////////////
+      //First check scoped allocator with just OuterAlloc.
+      //In this case OuterAlloc (propagation_test_allocator with tag 0) should be
+      //used to construct types.
+      ////////////////////////////////////////////////////////////
+      {
+         Scoped0Inner s0i;
+         //Check construction with 0 user arguments
+         {
+            typedef ::allocator_argument_tester<NotUsesAllocator, 0> MarkType;
+            MarkType dummy;
+            dummy.~MarkType();
+            s0i.construct(&dummy);
+            BOOST_TEST(dummy.construction_type == NotUsesAllocator);
+            BOOST_TEST(dummy.value == 0 );
+            dummy.~MarkType();
+         }
+         {
+            typedef ::allocator_argument_tester<ConstructibleSuffix, 0> MarkType;
+            MarkType dummy;
+            dummy.~MarkType();
+            s0i.construct(&dummy);
+            BOOST_TEST(dummy.construction_type == ConstructibleSuffix);
+            BOOST_TEST(dummy.value == 0);
+            dummy.~MarkType();
+         }
+         {
+            typedef ::allocator_argument_tester<ConstructiblePrefix, 0> MarkType;
+            MarkType dummy;
+            dummy.~MarkType();
+            s0i.construct(&dummy);
+            BOOST_TEST(dummy.construction_type == ConstructiblePrefix);
+            BOOST_TEST(dummy.value == 0);
+            dummy.~MarkType();
+         }
+
+         //Check construction with 1 user arguments
+         {
+            typedef ::allocator_argument_tester<NotUsesAllocator, 0> MarkType;
+            MarkType dummy;
+            dummy.~MarkType();
+            s0i.construct(&dummy, 1);
+            BOOST_TEST(dummy.construction_type == NotUsesAllocator);
+            BOOST_TEST(dummy.value == 1);
+            dummy.~MarkType();
+         }
+         {
+            typedef ::allocator_argument_tester<ConstructibleSuffix, 0> MarkType;
+            MarkType dummy;
+            dummy.~MarkType();
+            s0i.construct(&dummy, 2);
+            BOOST_TEST(dummy.construction_type == ConstructibleSuffix);
+            BOOST_TEST(dummy.value == 2);
+            dummy.~MarkType();
+         }
+         {
+            typedef ::allocator_argument_tester<ConstructiblePrefix, 0> MarkType;
+            MarkType dummy;
+            dummy.~MarkType();
+            s0i.construct(&dummy, 3);
+            BOOST_TEST(dummy.construction_type == ConstructiblePrefix);
+            BOOST_TEST(dummy.value == 3);
+            dummy.~MarkType();
+         }
+      }
+      ////////////////////////////////////////////////////////////
+      //Then check scoped allocator with OuterAlloc and InnerAlloc.
+      //In this case InnerAlloc (propagation_test_allocator with tag 1) should be
+      //used to construct types.
+      ////////////////////////////////////////////////////////////
+      {
+         Scoped1Inner s1i;
+         //Check construction with 0 user arguments
+         {
+            typedef ::allocator_argument_tester<NotUsesAllocator, 1> MarkType;
+            MarkType dummy;
+            dummy.~MarkType();
+            s1i.construct(&dummy);
+            BOOST_TEST(dummy.construction_type == NotUsesAllocator);
+            BOOST_TEST(dummy.value == 0);
+            dummy.~MarkType();
+         }
+         {
+            typedef ::allocator_argument_tester<ConstructibleSuffix, 1> MarkType;
+            MarkType dummy;
+            dummy.~MarkType();
+            s1i.construct(&dummy);
+            BOOST_TEST(dummy.construction_type == ConstructibleSuffix);
+            BOOST_TEST(dummy.value == 0);
+            dummy.~MarkType();
+         }
+         {
+            typedef ::allocator_argument_tester<ConstructiblePrefix, 1> MarkType;
+            MarkType dummy;
+            dummy.~MarkType();
+            s1i.construct(&dummy);
+            BOOST_TEST(dummy.construction_type == ConstructiblePrefix);
+            BOOST_TEST(dummy.value == 0);
+            dummy.~MarkType();
+         }
+
+         //Check construction with 1 user arguments
+         {
+            typedef ::allocator_argument_tester<NotUsesAllocator, 1> MarkType;
+            MarkType dummy;
+            dummy.~MarkType();
+            s1i.construct(&dummy, 1);
+            BOOST_TEST(dummy.construction_type == NotUsesAllocator);
+            BOOST_TEST(dummy.value == 1);
+            dummy.~MarkType();
+         }
+         {
+            typedef ::allocator_argument_tester<ConstructibleSuffix, 1> MarkType;
+            MarkType dummy;
+            dummy.~MarkType();
+            s1i.construct(&dummy, 2);
+            BOOST_TEST(dummy.construction_type == ConstructibleSuffix);
+            BOOST_TEST(dummy.value == 2);
+            dummy.~MarkType();
+         }
+         {
+            typedef ::allocator_argument_tester<ConstructiblePrefix, 1> MarkType;
+            MarkType dummy;
+            dummy.~MarkType();
+            s1i.construct(&dummy, 3);
+            BOOST_TEST(dummy.construction_type == ConstructiblePrefix);
+            BOOST_TEST(dummy.value == 3);
+            dummy.~MarkType();
+         }
+      }
+
+      //////////////////////////////////////////////////////////////////////////////////
+      //Now test recursive OuterAllocator types (OuterAllocator is a scoped_allocator)
+      //////////////////////////////////////////////////////////////////////////////////
+
+      ////////////////////////////////////////////////////////////
+      //First check scoped allocator with just OuterAlloc.
+      //In this case OuterAlloc (propagation_test_allocator with tag 0) should be
+      //used to construct types.
+      ////////////////////////////////////////////////////////////
+      {
+         //Check outer_allocator_type is scoped
+         BOOST_STATIC_ASSERT(( is_scoped_allocator
+            <ScopedScoped0Inner::outer_allocator_type>::value ));
+         BOOST_STATIC_ASSERT(( dtl::is_same
+            < outermost_allocator<ScopedScoped0Inner>::type
+            , Outer10IdAlloc
+            >::value ));
+         BOOST_STATIC_ASSERT(( dtl::is_same
+            < ScopedScoped0Inner::outer_allocator_type
+            , scoped_allocator_adaptor<Outer10IdAlloc>
+            >::value ));
+         BOOST_STATIC_ASSERT(( dtl::is_same
+            < scoped_allocator_adaptor<Outer10IdAlloc>::outer_allocator_type
+            , Outer10IdAlloc
+            >::value ));
+         ScopedScoped0Inner ssro0i;
+         Outer10IdAlloc & val = outermost_allocator<ScopedScoped0Inner>::get(ssro0i);
+         (void)val;
+         //Check construction with 0 user arguments
+         {
+            typedef ::allocator_argument_tester<NotUsesAllocator, 10> MarkType;
+            MarkType dummy;
+            dummy.~MarkType();
+            ssro0i.construct(&dummy);
+            BOOST_TEST(dummy.construction_type == NotUsesAllocator);
+            BOOST_TEST(dummy.value == 0);
+            dummy.~MarkType();
+         }
+         {
+            typedef ::allocator_argument_tester<ConstructibleSuffix, 10> MarkType;
+            MarkType dummy;
+            dummy.~MarkType();
+            ssro0i.construct(&dummy);
+            BOOST_TEST(dummy.construction_type == ConstructibleSuffix);
+            BOOST_TEST(dummy.value == 0);
+            dummy.~MarkType();
+         }
+         {
+            typedef ::allocator_argument_tester<ConstructiblePrefix, 10> MarkType;
+            MarkType dummy;
+            dummy.~MarkType();
+            ssro0i.construct(&dummy);
+            BOOST_TEST(dummy.construction_type == ConstructiblePrefix);
+            BOOST_TEST(dummy.value == 0);
+            dummy.~MarkType();
+         }
+
+         //Check construction with 1 user arguments
+         {
+            typedef ::allocator_argument_tester<NotUsesAllocator, 10> MarkType;
+            MarkType dummy;
+            dummy.~MarkType();
+            ssro0i.construct(&dummy, 1);
+            BOOST_TEST(dummy.construction_type == NotUsesAllocator);
+            BOOST_TEST(dummy.value == 1);
+            dummy.~MarkType();
+         }
+         {
+            typedef ::allocator_argument_tester<ConstructibleSuffix, 10> MarkType;
+            MarkType dummy;
+            dummy.~MarkType();
+            ssro0i.construct(&dummy, 2);
+            BOOST_TEST(dummy.construction_type == ConstructibleSuffix);
+            BOOST_TEST(dummy.value == 2);
+            dummy.~MarkType();
+         }
+         {
+            typedef ::allocator_argument_tester<ConstructiblePrefix, 10> MarkType;
+            MarkType dummy;
+            dummy.~MarkType();
+            ssro0i.construct(&dummy, 3);
+            BOOST_TEST(dummy.construction_type == ConstructiblePrefix);
+            BOOST_TEST(dummy.value == 3);
+            dummy.~MarkType();
+         }
+      }
+      ////////////////////////////////////////////////////////////
+      //Then check scoped allocator with OuterAlloc and InnerAlloc.
+      //In this case inner_allocator_type is not convertible to
+      //::allocator_argument_tester<XXX, 10> so uses_allocator
+      //should be false on all tests.
+      ////////////////////////////////////////////////////////////
+      {
+         //Check outer_allocator_type is scoped
+         BOOST_STATIC_ASSERT(( is_scoped_allocator
+            <ScopedScoped1Inner::outer_allocator_type>::value ));
+         BOOST_STATIC_ASSERT(( dtl::is_same
+            < outermost_allocator<ScopedScoped1Inner>::type
+            , Outer10IdAlloc
+            >::value ));
+         BOOST_STATIC_ASSERT(( dtl::is_same
+            < ScopedScoped1Inner::outer_allocator_type
+            , scoped_allocator_adaptor<Outer10IdAlloc, Inner11IdAlloc1>
+            >::value ));
+         BOOST_STATIC_ASSERT(( dtl::is_same
+            < scoped_allocator_adaptor<Outer10IdAlloc, Inner11IdAlloc1>::outer_allocator_type
+            , Outer10IdAlloc
+            >::value ));
+         BOOST_STATIC_ASSERT(( !
+            uses_allocator
+               < ::allocator_argument_tester<ConstructibleSuffix, 10>
+               , ScopedScoped1Inner::inner_allocator_type::outer_allocator_type
+               >::value ));
+         ScopedScoped1Inner ssro1i;
+         Outer10IdAlloc & val = outermost_allocator<ScopedScoped1Inner>::get(ssro1i);
+         (void)val;
+
+         //Check construction with 0 user arguments
+         {
+            typedef ::allocator_argument_tester<NotUsesAllocator, 10> MarkType;
+            MarkType dummy;
+            dummy.~MarkType();
+            ssro1i.construct(&dummy);
+            BOOST_TEST(dummy.construction_type == NotUsesAllocator);
+            BOOST_TEST(dummy.value == 0);
+            dummy.~MarkType();
+         }
+         {
+            typedef ::allocator_argument_tester<ConstructibleSuffix, 10> MarkType;
+            MarkType dummy;
+            dummy.~MarkType();
+            ssro1i.construct(&dummy);
+            BOOST_TEST(dummy.construction_type == NotUsesAllocator);
+            BOOST_TEST(dummy.value == 0);
+            dummy.~MarkType();
+         }
+         {
+            typedef ::allocator_argument_tester<ConstructiblePrefix, 10> MarkType;
+            MarkType dummy;
+            dummy.~MarkType();
+            ssro1i.construct(&dummy);
+            BOOST_TEST(dummy.construction_type == NotUsesAllocator);
+            BOOST_TEST(dummy.value == 0);
+            dummy.~MarkType();
+         }
+
+         //Check construction with 1 user arguments
+         {
+            typedef ::allocator_argument_tester<NotUsesAllocator, 10> MarkType;
+            MarkType dummy;
+            dummy.~MarkType();
+            ssro1i.construct(&dummy, 1);
+            BOOST_TEST(dummy.construction_type == NotUsesAllocator);
+            BOOST_TEST(dummy.value == 1);
+            dummy.~MarkType();
+         }
+         {
+            typedef ::allocator_argument_tester<ConstructibleSuffix, 10> MarkType;
+            MarkType dummy;
+            dummy.~MarkType();
+            ssro1i.construct(&dummy, 2);
+            BOOST_TEST(dummy.construction_type == NotUsesAllocator);
+            BOOST_TEST(dummy.value == 2);
+            dummy.~MarkType();
+         }
+         {
+            typedef ::allocator_argument_tester<ConstructiblePrefix, 10> MarkType;
+            MarkType dummy;
+            dummy.~MarkType();
+            ssro1i.construct(&dummy, 3);
+            BOOST_TEST(dummy.construction_type == NotUsesAllocator);
+            BOOST_TEST(dummy.value == 3);
+            dummy.~MarkType();
+         }
+      }
+
+      ////////////////////////////////////////////////////////////
+      //Now check propagation to pair
+      ////////////////////////////////////////////////////////////
+      //First check scoped allocator with just OuterAlloc.
+      //In this case OuterAlloc (propagation_test_allocator with tag 0) should be
+      //used to construct types.
+      ////////////////////////////////////////////////////////////
+      {
+         using dtl::pair;
+         typedef propagation_test_allocator< pair< tagged_integer<0>
+                               , tagged_integer<0> >, 0> OuterPairAlloc;
+         //
+         typedef scoped_allocator_adaptor < OuterPairAlloc  >  ScopedPair0Inner;
+
+         ScopedPair0Inner s0i;
+         //Check construction with 0 user arguments
+         {
+            typedef ::allocator_argument_tester<NotUsesAllocator, 0> MarkType;
+            typedef pair<MarkType, MarkType> MarkTypePair;
+            MarkTypePair dummy;
+            dummy.~MarkTypePair();
+            s0i.construct(&dummy);
+            BOOST_TEST(dummy.first.construction_type == NotUsesAllocator);
+            BOOST_TEST(dummy.second.construction_type == NotUsesAllocator);
+            BOOST_TEST(dummy.first.value  == 0);
+            BOOST_TEST(dummy.second.value == 0);
+            dummy.~MarkTypePair();
+         }
+         {
+            typedef ::allocator_argument_tester<ConstructibleSuffix, 0> MarkType;
+            typedef pair<MarkType, MarkType> MarkTypePair;
+            MarkTypePair dummy;
+            dummy.~MarkTypePair();
+            s0i.construct(&dummy);
+            BOOST_TEST(dummy.first.construction_type == ConstructibleSuffix);
+            BOOST_TEST(dummy.second.construction_type == ConstructibleSuffix);
+            BOOST_TEST(dummy.first.value  == 0);
+            BOOST_TEST(dummy.second.value == 0);
+            dummy.~MarkTypePair();
+         }
+         {
+            typedef ::allocator_argument_tester<ConstructiblePrefix, 0> MarkType;
+            typedef pair<MarkType, MarkType> MarkTypePair;
+            MarkTypePair dummy;
+            dummy.~MarkTypePair();
+            s0i.construct(&dummy);
+            BOOST_TEST(dummy.first.construction_type  == ConstructiblePrefix);
+            BOOST_TEST(dummy.second.construction_type == ConstructiblePrefix);
+            BOOST_TEST(dummy.first.value  == 0);
+            BOOST_TEST(dummy.second.value == 0);
+            dummy.~MarkTypePair();
+         }
+         #if defined(BOOST_CONTAINER_PAIR_TEST_HAS_HEADER_TUPLE)
+         //Check construction with 0 user arguments and Std tuple
+         {
+            typedef ::allocator_argument_tester<NotUsesAllocator, 0> MarkType;
+            typedef pair<MarkType, MarkType> MarkTypePair;
+            MarkTypePair dummy;
+            dummy.~MarkTypePair();
+            s0i.construct(&dummy, piecewise_construct, std::tuple<>(), std::tuple<>());
+            BOOST_TEST(dummy.first.construction_type == NotUsesAllocator);
+            BOOST_TEST(dummy.second.construction_type == NotUsesAllocator);
+            BOOST_TEST(dummy.first.value  == 0);
+            BOOST_TEST(dummy.second.value == 0);
+            dummy.~MarkTypePair();
+         }
+         {
+            typedef ::allocator_argument_tester<ConstructibleSuffix, 0> MarkType;
+            typedef pair<MarkType, MarkType> MarkTypePair;
+            MarkTypePair dummy;
+            dummy.~MarkTypePair();
+            s0i.construct(&dummy, piecewise_construct, std::tuple<>(), std::tuple<>());
+            BOOST_TEST(dummy.first.construction_type == ConstructibleSuffix);
+            BOOST_TEST(dummy.second.construction_type == ConstructibleSuffix);
+            BOOST_TEST(dummy.first.value  == 0);
+            BOOST_TEST(dummy.second.value == 0);
+            dummy.~MarkTypePair();
+         }
+         {
+            typedef ::allocator_argument_tester<ConstructiblePrefix, 0> MarkType;
+            typedef pair<MarkType, MarkType> MarkTypePair;
+            MarkTypePair dummy;
+            dummy.~MarkTypePair();
+            s0i.construct(&dummy, piecewise_construct, std::tuple<>(), std::tuple<>());
+            BOOST_TEST(dummy.first.construction_type  == ConstructiblePrefix);
+            BOOST_TEST(dummy.second.construction_type == ConstructiblePrefix);
+            BOOST_TEST(dummy.first.value  == 0);
+            BOOST_TEST(dummy.second.value == 0);
+            dummy.~MarkTypePair();
+         }
+         {
+            typedef ::allocator_argument_tester<NotUsesAllocator, 0> MarkType;
+            typedef pair<MarkType, MarkType> MarkTypePair;
+            MarkTypePair dummy;
+            dummy.~MarkTypePair();
+            s0i.construct(&dummy, piecewise_construct, std::tuple<>(), std::tuple<>());
+            BOOST_TEST(dummy.first.construction_type == NotUsesAllocator);
+            BOOST_TEST(dummy.second.construction_type == NotUsesAllocator);
+            BOOST_TEST(dummy.first.value  == 0);
+            BOOST_TEST(dummy.second.value == 0);
+            dummy.~MarkTypePair();
+         }
+         {
+            typedef ::allocator_argument_tester<ConstructibleSuffix, 0> MarkType;
+            typedef pair<MarkType, MarkType> MarkTypePair;
+            MarkTypePair dummy;
+            dummy.~MarkTypePair();
+            s0i.construct(&dummy, piecewise_construct, std::tuple<>(), std::tuple<>());
+            BOOST_TEST(dummy.first.construction_type == ConstructibleSuffix);
+            BOOST_TEST(dummy.second.construction_type == ConstructibleSuffix);
+            BOOST_TEST(dummy.first.value  == 0);
+            BOOST_TEST(dummy.second.value == 0);
+            dummy.~MarkTypePair();
+         }
+         {
+            typedef ::allocator_argument_tester<ConstructiblePrefix, 0> MarkType;
+            typedef pair<MarkType, MarkType> MarkTypePair;
+            MarkTypePair dummy;
+            dummy.~MarkTypePair();
+            s0i.construct(&dummy, piecewise_construct, std::tuple<>(), std::tuple<>());
+            BOOST_TEST(dummy.first.construction_type  == ConstructiblePrefix);
+            BOOST_TEST(dummy.second.construction_type == ConstructiblePrefix);
+            BOOST_TEST(dummy.first.value  == 0);
+            BOOST_TEST(dummy.second.value == 0);
+            dummy.~MarkTypePair();
+         }
+         #endif   //BOOST_CONTAINER_PAIR_TEST_HAS_HEADER_TUPLE
+         //Check construction with 1 user arguments for each pair
+         {
+            typedef ::allocator_argument_tester<NotUsesAllocator, 0> MarkType;
+            typedef pair<MarkType, MarkType> MarkTypePair;
+            MarkTypePair dummy;
+            dummy.~MarkTypePair();
+            s0i.construct(&dummy, 1, 1);
+            BOOST_TEST(dummy.first.construction_type  == NotUsesAllocator);
+            BOOST_TEST(dummy.second.construction_type == NotUsesAllocator);
+            BOOST_TEST(dummy.first.value  == 1);
+            BOOST_TEST(dummy.second.value == 1);
+            dummy.~MarkTypePair();
+         }
+         {
+            typedef ::allocator_argument_tester<ConstructibleSuffix, 0> MarkType;
+            typedef pair<MarkType, MarkType> MarkTypePair;
+            MarkTypePair dummy;
+            dummy.~MarkTypePair();
+            s0i.construct(&dummy, 1, 1);
+            BOOST_TEST(dummy.first.construction_type  == ConstructibleSuffix);
+            BOOST_TEST(dummy.second.construction_type == ConstructibleSuffix);
+            BOOST_TEST(dummy.first.value  == 1);
+            BOOST_TEST(dummy.second.value == 1);
+            dummy.~MarkTypePair();
+         }
+         {
+            typedef ::allocator_argument_tester<ConstructiblePrefix, 0> MarkType;
+            typedef pair<MarkType, MarkType> MarkTypePair;
+            MarkTypePair dummy;
+            dummy.~MarkTypePair();
+            s0i.construct(&dummy, 2, 2);
+            BOOST_TEST(dummy.first.construction_type  == ConstructiblePrefix);
+            BOOST_TEST(dummy.second.construction_type == ConstructiblePrefix);
+            BOOST_TEST(dummy.first.value  == 2);
+            BOOST_TEST(dummy.second.value == 2);
+            dummy.~MarkTypePair();
+         }
+         //Check construction with 1 user arguments for each pair and Boost tuple
+         {
+            typedef ::allocator_argument_tester<NotUsesAllocator, 0> MarkType;
+            typedef pair<MarkType, MarkType> MarkTypePair;
+            MarkTypePair dummy;
+            dummy.~MarkTypePair();
+            s0i.construct(&dummy, piecewise_construct, boost::tuple<int>(1), boost::tuple<int>(1));
+            BOOST_TEST(dummy.first.construction_type  == NotUsesAllocator);
+            BOOST_TEST(dummy.second.construction_type == NotUsesAllocator);
+            BOOST_TEST(dummy.first.value  == 1);
+            BOOST_TEST(dummy.second.value == 1);
+            dummy.~MarkTypePair();
+         }
+         {
+            typedef ::allocator_argument_tester<ConstructibleSuffix, 0> MarkType;
+            typedef pair<MarkType, MarkType> MarkTypePair;
+            MarkTypePair dummy;
+            dummy.~MarkTypePair();
+            s0i.construct(&dummy, piecewise_construct, boost::tuple<int>(1), boost::tuple<int>(1));
+            BOOST_TEST(dummy.first.construction_type  == ConstructibleSuffix);
+            BOOST_TEST(dummy.second.construction_type == ConstructibleSuffix);
+            BOOST_TEST(dummy.first.value  == 1);
+            BOOST_TEST(dummy.second.value == 1);
+            dummy.~MarkTypePair();
+         }
+         {
+            typedef ::allocator_argument_tester<ConstructiblePrefix, 0> MarkType;
+            typedef pair<MarkType, MarkType> MarkTypePair;
+            MarkTypePair dummy;
+            dummy.~MarkTypePair();
+            s0i.construct(&dummy, piecewise_construct, boost::tuple<int>(2), boost::tuple<int>(2));
+            BOOST_TEST(dummy.first.construction_type  == ConstructiblePrefix);
+            BOOST_TEST(dummy.second.construction_type == ConstructiblePrefix);
+            BOOST_TEST(dummy.first.value  == 2);
+            BOOST_TEST(dummy.second.value == 2);
+            dummy.~MarkTypePair();
+         }
+         #if defined(BOOST_CONTAINER_PAIR_TEST_HAS_HEADER_TUPLE)
+         //Check construction with 1 user arguments for each pair and Boost tuple
+         {
+            typedef ::allocator_argument_tester<NotUsesAllocator, 0> MarkType;
+            typedef pair<MarkType, MarkType> MarkTypePair;
+            MarkTypePair dummy;
+            dummy.~MarkTypePair();
+            s0i.construct(&dummy, piecewise_construct, std::tuple<int>(1), std::tuple<int>(1));
+            BOOST_TEST(dummy.first.construction_type  == NotUsesAllocator);
+            BOOST_TEST(dummy.second.construction_type == NotUsesAllocator);
+            BOOST_TEST(dummy.first.value  == 1);
+            BOOST_TEST(dummy.second.value == 1);
+            dummy.~MarkTypePair();
+         }
+         {
+            typedef ::allocator_argument_tester<ConstructibleSuffix, 0> MarkType;
+            typedef pair<MarkType, MarkType> MarkTypePair;
+            MarkTypePair dummy;
+            dummy.~MarkTypePair();
+            s0i.construct(&dummy, piecewise_construct, std::tuple<int>(1), std::tuple<int>(1));
+            BOOST_TEST(dummy.first.construction_type  == ConstructibleSuffix);
+            BOOST_TEST(dummy.second.construction_type == ConstructibleSuffix);
+            BOOST_TEST(dummy.first.value  == 1);
+            BOOST_TEST(dummy.second.value == 1);
+            dummy.~MarkTypePair();
+         }
+         {
+            typedef ::allocator_argument_tester<ConstructiblePrefix, 0> MarkType;
+            typedef pair<MarkType, MarkType> MarkTypePair;
+            MarkTypePair dummy;
+            dummy.~MarkTypePair();
+            s0i.construct(&dummy, piecewise_construct, std::tuple<int>(2), std::tuple<int>(2));
+            BOOST_TEST(dummy.first.construction_type  == ConstructiblePrefix);
+            BOOST_TEST(dummy.second.construction_type == ConstructiblePrefix);
+            BOOST_TEST(dummy.first.value  == 2);
+            BOOST_TEST(dummy.second.value == 2);
+            dummy.~MarkTypePair();
+         }
+         #endif   //BOOST_CONTAINER_PAIR_TEST_HAS_HEADER_TUPLE
+         //Check construction with pair copy construction
+         {
+            typedef ::allocator_argument_tester<NotUsesAllocator, 0> MarkType;
+            typedef pair<MarkType, MarkType> MarkTypePair;
+            MarkTypePair dummy, dummy2;
+            dummy.~MarkTypePair();
+            s0i.construct(&dummy, dummy2);
+            BOOST_TEST(dummy.first.construction_type  == NotUsesAllocator);
+            BOOST_TEST(dummy.second.construction_type == NotUsesAllocator);
+            BOOST_TEST(dummy.first.value  == 0);
+            BOOST_TEST(dummy.second.value == 0);
+            dummy.~MarkTypePair();
+         }
+         {
+            typedef ::allocator_argument_tester<ConstructibleSuffix, 0> MarkType;
+            typedef pair<MarkType, MarkType> MarkTypePair;
+            MarkTypePair dummy, dummy2(1, 1);
+            dummy.~MarkTypePair();
+            s0i.construct(&dummy, dummy2);
+            BOOST_TEST(dummy.first.construction_type  == ConstructibleSuffix);
+            BOOST_TEST(dummy.second.construction_type == ConstructibleSuffix);
+            BOOST_TEST(dummy.first.value  == 1);
+            BOOST_TEST(dummy.second.value == 1);
+            dummy.~MarkTypePair();
+         }
+         {
+            typedef ::allocator_argument_tester<ConstructiblePrefix, 0> MarkType;
+            typedef pair<MarkType, MarkType> MarkTypePair;
+            MarkTypePair dummy, dummy2(2, 2);
+            dummy.~MarkTypePair();
+            s0i.construct(&dummy, dummy2);
+            BOOST_TEST(dummy.first.construction_type  == ConstructiblePrefix);
+            BOOST_TEST(dummy.second.construction_type == ConstructiblePrefix);
+            BOOST_TEST(dummy.first.value  == 2);
+            BOOST_TEST(dummy.second.value == 2);
+            dummy.~MarkTypePair();
+         }
+         //Check construction with pair move construction
+         {
+            typedef ::allocator_argument_tester<NotUsesAllocator, 0> MarkType;
+            typedef pair<MarkType, MarkType> MarkTypePair;
+            MarkTypePair dummy, dummy2(3, 3);
+            dummy2.first.construction_type = dummy2.second.construction_type = ConstructibleSuffix;
+            dummy.~MarkTypePair();
+            s0i.construct(&dummy, ::boost::move(dummy2));
+            BOOST_TEST(dummy.first.construction_type  == NotUsesAllocator);
+            BOOST_TEST(dummy.second.construction_type == NotUsesAllocator);
+            BOOST_TEST(dummy.first.value  == 3);
+            BOOST_TEST(dummy.second.value == 3);
+            BOOST_TEST(dummy2.first.construction_type  == NotUsesAllocator);
+            BOOST_TEST(dummy2.second.construction_type == NotUsesAllocator);
+            BOOST_TEST(dummy2.first.value  == 0);
+            BOOST_TEST(dummy2.second.value == 0);
+            dummy.~MarkTypePair();
+         }
+         {
+            typedef ::allocator_argument_tester<ConstructibleSuffix, 0> MarkType;
+            typedef pair<MarkType, MarkType> MarkTypePair;
+            MarkTypePair dummy, dummy2(1, 1);
+            dummy.~MarkTypePair();
+            s0i.construct(&dummy, ::boost::move(dummy2));
+            BOOST_TEST(dummy.first.construction_type  == ConstructibleSuffix);
+            BOOST_TEST(dummy.second.construction_type == ConstructibleSuffix);
+            BOOST_TEST(dummy.first.value  == 1);
+            BOOST_TEST(dummy.second.value == 1);
+            BOOST_TEST(dummy2.first.construction_type  == ConstructibleSuffix);
+            BOOST_TEST(dummy2.second.construction_type == ConstructibleSuffix);
+            BOOST_TEST(dummy2.first.value  == 0);
+            BOOST_TEST(dummy2.second.value == 0);
+            dummy.~MarkTypePair();
+         }
+         {
+            typedef ::allocator_argument_tester<ConstructiblePrefix, 0> MarkType;
+            typedef pair<MarkType, MarkType> MarkTypePair;
+            MarkTypePair dummy, dummy2(2, 2);
+            dummy.~MarkTypePair();
+            s0i.construct(&dummy, ::boost::move(dummy2));
+            BOOST_TEST(dummy.first.construction_type  == ConstructiblePrefix);
+            BOOST_TEST(dummy.second.construction_type == ConstructiblePrefix);
+            BOOST_TEST(dummy.first.value  == 2);
+            BOOST_TEST(dummy.second.value == 2);
+            BOOST_TEST(dummy2.first.construction_type  == ConstructiblePrefix);
+            BOOST_TEST(dummy2.second.construction_type == ConstructiblePrefix);
+            BOOST_TEST(dummy2.first.value  == 0);
+            BOOST_TEST(dummy2.second.value == 0);
+            dummy.~MarkTypePair();
+         }
+         //Check construction with related pair copy construction
+         {
+            typedef ::allocator_argument_tester<NotUsesAllocator, 0> MarkType;
+            typedef pair<MarkType, MarkType> MarkTypePair;
+            MarkTypePair dummy;
+            pair<int, int> dummy2;
+            dummy.~MarkTypePair();
+            s0i.construct(&dummy, dummy2);
+            BOOST_TEST(dummy.first.construction_type  == NotUsesAllocator);
+            BOOST_TEST(dummy.second.construction_type == NotUsesAllocator);
+            BOOST_TEST(dummy.first.value  == 0);
+            BOOST_TEST(dummy.second.value == 0);
+            dummy.~MarkTypePair();
+         }
+         {
+            typedef ::allocator_argument_tester<ConstructibleSuffix, 0> MarkType;
+            typedef pair<MarkType, MarkType> MarkTypePair;
+            MarkTypePair dummy;
+            pair<int, int> dummy2(1, 1);
+            dummy.~MarkTypePair();
+            s0i.construct(&dummy, dummy2);
+            BOOST_TEST(dummy.first.construction_type  == ConstructibleSuffix);
+            BOOST_TEST(dummy.second.construction_type == ConstructibleSuffix);
+            BOOST_TEST(dummy.first.value  == 1);
+            BOOST_TEST(dummy.second.value == 1);
+            dummy.~MarkTypePair();
+         }
+         {
+            typedef ::allocator_argument_tester<ConstructiblePrefix, 0> MarkType;
+            typedef pair<MarkType, MarkType> MarkTypePair;
+            MarkTypePair dummy;
+            pair<int, int> dummy2(2, 2);
+            dummy.~MarkTypePair();
+            s0i.construct(&dummy, dummy2);
+            BOOST_TEST(dummy.first.construction_type  == ConstructiblePrefix);
+            BOOST_TEST(dummy.second.construction_type == ConstructiblePrefix);
+            BOOST_TEST(dummy.first.value  == 2);
+            BOOST_TEST(dummy.second.value == 2);
+            dummy.~MarkTypePair();
+         }
+         //Check construction with related pair move construction
+         {
+            typedef ::allocator_argument_tester<NotUsesAllocator, 0> MarkType;
+            typedef pair<MarkType, MarkType> MarkTypePair;
+            MarkTypePair dummy;
+            pair<int, int> dummy2(3, 3);
+            dummy.~MarkTypePair();
+            s0i.construct(&dummy, ::boost::move(dummy2));
+            BOOST_TEST(dummy.first.construction_type  == NotUsesAllocator);
+            BOOST_TEST(dummy.second.construction_type == NotUsesAllocator);
+            BOOST_TEST(dummy.first.value  == 3);
+            BOOST_TEST(dummy.second.value == 3);
+            dummy.~MarkTypePair();
+         }
+         {
+            typedef ::allocator_argument_tester<ConstructibleSuffix, 0> MarkType;
+            typedef pair<MarkType, MarkType> MarkTypePair;
+            MarkTypePair dummy;
+            pair<int, int> dummy2(1, 1);
+            dummy.~MarkTypePair();
+            s0i.construct(&dummy, ::boost::move(dummy2));
+            BOOST_TEST(dummy.first.construction_type  == ConstructibleSuffix);
+            BOOST_TEST(dummy.second.construction_type == ConstructibleSuffix);
+            BOOST_TEST(dummy.first.value  == 1);
+            BOOST_TEST(dummy.second.value == 1);
+            dummy.~MarkTypePair();
+         }
+         {
+            typedef ::allocator_argument_tester<ConstructiblePrefix, 0> MarkType;
+            typedef pair<MarkType, MarkType> MarkTypePair;
+            MarkTypePair dummy;
+            pair<int, int> dummy2(2, 2);
+            dummy.~MarkTypePair();
+            s0i.construct(&dummy, ::boost::move(dummy2));
+            BOOST_TEST(dummy.first.construction_type  == ConstructiblePrefix);
+            BOOST_TEST(dummy.second.construction_type == ConstructiblePrefix);
+            BOOST_TEST(dummy.first.value  == 2);
+            BOOST_TEST(dummy.second.value == 2);
+            dummy.~MarkTypePair();
+         }
+         //Check construction with 0/1 arguments for each pair and Boost tuple
+         {
+            typedef ::allocator_argument_tester<NotUsesAllocator, 0> MarkType;
+            typedef pair<MarkType, MarkType> MarkTypePair;
+            MarkTypePair dummy;
+            dummy.~MarkTypePair();
+            s0i.construct(&dummy, piecewise_construct, boost::tuple<>(), boost::tuple<int>(1));
+            BOOST_TEST(dummy.first.construction_type  == NotUsesAllocator);
+            BOOST_TEST(dummy.second.construction_type == NotUsesAllocator);
+            BOOST_TEST(dummy.first.value  == 0);
+            BOOST_TEST(dummy.second.value == 1);
+            dummy.~MarkTypePair();
+         }
+         {
+            typedef ::allocator_argument_tester<ConstructibleSuffix, 0> MarkType;
+            typedef pair<MarkType, MarkType> MarkTypePair;
+            MarkTypePair dummy;
+            dummy.~MarkTypePair();
+            s0i.construct(&dummy, piecewise_construct, boost::tuple<int>(1), boost::tuple<>());
+            BOOST_TEST(dummy.first.construction_type  == ConstructibleSuffix);
+            BOOST_TEST(dummy.second.construction_type == ConstructibleSuffix);
+            BOOST_TEST(dummy.first.value  == 1);
+            BOOST_TEST(dummy.second.value == 0);
+            dummy.~MarkTypePair();
+         }
+         {
+            typedef ::allocator_argument_tester<ConstructiblePrefix, 0> MarkType;
+            typedef pair<MarkType, MarkType> MarkTypePair;
+            MarkTypePair dummy;
+            dummy.~MarkTypePair();
+            s0i.construct(&dummy, piecewise_construct, boost::tuple<>(), boost::tuple<int>(2));
+            BOOST_TEST(dummy.first.construction_type  == ConstructiblePrefix);
+            BOOST_TEST(dummy.second.construction_type == ConstructiblePrefix);
+            BOOST_TEST(dummy.first.value  == 0);
+            BOOST_TEST(dummy.second.value == 2);
+            dummy.~MarkTypePair();
+         }
+         #if defined(BOOST_CONTAINER_PAIR_TEST_HAS_HEADER_TUPLE)
+         //Check construction with 0/1 arguments for each pair and Boost tuple
+         {
+            typedef ::allocator_argument_tester<NotUsesAllocator, 0> MarkType;
+            typedef pair<MarkType, MarkType> MarkTypePair;
+            MarkTypePair dummy;
+            dummy.~MarkTypePair();
+            s0i.construct(&dummy, piecewise_construct, std::tuple<>(), std::tuple<int>(1));
+            BOOST_TEST(dummy.first.construction_type  == NotUsesAllocator);
+            BOOST_TEST(dummy.second.construction_type == NotUsesAllocator);
+            BOOST_TEST(dummy.first.value  == 0);
+            BOOST_TEST(dummy.second.value == 1);
+            dummy.~MarkTypePair();
+         }
+         {
+            typedef ::allocator_argument_tester<ConstructibleSuffix, 0> MarkType;
+            typedef pair<MarkType, MarkType> MarkTypePair;
+            MarkTypePair dummy;
+            dummy.~MarkTypePair();
+            s0i.construct(&dummy, piecewise_construct, std::tuple<int>(1), std::tuple<>());
+            BOOST_TEST(dummy.first.construction_type  == ConstructibleSuffix);
+            BOOST_TEST(dummy.second.construction_type == ConstructibleSuffix);
+            BOOST_TEST(dummy.first.value  == 1);
+            BOOST_TEST(dummy.second.value == 0);
+            dummy.~MarkTypePair();
+         }
+         {
+            typedef ::allocator_argument_tester<ConstructiblePrefix, 0> MarkType;
+            typedef pair<MarkType, MarkType> MarkTypePair;
+            MarkTypePair dummy;
+            dummy.~MarkTypePair();
+            s0i.construct(&dummy, piecewise_construct, std::tuple<>(), std::tuple<int>(2));
+            BOOST_TEST(dummy.first.construction_type  == ConstructiblePrefix);
+            BOOST_TEST(dummy.second.construction_type == ConstructiblePrefix);
+            BOOST_TEST(dummy.first.value  == 0);
+            BOOST_TEST(dummy.second.value == 2);
+            dummy.~MarkTypePair();
+         }
+         #endif   //BOOST_CONTAINER_PAIR_TEST_HAS_HEADER_TUPLE
+
+         //Check construction with try_emplace_t 0/1 arguments for each pair
+         {
+            typedef ::allocator_argument_tester<NotUsesAllocator, 0> MarkType;
+            typedef pair<MarkType, MarkType> MarkTypePair;
+            MarkTypePair dummy;
+            dummy.~MarkTypePair();
+            s0i.construct(&dummy, try_emplace_t(), 5, 1);
+            BOOST_TEST(dummy.first.construction_type  == NotUsesAllocator);
+            BOOST_TEST(dummy.second.construction_type == NotUsesAllocator);
+            BOOST_TEST(dummy.first.value  == 5);
+            BOOST_TEST(dummy.second.value == 1);
+            dummy.~MarkTypePair();
+         }
+         {
+            typedef ::allocator_argument_tester<ConstructibleSuffix, 0> MarkType;
+            typedef pair<MarkType, MarkType> MarkTypePair;
+            MarkTypePair dummy;
+            dummy.~MarkTypePair();
+            s0i.construct(&dummy, try_emplace_t(), 6);
+            BOOST_TEST(dummy.first.construction_type  == ConstructibleSuffix);
+            BOOST_TEST(dummy.second.construction_type == ConstructibleSuffix);
+            BOOST_TEST(dummy.first.value  == 6);
+            BOOST_TEST(dummy.second.value == 0);
+            dummy.~MarkTypePair();
+         }
+         {
+            typedef ::allocator_argument_tester<ConstructiblePrefix, 0> MarkType;
+            typedef pair<MarkType, MarkType> MarkTypePair;
+            MarkTypePair dummy;
+            dummy.~MarkTypePair();
+            s0i.construct(&dummy, try_emplace_t(), 7, 2);
+            BOOST_TEST(dummy.first.construction_type  == ConstructiblePrefix);
+            BOOST_TEST(dummy.second.construction_type == ConstructiblePrefix);
+            BOOST_TEST(dummy.first.value  == 7);
+            BOOST_TEST(dummy.second.value == 2);
+            dummy.~MarkTypePair();
+         }
+      }
+   }
+
+   return ::boost::report_errors();
+}
+#include <boost/container/detail/config_end.hpp>
diff --git a/src/boost/libs/container/test/scoped_allocator_usage_test.cpp b/src/boost/libs/container/test/scoped_allocator_usage_test.cpp
new file mode 100644
index 000000000..6eb143811
--- /dev/null
+++ b/src/boost/libs/container/test/scoped_allocator_usage_test.cpp
@@ -0,0 +1,428 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2011-2013. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/container for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+#include <boost/container/detail/config_begin.hpp>
+#include <memory>
+
+#include <boost/move/utility_core.hpp>
+#include <boost/container/vector.hpp>
+#include <boost/container/deque.hpp>
+#include <boost/container/list.hpp>
+#include <boost/container/slist.hpp>
+#include <boost/container/stable_vector.hpp>
+#include <boost/container/small_vector.hpp>
+#include <boost/container/flat_map.hpp>
+#include <boost/container/flat_set.hpp>
+#include <boost/container/map.hpp>
+#include <boost/container/set.hpp>
+#include <boost/container/detail/mpl.hpp>
+
+#include <boost/container/scoped_allocator.hpp>
+
+template <typename Ty>
+class SimpleAllocator
+{
+public:
+   typedef Ty value_type;
+
+   explicit SimpleAllocator(int value)
+      : m_state(value)
+   {}
+
+   template <typename T>
+   SimpleAllocator(const SimpleAllocator<T> &other)
+      : m_state(other.m_state)
+   {}
+
+   Ty* allocate(std::size_t n)
+   {
+      return m_allocator.allocate(n);
+   }
+
+   void deallocate(Ty* p, std::size_t n)
+   {
+      m_allocator.deallocate(p, n);
+   }
+
+   int get_value() const
+   {  return m_state;   }
+
+   private:
+   int m_state;
+   std::allocator<Ty> m_allocator;
+
+   template <typename T> friend class SimpleAllocator;
+
+   friend bool operator == (const SimpleAllocator &, const SimpleAllocator &)
+   {  return true;  }
+
+   friend bool operator != (const SimpleAllocator &, const SimpleAllocator &)
+   {  return false;  }
+};
+
+class alloc_int
+{
+   private: // Not copyable
+
+   BOOST_MOVABLE_BUT_NOT_COPYABLE(alloc_int)
+
+   public:
+   typedef SimpleAllocator<int> allocator_type;
+
+   alloc_int(BOOST_RV_REF(alloc_int)other)
+      : m_value(other.m_value), m_allocator(boost::move(other.m_allocator))
+   {
+      other.m_value = -1;
+   }
+
+   alloc_int(BOOST_RV_REF(alloc_int)other, const allocator_type &allocator)
+      : m_value(other.m_value), m_allocator(allocator)
+   {
+      other.m_value = -1;
+   }
+
+   alloc_int(int value, const allocator_type &allocator)
+      : m_value(value), m_allocator(allocator)
+   {}
+
+   alloc_int & operator=(BOOST_RV_REF(alloc_int)other)
+   {
+      other.m_value = other.m_value;
+      return *this;
+   }
+
+   int get_allocator_state() const
+   {  return m_allocator.get_value();  }
+
+   int get_value() const
+   {  return m_value;   }
+
+   friend bool operator < (const alloc_int &l, const alloc_int &r)
+   {  return l.m_value < r.m_value;  }
+
+   friend bool operator == (const alloc_int &l, const alloc_int &r)
+   {  return l.m_value == r.m_value;  }
+
+   private:
+   int m_value;
+   allocator_type m_allocator;
+};
+
+using namespace ::boost::container;
+
+//general allocator
+typedef scoped_allocator_adaptor<SimpleAllocator<alloc_int> > AllocIntAllocator;
+
+//[multi]map/set
+typedef std::pair<const alloc_int, alloc_int> MapNode;
+typedef scoped_allocator_adaptor<SimpleAllocator<MapNode> > MapAllocator;
+typedef map<alloc_int, alloc_int, std::less<alloc_int>, MapAllocator> Map;
+typedef set<alloc_int, std::less<alloc_int>, AllocIntAllocator> Set;
+typedef multimap<alloc_int, alloc_int, std::less<alloc_int>, MapAllocator> MultiMap;
+typedef multiset<alloc_int, std::less<alloc_int>, AllocIntAllocator> MultiSet;
+
+//[multi]flat_map/set
+typedef std::pair<alloc_int, alloc_int> FlatMapNode;
+typedef scoped_allocator_adaptor<SimpleAllocator<FlatMapNode> > FlatMapAllocator;
+typedef flat_map<alloc_int, alloc_int, std::less<alloc_int>, FlatMapAllocator> FlatMap;
+typedef flat_set<alloc_int, std::less<alloc_int>, AllocIntAllocator> FlatSet;
+typedef flat_multimap<alloc_int, alloc_int, std::less<alloc_int>, FlatMapAllocator> FlatMultiMap;
+typedef flat_multiset<alloc_int, std::less<alloc_int>, AllocIntAllocator> FlatMultiSet;
+
+//vector, deque, list, slist, stable_vector.
+typedef vector<alloc_int, AllocIntAllocator>          Vector;
+typedef deque<alloc_int, AllocIntAllocator>           Deque;
+typedef list<alloc_int, AllocIntAllocator>            List;
+typedef slist<alloc_int, AllocIntAllocator>           Slist;
+typedef stable_vector<alloc_int, AllocIntAllocator>   StableVector;
+typedef small_vector<alloc_int, 9, AllocIntAllocator> SmallVector;
+
+/////////
+//is_unique_assoc
+/////////
+
+template<class T>
+struct is_unique_assoc
+{
+   static const bool value = false;
+};
+
+template<class Key, class T, class Compare, class Allocator>
+struct is_unique_assoc< map<Key, T, Compare, Allocator> >
+{
+   static const bool value = true;
+};
+
+template<class Key, class T, class Compare, class Allocator>
+struct is_unique_assoc< flat_map<Key, T, Compare, Allocator> >
+{
+   static const bool value = true;
+};
+
+template<class Key, class Compare, class Allocator>
+struct is_unique_assoc< set<Key, Compare, Allocator> >
+{
+   static const bool value = true;
+};
+
+template<class Key, class Compare, class Allocator>
+struct is_unique_assoc< flat_set<Key, Compare, Allocator> >
+{
+   static const bool value = true;
+};
+
+
+/////////
+//is_map
+/////////
+
+template<class T>
+struct is_map
+{
+   static const bool value = false;
+};
+
+template<class Key, class T, class Compare, class Allocator>
+struct is_map< map<Key, T, Compare, Allocator> >
+{
+   static const bool value = true;
+};
+
+template<class Key, class T, class Compare, class Allocator>
+struct is_map< flat_map<Key, T, Compare, Allocator> >
+{
+   static const bool value = true;
+};
+
+template<class Key, class T, class Compare, class Allocator>
+struct is_map< multimap<Key, T, Compare, Allocator> >
+{
+   static const bool value = true;
+};
+
+template<class Key, class T, class Compare, class Allocator>
+struct is_map< flat_multimap<Key, T, Compare, Allocator> >
+{
+   static const bool value = true;
+};
+
+template<class T>
+struct is_set
+{
+   static const bool value = false;
+};
+
+template<class Key, class Compare, class Allocator>
+struct is_set< set<Key, Compare, Allocator> >
+{
+   static const bool value = true;
+};
+
+template<class Key, class Compare, class Allocator>
+struct is_set< flat_set<Key, Compare, Allocator> >
+{
+   static const bool value = true;
+};
+
+template<class Key, class Compare, class Allocator>
+struct is_set< multiset<Key, Compare, Allocator> >
+{
+   static const bool value = true;
+};
+
+template<class Key, class Compare, class Allocator>
+struct is_set< flat_multiset<Key, Compare, Allocator> >
+{
+   static const bool value = true;
+};
+
+/////////
+//container_wrapper
+/////////
+
+//Try to define-allocator_aware requirements
+template< class Container
+        , bool Assoc = is_set<Container>::value || is_map<Container>::value
+        , bool UniqueAssoc = is_unique_assoc<Container>::value
+        , bool Map  = is_map<Container>::value
+        >
+struct container_wrapper_inserter
+{
+   typedef typename Container::const_iterator   const_iterator;
+   typedef typename Container::iterator         iterator;
+
+   template<class Arg>
+   static iterator emplace(Container &c, const_iterator p, const Arg &arg)
+   {  return c.emplace(p, arg);   }
+};
+
+template<class Container>  //map
+struct container_wrapper_inserter<Container, true, true, true>
+{
+   typedef typename Container::const_iterator   const_iterator;
+   typedef typename Container::iterator         iterator;
+
+   template<class Arg>
+   static iterator emplace(Container &c, const_iterator, const Arg &arg)
+   {  return c.emplace(arg, arg).first;   }
+};
+
+template<class Container>  //set
+struct container_wrapper_inserter<Container, true, true, false>
+{
+   typedef typename Container::const_iterator   const_iterator;
+   typedef typename Container::iterator         iterator;
+
+   template<class Arg>
+   static iterator emplace(Container &c, const_iterator, const Arg &arg)
+   {  return c.emplace(arg).first;  }
+};
+
+template<class Container>  //multimap
+struct container_wrapper_inserter<Container, true, false, true>
+{
+   typedef typename Container::const_iterator   const_iterator;
+   typedef typename Container::iterator         iterator;
+
+   template<class Arg>
+   static iterator emplace(Container &c, const_iterator, const Arg &arg)
+   {  return c.emplace(arg, arg);   }
+};
+
+//multiset
+template<class Container>  //multimap
+struct container_wrapper_inserter<Container, true, false, false>
+{
+   typedef typename Container::const_iterator   const_iterator;
+   typedef typename Container::iterator         iterator;
+
+   template<class Arg>
+   static iterator emplace(Container &c, const_iterator, const Arg &arg)
+   {  return c.emplace(arg);  }
+};
+
+template< class Container>
+struct container_wrapper
+   : public Container
+{
+   private:
+   BOOST_COPYABLE_AND_MOVABLE(container_wrapper)
+
+   public:
+   typedef typename Container::allocator_type   allocator_type;
+   typedef typename Container::const_iterator   const_iterator;
+   typedef typename Container::iterator         iterator;
+
+   container_wrapper(const allocator_type &a)
+      : Container(a)
+   {}
+
+   container_wrapper(BOOST_RV_REF(container_wrapper) o, const allocator_type &a)
+      : Container(BOOST_MOVE_BASE(Container, o), a)
+   {}
+
+   container_wrapper(const container_wrapper &o, const allocator_type &a)
+      : Container(o, a)
+   {}
+
+   template<class Arg>
+   iterator emplace(const_iterator p, const Arg &arg)
+   {  return container_wrapper_inserter<Container>::emplace(*this, p, arg);  }
+};
+
+
+bool test_value_and_state_equals(const alloc_int &r, int value, int state)
+{  return r.get_value() == value && r.get_allocator_state() == state;  }
+
+template<class F, class S>
+bool test_value_and_state_equals(const dtl::pair<F, S> &p, int value, int state)
+{  return test_value_and_state_equals(p.first, value, state) && test_alloc_state_equals(p.second, value, state);  }
+
+template<class F, class S>
+bool test_value_and_state_equals(const std::pair<F, S> &p, int value, int state)
+{  return test_value_and_state_equals(p.first, value, state) && test_value_and_state_equals(p.second, value, state);  }
+
+template<class Container>
+bool one_level_allocator_propagation_test()
+{
+   typedef container_wrapper<Container> ContainerWrapper;
+   typedef typename ContainerWrapper::iterator iterator;
+   typedef typename ContainerWrapper::allocator_type allocator_type;
+   typedef typename ContainerWrapper::value_type value_type;
+   {
+      allocator_type al(SimpleAllocator<value_type>(5));
+      ContainerWrapper c(al);
+
+      c.clear();
+      iterator it = c.emplace(c.cbegin(), 42);
+
+      if(!test_value_and_state_equals(*it, 42, 5))
+         return false;
+   }
+   {
+      allocator_type al(SimpleAllocator<value_type>(4));
+      ContainerWrapper c2(al);
+      ContainerWrapper c(::boost::move(c2), allocator_type(SimpleAllocator<value_type>(5)));
+
+      c.clear();
+      iterator it = c.emplace(c.cbegin(), 42);
+
+      if(!test_value_and_state_equals(*it, 42, 5))
+         return false;
+   }/*
+   {
+      ContainerWrapper c2(allocator_type(SimpleAllocator<value_type>(3)));
+      ContainerWrapper c(c2, allocator_type(SimpleAllocator<value_type>(5)));
+
+      c.clear();
+      iterator it = c.emplace(c.cbegin(), 42);
+
+      if(!test_value_and_state_equals(*it, 42, 5))
+         return false;
+   }*/
+   return true;
+}
+
+int main()
+{
+   //unique assoc
+   if(!one_level_allocator_propagation_test<FlatMap>())
+      return 1;
+   if(!one_level_allocator_propagation_test<Map>())
+      return 1;
+   if(!one_level_allocator_propagation_test<FlatSet>())
+      return 1;
+   if(!one_level_allocator_propagation_test<Set>())
+      return 1;
+   //multi assoc
+   if(!one_level_allocator_propagation_test<FlatMultiMap>())
+      return 1;
+   if(!one_level_allocator_propagation_test<MultiMap>())
+      return 1;
+   if(!one_level_allocator_propagation_test<FlatMultiSet>())
+      return 1;
+   if(!one_level_allocator_propagation_test<MultiSet>())
+      return 1;
+   //sequence containers
+   if(!one_level_allocator_propagation_test<Vector>())
+      return 1;
+   if(!one_level_allocator_propagation_test<Deque>())
+      return 1;
+   if(!one_level_allocator_propagation_test<List>())
+      return 1;
+   if(!one_level_allocator_propagation_test<Slist>())
+      return 1;
+   if(!one_level_allocator_propagation_test<StableVector>())
+      return 1;
+   if(!one_level_allocator_propagation_test<SmallVector>())
+      return 1;
+   return 0;
+}
+
+#include <boost/container/detail/config_end.hpp>
diff --git a/src/boost/libs/container/test/set_test.cpp b/src/boost/libs/container/test/set_test.cpp
new file mode 100644
index 000000000..a7d0b4741
--- /dev/null
+++ b/src/boost/libs/container/test/set_test.cpp
@@ -0,0 +1,655 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2004-2013. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/container for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+#include <boost/container/detail/config_begin.hpp>
+#include <set>
+#include <boost/container/set.hpp>
+#include <boost/container/adaptive_pool.hpp>
+
+#include "print_container.hpp"
+#include "movable_int.hpp"
+#include "dummy_test_allocator.hpp"
+#include "set_test.hpp"
+#include "propagate_allocator_test.hpp"
+#include "emplace_test.hpp"
+#include "../../intrusive/test/iterator_test.hpp"
+
+using namespace boost::container;
+
+//Test recursive structures
+class recursive_set
+{
+public:
+   recursive_set & operator=(const recursive_set &x)
+   {  id_ = x.id_;  set_ = x.set_; return *this; }
+
+   int id_;
+   set<recursive_set> set_;
+   set<recursive_set>::iterator it_;
+   set<recursive_set>::const_iterator cit_;
+   set<recursive_set>::reverse_iterator rit_;
+   set<recursive_set>::const_reverse_iterator crit_;
+
+   friend bool operator< (const recursive_set &a, const recursive_set &b)
+   {  return a.id_ < b.id_;   }
+};
+
+//Test recursive structures
+class recursive_multiset
+{
+   public:
+   recursive_multiset & operator=(const recursive_multiset &x)
+   {  id_ = x.id_;  multiset_ = x.multiset_; return *this;  }
+
+   int id_;
+   multiset<recursive_multiset> multiset_;
+   multiset<recursive_multiset>::iterator it_;
+   multiset<recursive_multiset>::const_iterator cit_;
+   multiset<recursive_multiset>::reverse_iterator rit_;
+   multiset<recursive_multiset>::const_reverse_iterator crit_;
+
+   friend bool operator< (const recursive_multiset &a, const recursive_multiset &b)
+   {  return a.id_ < b.id_;   }
+};
+
+template<class C>
+void test_move()
+{
+   //Now test move semantics
+   C original;
+   original.emplace();
+   C move_ctor(boost::move(original));
+   C move_assign;
+   move_assign.emplace();
+   move_assign = boost::move(move_ctor);
+   move_assign.swap(original);
+}
+
+bool node_type_test()
+{
+   using namespace boost::container;
+   {
+      typedef set<test::movable_int> set_type;
+      set_type src;
+      {
+         test::movable_int mv_1(1), mv_2(2), mv_3(3);
+         src.emplace(boost::move(mv_1)); 
+         src.emplace(boost::move(mv_2)); 
+         src.emplace(boost::move(mv_3)); 
+      }
+      if(src.size() != 3)
+         return false;
+
+      set_type dst;
+      {
+         test::movable_int mv_3(3);
+         dst.emplace(boost::move(mv_3)); 
+      }
+
+      if(dst.size() != 1)
+         return false;
+
+      const test::movable_int mv_1(1);
+      const test::movable_int mv_2(2);
+      const test::movable_int mv_3(3);
+      const test::movable_int mv_33(33);
+      set_type::insert_return_type r;
+
+      r = dst.insert(src.extract(mv_33)); // Key version, try to insert empty node
+      if(! (r.position == dst.end() && r.inserted == false && r.node.empty()) )
+         return false;
+      r = dst.insert(src.extract(src.find(mv_1))); // Iterator version, successful
+      if(! (r.position == dst.find(mv_1) && r.inserted == true && r.node.empty()) )
+         return false;
+      r = dst.insert(dst.begin(), src.extract(mv_2)); // Key type version, successful
+      if(! (r.position == dst.find(mv_2) && r.inserted == true && r.node.empty()) )
+         return false;
+      r = dst.insert(src.extract(mv_3)); // Key type version, unsuccessful
+
+      if(!src.empty())
+         return false;
+      if(dst.size() != 3)
+         return false;
+      if(! (r.position == dst.find(mv_3) && r.inserted == false && r.node.value() == mv_3) )
+         return false;
+   }
+
+   {
+      typedef multiset<test::movable_int> multiset_type;
+      multiset_type src;
+      {
+         test::movable_int mv_1(1), mv_2(2), mv_3(3), mv_3bis(3);
+         src.emplace(boost::move(mv_1));
+         src.emplace(boost::move(mv_2));
+         src.emplace(boost::move(mv_3));
+         src.emplace_hint(src.begin(), boost::move(mv_3bis));
+      }
+      if(src.size() != 4)
+         return false;
+
+      multiset_type dst;
+      {
+         test::movable_int mv_3(3);
+         dst.emplace(boost::move(mv_3)); 
+      }
+
+      if(dst.size() != 1)
+         return false;
+
+      const test::movable_int mv_1(1);
+      const test::movable_int mv_2(2);
+      const test::movable_int mv_3(3);
+      const test::movable_int mv_4(4);
+      multiset_type::iterator r;
+
+      multiset_type::node_type nt(src.extract(mv_3));
+      r = dst.insert(dst.begin(), boost::move(nt));
+      if(! (*r == mv_3 && dst.find(mv_3) == r && nt.empty()) )
+         return false;
+
+      nt = src.extract(src.find(mv_1));
+      r = dst.insert(boost::move(nt)); // Iterator version, successful
+      if(! (*r == mv_1 && nt.empty()) )
+         return false;
+
+      nt = src.extract(mv_2);
+      r = dst.insert(boost::move(nt)); // Key type version, successful
+      if(! (*r == mv_2 && nt.empty()) )
+         return false;
+
+      r = dst.insert(src.extract(mv_3)); // Key type version, successful
+      if(! (*r == mv_3 && r == --multiset_type::iterator(dst.upper_bound(mv_3)) && nt.empty()) )
+         return false;
+
+      r = dst.insert(src.extract(mv_4)); // Key type version, unsuccessful
+      if(! (r == dst.end()) )
+         return false;
+
+      if(!src.empty())
+         return false;
+      if(dst.size() != 5)
+         return false;
+   }
+   return true;
+}
+
+struct boost_container_set;
+struct boost_container_multiset;
+
+namespace boost {
+namespace container {
+namespace test {
+
+template<>
+struct alloc_propagate_base<boost_container_set>
+{
+   template <class T, class Allocator>
+   struct apply
+   {
+      typedef boost::container::set<T, std::less<T>, Allocator> type;
+   };
+};
+
+template<>
+struct alloc_propagate_base<boost_container_multiset>
+{
+   template <class T, class Allocator>
+   struct apply
+   {
+      typedef boost::container::multiset<T, std::less<T>, Allocator> type;
+   };
+};
+
+bool constructor_template_auto_deduction_test()
+{
+#ifndef BOOST_CONTAINER_NO_CXX17_CTAD
+   using namespace boost::container;
+   const std::size_t NumElements = 100;
+   {
+      std::set<int> int_set;
+      for (std::size_t i = 0; i != NumElements; ++i) {
+         int_set.insert(static_cast<int>(i));
+      }
+      std::multiset<int> int_mset;
+      for (std::size_t i = 0; i != NumElements; ++i) {
+         int_mset.insert(static_cast<int>(i));
+      }
+
+      typedef std::less<int> comp_int_t;
+      typedef std::allocator<int> alloc_int_t;
+
+      //range
+      {
+         auto fset = set(int_set.begin(), int_set.end());
+         if (!CheckEqualContainers(int_set, fset))
+            return false;
+         auto fmset = multiset(int_mset.begin(), int_mset.end());
+         if (!CheckEqualContainers(int_mset, fmset))
+            return false;
+      }
+      //range+comp
+      {
+         auto fset = set(int_set.begin(), int_set.end(), comp_int_t());
+         if (!CheckEqualContainers(int_set, fset))
+            return false;
+         auto fmset = multiset(int_mset.begin(), int_mset.end(), comp_int_t());
+         if (!CheckEqualContainers(int_mset, fmset))
+            return false;
+      }
+      //range+comp+alloc
+      {
+         auto fset = set(int_set.begin(), int_set.end(), comp_int_t(), alloc_int_t());
+         if (!CheckEqualContainers(int_set, fset))
+            return false;
+         auto fmset = multiset(int_mset.begin(), int_mset.end(), comp_int_t(), alloc_int_t());
+         if (!CheckEqualContainers(int_mset, fmset))
+            return false;
+      }
+      //range+alloc
+      {
+         auto fset = set(int_set.begin(), int_set.end(), alloc_int_t());
+         if (!CheckEqualContainers(int_set, fset))
+            return false;
+         auto fmset = multiset(int_mset.begin(), int_mset.end(), alloc_int_t());
+         if (!CheckEqualContainers(int_mset, fmset))
+            return false;
+      }
+
+      //ordered_unique_range / ordered_range
+
+      //range
+      {
+         auto fset = set(ordered_unique_range, int_set.begin(), int_set.end());
+         if (!CheckEqualContainers(int_set, fset))
+            return false;
+         auto fmset = multiset(ordered_range, int_mset.begin(), int_mset.end());
+         if (!CheckEqualContainers(int_mset, fmset))
+            return false;
+      }
+      //range+comp
+      {
+         auto fset = set(ordered_unique_range, int_set.begin(), int_set.end(), comp_int_t());
+         if (!CheckEqualContainers(int_set, fset))
+            return false;
+         auto fmset = multiset(ordered_range, int_mset.begin(), int_mset.end(), comp_int_t());
+         if (!CheckEqualContainers(int_mset, fmset))
+            return false;
+      }
+      //range+comp+alloc
+      {
+         auto fset = set(ordered_unique_range, int_set.begin(), int_set.end(), comp_int_t(), alloc_int_t());
+         if (!CheckEqualContainers(int_set, fset))
+            return false;
+         auto fmset = multiset(ordered_range, int_mset.begin(), int_mset.end(), comp_int_t(), alloc_int_t());
+         if (!CheckEqualContainers(int_mset, fmset))
+            return false;
+      }
+      //range+alloc
+      {
+         auto fset = set(ordered_unique_range, int_set.begin(), int_set.end(), alloc_int_t());
+         if (!CheckEqualContainers(int_set, fset))
+            return false;
+         auto fmset = multiset(ordered_range, int_mset.begin(), int_mset.end(), alloc_int_t());
+         if (!CheckEqualContainers(int_mset, fmset))
+            return false;
+      }
+   }
+#endif
+   return true;
+}
+
+}}}   //boost::container::test
+
+template<class VoidAllocator, boost::container::tree_type_enum tree_type_value>
+struct GetAllocatorSet
+{
+   template<class ValueType>
+   struct apply
+   {
+      typedef set < ValueType
+                  , std::less<ValueType>
+                  , typename allocator_traits<VoidAllocator>
+                     ::template portable_rebind_alloc<ValueType>::type
+                  , typename boost::container::tree_assoc_options
+                        < boost::container::tree_type<tree_type_value>
+                        >::type
+                  > set_type;
+
+      typedef multiset < ValueType
+                  , std::less<ValueType>
+                  , typename allocator_traits<VoidAllocator>
+                     ::template portable_rebind_alloc<ValueType>::type
+                  , typename boost::container::tree_assoc_options
+                        < boost::container::tree_type<tree_type_value>
+                        >::type
+                  > multiset_type;
+   };
+};
+
+void test_merge_from_different_comparison()
+{
+   set<int> set1;
+   set<int, std::greater<int> > set2;
+   set1.merge(set2);
+}
+
+bool test_heterogeneous_lookups()
+{
+   typedef set<int, test::less_transparent> set_t;
+   typedef multiset<int, test::less_transparent> mset_t;
+
+   set_t set1;
+   mset_t mset1;
+
+   const set_t &cset1 = set1;
+   const mset_t &cmset1 = mset1;
+
+   set1.insert(1);
+   set1.insert(1);
+   set1.insert(2);
+   set1.insert(2);
+   set1.insert(3);
+
+   mset1.insert(1);
+   mset1.insert(1);
+   mset1.insert(2);
+   mset1.insert(2);
+   mset1.insert(3);
+
+   const test::non_copymovable_int find_me(2);
+
+   //find
+   if(*set1.find(find_me) != 2)
+      return false;
+   if(*cset1.find(find_me) != 2)
+      return false;
+   if(*mset1.find(find_me) != 2)
+      return false;
+   if(*cmset1.find(find_me) != 2)
+      return false;
+
+   //count
+   if(set1.count(find_me) != 1)
+      return false;
+   if(cset1.count(find_me) != 1)
+      return false;
+   if(mset1.count(find_me) != 2)
+      return false;
+   if(cmset1.count(find_me) != 2)
+      return false;
+
+   //contains
+   if(!set1.contains(find_me))
+      return false;
+   if(!cset1.contains(find_me))
+      return false;
+   if(!mset1.contains(find_me))
+      return false;
+   if(!cmset1.contains(find_me))
+      return false;
+
+   //lower_bound
+   if(*set1.lower_bound(find_me) != 2)
+      return false;
+   if(*cset1.lower_bound(find_me) != 2)
+      return false;
+   if(*mset1.lower_bound(find_me) != 2)
+      return false;
+   if(*cmset1.lower_bound(find_me) != 2)
+      return false;
+
+   //upper_bound
+   if(*set1.upper_bound(find_me) != 3)
+      return false;
+   if(*cset1.upper_bound(find_me) != 3)
+      return false;
+   if(*mset1.upper_bound(find_me) != 3)
+      return false;
+   if(*cmset1.upper_bound(find_me) != 3)
+      return false;
+
+   //equal_range
+   if(*set1.equal_range(find_me).first != 2)
+      return false;
+   if(*cset1.equal_range(find_me).second != 3)
+      return false;
+   if(*mset1.equal_range(find_me).first != 2)
+      return false;
+   if(*cmset1.equal_range(find_me).second != 3)
+      return false;
+
+   return true;
+}
+
+int main ()
+{
+   //Recursive container instantiation
+   {
+      set<recursive_set> set_;
+      multiset<recursive_multiset> multiset_;
+   }
+   //Allocator argument container
+   {
+      set<int> set_((set<int>::allocator_type()));
+      multiset<int> multiset_((multiset<int>::allocator_type()));
+   }
+   //Now test move semantics
+   {
+      test_move<set<recursive_set> >();
+      test_move<multiset<recursive_multiset> >();
+   }
+   //Test std::pair value type as tree has workarounds to make old std::pair
+   //implementations movable that can break things
+   {
+      boost::container::set<std::pair<int,int> > s;
+      std::pair<int,int> p(0, 0);
+      s.insert(p);
+      s.emplace(p);
+   }
+
+   if (!boost::container::test::instantiate_constructors<set<int>, multiset<int> >())
+      return 1;
+
+   test_merge_from_different_comparison();
+
+   ////////////////////////////////////
+   //    Constructor Template Auto Deduction test
+   ////////////////////////////////////
+   if (!test::constructor_template_auto_deduction_test()) {
+      return 1;
+   }
+
+   if(!test_heterogeneous_lookups())
+      return 1;
+
+   ////////////////////////////////////
+   //    Testing allocator implementations
+   ////////////////////////////////////
+   {
+      typedef std::set<int>                                          MyStdSet;
+      typedef std::multiset<int>                                     MyStdMultiSet;
+
+      if (0 != test::set_test
+         < GetAllocatorSet<std::allocator<void>, red_black_tree>::apply<int>::set_type
+         , MyStdSet
+         , GetAllocatorSet<std::allocator<void>, red_black_tree>::apply<int>::multiset_type
+         , MyStdMultiSet>()) {
+         std::cout << "Error in set_test<std::allocator<void>, red_black_tree>" << std::endl;
+         return 1;
+      }
+
+      if (0 != test::set_test
+         < GetAllocatorSet<new_allocator<void>, avl_tree>::apply<int>::set_type
+         , MyStdSet
+         , GetAllocatorSet<new_allocator<void>, avl_tree>::apply<int>::multiset_type
+         , MyStdMultiSet>()) {
+         std::cout << "Error in set_test<new_allocator<void>, avl_tree>" << std::endl;
+         return 1;
+      }
+
+      if (0 != test::set_test
+         < GetAllocatorSet<adaptive_pool<void>, scapegoat_tree>::apply<int>::set_type
+         , MyStdSet
+         , GetAllocatorSet<adaptive_pool<void>, scapegoat_tree>::apply<int>::multiset_type
+         , MyStdMultiSet>()) {
+         std::cout << "Error in set_test<adaptive_pool<void>, scapegoat_tree>" << std::endl;
+         return 1;
+      }
+
+      ///////////
+
+     if (0 != test::set_test
+         < GetAllocatorSet<new_allocator<void>, splay_tree>::apply<test::movable_int>::set_type
+         , MyStdSet
+         , GetAllocatorSet<new_allocator<void>, splay_tree>::apply<test::movable_int>::multiset_type
+         , MyStdMultiSet>()) {
+         std::cout << "Error in set_test<new_allocator<void>, splay_tree>" << std::endl;
+         return 1;
+      }
+
+      if (0 != test::set_test
+         < GetAllocatorSet<new_allocator<void>, red_black_tree>::apply<test::copyable_int>::set_type
+         , MyStdSet
+         , GetAllocatorSet<new_allocator<void>, red_black_tree>::apply<test::copyable_int>::multiset_type
+         , MyStdMultiSet>()) {
+         std::cout << "Error in set_test<new_allocator<void>, red_black_tree>" << std::endl;
+         return 1;
+      }
+
+      if (0 != test::set_test
+         < GetAllocatorSet<new_allocator<void>, red_black_tree>::apply<test::movable_and_copyable_int>::set_type
+         , MyStdSet
+         , GetAllocatorSet<new_allocator<void>, red_black_tree>::apply<test::movable_and_copyable_int>::multiset_type
+         , MyStdMultiSet>()) {
+         std::cout << "Error in set_test<new_allocator<void>, red_black_tree>" << std::endl;
+         return 1;
+      }
+   }
+
+   ////////////////////////////////////
+   //    Emplace testing
+   ////////////////////////////////////
+   const test::EmplaceOptions SetOptions = (test::EmplaceOptions)(test::EMPLACE_HINT | test::EMPLACE_ASSOC);
+   if(!boost::container::test::test_emplace<set<test::EmplaceInt>, SetOptions>())
+      return 1;
+   if(!boost::container::test::test_emplace<multiset<test::EmplaceInt>, SetOptions>())
+      return 1;
+
+   ////////////////////////////////////
+   //    Allocator propagation testing
+   ////////////////////////////////////
+   if(!boost::container::test::test_propagate_allocator<boost_container_set>())
+      return 1;
+
+   if(!boost::container::test::test_propagate_allocator<boost_container_multiset>())
+      return 1;
+
+   if (!boost::container::test::test_set_methods_with_initializer_list_as_argument_for<set<int> >())
+      return 1;
+
+   if (!boost::container::test::test_set_methods_with_initializer_list_as_argument_for<multiset<int> >())
+      return 1;
+
+   ////////////////////////////////////
+   //    Test optimize_size option
+   ////////////////////////////////////
+   //
+   // set
+   //
+   typedef set< int*, std::less<int*>, std::allocator<int*>
+              , tree_assoc_options< optimize_size<false>, tree_type<red_black_tree> >::type > rbset_size_optimized_no;
+
+   typedef set< int*, std::less<int*>, std::allocator<int*>
+              , tree_assoc_options< optimize_size<true>, tree_type<avl_tree>  >::type > avlset_size_optimized_yes;
+   //
+   // multiset
+   //
+   typedef multiset< int*, std::less<int*>, std::allocator<int*>
+                   , tree_assoc_options< optimize_size<true>, tree_type<red_black_tree>  >::type > rbmset_size_optimized_yes;
+
+   typedef multiset< int*, std::less<int*>, std::allocator<int*>
+                   , tree_assoc_options< optimize_size<false>, tree_type<avl_tree> >::type > avlmset_size_optimized_no;
+
+   BOOST_STATIC_ASSERT(sizeof(rbmset_size_optimized_yes) < sizeof(rbset_size_optimized_no));
+   BOOST_STATIC_ASSERT(sizeof(avlset_size_optimized_yes) < sizeof(avlmset_size_optimized_no));
+
+   ////////////////////////////////////
+   //    Iterator testing
+   ////////////////////////////////////
+   {
+      typedef boost::container::set<int> cont_int;
+      cont_int a; a.insert(0); a.insert(1); a.insert(2);
+      boost::intrusive::test::test_iterator_bidirectional< cont_int >(a);
+      if(boost::report_errors() != 0) {
+         return 1;
+      }
+   }
+   {
+      typedef boost::container::multiset<int> cont_int;
+      cont_int a; a.insert(0); a.insert(1); a.insert(2);
+      boost::intrusive::test::test_iterator_bidirectional< cont_int >(a);
+      if(boost::report_errors() != 0) {
+         return 1;
+      }
+   }
+
+   ////////////////////////////////////
+   //    Node extraction/insertion testing functions
+   ////////////////////////////////////
+   if(!node_type_test())
+      return 1;
+
+   ////////////////////////////////////
+   //    has_trivial_destructor_after_move testing
+   ////////////////////////////////////
+   // set, default allocator
+   {
+      typedef boost::container::set<int> cont;
+      typedef boost::container::dtl::tree<int, void, std::less<int>, void, void> tree;
+      if (boost::has_trivial_destructor_after_move<cont>::value !=
+          boost::has_trivial_destructor_after_move<tree>::value) {
+         std::cerr << "has_trivial_destructor_after_move(set, default allocator) test failed" << std::endl;
+         return 1;
+      }
+   }
+   // set, std::allocator
+   {
+      typedef boost::container::set<int, std::less<int>, std::allocator<int> > cont;
+      typedef boost::container::dtl::tree<int, void, std::less<int>, std::allocator<int>, void> tree;
+      if (boost::has_trivial_destructor_after_move<cont>::value !=
+          boost::has_trivial_destructor_after_move<tree>::value) {
+         std::cerr << "has_trivial_destructor_after_move(set, std::allocator) test failed" << std::endl;
+         return 1;
+      }
+   }
+   // multiset, default allocator
+   {
+      typedef boost::container::multiset<int> cont;
+      typedef boost::container::dtl::tree<int, void, std::less<int>, void, void> tree;
+      if (boost::has_trivial_destructor_after_move<cont>::value !=
+          boost::has_trivial_destructor_after_move<tree>::value) {
+         std::cerr << "has_trivial_destructor_after_move(multiset, default allocator) test failed" << std::endl;
+         return 1;
+      }
+   }
+   // multiset, std::allocator
+   {
+      typedef boost::container::multiset<int, std::less<int>, std::allocator<int> > cont;
+      typedef boost::container::dtl::tree<int, void, std::less<int>, std::allocator<int>, void> tree;
+      if (boost::has_trivial_destructor_after_move<cont>::value !=
+          boost::has_trivial_destructor_after_move<tree>::value) {
+         std::cerr << "has_trivial_destructor_after_move(multiset, std::allocator) test failed" << std::endl;
+         return 1;
+      }
+   }
+
+   return 0;
+}
+
+#include <boost/container/detail/config_end.hpp>
diff --git a/src/boost/libs/container/test/set_test.hpp b/src/boost/libs/container/test/set_test.hpp
new file mode 100644
index 000000000..7bc3a0933
--- /dev/null
+++ b/src/boost/libs/container/test/set_test.hpp
@@ -0,0 +1,942 @@
+////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2004-2013. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/container for documentation.
+//
+////////////////////////////////////////
+
+#ifndef BOOST_CONTAINER_TEST_SET_TEST_HEADER
+#define BOOST_CONTAINER_TEST_SET_TEST_HEADER
+
+#include <boost/container/detail/config_begin.hpp>
+#include "check_equal_containers.hpp"
+#include "print_container.hpp"
+#include "movable_int.hpp"
+#include <boost/move/utility_core.hpp>
+#include <boost/move/iterator.hpp>
+#include <boost/move/make_unique.hpp>
+
+#define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME rebalance
+#define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_NS_BEG namespace boost { namespace container { namespace test {
+#define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_NS_END   }}}
+#define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_MIN 0
+#define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_MAX 0
+#include <boost/intrusive/detail/has_member_function_callable_with.hpp>
+
+namespace boost{
+namespace container {
+namespace test{
+
+template<class C>
+void set_test_rebalanceable(C &, boost::container::dtl::false_type)
+{}
+
+template<class C>
+void set_test_rebalanceable(C &c, boost::container::dtl::true_type)
+{
+   c.rebalance();
+}
+
+template<class MyBoostSet
+        ,class MyStdSet
+        ,class MyBoostMultiSet
+        ,class MyStdMultiSet>
+int set_test_copyable(boost::container::dtl::false_type)
+{  return 0; }
+
+const int MaxElem = 50;
+
+template<class MyBoostSet
+        ,class MyStdSet
+        ,class MyBoostMultiSet
+        ,class MyStdMultiSet>
+int set_test_copyable(boost::container::dtl::true_type)
+{
+   typedef typename MyBoostSet::value_type IntType;
+
+   ::boost::movelib::unique_ptr<MyBoostSet> const pboostset = ::boost::movelib::make_unique<MyBoostSet>();
+   ::boost::movelib::unique_ptr<MyStdSet>   const pstdset = ::boost::movelib::make_unique<MyStdSet>();
+   ::boost::movelib::unique_ptr<MyBoostMultiSet> const pboostmultiset = ::boost::movelib::make_unique<MyBoostMultiSet>();
+   ::boost::movelib::unique_ptr<MyStdMultiSet>   const pstdmultiset   = ::boost::movelib::make_unique<MyStdMultiSet>();
+
+   MyBoostSet &boostset = *pboostset;
+   MyStdSet   &stdset   = *pstdset;
+   MyBoostMultiSet &boostmultiset = *pboostmultiset;
+   MyStdMultiSet   &stdmultiset   = *pstdmultiset;
+
+   //Just to test move aware catch conversions
+   boostset.insert(boostset.cbegin(), boostset.cend());
+   boostmultiset.insert(boostmultiset.cbegin(), boostmultiset.cend());
+   boostset.insert(boostset.begin(), boostset.end());
+   boostmultiset.insert(boostmultiset.begin(), boostmultiset.end());
+
+   for(int i = 0; i < MaxElem; ++i){
+      IntType move_me(i);
+      boostset.insert(boost::move(move_me));
+      stdset.insert(i);
+      IntType move_me2(i);
+      boostmultiset.insert(boost::move(move_me2));
+      stdmultiset.insert(i);
+   }
+   if(!CheckEqualContainers(boostset, stdset)) return 1;
+   if(!CheckEqualContainers(boostmultiset, stdmultiset)) return 1;
+
+   {
+      //Now, test copy constructor
+      MyBoostSet boostsetcopy(boostset);
+      MyStdSet stdsetcopy(stdset);
+
+      if(!CheckEqualContainers(boostsetcopy, stdsetcopy))
+         return 1;
+
+      MyBoostMultiSet boostmsetcopy(boostmultiset);
+      MyStdMultiSet stdmsetcopy(stdmultiset);
+
+      if(!CheckEqualContainers(boostmsetcopy, stdmsetcopy))
+         return 1;
+
+      //And now assignment
+      boostsetcopy  =boostset;
+      stdsetcopy  = stdset;
+
+      if(!CheckEqualContainers(boostsetcopy, stdsetcopy))
+         return 1;
+
+      boostmsetcopy = boostmultiset;
+      stdmsetcopy = stdmultiset;
+
+      if(!CheckEqualContainers(boostmsetcopy, stdmsetcopy))
+         return 1;
+   }
+   {
+      //Now, test copy constructor
+      MyBoostSet boostsetcopy(boostset, typename MyBoostSet::allocator_type());
+      MyStdSet stdsetcopy(stdset);
+
+      if(!CheckEqualContainers(boostsetcopy, stdsetcopy))
+         return 1;
+
+      MyBoostMultiSet boostmsetcopy(boostmultiset, typename MyBoostSet::allocator_type());
+      MyStdMultiSet stdmsetcopy(stdmultiset);
+
+      if(!CheckEqualContainers(boostmsetcopy, stdmsetcopy))
+         return 1;
+   }
+   return 0;
+}
+
+
+template<class MyBoostSet
+        ,class MyStdSet
+        ,class MyBoostMultiSet
+        ,class MyStdMultiSet>
+int set_test ()
+{
+   typedef typename MyBoostSet::value_type IntType;
+
+   ::boost::movelib::unique_ptr<MyBoostSet> const pboostset = ::boost::movelib::make_unique<MyBoostSet>();
+   ::boost::movelib::unique_ptr<MyStdSet>   const pstdset = ::boost::movelib::make_unique<MyStdSet>();
+   ::boost::movelib::unique_ptr<MyBoostMultiSet> const pboostmultiset = ::boost::movelib::make_unique<MyBoostMultiSet>();
+   ::boost::movelib::unique_ptr<MyStdMultiSet>   const pstdmultiset   = ::boost::movelib::make_unique<MyStdMultiSet>();
+
+   MyBoostSet &boostset = *pboostset;
+   MyStdSet   &stdset   = *pstdset;
+   MyBoostMultiSet &boostmultiset = *pboostmultiset;
+   MyStdMultiSet   &stdmultiset   = *pstdmultiset;
+
+   //Test construction from a range
+   {  //Set(beg, end, compare)
+      IntType aux_vect[50];
+      for(int i = 0; i < 50; ++i){
+         IntType move_me(i/2);
+         aux_vect[i] = boost::move(move_me);
+      }
+      int aux_vect2[50];
+      for(int i = 0; i < 50; ++i){
+         aux_vect2[i] = i/2;
+      }
+      IntType aux_vect3[50];
+      for(int i = 0; i < 50; ++i){
+         IntType move_me(i/2);
+         aux_vect3[i] = boost::move(move_me);
+      }
+      ::boost::movelib::unique_ptr<MyBoostSet> const pboostset2 = ::boost::movelib::make_unique<MyBoostSet>
+         (boost::make_move_iterator(&aux_vect[0]), boost::make_move_iterator(&aux_vect[0]+50), typename MyBoostSet::key_compare());
+      ::boost::movelib::unique_ptr<MyStdSet> const pstdset2 = ::boost::movelib::make_unique<MyStdSet>(&aux_vect2[0], &aux_vect2[0]+50);
+      if(!test::CheckEqualContainers(*pboostset2, *pstdset2)) return 1;
+      ::boost::movelib::unique_ptr<MyBoostMultiSet> const pboostmultiset2 = ::boost::movelib::make_unique<MyBoostMultiSet>
+         (boost::make_move_iterator(&aux_vect3[0]), boost::make_move_iterator(&aux_vect3[0]+50), typename MyBoostMultiSet::key_compare());
+      ::boost::movelib::unique_ptr<MyStdMultiSet> const pstdmultiset2 = ::boost::movelib::make_unique<MyStdMultiSet>(&aux_vect2[0], &aux_vect2[0]+50);
+      if(!test::CheckEqualContainers(*pboostmultiset2, *pstdmultiset2)) return 1;
+   }
+   {  //Set(beg, end, alloc)
+      IntType aux_vect[50];
+      for(int i = 0; i < 50; ++i){
+         IntType move_me(i/2);
+         aux_vect[i] = boost::move(move_me);
+      }
+      int aux_vect2[50];
+      for(int i = 0; i < 50; ++i){
+         aux_vect2[i] = i/2;
+      }
+      IntType aux_vect3[50];
+      for(int i = 0; i < 50; ++i){
+         IntType move_me(i/2);
+         aux_vect3[i] = boost::move(move_me);
+      }
+      ::boost::movelib::unique_ptr<MyBoostSet> const pboostset2 = ::boost::movelib::make_unique<MyBoostSet>
+         (boost::make_move_iterator(&aux_vect[0]), boost::make_move_iterator(&aux_vect[0]+50), typename MyBoostSet::allocator_type());
+      ::boost::movelib::unique_ptr<MyStdSet> const pstdset2 = ::boost::movelib::make_unique<MyStdSet>(&aux_vect2[0], &aux_vect2[0]+50);
+      if(!test::CheckEqualContainers(*pboostset2, *pstdset2)) return 1;
+      ::boost::movelib::unique_ptr<MyBoostMultiSet> const pboostmultiset2 = ::boost::movelib::make_unique<MyBoostMultiSet>
+         (boost::make_move_iterator(&aux_vect3[0]), boost::make_move_iterator(&aux_vect3[0]+50), typename MyBoostMultiSet::allocator_type());
+      ::boost::movelib::unique_ptr<MyStdMultiSet> const pstdmultiset2 = ::boost::movelib::make_unique<MyStdMultiSet>(&aux_vect2[0], &aux_vect2[0]+50);
+      if(!test::CheckEqualContainers(*pboostmultiset2, *pstdmultiset2)) return 1;
+   }
+   {
+      IntType aux_vect[50];
+      for(int i = 0; i < 50; ++i){
+         IntType move_me(i/2);
+         aux_vect[i] = boost::move(move_me);
+      }
+      int aux_vect2[50];
+      for(int i = 0; i < 50; ++i){
+         aux_vect2[i] = i/2;
+      }
+      IntType aux_vect3[50];
+      for(int i = 0; i < 50; ++i){
+         IntType move_me(i/2);
+         aux_vect3[i] = boost::move(move_me);
+      }
+
+      ::boost::movelib::unique_ptr<MyBoostSet> const pboostset2 = ::boost::movelib::make_unique<MyBoostSet>
+            ( boost::make_move_iterator(&aux_vect[0])
+            , boost::make_move_iterator(aux_vect + 50));
+      ::boost::movelib::unique_ptr<MyStdSet>  const pstdset2 = ::boost::movelib::make_unique<MyStdSet>
+            (&aux_vect2[0], &aux_vect2[0] + 50);
+      ::boost::movelib::unique_ptr<MyBoostMultiSet> const pboostmultiset2 = ::boost::movelib::make_unique<MyBoostMultiSet>
+            ( boost::make_move_iterator(&aux_vect3[0])
+            , boost::make_move_iterator(aux_vect3 + 50));
+      ::boost::movelib::unique_ptr<MyStdMultiSet>   const pstdmultiset2   = ::boost::movelib::make_unique<MyStdMultiSet>
+            (&aux_vect2[0], &aux_vect2[0] + 50);
+
+      MyBoostSet &boostset2 = *pboostset2;
+      MyStdSet   &stdset2   = *pstdset2;
+      MyBoostMultiSet &boostmultiset2 = *pboostmultiset2;
+      MyStdMultiSet   &stdmultiset2   = *pstdmultiset2;
+
+      if(!CheckEqualContainers(boostset2, stdset2)){
+         std::cout << "Error in construct<MyBoostSet>(MyBoostSet2)" << std::endl;
+         return 1;
+      }
+      if(!CheckEqualContainers(boostmultiset2, stdmultiset2)){
+         std::cout << "Error in construct<MyBoostMultiSet>(MyBoostMultiSet2)" << std::endl;
+         return 1;
+      }
+
+      //ordered range insertion
+      for(int i = 0; i < 50; ++i){
+         IntType move_me(i);
+         aux_vect[i] = boost::move(move_me);
+      }
+
+      for(int i = 0; i < 50; ++i){
+         aux_vect2[i] = i;
+      }
+
+      for(int i = 0; i < 50; ++i){
+         IntType move_me(i);
+         aux_vect3[i] = boost::move(move_me);
+      }
+
+      //some comparison operators
+      if(!(boostset2 == boostset2))
+         return 1;
+      if(boostset2 != boostset2)
+         return 1;
+      if(boostset2 < boostset2)
+         return 1;
+      if(boostset2 > boostset2)
+         return 1;
+      if(!(boostset2 <= boostset2))
+         return 1;
+      if(!(boostset2 >= boostset2))
+         return 1;
+
+      ::boost::movelib::unique_ptr<MyBoostSet> const pboostset3 = ::boost::movelib::make_unique<MyBoostSet>
+            ( ordered_unique_range
+            , boost::make_move_iterator(&aux_vect[0])
+            , boost::make_move_iterator(&aux_vect[0] + 50));
+      ::boost::movelib::unique_ptr<MyStdSet>   const pstdset3 = ::boost::movelib::make_unique<MyStdSet>
+            (&aux_vect2[0], &aux_vect2[0] + 50);
+      ::boost::movelib::unique_ptr<MyBoostMultiSet> const pboostmultiset3 = ::boost::movelib::make_unique<MyBoostMultiSet>
+            ( ordered_range
+            , boost::make_move_iterator(&aux_vect3[0])
+            , boost::make_move_iterator(aux_vect3 + 50));
+      ::boost::movelib::unique_ptr<MyStdMultiSet>   const pstdmultiset3   = ::boost::movelib::make_unique<MyStdMultiSet>
+            (&aux_vect2[0], &aux_vect2[0] + 50);
+
+      MyBoostSet &boostset3 = *pboostset3;
+      MyStdSet   &stdset3   = *pstdset3;
+      MyBoostMultiSet &boostmultiset3 = *pboostmultiset3;
+      MyStdMultiSet   &stdmultiset3   = *pstdmultiset3;
+
+      if(!CheckEqualContainers(boostset3, stdset3)){
+         std::cout << "Error in construct<MyBoostSet>(MyBoostSet3)" << std::endl;
+         return 1;
+      }
+      if(!CheckEqualContainers(boostmultiset3, stdmultiset3)){
+         std::cout << "Error in construct<MyBoostMultiSet>(MyBoostMultiSet3)" << std::endl;
+         return 1;
+      }
+   }
+
+   for(int i = 0; i < MaxElem; ++i){
+      IntType move_me(i);
+      boostset.insert(boost::move(move_me));
+      stdset.insert(i);
+      boostset.insert(IntType(i));
+      stdset.insert(i);
+      IntType move_me2(i);
+      boostmultiset.insert(boost::move(move_me2));
+      stdmultiset.insert(i);
+      boostmultiset.insert(IntType(i));
+      stdmultiset.insert(i);
+   }
+
+   if(!CheckEqualContainers(boostset, stdset)){
+      std::cout << "Error in boostset.insert(boost::move(move_me)" << std::endl;
+      return 1;
+   }
+
+   if(!CheckEqualContainers(boostmultiset, stdmultiset)){
+      std::cout << "Error in boostmultiset.insert(boost::move(move_me)" << std::endl;
+      return 1;
+   }
+
+   typename MyBoostSet::iterator it = boostset.begin();
+   typename MyBoostSet::const_iterator cit = it;
+   (void)cit;
+
+   boostset.erase(boostset.begin());
+   stdset.erase(stdset.begin());
+   boostmultiset.erase(boostmultiset.begin());
+   stdmultiset.erase(stdmultiset.begin());
+   if(!CheckEqualContainers(boostset, stdset)){
+      std::cout << "Error in boostset.erase(boostset.begin())" << std::endl;
+      return 1;
+   }
+   if(!CheckEqualContainers(boostmultiset, stdmultiset)){
+      std::cout << "Error in boostmultiset.erase(boostmultiset.begin())" << std::endl;
+      return 1;
+   }
+
+   boostset.erase(boostset.begin());
+   stdset.erase(stdset.begin());
+   boostmultiset.erase(boostmultiset.begin());
+   stdmultiset.erase(stdmultiset.begin());
+   if(!CheckEqualContainers(boostset, stdset)){
+      std::cout << "Error in boostset.erase(boostset.begin())" << std::endl;
+      return 1;
+   }
+   if(!CheckEqualContainers(boostmultiset, stdmultiset)){
+      std::cout << "Error in boostmultiset.erase(boostmultiset.begin())" << std::endl;
+      return 1;
+   }
+
+   //Swapping test
+   MyBoostSet tmpboosteset2;
+   MyStdSet tmpstdset2;
+   MyBoostMultiSet tmpboostemultiset2;
+   MyStdMultiSet tmpstdmultiset2;
+   boostset.swap(tmpboosteset2);
+   stdset.swap(tmpstdset2);
+   boostmultiset.swap(tmpboostemultiset2);
+   stdmultiset.swap(tmpstdmultiset2);
+   boostset.swap(tmpboosteset2);
+   stdset.swap(tmpstdset2);
+   boostmultiset.swap(tmpboostemultiset2);
+   stdmultiset.swap(tmpstdmultiset2);
+   if(!CheckEqualContainers(boostset, stdset)){
+      std::cout << "Error in boostset.swap(tmpboosteset2)" << std::endl;
+      return 1;
+   }
+   if(!CheckEqualContainers(boostmultiset, stdmultiset)){
+      std::cout << "Error in boostmultiset.swap(tmpboostemultiset2)" << std::endl;
+      return 1;
+   }
+
+   //Insertion from other container
+   //Initialize values
+   {
+      IntType aux_vect[50];
+      for(int i = 0; i < 50; ++i){
+         IntType move_me(-1);
+         aux_vect[i] = boost::move(move_me);
+      }
+      int aux_vect2[50];
+      for(int i = 0; i < 50; ++i){
+         aux_vect2[i] = -1;
+      }
+      IntType aux_vect3[50];
+      for(int i = 0; i < 50; ++i){
+         IntType move_me(-1);
+         aux_vect3[i] = boost::move(move_me);
+      }
+
+      boostset.insert(boost::make_move_iterator(&aux_vect[0]), boost::make_move_iterator(&aux_vect[0] + 50));
+      stdset.insert(&aux_vect2[0], &aux_vect2[0] + 50);
+      if(!CheckEqualContainers(boostset, stdset)){
+         std::cout << "Error in boostset.insert(boost::make_move_iterator(&aux_vect3[0])..." << std::endl;
+         return 1;
+      }
+      boostmultiset.insert(boost::make_move_iterator(&aux_vect3[0]), boost::make_move_iterator(aux_vect3 + 50));
+      stdmultiset.insert(&aux_vect2[0], &aux_vect2[0] + 50);
+      if(!CheckEqualContainers(boostmultiset, stdmultiset)){
+         std::cout << "Error in boostmultiset.insert(boost::make_move_iterator(&aux_vect3[0]), ..." << std::endl;
+         return 1;
+      }
+
+      for(int i = 0, j = static_cast<int>(boostset.size()); i < j; ++i){
+         IntType erase_me(i);
+         boostset.erase(erase_me);
+         stdset.erase(i);
+         boostmultiset.erase(erase_me);
+         stdmultiset.erase(i);
+         if(!CheckEqualContainers(boostset, stdset)){
+            std::cout << "Error in boostset.erase(erase_me)" << boostset.size() << " " << stdset.size() << std::endl;
+            return 1;
+         }
+         if(!CheckEqualContainers(boostmultiset, stdmultiset)){
+            std::cout << "Error in boostmultiset.erase(erase_me)" << std::endl;
+            return 1;
+         }
+      }
+   }
+   {
+      IntType aux_vect[50];
+      for(int i = 0; i < 50; ++i){
+         IntType move_me(-1);
+         aux_vect[i] = boost::move(move_me);
+      }
+      int aux_vect2[50];
+      for(int i = 0; i < 50; ++i){
+         aux_vect2[i] = -1;
+      }
+      IntType aux_vect3[50];
+      for(int i = 0; i < 50; ++i){
+         IntType move_me(-1);
+         aux_vect3[i] = boost::move(move_me);
+      }
+
+      IntType aux_vect4[50];
+      for(int i = 0; i < 50; ++i){
+         IntType move_me(-1);
+         aux_vect4[i] = boost::move(move_me);
+      }
+
+      IntType aux_vect5[50];
+      for(int i = 0; i < 50; ++i){
+         IntType move_me(-1);
+         aux_vect5[i] = boost::move(move_me);
+      }
+
+      boostset.insert(boost::make_move_iterator(&aux_vect[0]), boost::make_move_iterator(&aux_vect[0] + 50));
+      boostset.insert(boost::make_move_iterator(&aux_vect3[0]), boost::make_move_iterator(&aux_vect3[0] + 50));
+      stdset.insert(&aux_vect2[0], &aux_vect2[0] + 50);
+      stdset.insert(&aux_vect2[0], &aux_vect2[0] + 50);
+      if(!CheckEqualContainers(boostset, stdset)){
+         std::cout << "Error in boostset.insert(boost::make_move_iterator(&aux_vect3[0])..." << std::endl;
+         return 1;
+      }
+      boostmultiset.insert(boost::make_move_iterator(&aux_vect4[0]), boost::make_move_iterator(&aux_vect4[0] + 50));
+      boostmultiset.insert(boost::make_move_iterator(&aux_vect5[0]), boost::make_move_iterator(&aux_vect5[0] + 50));
+      stdmultiset.insert(&aux_vect2[0], &aux_vect2[0] + 50);
+      stdmultiset.insert(&aux_vect2[0], &aux_vect2[0] + 50);
+      if(!CheckEqualContainers(boostmultiset, stdmultiset)){
+         std::cout << "Error in boostmultiset.insert(boost::make_move_iterator(&aux_vect5[0])..." << std::endl;
+         return 1;
+      }
+
+      boostset.erase(*boostset.begin());
+      stdset.erase(*stdset.begin());
+      if(!CheckEqualContainers(boostset, stdset)){
+         std::cout << "Error in boostset.erase(*boostset.begin())" << std::endl;
+         return 1;
+      }
+      boostmultiset.erase(*boostmultiset.begin());
+      stdmultiset.erase(*stdmultiset.begin());
+      if(!CheckEqualContainers(boostmultiset, stdmultiset)){
+         std::cout << "Error in boostmultiset.erase(*boostmultiset.begin())" << std::endl;
+         return 1;
+      }
+   }
+
+   for(int i = 0; i < MaxElem; ++i){
+      IntType move_me(i);
+      boostset.insert(boost::move(move_me));
+      stdset.insert(i);
+      IntType move_me2(i);
+      boostmultiset.insert(boost::move(move_me2));
+      stdmultiset.insert(i);
+   }
+
+   if(!CheckEqualContainers(boostset, stdset)){
+      std::cout << "Error in boostset.insert(boost::move(move_me)) try 2" << std::endl;
+      return 1;
+   }
+   if(!CheckEqualContainers(boostmultiset, stdmultiset)){
+      std::cout << "Error in boostmultiset.insert(boost::move(move_me2)) try 2" << std::endl;
+      return 1;
+   }
+
+   for(int i = 0; i < MaxElem; ++i){
+      {
+         IntType move_me(i);
+         boostset.insert(boostset.begin(), boost::move(move_me));
+         stdset.insert(stdset.begin(), i);
+         //PrintContainers(boostset, stdset);
+         IntType move_me2(i);
+         boostmultiset.insert(boostmultiset.begin(), boost::move(move_me2));
+         stdmultiset.insert(stdmultiset.begin(), i);
+         //PrintContainers(boostmultiset, stdmultiset);
+         if(!CheckEqualContainers(boostset, stdset)){
+            std::cout << "Error in boostset.insert(boostset.begin(), boost::move(move_me))" << std::endl;
+            return 1;
+         }
+         if(!CheckEqualContainers(boostmultiset, stdmultiset)){
+            std::cout << "Error in boostmultiset.insert(boostmultiset.begin(), boost::move(move_me2))" << std::endl;
+            return 1;
+         }
+
+         IntType move_me3(i);
+         boostset.insert(boostset.end(), boost::move(move_me3));
+         stdset.insert(stdset.end(), i);
+         IntType move_me4(i);
+         boostmultiset.insert(boostmultiset.end(), boost::move(move_me4));
+         stdmultiset.insert(stdmultiset.end(), i);
+         if(!CheckEqualContainers(boostset, stdset)){
+            std::cout << "Error in boostset.insert(boostset.end(), boost::move(move_me3))" << std::endl;
+            return 1;
+         }
+         if(!CheckEqualContainers(boostmultiset, stdmultiset)){
+            std::cout << "Error in boostmultiset.insert(boostmultiset.end(), boost::move(move_me4))" << std::endl;
+            return 1;
+         }
+      }
+      {
+         IntType move_me(i);
+         boostset.insert(boostset.upper_bound(move_me), boost::move(move_me));
+         stdset.insert(stdset.upper_bound(i), i);
+         //PrintContainers(boostset, stdset);
+         IntType move_me2(i);
+         boostmultiset.insert(boostmultiset.upper_bound(move_me2), boost::move(move_me2));
+         stdmultiset.insert(stdmultiset.upper_bound(i), i);
+         //PrintContainers(boostmultiset, stdmultiset);
+         if(!CheckEqualContainers(boostset, stdset)){
+            std::cout << "Error in boostset.insert(boostset.upper_bound(move_me), boost::move(move_me))" << std::endl;
+            return 1;
+         }
+         if(!CheckEqualContainers(boostmultiset, stdmultiset)){
+            std::cout << "Error in boostmultiset.insert(boostmultiset.upper_bound(move_me2), boost::move(move_me2))" << std::endl;
+            return 1;
+         }
+
+      }
+      {
+         IntType move_me(i);
+         IntType move_me2(i);
+         boostset.insert(boostset.lower_bound(move_me), boost::move(move_me2));
+         stdset.insert(stdset.lower_bound(i), i);
+         //PrintContainers(boostset, stdset);
+         move_me2 = i;
+         boostmultiset.insert(boostmultiset.lower_bound(move_me2), boost::move(move_me2));
+         stdmultiset.insert(stdmultiset.lower_bound(i), i);
+         //PrintContainers(boostmultiset, stdmultiset);
+         if(!CheckEqualContainers(boostset, stdset)){
+            std::cout << "Error in boostset.insert(boostset.lower_bound(move_me), boost::move(move_me2))" << std::endl;
+            return 1;
+         }
+         if(!CheckEqualContainers(boostmultiset, stdmultiset)){
+            std::cout << "Error in boostmultiset.insert(boostmultiset.lower_bound(move_me2), boost::move(move_me2))" << std::endl;
+            return 1;
+         }
+         set_test_rebalanceable(boostset
+            , dtl::bool_<has_member_function_callable_with_rebalance<MyBoostSet>::value>());
+         if(!CheckEqualContainers(boostset, stdset)){
+            std::cout << "Error in boostset.rebalance()" << std::endl;
+            return 1;
+         }
+         set_test_rebalanceable(boostmultiset
+            , dtl::bool_<has_member_function_callable_with_rebalance<MyBoostMultiSet>::value>());
+         if(!CheckEqualContainers(boostmultiset, stdmultiset)){
+            std::cout << "Error in boostmultiset.rebalance()" << std::endl;
+            return 1;
+         }
+      }
+   }
+
+   //Compare count with std containers
+   for(int i = 0; i < MaxElem; ++i){
+      IntType k(i);
+      if(boostset.count(k) != stdset.count(i)){
+         return -1;
+      }
+
+      if(boostset.contains(k) != (stdset.find(i) != stdset.end())){
+         return -1;
+      }
+
+      if(boostmultiset.count(k) != stdmultiset.count(i)){
+         return -1;
+      }
+
+      if(boostmultiset.contains(k) != (stdmultiset.find(i) != stdmultiset.end())){
+         return -1;
+      }
+   }
+
+   //Compare find/lower_bound/upper_bound in set
+   {
+      typename MyBoostSet::iterator bs_b = boostset.begin();
+      typename MyBoostSet::iterator bs_e = boostset.end();
+      typename MyStdSet::iterator ss_b   = stdset.begin();
+
+      std::size_t i = 0;
+      while(bs_b != bs_e){
+         ++i;
+         typename MyBoostSet::iterator bs_i;
+         typename MyStdSet::iterator ss_i;
+         //find
+         bs_i = boostset.find(*bs_b);
+         ss_i = stdset.find(*ss_b);
+         if(!CheckEqualIt(bs_i, ss_i, boostset, stdset)){
+            return -1;
+         }
+         //lower bound
+         bs_i = boostset.lower_bound(*bs_b);
+         ss_i = stdset.lower_bound(*ss_b);
+         if(!CheckEqualIt(bs_i, ss_i, boostset, stdset)){
+            return -1;
+         }
+         //upper bound
+         bs_i = boostset.upper_bound(*bs_b);
+         ss_i = stdset.upper_bound(*ss_b);
+         if(!CheckEqualIt(bs_i, ss_i, boostset, stdset)){
+            return -1;
+         }
+         //equal range
+         std::pair<typename MyBoostSet::iterator
+                  ,typename MyBoostSet::iterator> bs_ip;
+         std::pair<typename MyStdSet::iterator
+                  ,typename MyStdSet::iterator>   ss_ip;
+         bs_ip = boostset.equal_range(*bs_b);
+         ss_ip = stdset.equal_range(*ss_b);
+         if(!CheckEqualIt(bs_ip.first, ss_ip.first, boostset, stdset)){
+            return -1;
+         }
+         if(!CheckEqualIt(bs_ip.second, ss_ip.second, boostset, stdset)){
+            return -1;
+         }
+         ++bs_b;
+         ++ss_b;
+      }
+   }
+   //Compare find/lower_bound/upper_bound in multiset
+   {
+      typename MyBoostMultiSet::iterator bm_b = boostmultiset.begin();
+      typename MyBoostMultiSet::iterator bm_e = boostmultiset.end();
+      typename MyStdMultiSet::iterator sm_b   = stdmultiset.begin();
+
+      while(bm_b != bm_e){
+         typename MyBoostMultiSet::iterator bm_i;
+         typename MyStdMultiSet::iterator sm_i;
+         //find
+         bm_i = boostmultiset.find(*bm_b);
+         sm_i = stdmultiset.find(*sm_b);
+         if(!CheckEqualIt(bm_i, sm_i, boostmultiset, stdmultiset)){
+            return -1;
+         }
+         //lower bound
+         bm_i = boostmultiset.lower_bound(*bm_b);
+         sm_i = stdmultiset.lower_bound(*sm_b);
+         if(!CheckEqualIt(bm_i, sm_i, boostmultiset, stdmultiset)){
+            return -1;
+         }
+         //upper bound
+         bm_i = boostmultiset.upper_bound(*bm_b);
+         sm_i = stdmultiset.upper_bound(*sm_b);
+         if(!CheckEqualIt(bm_i, sm_i, boostmultiset, stdmultiset)){
+            return -1;
+         }
+         //equal range
+         std::pair<typename MyBoostMultiSet::iterator
+                  ,typename MyBoostMultiSet::iterator> bm_ip;
+         std::pair<typename MyStdMultiSet::iterator
+                  ,typename MyStdMultiSet::iterator>   sm_ip;
+         bm_ip = boostmultiset.equal_range(*bm_b);
+         sm_ip = stdmultiset.equal_range(*sm_b);
+         if(!CheckEqualIt(bm_ip.first, sm_ip.first, boostmultiset, stdmultiset)){
+            return -1;
+         }
+         if(!CheckEqualIt(bm_ip.second, sm_ip.second, boostmultiset, stdmultiset)){
+            return -1;
+         }
+         ++bm_b;
+         ++sm_b;
+      }
+   }
+
+   //Now do count exercise
+   boostset.erase(boostset.begin(), boostset.end());
+   boostmultiset.erase(boostmultiset.begin(), boostmultiset.end());
+   boostset.clear();
+   boostmultiset.clear();
+
+   for(int j = 0; j < 3; ++j)
+   for(int i = 0; i < 100; ++i){
+      IntType move_me(i);
+      boostset.insert(boost::move(move_me));
+      IntType move_me2(i);
+      boostmultiset.insert(boost::move(move_me2));
+      IntType count_me(i);
+      if(boostset.count(count_me) != typename MyBoostMultiSet::size_type(1)){
+         std::cout << "Error in boostset.count(count_me)" << std::endl;
+         return 1;
+      }
+      if(boostmultiset.count(count_me) != typename MyBoostMultiSet::size_type(j+1)){
+         std::cout << "Error in boostmultiset.count(count_me)" << std::endl;
+         return 1;
+      }
+   }
+
+   {  //merge
+      ::boost::movelib::unique_ptr<MyBoostSet> const pboostset2 = ::boost::movelib::make_unique<MyBoostSet>();
+      ::boost::movelib::unique_ptr<MyBoostMultiSet> const pboostmultiset2 = ::boost::movelib::make_unique<MyBoostMultiSet>();
+
+      MyBoostSet &boostset2 = *pboostset2;
+      MyBoostMultiSet &boostmultiset2 = *pboostmultiset2;
+
+      boostset.clear();
+      boostset2.clear();
+      boostmultiset.clear();
+      boostmultiset2.clear();
+      stdset.clear();
+      stdmultiset.clear();
+
+      {
+         IntType aux_vect[MaxElem];
+         for(int i = 0; i < MaxElem; ++i){
+            aux_vect[i] = i;
+         }
+
+         IntType aux_vect2[MaxElem];
+         for(int i = 0; i < MaxElem; ++i){
+            aux_vect2[i] = MaxElem/2+i;
+         }
+         IntType aux_vect3[MaxElem];
+         for(int i = 0; i < MaxElem; ++i){
+            aux_vect3[i] = MaxElem*2/2+i;
+         }
+         boostset.insert(boost::make_move_iterator(&aux_vect[0]), boost::make_move_iterator(&aux_vect[0] + MaxElem));
+         boostset2.insert(boost::make_move_iterator(&aux_vect2[0]), boost::make_move_iterator(&aux_vect2[0] + MaxElem));
+         boostmultiset2.insert(boost::make_move_iterator(&aux_vect3[0]), boost::make_move_iterator(&aux_vect3[0] + MaxElem));
+      }
+      for(int i = 0; i < MaxElem; ++i){
+         stdset.insert(i);
+      }
+      for(int i = 0; i < MaxElem; ++i){
+         stdset.insert(MaxElem/2+i);
+      }
+
+      boostset.merge(boost::move(boostset2));
+      if(!CheckEqualContainers(boostset, stdset)) return 1;
+
+      for(int i = 0; i < MaxElem; ++i){
+         stdset.insert(MaxElem*2/2+i);
+      }
+
+      boostset.merge(boost::move(boostmultiset2));
+      if(!CheckEqualContainers(boostset, stdset)) return 1;
+
+      boostset.clear();
+      boostset2.clear();
+      boostmultiset.clear();
+      boostmultiset2.clear();
+      stdset.clear();
+      stdmultiset.clear();
+      {
+         IntType aux_vect[MaxElem];
+         for(int i = 0; i < MaxElem; ++i){
+            aux_vect[i] = i;
+         }
+
+         IntType aux_vect2[MaxElem];
+         for(int i = 0; i < MaxElem; ++i){
+            aux_vect2[i] = MaxElem/2+i;
+         }
+         IntType aux_vect3[MaxElem];
+         for(int i = 0; i < MaxElem; ++i){
+            aux_vect3[i] = MaxElem*2/2+i;
+         }
+         boostmultiset.insert(boost::make_move_iterator(&aux_vect[0]), boost::make_move_iterator(&aux_vect[0] + MaxElem));
+         boostmultiset2.insert(boost::make_move_iterator(&aux_vect2[0]), boost::make_move_iterator(&aux_vect2[0] + MaxElem));
+         boostset2.insert(boost::make_move_iterator(&aux_vect3[0]), boost::make_move_iterator(&aux_vect3[0] + MaxElem));
+      }
+      for(int i = 0; i < MaxElem; ++i){
+         stdmultiset.insert(i);
+      }
+      for(int i = 0; i < MaxElem; ++i){
+         stdmultiset.insert(MaxElem/2+i);
+      }
+      boostmultiset.merge(boost::move(boostmultiset2));
+      if(!CheckEqualContainers(boostmultiset, stdmultiset)) return 1;
+
+      for(int i = 0; i < MaxElem; ++i){
+         stdmultiset.insert(MaxElem*2/2+i);
+      }
+
+      boostmultiset.merge(boost::move(boostset2));
+      if(!CheckEqualContainers(boostmultiset, stdmultiset)) return 1;
+   }
+
+   if(set_test_copyable<MyBoostSet, MyStdSet, MyBoostMultiSet, MyStdMultiSet>
+      (dtl::bool_<boost::container::test::is_copyable<IntType>::value>())){
+      return 1;
+   }
+
+   return 0;
+}
+
+template<typename SetType>
+bool test_set_methods_with_initializer_list_as_argument_for()
+{
+#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
+   std::initializer_list<int> il = { 1, 2, 3, 4, 5, 5 };
+   std::initializer_list<int> ilu = { 1, 2, 3, 4, 5 };
+   SetType expected(il.begin(), il.end());
+   SetType expectedu(ilu.begin(), ilu.end());
+   {
+      SetType sil((il));
+      if (sil != expected)
+         return false;
+
+      SetType sila(il, typename SetType::allocator_type());
+      if (sila != expected)
+         return false;
+
+      SetType silca(il, typename SetType::key_compare(), typename SetType::allocator_type());
+      if (silca != expected)
+         return false;
+
+      SetType sil_ordered(ordered_unique_range, ilu);
+      if (sil_ordered != expectedu)
+         return false;
+
+      SetType sil_assign = { 99, 100, 101, 102, 103, 104, 105 };
+      sil_assign = il;
+      if (sil_assign != expected)
+         return false;
+   }
+   {
+      SetType sil;
+      sil.insert(il);
+      if (sil != expected)
+         return false;
+   }
+   return true;
+#endif
+   return true;
+}
+
+template<typename SetType, typename MultisetType>
+bool instantiate_constructors()
+{
+   {
+      typedef typename SetType::value_type value_type;
+      typename SetType::key_compare comp;
+      typename SetType::allocator_type a;
+      value_type value;
+      {
+         SetType s0;
+         SetType s1(comp);
+         SetType s2(a);
+         SetType s3(comp, a);
+      }
+      {
+         SetType s0(&value, &value);
+         SetType s1(&value, &value ,comp);
+         SetType s2(&value, &value ,a);
+         SetType s3(&value, &value ,comp, a);
+      }
+      #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
+      {
+         SetType s0({ 0 });
+         SetType s1({ 0 },comp);
+         SetType s2({ 0 },a);
+         SetType s3({ 0 },comp, a);
+      }
+      {
+         std::initializer_list<value_type> il{0};
+         SetType s0(ordered_unique_range, il);
+         SetType s1(ordered_unique_range, il,comp);
+         SetType s3(ordered_unique_range, il,comp, a);
+      }
+      #endif
+      {
+         SetType s0(ordered_unique_range, &value, &value);
+         SetType s1(ordered_unique_range, &value, &value ,comp);
+         SetType s2(ordered_unique_range, &value, &value ,comp, a);
+      }
+   }
+
+   {
+      typedef typename MultisetType::value_type value_type;
+      typename MultisetType::key_compare comp;
+      typename MultisetType::allocator_type a;
+      value_type value;
+      {
+         MultisetType s0;
+         MultisetType s1(comp);
+         MultisetType s2(a);
+         MultisetType s3(comp, a);
+      }
+      {
+         MultisetType s0(&value, &value);
+         MultisetType s1(&value, &value ,comp);
+         MultisetType s2(&value, &value ,a);
+         MultisetType s3(&value, &value ,comp, a);
+      }
+      #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
+      {
+         MultisetType s0({ 0 });
+         MultisetType s1({ 0 },comp);
+         MultisetType s2({ 0 },a);
+         MultisetType s3({ 0 },comp, a);
+      }
+      {
+         std::initializer_list<value_type>il{0};
+         MultisetType s0(ordered_range, il);
+         MultisetType s1(ordered_range, il,comp);
+         MultisetType s3(ordered_range, il,comp, a);
+      }
+      #endif
+      {
+         MultisetType s0(ordered_range, &value, &value);
+         MultisetType s1(ordered_range, &value, &value ,comp);
+         MultisetType s2(ordered_range, &value, &value ,comp, a);
+      }
+   }
+   return true;
+}
+
+}  //namespace test{
+}  //namespace container {
+}  //namespace boost{
+
+#include <boost/container/detail/config_end.hpp>
+
+#endif
diff --git a/src/boost/libs/container/test/slist_test.cpp b/src/boost/libs/container/test/slist_test.cpp
new file mode 100644
index 000000000..08943448a
--- /dev/null
+++ b/src/boost/libs/container/test/slist_test.cpp
@@ -0,0 +1,290 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2004-2013. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/container for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+#include <boost/container/detail/config_begin.hpp>
+#include <boost/container/slist.hpp>
+#include <boost/container/node_allocator.hpp>
+
+#include <memory>
+#include "dummy_test_allocator.hpp"
+#include "movable_int.hpp"
+#include "list_test.hpp"
+#include "propagate_allocator_test.hpp"
+#include "emplace_test.hpp"
+#include "../../intrusive/test/iterator_test.hpp"
+
+using namespace boost::container;
+
+class recursive_slist
+{
+public:
+   int id_;
+   slist<recursive_slist> slist_;
+   slist<recursive_slist>::iterator it_;
+   slist<recursive_slist>::const_iterator cit_;
+
+   recursive_slist &operator=(const recursive_slist &o)
+   { slist_ = o.slist_;  return *this; }
+};
+
+void recursive_slist_test()//Test for recursive types
+{
+   slist<recursive_slist> recursive_list_list;
+}
+
+template<class VoidAllocator>
+struct GetAllocatorCont
+{
+   template<class ValueType>
+   struct apply
+   {
+      typedef slist< ValueType
+                   , typename allocator_traits<VoidAllocator>
+                        ::template portable_rebind_alloc<ValueType>::type
+                   > type;
+   };
+};
+
+bool test_support_for_initializer_list()
+{
+#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
+   const std::initializer_list<int> il = {5, 10, 15};
+   const slist<int> expected_list(il.begin(), il.end());
+   {
+      slist<int> sl = il;
+      if(sl != expected_list)
+         return false;
+   }
+
+   {
+      slist<int> sl = {1, 2};
+      sl = il;
+      if(sl != expected_list)
+         return false;
+   }
+   {
+      slist<int> sl({ 1, 2 }, slist<int>::allocator_type());
+      sl = il;
+      if (sl != expected_list)
+         return false;
+   }
+   {
+      slist<int> sl = {4, 5};
+      sl.assign(il);
+      if(sl != expected_list)
+         return false;
+   }
+
+   {
+      slist<int> sl = {15};
+      sl.insert(sl.cbegin(), {5, 10});
+      if(sl != expected_list)
+         return false;
+   }
+
+   {
+       slist<int> sl = {5};
+       sl.insert_after(sl.cbegin(), {10, 15});
+       if(sl != expected_list)
+          return false;
+   }
+   return true;
+#endif
+   return true;
+}
+
+bool test_for_splice()
+{
+   {
+      slist<int> list1; list1.push_front(3); list1.push_front(2); list1.push_front(1); list1.push_front(0);
+      slist<int> list2;
+      slist<int> expected1; expected1.push_front(3); expected1.push_front(2);  expected1.push_front(0);
+      slist<int> expected2; expected2.push_front(1);
+
+      list2.splice(list2.begin(), list1, ++list1.begin());
+
+      if (!(expected1 == list1 && expected2 == list2))
+         return false;
+   }
+   {
+      slist<int> list1; list1.push_front(3); list1.push_front(2); list1.push_front(1); list1.push_front(0);
+      slist<int> list2;
+      slist<int> expected1;
+      slist<int> expected2; expected2.push_front(3); expected2.push_front(2); expected2.push_front(1); expected2.push_front(0);
+
+      list2.splice(list2.begin(), list1, list1.begin(), list1.end());
+
+      if (!(expected1 == list1 && expected2 == list2))
+         return false;
+   }
+   return true;
+}
+
+struct boost_container_slist;
+
+namespace boost {
+namespace container {
+namespace test {
+
+template<>
+struct alloc_propagate_base<boost_container_slist>
+{
+   template <class T, class Allocator>
+   struct apply
+   {
+      typedef boost::container::slist<T, Allocator> type;
+   };
+};
+
+}}}
+
+int main ()
+{
+   recursive_slist_test();
+   {
+      //Now test move semantics
+      slist<recursive_slist> original;
+      slist<recursive_slist> move_ctor(boost::move(original));
+      slist<recursive_slist> move_assign;
+      move_assign = boost::move(move_ctor);
+      move_assign.swap(original);
+      {
+         slist<recursive_slist> recursive, copy;
+         //Test to test both move emulations
+         if(!copy.size()){
+            copy = recursive;
+         }
+      }
+   }
+   ////////////////////////////////////
+   //    Testing allocator implementations
+   ////////////////////////////////////
+   if (test::list_test<slist<int, std::allocator<int> >, false>())
+      return 1;
+   if (test::list_test<slist<int>, false>())
+      return 1;
+   if (test::list_test<slist<int, node_allocator<int> >, false>())
+      return 1;
+   if (test::list_test<slist<test::movable_int>, false>())
+      return 1;
+   if (test::list_test<slist<test::movable_and_copyable_int>, false>())
+      return 1;
+   if (test::list_test<slist<test::copyable_int>, false>())
+      return 1;
+
+   ////////////////////////////////////
+   //    Emplace testing
+   ////////////////////////////////////
+   const test::EmplaceOptions Options = (test::EmplaceOptions)
+      (test::EMPLACE_FRONT | test::EMPLACE_AFTER | test::EMPLACE_BEFORE  | test::EMPLACE_AFTER);
+
+   if(!boost::container::test::test_emplace
+      < slist<test::EmplaceInt>, Options>())
+      return 1;
+
+   ////////////////////////////////////
+   //    Allocator propagation testing
+   ////////////////////////////////////
+   if(!boost::container::test::test_propagate_allocator<boost_container_slist>())
+      return 1;
+
+   ////////////////////////////////////
+   //    Initializer lists
+   ////////////////////////////////////
+   if(!test_support_for_initializer_list())
+      return 1;
+
+   ////////////////////////////////////
+   //    Splice testing
+   ////////////////////////////////////
+   if(!test_for_splice())
+      return 1;
+
+   ////////////////////////////////////
+   //    Iterator testing
+   ////////////////////////////////////
+   {
+      typedef boost::container::slist<int> vector_int;
+      vector_int a; a.push_front(2); a.push_front(1); a.push_front(0);
+      boost::intrusive::test::test_iterator_forward< boost::container::slist<int> >(a);
+      if(boost::report_errors() != 0) {
+         return 1;
+      }
+   }
+#ifndef BOOST_CONTAINER_NO_CXX17_CTAD
+   ////////////////////////////////////
+   //    Constructor Template Auto Deduction Tests
+   ////////////////////////////////////
+   {
+      auto gold = std::list{ 1, 2, 3 };
+      auto test = boost::container::slist(gold.begin(), gold.end());
+      if (test.size() != 3) {
+         return 1;
+      }
+      if (test.front() != 1)
+         return 1;
+      test.pop_front();
+      if (test.front() != 2)
+         return 1;
+      test.pop_front();
+      if (test.front() != 3)
+         return 1;
+      test.pop_front();
+   }
+   {
+      auto gold = std::list{ 1, 2, 3 };
+      auto test = boost::container::slist(gold.begin(), gold.end(), new_allocator<int>());
+      if (test.size() != 3) {
+         return 1;
+      }
+      if (test.front() != 1)
+         return 1;
+      test.pop_front();
+      if (test.front() != 2)
+         return 1;
+      test.pop_front();
+      if (test.front() != 3)
+         return 1;
+      test.pop_front();
+   }
+#endif
+
+   ////////////////////////////////////
+   //    has_trivial_destructor_after_move testing
+   ////////////////////////////////////
+   // default allocator
+   {
+      typedef boost::container::slist<int> cont;
+      typedef cont::allocator_type allocator_type;
+      typedef boost::container::allocator_traits<allocator_type>::pointer pointer;
+      if (boost::has_trivial_destructor_after_move<cont>::value !=
+          boost::has_trivial_destructor_after_move<allocator_type>::value &&
+          boost::has_trivial_destructor_after_move<pointer>::value) {
+         std::cerr << "has_trivial_destructor_after_move(default allocator) test failed" << std::endl;
+         return 1;
+      }
+   }
+   // std::allocator
+   {
+      typedef boost::container::slist<int, std::allocator<int> > cont;
+      typedef cont::allocator_type allocator_type;
+      typedef boost::container::allocator_traits<allocator_type>::pointer pointer;
+      if (boost::has_trivial_destructor_after_move<cont>::value !=
+          boost::has_trivial_destructor_after_move<allocator_type>::value &&
+          boost::has_trivial_destructor_after_move<pointer>::value) {
+         std::cerr << "has_trivial_destructor_after_move(std::allocator) test failed" << std::endl;
+         return 1;
+      }
+   }
+
+   return 0;
+}
+
+#include <boost/container/detail/config_end.hpp>
+
diff --git a/src/boost/libs/container/test/small_vector_options_test.cpp b/src/boost/libs/container/test/small_vector_options_test.cpp
new file mode 100644
index 000000000..73e485536
--- /dev/null
+++ b/src/boost/libs/container/test/small_vector_options_test.cpp
@@ -0,0 +1,110 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2004-2013. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/container for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+#include <boost/container/small_vector.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <boost/assert.hpp>
+using namespace boost::container;
+
+const std::size_t Capacity = 10u;
+
+void test_alignment()
+{
+   {  //extended alignment
+      const std::size_t extended_alignment = sizeof(int)*4u;
+      BOOST_STATIC_ASSERT(extended_alignment > dtl::alignment_of<int>::value);
+      #if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
+      using options_t = small_vector_options_t< inplace_alignment<extended_alignment> >;
+      #else
+      typedef small_vector_options
+         < inplace_alignment<extended_alignment> >::type options_t;
+      #endif
+
+      small_vector<int, Capacity, void, options_t> v;
+      v.resize(v.capacity());
+      BOOST_ASSERT((reinterpret_cast<std::size_t>(&v[0]) % extended_alignment) == 0);
+   }
+   {  //default alignment
+      #if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
+      using options_t = small_vector_options_t< inplace_alignment<0> >;
+      #else
+      typedef small_vector_options< inplace_alignment<0> >::type options_t;
+      #endif
+
+      small_vector<int, Capacity, void, options_t> v;
+      v.resize(v.capacity());
+      BOOST_ASSERT((reinterpret_cast<std::size_t>(&v[0]) % dtl::alignment_of<int>::value) == 0);
+   }
+}
+
+void test_growth_factor_50()
+{
+   #if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
+   using options_t = small_vector_options_t< growth_factor<growth_factor_50> >;
+   #else
+   typedef small_vector_options
+      < growth_factor<growth_factor_50> >::type options_t;
+   #endif
+
+   small_vector<int, Capacity, new_allocator<int>, options_t> v;
+
+   v.resize(5);
+   v.resize(v.capacity());
+   std::size_t old_capacity = v.capacity();
+   v.push_back(0);
+   std::size_t new_capacity = v.capacity();
+   BOOST_TEST(new_capacity == old_capacity + old_capacity/2);
+}
+
+void test_growth_factor_60()
+{
+   #if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
+   using options_t = small_vector_options_t< growth_factor<growth_factor_60> >;
+   #else
+   typedef small_vector_options
+      < growth_factor<growth_factor_60> >::type options_t;
+   #endif
+
+   small_vector<int, Capacity, new_allocator<int>, options_t> v;
+
+   v.resize(5);
+   v.resize(v.capacity());
+   std::size_t old_capacity = v.capacity();
+   v.push_back(0);
+   std::size_t new_capacity = v.capacity();
+   BOOST_TEST(new_capacity == old_capacity + 3*old_capacity/5);
+}
+
+void test_growth_factor_100()
+{
+   #if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
+   using options_t = small_vector_options_t< growth_factor<growth_factor_100> >;
+   #else
+   typedef small_vector_options
+      < growth_factor<growth_factor_100> >::type options_t;
+   #endif
+
+   small_vector<int, Capacity, new_allocator<int>, options_t> v;
+
+   v.resize(5);
+   v.resize(v.capacity());
+   std::size_t old_capacity = v.capacity();
+   v.push_back(0);
+   std::size_t new_capacity = v.capacity();
+   BOOST_TEST(new_capacity == 2*old_capacity);
+}
+
+int main()
+{
+   test_alignment();
+   test_growth_factor_50();
+   test_growth_factor_60();
+   test_growth_factor_100();
+   return ::boost::report_errors();
+}
diff --git a/src/boost/libs/container/test/small_vector_test.cpp b/src/boost/libs/container/test/small_vector_test.cpp
new file mode 100644
index 000000000..315d64ddc
--- /dev/null
+++ b/src/boost/libs/container/test/small_vector_test.cpp
@@ -0,0 +1,236 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2004-2013. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/container for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+#include <boost/container/small_vector.hpp>
+#include "vector_test.hpp"
+#include "movable_int.hpp"
+#include "propagate_allocator_test.hpp"
+#include "default_init_test.hpp"
+#include "../../intrusive/test/iterator_test.hpp"
+
+#include <boost/container/allocator.hpp>
+
+#include <iostream>
+
+struct boost_container_small_vector;
+
+namespace boost { namespace container {   namespace test {
+
+template<>
+struct alloc_propagate_base<boost_container_small_vector>
+{
+   template <class T, class Allocator>
+   struct apply
+   {
+      typedef boost::container::small_vector<T, 10, Allocator> type;
+   };
+};
+
+}}}   //namespace boost::container::test
+
+bool test_small_vector_base_test()
+{
+   typedef boost::container::small_vector_base<int> smb_t;
+   {
+      typedef boost::container::small_vector<int, 5> sm5_t;
+      BOOST_STATIC_ASSERT(sm5_t::static_capacity == 5);
+      sm5_t sm5;
+      smb_t &smb = sm5;
+      smb.push_back(1);
+      sm5_t sm5_copy(sm5);
+      sm5_copy.push_back(1);
+      if (!boost::container::test::CheckEqualContainers(sm5, smb))
+         return false;
+   }
+   {
+      typedef boost::container::small_vector<int, 7> sm7_t;
+      BOOST_STATIC_ASSERT(sm7_t::static_capacity == 7);
+      sm7_t sm7;
+      smb_t &smb = sm7;
+      smb.push_back(2);
+      sm7_t sm7_copy(sm7);
+      sm7_copy.push_back(2);
+      if (!boost::container::test::CheckEqualContainers(sm7, smb))
+         return false;
+   }
+   {
+      typedef boost::container::small_vector<int, 5> sm5_t;
+      sm5_t sm5;
+      smb_t &smb = sm5;
+      smb.push_back(1);
+      sm5_t sm5_copy(smb);
+      if (!boost::container::test::CheckEqualContainers(sm5, sm5_copy))
+         return false;
+      smb.push_back(2);
+      if(smb.size() != 2){
+         return false;
+      }
+      sm5_copy = smb;
+      if (!boost::container::test::CheckEqualContainers(sm5, sm5_copy))
+         return false;
+      sm5_t sm5_move(boost::move(smb));
+      smb.clear();
+      if (!boost::container::test::CheckEqualContainers(sm5_move, sm5_copy))
+         return false;
+      smb = sm5_copy;
+      sm5_move = boost::move(smb);
+      smb.clear();
+      if (!boost::container::test::CheckEqualContainers(sm5_move, sm5_copy))
+         return false;
+   }
+
+   return true;
+}
+
+//small vector has internal storage so some special swap cases must be tested
+bool test_swap()
+{
+   typedef boost::container::small_vector<int, 10> vec;
+   {  //v bigger than static capacity, w empty
+      vec v;
+      for(std::size_t i = 0, max = v.capacity()+1; i != max; ++i){
+         v.push_back(int(i));
+      }
+      vec w;
+      const std::size_t v_size = v.size();
+      const std::size_t w_size = w.size();
+      v.swap(w);
+      if(v.size() != w_size || w.size() != v_size)
+         return false;
+   }
+   {  //v smaller than static capacity, w empty
+      vec v;
+      for(std::size_t i = 0, max = v.capacity()-1; i != max; ++i){
+         v.push_back(int(i));
+      }
+      vec w;
+      const std::size_t v_size = v.size();
+      const std::size_t w_size = w.size();
+      v.swap(w);
+      if(v.size() != w_size || w.size() != v_size)
+         return false;
+   }
+   {  //v & w smaller than static capacity
+      vec v;
+      for(std::size_t i = 0, max = v.capacity()-1; i != max; ++i){
+         v.push_back(int(i));
+      }
+      vec w;
+      for(std::size_t i = 0, max = v.capacity()/2; i != max; ++i){
+         w.push_back(int(i));
+      }
+      const std::size_t v_size = v.size();
+      const std::size_t w_size = w.size();
+      v.swap(w);
+      if(v.size() != w_size || w.size() != v_size)
+         return false;
+   }
+   {  //v & w bigger than static capacity
+      vec v;
+      for(std::size_t i = 0, max = v.capacity()+1; i != max; ++i){
+         v.push_back(int(i));
+      }
+      vec w;
+      for(std::size_t i = 0, max = v.capacity()*2; i != max; ++i){
+         w.push_back(int(i));
+      }
+      const std::size_t v_size = v.size();
+      const std::size_t w_size = w.size();
+      v.swap(w);
+      if(v.size() != w_size || w.size() != v_size)
+         return false;
+   }
+   return true;
+}
+
+int main()
+{
+   using namespace boost::container;
+
+   if(!test_swap())
+      return 1;
+
+   if(test::vector_test< small_vector<int, 0> >())
+      return 1;
+
+   if(test::vector_test< small_vector<int, 2000> >())
+      return 1;
+
+   ////////////////////////////////////
+   //    Default init test
+   ////////////////////////////////////
+   if(!test::default_init_test< small_vector<int, 5, test::default_init_allocator<int> > >()){
+      std::cerr << "Default init test failed" << std::endl;
+      return 1;
+   }
+
+   ////////////////////////////////////
+   //    Emplace testing
+   ////////////////////////////////////
+   const test::EmplaceOptions Options = (test::EmplaceOptions)(test::EMPLACE_BACK | test::EMPLACE_BEFORE);
+   if(!boost::container::test::test_emplace< small_vector<test::EmplaceInt, 5>, Options>()){
+      return 1;
+   }
+
+   ////////////////////////////////////
+   //    Allocator propagation testing
+   ////////////////////////////////////
+   if(!boost::container::test::test_propagate_allocator<boost_container_small_vector>()){
+      return 1;
+   }
+
+   ////////////////////////////////////
+   //    Initializer lists testing
+   ////////////////////////////////////
+   if(!boost::container::test::test_vector_methods_with_initializer_list_as_argument_for
+      < boost::container::small_vector<int, 5> >()) {
+      return 1;
+   }
+
+   ////////////////////////////////////
+   //       Small vector base
+   ////////////////////////////////////
+   if (!test_small_vector_base_test()){
+      return 1;
+   }
+
+   ////////////////////////////////////
+   //    Iterator testing
+   ////////////////////////////////////
+   {
+      typedef boost::container::small_vector<int, 0> cont_int;
+      cont_int a; a.push_back(0); a.push_back(1); a.push_back(2);
+      boost::intrusive::test::test_iterator_random< cont_int >(a);
+      if(boost::report_errors() != 0) {
+         return 1;
+      }
+   }
+
+   ////////////////////////////////////
+   //    has_trivial_destructor_after_move testing
+   ////////////////////////////////////
+   // default allocator
+   {
+      typedef boost::container::small_vector<int, 0> cont;
+      if (boost::has_trivial_destructor_after_move<cont>::value) {
+         std::cerr << "has_trivial_destructor_after_move(default allocator) test failed" << std::endl;
+         return 1;
+      }
+   }
+   // std::allocator
+   {
+      typedef boost::container::small_vector<int, 0, std::allocator<int> > cont;
+      if (boost::has_trivial_destructor_after_move<cont>::value) {
+         std::cerr << "has_trivial_destructor_after_move(std::allocator) test failed" << std::endl;
+         return 1;
+      }
+   }
+
+   return 0;
+}
diff --git a/src/boost/libs/container/test/stable_vector_test.cpp b/src/boost/libs/container/test/stable_vector_test.cpp
new file mode 100644
index 000000000..e0fb5867f
--- /dev/null
+++ b/src/boost/libs/container/test/stable_vector_test.cpp
@@ -0,0 +1,227 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2004-2013. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/container for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+#define STABLE_VECTOR_ENABLE_INVARIANT_CHECKING
+#include <boost/container/detail/config_begin.hpp>
+#include <memory>
+
+#include <boost/container/stable_vector.hpp>
+#include <boost/container/node_allocator.hpp>
+
+#include "check_equal_containers.hpp"
+#include "movable_int.hpp"
+#include "expand_bwd_test_allocator.hpp"
+#include "expand_bwd_test_template.hpp"
+#include "dummy_test_allocator.hpp"
+#include "propagate_allocator_test.hpp"
+#include "vector_test.hpp"
+#include "default_init_test.hpp"
+#include "../../intrusive/test/iterator_test.hpp"
+
+using namespace boost::container;
+
+class recursive_vector
+{
+   public:
+   int id_;
+   stable_vector<recursive_vector> vector_;
+   stable_vector<recursive_vector>::iterator it_;
+   stable_vector<recursive_vector>::const_iterator cit_;
+   stable_vector<recursive_vector>::reverse_iterator rit_;
+   stable_vector<recursive_vector>::const_reverse_iterator crit_;
+
+   recursive_vector &operator=(const recursive_vector &o)
+   { vector_ = o.vector_;  return *this; }
+};
+
+void recursive_vector_test()//Test for recursive types
+{
+   stable_vector<recursive_vector> recursive, copy;
+   //Test to test both move emulations
+   if(!copy.size()){
+      copy = recursive;
+   }
+}
+
+template<class VoidAllocator>
+struct GetAllocatorCont
+{
+   template<class ValueType>
+   struct apply
+   {
+      typedef stable_vector< ValueType
+                           , typename allocator_traits<VoidAllocator>
+                              ::template portable_rebind_alloc<ValueType>::type
+                           > type;
+   };
+};
+
+template<class VoidAllocator>
+int test_cont_variants()
+{
+   typedef typename GetAllocatorCont<VoidAllocator>::template apply<int>::type MyCont;
+   typedef typename GetAllocatorCont<VoidAllocator>::template apply<test::movable_int>::type MyMoveCont;
+   typedef typename GetAllocatorCont<VoidAllocator>::template apply<test::movable_and_copyable_int>::type MyCopyMoveCont;
+   typedef typename GetAllocatorCont<VoidAllocator>::template apply<test::copyable_int>::type MyCopyCont;
+
+   if(test::vector_test<MyCont>())
+      return 1;
+   if(test::vector_test<MyMoveCont>())
+      return 1;
+   if(test::vector_test<MyCopyMoveCont>())
+      return 1;
+   if(test::vector_test<MyCopyCont>())
+      return 1;
+
+   return 0;
+}
+
+struct boost_container_stable_vector;
+
+namespace boost { namespace container {   namespace test {
+
+template<>
+struct alloc_propagate_base<boost_container_stable_vector>
+{
+   template <class T, class Allocator>
+   struct apply
+   {
+      typedef boost::container::stable_vector<T, Allocator> type;
+   };
+};
+
+}}}   //namespace boost::container::test
+
+
+int main()
+{
+   recursive_vector_test();
+   {
+      //Now test move semantics
+      stable_vector<recursive_vector> original;
+      stable_vector<recursive_vector> move_ctor(boost::move(original));
+      stable_vector<recursive_vector> move_assign;
+      move_assign = boost::move(move_ctor);
+      move_assign.swap(original);
+   }
+
+   //Test non-copy-move operations
+   {
+      stable_vector<test::non_copymovable_int> sv;
+      sv.emplace_back();
+      sv.resize(10);
+      sv.resize(1);
+   }
+
+   ////////////////////////////////////
+   //    Testing allocator implementations
+   ////////////////////////////////////
+   //       std:allocator
+   if(test_cont_variants< std::allocator<void> >()){
+      std::cerr << "test_cont_variants< std::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;
+   }
+
+   ////////////////////////////////////
+   //    Default init test
+   ////////////////////////////////////
+   if(!test::default_init_test< stable_vector<int, test::default_init_allocator<int> > >()){
+      std::cerr << "Default init test failed" << std::endl;
+      return 1;
+   }
+
+   ////////////////////////////////////
+   //    Emplace testing
+   ////////////////////////////////////
+   const test::EmplaceOptions Options = (test::EmplaceOptions)(test::EMPLACE_BACK | test::EMPLACE_BEFORE);
+   if(!boost::container::test::test_emplace
+      < stable_vector<test::EmplaceInt>, Options>())
+      return 1;
+
+   ////////////////////////////////////
+   //    Allocator propagation testing
+   ////////////////////////////////////
+   if(!boost::container::test::test_propagate_allocator<boost_container_stable_vector>())
+      return 1;
+
+   ////////////////////////////////////
+   //    Initializer lists testing
+   ////////////////////////////////////
+   if(!boost::container::test::test_vector_methods_with_initializer_list_as_argument_for
+      < boost::container::stable_vector<int> >())
+   {
+       std::cerr << "test_methods_with_initializer_list_as_argument failed" << std::endl;
+       return 1;
+   }
+
+   ////////////////////////////////////
+   //    Iterator testing
+   ////////////////////////////////////
+   {
+      typedef boost::container::stable_vector<int> cont_int;
+      cont_int a; a.push_back(0); a.push_back(1); a.push_back(2);
+      boost::intrusive::test::test_iterator_random< cont_int >(a);
+      if(boost::report_errors() != 0) {
+         return 1;
+      }
+   }
+
+#ifndef BOOST_CONTAINER_NO_CXX17_CTAD
+   ////////////////////////////////////
+   //    Constructor Template Auto Deduction testing
+   ////////////////////////////////////
+   {
+      auto gold = std::vector{ 1, 2, 3 };
+      auto test = boost::container::stable_vector(gold.begin(), gold.end());
+      if (test.size() != 3) {
+         return 1;
+      }
+      if (!(test[0] == 1 && test[1] == 2 && test[2] == 3)) {
+         return 1;
+      }
+   }
+#endif
+
+   ////////////////////////////////////
+   //    has_trivial_destructor_after_move testing
+   ////////////////////////////////////
+   // default allocator
+   {
+      typedef boost::container::stable_vector<int> cont;
+      typedef cont::allocator_type allocator_type;
+      typedef boost::container::allocator_traits<allocator_type>::pointer pointer;
+      if (boost::has_trivial_destructor_after_move<cont>::value !=
+          boost::has_trivial_destructor_after_move<allocator_type>::value &&
+          boost::has_trivial_destructor_after_move<pointer>::value) {
+         std::cerr << "has_trivial_destructor_after_move(default allocator) test failed" << std::endl;
+         return 1;
+      }
+   }
+   // std::allocator
+   {
+      typedef boost::container::stable_vector<int, std::allocator<int> > cont;
+      typedef cont::allocator_type allocator_type;
+      typedef boost::container::allocator_traits<allocator_type>::pointer pointer;
+      if (boost::has_trivial_destructor_after_move<cont>::value !=
+          boost::has_trivial_destructor_after_move<allocator_type>::value &&
+          boost::has_trivial_destructor_after_move<pointer>::value) {
+         std::cerr << "has_trivial_destructor_after_move(std::allocator) test failed" << std::endl;
+         return 1;
+      }
+   }
+
+   return 0;
+}
+
+#include <boost/container/detail/config_end.hpp>
diff --git a/src/boost/libs/container/test/static_vector_options_test.cpp b/src/boost/libs/container/test/static_vector_options_test.cpp
new file mode 100644
index 000000000..e8965d54f
--- /dev/null
+++ b/src/boost/libs/container/test/static_vector_options_test.cpp
@@ -0,0 +1,124 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2004-2013. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/container for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+#define BOOST_ENABLE_ASSERT_HANDLER
+#include <boost/container/static_vector.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <new> //for bad_alloc
+#include <boost/assert.hpp>
+using namespace boost::container;
+
+//User-defined assertion to test throw_on_overflow
+struct throw_on_overflow_off
+{};
+
+namespace boost {
+   void assertion_failed(char const *, char const *, char const *, long)
+   {
+      throw throw_on_overflow_off();
+   }
+
+   void assertion_failed_msg(char const *, char const *, char const *, char const *, long )
+   {
+      throw throw_on_overflow_off();
+   }
+}
+
+void test_alignment()
+{
+   const std::size_t Capacity = 10u;
+   {  //extended alignment
+      const std::size_t extended_alignment = sizeof(int)*4u;
+      BOOST_STATIC_ASSERT(extended_alignment > dtl::alignment_of<int>::value);
+      #if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
+      using options_t = static_vector_options_t< inplace_alignment<extended_alignment> >;
+      #else
+      typedef static_vector_options
+         < inplace_alignment<extended_alignment> >::type options_t;
+      #endif
+
+      static_vector<int, Capacity, options_t> v;
+      v.resize(v.capacity());
+      BOOST_ASSERT((reinterpret_cast<std::size_t>(&v[0]) % extended_alignment) == 0);
+   }
+   {  //default alignment
+      #if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
+      using options_t = static_vector_options_t< inplace_alignment<0> >;
+      #else
+      typedef static_vector_options< inplace_alignment<0> >::type options_t;
+      #endif
+
+      static_vector<int, Capacity, options_t> v;
+      v.resize(v.capacity());
+      BOOST_ASSERT((reinterpret_cast<std::size_t>(&v[0]) % dtl::alignment_of<int>::value) == 0);
+   }
+}
+
+void test_throw_on_overflow()
+{
+   #if !defined(BOOST_NO_EXCEPTIONS)
+   const std::size_t Capacity = 10u;
+   {  //throw_on_overflow == true, expect bad_alloc
+      #if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
+      using options_t = static_vector_options_t< throw_on_overflow<true> >;
+      #else
+      typedef static_vector_options
+         < throw_on_overflow<true> >::type options_t;
+      #endif
+
+      static_vector<int, Capacity, options_t> v;
+
+      v.resize(Capacity);
+      bool expected_type_thrown = false;
+      try{
+         v.push_back(0);
+      }
+      catch(std::bad_alloc&)
+      {
+         expected_type_thrown = true;
+      }
+      catch(...)
+      {}
+      BOOST_TEST(expected_type_thrown == true);
+      BOOST_TEST(v.capacity() == Capacity);
+   }
+   {  //throw_on_overflow == false, test it through BOOST_ASSERT
+      //even in release mode (BOOST_ENABLE_ASSERT_HANDLER), and throwing
+      //a special type in that assertion.
+      #if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
+      using options_t = static_vector_options_t< throw_on_overflow<false> >;
+      #else
+      typedef static_vector_options< throw_on_overflow<false> >::type options_t;
+      #endif
+
+      static_vector<int, Capacity, options_t> v;
+
+      v.resize(Capacity);
+      bool expected_type_thrown = false;
+      try{
+         v.push_back(0);
+      }
+      catch(throw_on_overflow_off)
+      {
+         expected_type_thrown = true;
+      }
+      catch(...)
+      {}
+      BOOST_TEST(expected_type_thrown == true);
+      BOOST_TEST(v.capacity() == Capacity);
+   }
+   #endif
+}
+
+int main()
+{
+   test_alignment();
+   test_throw_on_overflow();
+   return ::boost::report_errors();
+}
diff --git a/src/boost/libs/container/test/static_vector_test.cpp b/src/boost/libs/container/test/static_vector_test.cpp
new file mode 100644
index 000000000..f47df2e0c
--- /dev/null
+++ b/src/boost/libs/container/test/static_vector_test.cpp
@@ -0,0 +1,827 @@
+// Boost.Container static_vector
+// Unit Test
+
+// Copyright (c) 2012-2013 Adam Wulkiewicz, Lodz, Poland.
+// Copyright (c) 2012-2013 Andrew Hundt.
+
+// Use, modification and distribution is subject to 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/container/detail/config_begin.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <boost/core/no_exceptions_support.hpp>
+#include <boost/container/vector.hpp>
+#include <boost/container/stable_vector.hpp>
+#include <boost/container/detail/iterator.hpp>
+#include "../../intrusive/test/iterator_test.hpp"
+
+#include <vector>
+#include <list>
+
+#include "static_vector_test.hpp"
+
+
+template <typename T, size_t N>
+void test_ctor_ndc()
+{
+   static_vector<T, N> s;
+   BOOST_STATIC_ASSERT((static_vector<T, N>::static_capacity) == N);
+   BOOST_TEST_EQ(s.size() , 0u);
+   BOOST_TEST(s.capacity() == N);
+   BOOST_TEST(s.max_size() == N);
+   BOOST_TEST_THROWS( s.at(0u), std::out_of_range );
+}
+
+template <typename T, size_t N>
+void test_ctor_nc(size_t n)
+{
+   static_vector<T, N> s(n);
+   BOOST_STATIC_ASSERT((static_vector<T, N>::static_capacity) == N);
+   BOOST_TEST(s.size() == n);
+   BOOST_TEST(s.capacity() == N);
+   BOOST_TEST(s.max_size() == N);
+   BOOST_TEST_THROWS( s.at(n), std::out_of_range );
+   if ( 1 < n )
+   {
+      T val10(10);
+      s[0] = val10;
+      BOOST_TEST(T(10) == s[0]);
+      BOOST_TEST(T(10) == s.at(0));
+      T val20(20);
+      s.at(1) = val20;
+      BOOST_TEST(T(20) == s[1]);
+      BOOST_TEST(T(20) == s.at(1));
+   }
+}
+
+template <typename T, size_t N>
+void test_ctor_nd(size_t n, T const& v)
+{
+   static_vector<T, N> s(n, v);
+   BOOST_STATIC_ASSERT((static_vector<T, N>::static_capacity) == N);
+   BOOST_TEST(s.size() == n);
+   BOOST_TEST(s.capacity() == N);
+   BOOST_TEST_THROWS( s.at(n), std::out_of_range );
+   if ( 1 < n )
+   {
+      BOOST_TEST(v == s[0]);
+      BOOST_TEST(v == s.at(0));
+      BOOST_TEST(v == s[1]);
+      BOOST_TEST(v == s.at(1));
+      s[0] = T(10);
+      BOOST_TEST(T(10) == s[0]);
+      BOOST_TEST(T(10) == s.at(0));
+      s.at(1) = T(20);
+      BOOST_TEST(T(20) == s[1]);
+      BOOST_TEST(T(20) == s.at(1));
+   }
+}
+
+void test_support_for_initializer_list()
+{
+#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
+   {
+      static_vector<int, 2> sv = {10, 8};
+      BOOST_TEST(10 == sv[0]);
+      BOOST_TEST(8 == sv[1]);
+
+      typedef static_vector<int, 1> sv_cap_1;
+      BOOST_TEST_THROWS(sv_cap_1({1, 1}), std::bad_alloc);
+   }
+
+   {
+      static_vector<int, 2> sv;
+      sv.assign({1, 2});
+      BOOST_TEST(1 == sv[0]);
+      BOOST_TEST(2 == sv[1]);
+
+      BOOST_TEST_THROWS(sv.assign({1, 2, 3}), std::bad_alloc);
+
+      static_vector<int, 3> greaterThanSv = {1, 2, 3};
+      BOOST_TEST_THROWS(sv = greaterThanSv, std::bad_alloc);
+   }
+
+   {
+      static_vector<int, 2> sv;
+      sv.insert(sv.begin(), {99, 95});
+      BOOST_TEST(99 == sv[0]);
+      BOOST_TEST(95 == sv[1]);
+
+      BOOST_TEST_THROWS(sv.insert(sv.begin(), {101, 102, 103}), std::bad_alloc);
+   }
+#endif
+}
+
+template <typename T, size_t N>
+void test_resize_nc(size_t n)
+{
+   static_vector<T, N> s;
+
+   s.resize(n);
+   BOOST_TEST(s.size() == n);
+   BOOST_TEST(s.capacity() == N);
+   BOOST_TEST_THROWS( s.at(n), std::out_of_range );
+   if ( 1 < n )
+   {
+      T val10(10);
+      s[0] = val10;
+      BOOST_TEST(T(10) == s[0]);
+      BOOST_TEST(T(10) == s.at(0));
+      T val20(20);
+      s.at(1) = val20;
+      BOOST_TEST(T(20) == s[1]);
+      BOOST_TEST(T(20) == s.at(1));
+   }
+}
+
+template <typename T, size_t N>
+void test_resize_nd(size_t n, T const& v)
+{
+   static_vector<T, N> s;
+
+   s.resize(n, v);
+   BOOST_TEST(s.size() == n);
+   BOOST_TEST(s.capacity() == N);
+   BOOST_TEST_THROWS( s.at(n), std::out_of_range );
+   if ( 1 < n )
+   {
+      BOOST_TEST(v == s[0]);
+      BOOST_TEST(v == s.at(0));
+      BOOST_TEST(v == s[1]);
+      BOOST_TEST(v == s.at(1));
+      s[0] = T(10);
+      BOOST_TEST(T(10) == s[0]);
+      BOOST_TEST(T(10) == s.at(0));
+      s.at(1) = T(20);
+      BOOST_TEST(T(20) == s[1]);
+      BOOST_TEST(T(20) == s.at(1));
+   }
+}
+
+template <typename T, size_t N>
+void test_push_back_nd()
+{
+   static_vector<T, N> s;
+
+   BOOST_TEST(s.size() == 0);
+   BOOST_TEST_THROWS( s.at(0), std::out_of_range );
+
+   for ( size_t i = 0 ; i < N ; ++i )
+   {
+      T t(i);
+      s.push_back(t);
+      BOOST_TEST(s.size() == i + 1);
+      BOOST_TEST_THROWS( s.at(i + 1), std::out_of_range );
+      BOOST_TEST(T(i) == s.at(i));
+      BOOST_TEST(T(i) == s[i]);
+      BOOST_TEST(T(i) == s.back());
+      BOOST_TEST(T(0) == s.front());
+      BOOST_TEST(T(i) == *(s.data() + i));
+   }
+}
+
+template <typename T, size_t N>
+void test_pop_back_nd()
+{
+   static_vector<T, N> s;
+
+   for ( size_t i = 0 ; i < N ; ++i )
+   {
+      T t(i);
+      s.push_back(t);
+   }
+
+   for ( size_t i = N ; i > 1 ; --i )
+   {
+      s.pop_back();
+      BOOST_TEST(s.size() == i - 1);
+      BOOST_TEST_THROWS( s.at(i - 1), std::out_of_range );
+      BOOST_TEST(T(i - 2) == s.at(i - 2));
+      BOOST_TEST(T(i - 2) == s[i - 2]);
+      BOOST_TEST(T(i - 2) == s.back());
+      BOOST_TEST(T(0) == s.front());
+   }
+}
+
+template <typename It1, typename It2>
+void test_compare_ranges(It1 first1, It1 last1, It2 first2, It2 last2)
+{
+   BOOST_TEST(boost::container::iterator_distance(first1, last1) == boost::container::iterator_distance(first2, last2));
+   for ( ; first1 != last1 && first2 != last2 ; ++first1, ++first2 )
+      BOOST_TEST(*first1 == *first2);
+}
+
+template <typename T, size_t N, typename C>
+void test_copy_and_assign(C const& c)
+{
+   {
+      static_vector<T, N> s(c.begin(), c.end());
+      BOOST_TEST(s.size() == c.size());
+      test_compare_ranges(s.begin(), s.end(), c.begin(), c.end());
+   }
+   {
+      static_vector<T, N> s;
+      BOOST_TEST(0 == s.size());
+      s.assign(c.begin(), c.end());
+      BOOST_TEST(s.size() == c.size());
+      test_compare_ranges(s.begin(), s.end(), c.begin(), c.end());
+   }
+}
+
+template <typename T, size_t N>
+void test_copy_and_assign_nd(T const& val)
+{
+   static_vector<T, N> s;
+   std::vector<T> v;
+   std::list<T> l;
+
+   for ( size_t i = 0 ; i < N ; ++i )
+   {
+      T t(i);
+      s.push_back(t);
+      v.push_back(t);
+      l.push_back(t);
+   }
+   // copy ctor
+   {
+      static_vector<T, N> s1(s);
+      BOOST_TEST(s.size() == s1.size());
+      test_compare_ranges(s.begin(), s.end(), s1.begin(), s1.end());
+   }
+   // copy assignment
+   {
+      static_vector<T, N> s1;
+      BOOST_TEST(0 == s1.size());
+      s1 = s;
+      BOOST_TEST(s.size() == s1.size());
+      test_compare_ranges(s.begin(), s.end(), s1.begin(), s1.end());
+   }
+
+   // ctor(Iter, Iter) and assign(Iter, Iter)
+   test_copy_and_assign<T, N>(s);
+   test_copy_and_assign<T, N>(v);
+   test_copy_and_assign<T, N>(l);
+
+   // assign(N, V)
+   {
+      static_vector<T, N> s1(s);
+      test_compare_ranges(s.begin(), s.end(), s1.begin(), s1.end());
+      std::vector<T> a(N, val);
+      s1.assign(N, val);
+      test_compare_ranges(a.begin(), a.end(), s1.begin(), s1.end());
+   }
+
+   stable_vector<T> bsv(s.begin(), s.end());
+   vector<T> bv(s.begin(), s.end());
+   test_copy_and_assign<T, N>(bsv);
+   test_copy_and_assign<T, N>(bv);
+}
+
+template <typename T, size_t N>
+void test_iterators_nd()
+{
+   static_vector<T, N> s;
+   std::vector<T> v;
+
+   for ( size_t i = 0 ; i < N ; ++i )
+   {
+      s.push_back(T(i));
+      v.push_back(T(i));
+   }
+
+   test_compare_ranges(s.begin(), s.end(), v.begin(), v.end());
+   test_compare_ranges(s.rbegin(), s.rend(), v.rbegin(), v.rend());
+
+   s.assign(v.rbegin(), v.rend());
+
+   test_compare_ranges(s.begin(), s.end(), v.rbegin(), v.rend());
+   test_compare_ranges(s.rbegin(), s.rend(), v.begin(), v.end());
+}
+
+template <typename T, size_t N>
+void test_erase_nd()
+{
+   static_vector<T, N> s;
+   typedef typename static_vector<T, N>::iterator It;
+
+   for ( size_t i = 0 ; i < N ; ++i )
+      s.push_back(T(i));
+
+   // erase(pos)
+   {
+      for ( size_t i = 0 ; i < N ; ++i )
+      {
+          static_vector<T, N> s1(s);
+          It it = s1.erase(s1.begin() + i);
+          BOOST_TEST(s1.begin() + i == it);
+          BOOST_TEST(s1.size() == N - 1);
+          for ( size_t j = 0 ; j < i ; ++j )
+              BOOST_TEST(s1[j] == T(j));
+          for ( size_t j = i+1 ; j < N ; ++j )
+              BOOST_TEST(s1[j-1] == T(j));
+      }
+   }
+   // erase(first, last)
+   {
+      size_t n = N/3;
+      for ( size_t i = 0 ; i <= N ; ++i )
+      {
+          static_vector<T, N> s1(s);
+          size_t removed = i + n < N ? n : N - i;
+          It it = s1.erase(s1.begin() + i, s1.begin() + i + removed);
+          BOOST_TEST(s1.begin() + i == it);
+          BOOST_TEST(s1.size() == N - removed);
+          for ( size_t j = 0 ; j < i ; ++j )
+              BOOST_TEST(s1[j] == T(j));
+          for ( size_t j = i+n ; j < N ; ++j )
+              BOOST_TEST(s1[j-n] == T(j));
+      }
+   }
+}
+
+template <typename T, size_t N, typename SV, typename C>
+void test_insert(SV const& s, C const& c)
+{
+   size_t h = N/2;
+   size_t n = size_t(h/1.5f);
+
+   for ( size_t i = 0 ; i <= h ; ++i )
+   {
+      static_vector<T, N> s1(s);
+
+      typename C::const_iterator it = c.begin();
+      boost::container::iterator_advance(it, n);
+      typename static_vector<T, N>::iterator
+          it1 = s1.insert(s1.begin() + i, c.begin(), it);
+
+      BOOST_TEST(s1.begin() + i == it1);
+      BOOST_TEST(s1.size() == h+n);
+      for ( size_t j = 0 ; j < i ; ++j )
+          BOOST_TEST(s1[j] == T(j));
+      for ( size_t j = 0 ; j < n ; ++j )
+          BOOST_TEST(s1[j+i] == T(100 + j));
+      for ( size_t j = 0 ; j < h-i ; ++j )
+          BOOST_TEST(s1[j+i+n] == T(j+i));
+   }
+}
+
+template <typename T, size_t N>
+void test_insert_nd(T const& val)
+{
+   size_t h = N/2;
+
+   static_vector<T, N> s, ss;
+   std::vector<T> v;
+   std::list<T> l;
+
+   typedef typename static_vector<T, N>::iterator It;
+
+   for ( size_t i = 0 ; i < h ; ++i )
+   {
+      s.push_back(T(i));
+      ss.push_back(T(100 + i));
+      v.push_back(T(100 + i));
+      l.push_back(T(100 + i));
+   }
+
+   // insert(pos, val)
+   {
+      for ( size_t i = 0 ; i <= h ; ++i )
+      {
+          static_vector<T, N> s1(s);
+          It it = s1.insert(s1.begin() + i, val);
+          BOOST_TEST(s1.begin() + i == it);
+          BOOST_TEST(s1.size() == h+1);
+          for ( size_t j = 0 ; j < i ; ++j )
+              BOOST_TEST(s1[j] == T(j));
+          BOOST_TEST(s1[i] == val);
+          for ( size_t j = 0 ; j < h-i ; ++j )
+              BOOST_TEST(s1[j+i+1] == T(j+i));
+      }
+   }
+   // insert(pos, n, val)
+   {
+      size_t n = size_t(h/1.5f);
+      for ( size_t i = 0 ; i <= h ; ++i )
+      {
+          static_vector<T, N> s1(s);
+          It it = s1.insert(s1.begin() + i, n, val);
+          BOOST_TEST(s1.begin() + i == it);
+          BOOST_TEST(s1.size() == h+n);
+          for ( size_t j = 0 ; j < i ; ++j )
+              BOOST_TEST(s1[j] == T(j));
+          for ( size_t j = 0 ; j < n ; ++j )
+              BOOST_TEST(s1[j+i] == val);
+          for ( size_t j = 0 ; j < h-i ; ++j )
+              BOOST_TEST(s1[j+i+n] == T(j+i));
+      }
+   }
+   // insert(pos, first, last)
+   test_insert<T, N>(s, ss);
+   test_insert<T, N>(s, v);
+   test_insert<T, N>(s, l);
+
+   stable_vector<T> bsv(ss.begin(), ss.end());
+   vector<T> bv(ss.begin(), ss.end());
+   test_insert<T, N>(s, bv);
+   test_insert<T, N>(s, bsv);
+}
+
+template <typename T>
+void test_capacity_0_nd()
+{
+   static_vector<T, 10> v(5u, T(0));
+
+   static_vector<T, 0 > s;
+   BOOST_TEST(s.size() == 0);
+   BOOST_TEST(s.capacity() == 0);
+   BOOST_TEST_THROWS(s.at(0), std::out_of_range);
+   BOOST_TEST_THROWS(s.resize(5u, T(0)), std::bad_alloc);
+   BOOST_TEST_THROWS(s.push_back(T(0)), std::bad_alloc);
+   BOOST_TEST_THROWS(s.insert(s.end(), T(0)), std::bad_alloc);
+   BOOST_TEST_THROWS(s.insert(s.end(), 5u, T(0)), std::bad_alloc);
+   BOOST_TEST_THROWS(s.insert(s.end(), v.begin(), v.end()), std::bad_alloc);
+   BOOST_TEST_THROWS(s.assign(v.begin(), v.end()), std::bad_alloc);
+   BOOST_TEST_THROWS(s.assign(5u, T(0)), std::bad_alloc);
+   BOOST_TEST_THROWS(s.assign(5u, T(0)), std::bad_alloc);
+   typedef static_vector<T, 0> static_vector_0_t;
+   BOOST_TEST_THROWS(static_vector_0_t s2(v.begin(), v.end()), std::bad_alloc);
+   BOOST_TEST_THROWS(static_vector_0_t s1(5u, T(0)), std::bad_alloc);
+}
+
+template <typename T, size_t N>
+void test_exceptions_nd()
+{
+   static_vector<T, N> v(N, T(0));
+   static_vector<T, N/2> s(N/2, T(0));
+
+   BOOST_TEST_THROWS(s.resize(N, T(0)), std::bad_alloc);
+   BOOST_TEST_THROWS(s.push_back(T(0)), std::bad_alloc);
+   BOOST_TEST_THROWS(s.insert(s.end(), T(0)), std::bad_alloc);
+   BOOST_TEST_THROWS(s.insert(s.end(), 1, T(0)), std::bad_alloc);
+   BOOST_TEST_THROWS(s.insert(s.end(), v.begin(), v.end()), std::bad_alloc);
+   BOOST_TEST_THROWS(s.assign(v.begin(), v.end()), std::bad_alloc);
+   BOOST_TEST_THROWS(s.assign(N, T(0)), std::bad_alloc);
+   typedef static_vector<T, N/2> static_vector_n_half_t;
+   BOOST_TEST_THROWS(static_vector_n_half_t s2(v.begin(), v.end()), std::bad_alloc);
+   BOOST_TEST_THROWS(static_vector_n_half_t s1(N/2+1, T(0)), std::bad_alloc);
+}
+
+template <typename T, size_t N>
+void test_swap_and_move_nd()
+{
+   {
+      static_vector<T, N> v1, v2, v3, v4;
+      static_vector<T, N> s1, s2;
+      static_vector<T, N> s4;
+
+      for (size_t i = 0 ; i < N ; ++i )
+      {
+          v1.push_back(T(i));
+          v2.push_back(T(i));
+          v3.push_back(T(i));
+          v4.push_back(T(i));
+      }
+      for (size_t i = 0 ; i < N/2 ; ++i )
+      {
+          s1.push_back(T(100 + i));
+          s2.push_back(T(100 + i));
+          s4.push_back(T(100 + i));
+      }
+
+      s1.swap(v1);
+      s2 = boost::move(v2);
+      static_vector<T, N> s3(boost::move(v3));
+      s4.swap(v4);
+
+      BOOST_TEST(v1.size() == N/2);
+      BOOST_TEST(s1.size() == N);
+      //iG moving does not imply emptying source
+      //BOOST_TEST(v2.size() == 0);
+      BOOST_TEST(s2.size() == N);
+      //iG moving does not imply emptying source
+      //BOOST_TEST(v3.size() == 0);
+      BOOST_TEST(s3.size() == N);
+      BOOST_TEST(v4.size() == N/2);
+      BOOST_TEST(s4.size() == N);
+      for (size_t i = 0 ; i < N/2 ; ++i )
+      {
+          BOOST_TEST(v1[i] == T(100 + i));
+          BOOST_TEST(v4[i] == T(100 + i));
+      }
+      for (size_t i = 0 ; i < N ; ++i )
+      {
+          BOOST_TEST(s1[i] == T(i));
+          BOOST_TEST(s2[i] == T(i));
+          BOOST_TEST(s3[i] == T(i));
+          BOOST_TEST(s4[i] == T(i));
+      }
+   }
+   {
+      static_vector<T, N> v1, v2, v3;
+      static_vector<T, N/2> s1, s2, s3;
+
+      for (size_t i = 0 ; i < N/2 ; ++i )
+      {
+          v1.push_back(T(i));
+          v2.push_back(T(i));
+          v3.push_back(T(i));
+      }
+      for (size_t i = 0 ; i < N/3 ; ++i )
+      {
+          s1.push_back(T(100 + i));
+          s2.push_back(T(100 + i));
+      }
+
+      s1.swap(v1);
+      s3 = v2;
+      s2 = boost::move(v2);
+      static_vector<T, N/2> s4(boost::move(v3));
+
+      BOOST_TEST(v1.size() == N/3);
+      BOOST_TEST(s1.size() == N/2);
+      //iG moving does not imply emptying source
+      //BOOST_TEST(v2.size() == 0);
+      BOOST_TEST(s2.size() == N/2);
+      BOOST_TEST(s3.size() == N/2);
+      //iG moving does not imply emptying source
+      //BOOST_TEST(v3.size() == 0);
+      BOOST_TEST(s4.size() == N/2);
+      for (size_t i = 0 ; i < N/3 ; ++i )
+          BOOST_TEST(v1[i] == T(100 + i));
+      for (size_t i = 0 ; i < N/2 ; ++i )
+      {
+          BOOST_TEST(s1[i] == T(i));
+          BOOST_TEST(s2[i] == T(i));
+          BOOST_TEST(s3[i] == T(i));
+          BOOST_TEST(s4[i] == T(i));
+      }
+   }
+   {
+      typedef static_vector<T, N/2> small_vector_t;
+      static_vector<T, N> v(N, T(0));
+      small_vector_t s(N/2, T(1));
+      BOOST_TEST_THROWS(s.swap(v), std::bad_alloc);
+      v.resize(N, T(0));
+      BOOST_TEST_THROWS(s = boost::move(v), std::bad_alloc);
+      BOOST_TEST_THROWS(s = v, std::bad_alloc);
+      v.resize(N, T(0));
+      BOOST_TEST_THROWS(small_vector_t s2(boost::move(v)), std::bad_alloc);
+   }
+}
+
+template <typename T, size_t N>
+void test_emplace_0p()
+{
+   //emplace_back()
+   {
+      static_vector<T, N> v;
+
+      for (int i = 0 ; i < int(N) ; ++i )
+          v.emplace_back();
+      BOOST_TEST(v.size() == N);
+      BOOST_TEST_THROWS(v.emplace_back(), std::bad_alloc);
+   }
+}
+
+template <typename T, size_t N>
+void test_emplace_2p()
+{
+   //emplace_back(pos, int, int)
+   {
+      static_vector<T, N> v;
+
+      for (int i = 0 ; i < int(N) ; ++i )
+          v.emplace_back(i, 100 + i);
+      BOOST_TEST(v.size() == N);
+      BOOST_TEST_THROWS(v.emplace_back(N, 100 + N), std::bad_alloc);
+      BOOST_TEST(v.size() == N);
+      for (int i = 0 ; i < int(N) ; ++i )
+          BOOST_TEST(v[i] == T(i, 100 + i));
+   }
+
+   // emplace(pos, int, int)
+   {
+      typedef typename static_vector<T, N>::iterator It;
+
+      int h = N / 2;
+
+      static_vector<T, N> v;
+      for ( int i = 0 ; i < h ; ++i )
+          v.emplace_back(i, 100 + i);
+
+      for ( int i = 0 ; i <= h ; ++i )
+      {
+          static_vector<T, N> vv(v);
+          It it = vv.emplace(vv.begin() + i, i+100, i+200);
+          BOOST_TEST(vv.begin() + i == it);
+          BOOST_TEST(vv.size() == size_t(h+1));
+          for ( int j = 0 ; j < i ; ++j )
+              BOOST_TEST(vv[j] == T(j, j+100));
+          BOOST_TEST(vv[i] == T(i+100, i+200));
+          for ( int j = 0 ; j < h-i ; ++j )
+              BOOST_TEST(vv[j+i+1] == T(j+i, j+i+100));
+      }
+   }
+}
+
+template <typename T, size_t N>
+void test_sv_elem(T const& t)
+{
+   typedef static_vector<T, N> V;
+
+   static_vector<V, N> v;
+
+   v.push_back(V(N/2, t));
+   V vvv(N/2, t);
+   v.push_back(boost::move(vvv));
+   v.insert(v.begin(), V(N/2, t));
+   v.insert(v.end(), V(N/2, t));
+   v.emplace_back(N/2, t);
+}
+
+bool default_init_test()//Test for default initialization
+{
+   const std::size_t Capacity = 100;
+
+   typedef static_vector<int, Capacity> di_vector_t;
+
+   {
+      di_vector_t v(Capacity, default_init);
+   }
+   {
+      di_vector_t v;
+      int *p = v.data();
+
+      for(std::size_t i = 0; i != Capacity; ++i, ++p){
+         *p = static_cast<int>(i);
+      }
+
+      //Destroy the vector, p still pointing to the storage
+      v.~di_vector_t();
+
+      di_vector_t &rv = *::new(&v)di_vector_t(Capacity, default_init);
+      di_vector_t::iterator it = rv.begin();
+
+      for(std::size_t i = 0; i != Capacity; ++i, ++it){
+         if(*it != static_cast<int>(i))
+            return false;
+      }
+
+      v.~di_vector_t();
+   }
+   {
+      di_vector_t v;
+
+      int *p = v.data();
+      for(std::size_t i = 0; i != Capacity; ++i, ++p){
+         *p = static_cast<int>(i+100);
+      }
+
+      v.resize(Capacity, default_init);
+
+      di_vector_t::iterator it = v.begin();
+      for(std::size_t i = 0; i != Capacity; ++i, ++it){
+         if(*it != static_cast<int>(i+100))
+            return false;
+      }
+   }
+
+   return true;
+}
+
+
+int main(int, char* [])
+{
+   using boost::container::test::movable_and_copyable_int;
+   using boost::container::test::produce_movable_and_copyable_int;
+   BOOST_TEST(counting_value::count() == 0);
+
+   test_ctor_ndc<int, 10>();
+   test_ctor_ndc<value_ndc, 10>();
+   test_ctor_ndc<counting_value, 10>();
+   BOOST_TEST(counting_value::count() == 0);
+   test_ctor_ndc<shptr_value, 10>();
+   test_ctor_ndc<movable_and_copyable_int, 10>();
+
+   test_ctor_nc<int, 10>(5);
+   test_ctor_nc<value_nc, 10>(5);
+   test_ctor_nc<counting_value, 10>(5);
+   BOOST_TEST(counting_value::count() == 0);
+   test_ctor_nc<shptr_value, 10>(5);
+   test_ctor_nc<movable_and_copyable_int, 10>(5);
+
+   test_ctor_nd<int, 10>(5, 1);
+   test_ctor_nd<value_nd, 10>(5, value_nd(1));
+   test_ctor_nd<counting_value, 10>(5, counting_value(1));
+   BOOST_TEST(counting_value::count() == 0);
+   test_ctor_nd<shptr_value, 10>(5, shptr_value(1));
+   test_ctor_nd<movable_and_copyable_int, 10>(5, produce_movable_and_copyable_int());
+
+   test_resize_nc<int, 10>(5);
+   test_resize_nc<value_nc, 10>(5);
+   test_resize_nc<counting_value, 10>(5);
+   BOOST_TEST(counting_value::count() == 0);
+   test_resize_nc<shptr_value, 10>(5);
+   test_resize_nc<movable_and_copyable_int, 10>(5);
+
+   test_resize_nd<int, 10>(5, 1);
+   test_resize_nd<value_nd, 10>(5, value_nd(1));
+   test_resize_nd<counting_value, 10>(5, counting_value(1));
+   BOOST_TEST(counting_value::count() == 0);
+   test_resize_nd<shptr_value, 10>(5, shptr_value(1));
+   test_resize_nd<movable_and_copyable_int, 10>(5, produce_movable_and_copyable_int());
+
+   test_push_back_nd<int, 10>();
+   test_push_back_nd<value_nd, 10>();
+   test_push_back_nd<counting_value, 10>();
+   BOOST_TEST(counting_value::count() == 0);
+   test_push_back_nd<shptr_value, 10>();
+   test_push_back_nd<movable_and_copyable_int, 10>();
+
+   test_pop_back_nd<int, 10>();
+   test_pop_back_nd<value_nd, 10>();
+   test_pop_back_nd<counting_value, 10>();
+   BOOST_TEST(counting_value::count() == 0);
+   test_pop_back_nd<shptr_value, 10>();
+   test_pop_back_nd<movable_and_copyable_int, 10>();
+
+   test_copy_and_assign_nd<int, 10>(1);
+   test_copy_and_assign_nd<value_nd, 10>(value_nd(1));
+   test_copy_and_assign_nd<counting_value, 10>(counting_value(1));
+   BOOST_TEST(counting_value::count() == 0);
+   test_copy_and_assign_nd<shptr_value, 10>(shptr_value(1));
+   test_copy_and_assign_nd<movable_and_copyable_int, 10>(produce_movable_and_copyable_int());
+
+   test_iterators_nd<int, 10>();
+   test_iterators_nd<value_nd, 10>();
+   test_iterators_nd<counting_value, 10>();
+   BOOST_TEST(counting_value::count() == 0);
+   test_iterators_nd<shptr_value, 10>();
+   test_iterators_nd<movable_and_copyable_int, 10>();
+
+   test_erase_nd<int, 10>();
+   test_erase_nd<value_nd, 10>();
+   test_erase_nd<counting_value, 10>();
+   BOOST_TEST(counting_value::count() == 0);
+   test_erase_nd<shptr_value, 10>();
+   test_erase_nd<movable_and_copyable_int, 10>();
+
+   test_insert_nd<int, 10>(50);
+   test_insert_nd<value_nd, 10>(value_nd(50));
+   test_insert_nd<counting_value, 10>(counting_value(50));
+   BOOST_TEST(counting_value::count() == 0);
+   test_insert_nd<shptr_value, 10>(shptr_value(50));
+   test_insert_nd<movable_and_copyable_int, 10>(produce_movable_and_copyable_int());
+
+   test_capacity_0_nd<int>();
+   test_capacity_0_nd<value_nd>();
+   test_capacity_0_nd<counting_value>();
+   BOOST_TEST(counting_value::count() == 0);
+   test_capacity_0_nd<shptr_value>();
+   test_capacity_0_nd<movable_and_copyable_int>();
+
+   test_exceptions_nd<int, 10>();
+   test_exceptions_nd<value_nd, 10>();
+   test_exceptions_nd<counting_value, 10>();
+   BOOST_TEST(counting_value::count() == 0);
+   test_exceptions_nd<shptr_value, 10>();
+   test_exceptions_nd<movable_and_copyable_int, 10>();
+
+   test_swap_and_move_nd<int, 10>();
+   test_swap_and_move_nd<value_nd, 10>();
+   test_swap_and_move_nd<counting_value, 10>();
+   BOOST_TEST(counting_value::count() == 0);
+   test_swap_and_move_nd<shptr_value, 10>();
+   test_swap_and_move_nd<movable_and_copyable_int, 10>();
+
+   test_emplace_0p<counting_value, 10>();
+   BOOST_TEST(counting_value::count() == 0);
+
+   test_emplace_2p<counting_value, 10>();
+   BOOST_TEST(counting_value::count() == 0);
+
+   test_sv_elem<int, 10>(50);
+   test_sv_elem<value_nd, 10>(value_nd(50));
+   test_sv_elem<counting_value, 10>(counting_value(50));
+   BOOST_TEST(counting_value::count() == 0);
+   test_sv_elem<shptr_value, 10>(shptr_value(50));
+   test_sv_elem<movable_and_copyable_int, 10>(movable_and_copyable_int(50));
+
+   BOOST_TEST(default_init_test() == true);
+
+   test_support_for_initializer_list();
+
+   ////////////////////////////////////
+   //    Iterator testing
+   ////////////////////////////////////
+   {
+      typedef boost::container::static_vector<int, 3> cont_int;
+      cont_int a; a.push_back(0); a.push_back(1); a.push_back(2);
+      boost::intrusive::test::test_iterator_random< cont_int >(a);
+   }
+
+   return boost::report_errors();
+}
+
+#include <boost/container/detail/config_end.hpp>
diff --git a/src/boost/libs/container/test/static_vector_test.hpp b/src/boost/libs/container/test/static_vector_test.hpp
new file mode 100644
index 000000000..ab931b274
--- /dev/null
+++ b/src/boost/libs/container/test/static_vector_test.hpp
@@ -0,0 +1,103 @@
+// Boost.Container static_vector
+// Unit Test
+
+// Copyright (c) 2012-2013 Adam Wulkiewicz, Lodz, Poland.
+// Copyright (c) 2012-2013 Andrew Hundt.
+
+// Use, modification and distribution is subject to 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)
+
+#ifndef BOOST_CONTAINER_TEST_STATIC_VECTOR_TEST_HPP
+#define BOOST_CONTAINER_TEST_STATIC_VECTOR_TEST_HPP
+
+#include <boost/container/static_vector.hpp>
+
+#define BOOST_SP_DISABLE_THREADS
+#include <boost/shared_ptr.hpp>
+#include "movable_int.hpp"
+
+using namespace boost::container;
+
+class value_ndc
+{
+public:
+    explicit value_ndc(int a) : aa(a) {}
+    ~value_ndc() {}
+    bool operator==(value_ndc const& v) const { return aa == v.aa; }
+    bool operator<(value_ndc const& v) const { return aa < v.aa; }
+private:
+    value_ndc(value_ndc const&) {}
+    value_ndc & operator=(value_ndc const&) { return *this; }
+    int aa;
+};
+
+class value_nd
+{
+public:
+    explicit value_nd(int a) : aa(a) {}
+    ~value_nd() {}
+    bool operator==(value_nd const& v) const { return aa == v.aa; }
+    bool operator<(value_nd const& v) const { return aa < v.aa; }
+private:
+    int aa;
+};
+
+class value_nc
+{
+public:
+    explicit value_nc(int a = 0) : aa(a) {}
+    ~value_nc() {}
+    bool operator==(value_nc const& v) const { return aa == v.aa; }
+    bool operator<(value_nc const& v) const { return aa < v.aa; }
+private:
+    value_nc(value_nc const&) {}
+    value_nc & operator=(value_ndc const&) { return *this; }
+    int aa;
+};
+
+class counting_value
+{
+    BOOST_COPYABLE_AND_MOVABLE(counting_value)
+
+public:
+    explicit counting_value(int a = 0, int b = 0) : aa(a), bb(b) { ++c(); }
+    counting_value(counting_value const& v) : aa(v.aa), bb(v.bb) { ++c(); }
+    counting_value(BOOST_RV_REF(counting_value) p) : aa(p.aa), bb(p.bb) { p.aa = 0; p.bb = 0; ++c(); }                      // Move constructor
+    counting_value& operator=(BOOST_RV_REF(counting_value) p) { aa = p.aa; p.aa = 0; bb = p.bb; p.bb = 0; return *this; }   // Move assignment
+    counting_value& operator=(BOOST_COPY_ASSIGN_REF(counting_value) p) { aa = p.aa; bb = p.bb; return *this; }              // Copy assignment
+    ~counting_value() { --c(); }
+    bool operator==(counting_value const& v) const { return aa == v.aa && bb == v.bb; }
+    bool operator<(counting_value const& v) const { return aa < v.aa || ( aa == v.aa && bb < v.bb ); }
+    static size_t count() { return c(); }
+
+private:
+    static size_t & c() { static size_t co = 0; return co; }
+    int aa, bb;
+};
+
+namespace boost {
+
+template <class T>
+struct has_nothrow_move;
+
+template <>
+struct has_nothrow_move<counting_value>
+{
+    static const bool value = true;
+};
+
+}
+
+class shptr_value
+{
+    typedef boost::shared_ptr<int> Ptr;
+public:
+    explicit shptr_value(int a = 0) : m_ptr(new int(a)) {}
+    bool operator==(shptr_value const& v) const { return *m_ptr == *(v.m_ptr); }
+    bool operator<(shptr_value const& v) const { return *m_ptr < *(v.m_ptr); }
+private:
+    boost::shared_ptr<int> m_ptr;
+};
+
+#endif // BOOST_CONTAINER_TEST_STATIC_VECTOR_TEST_HPP
diff --git a/src/boost/libs/container/test/string_test.cpp b/src/boost/libs/container/test/string_test.cpp
new file mode 100644
index 000000000..b2d17f6aa
--- /dev/null
+++ b/src/boost/libs/container/test/string_test.cpp
@@ -0,0 +1,596 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2004-2013. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/container for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#include <boost/container/detail/config_begin.hpp>
+#include <boost/container/vector.hpp>
+#include <boost/container/string.hpp>
+#include <string>
+#include <vector>
+#include <boost/container/detail/algorithm.hpp> //equal()
+#include <cstring>
+#include <cstdio>
+#include <cstddef>
+#include <new>
+#include "dummy_test_allocator.hpp"
+#include "check_equal_containers.hpp"
+#include "expand_bwd_test_allocator.hpp"
+#include "expand_bwd_test_template.hpp"
+#include "propagate_allocator_test.hpp"
+#include "default_init_test.hpp"
+#include "comparison_test.hpp"
+#include "../../intrusive/test/iterator_test.hpp"
+#include <boost/utility/string_view.hpp>
+#include <boost/core/lightweight_test.hpp>
+
+using namespace boost::container;
+
+struct StringEqual
+{
+   template<class Str1, class Str2>
+   bool operator ()(const Str1 &string1, const Str2 &string2) const
+   {
+      if(string1.size() != string2.size())
+         return false;
+      return std::char_traits<typename Str1::value_type>::compare
+         (string1.c_str(), string2.c_str(), string1.size()) == 0;
+   }
+};
+
+//Function to check if both lists are equal
+template<class StrVector1, class StrVector2>
+bool CheckEqualStringVector(StrVector1 *strvect1, StrVector2 *strvect2)
+{
+   StringEqual comp;
+   return boost::container::algo_equal(strvect1->begin(), strvect1->end(),
+                     strvect2->begin(), comp);
+}
+
+template<class ForwardIt>
+ForwardIt unique(ForwardIt first, ForwardIt const last)
+{
+   if(first == last){
+      ForwardIt i = first;
+      //Find first adjacent pair
+      while(1){
+         if(++i == last){
+            return last;
+         }
+         else if(*first == *i){
+            break;
+         }
+         ++first;
+      }
+      //Now overwrite skipping adjacent elements
+      while (++i != last) {
+         if (!(*first == *i)) {
+            *(++first) = boost::move(*i);
+         }
+      }
+      ++first;
+   }
+   return first;
+}
+
+template<class CharType>
+struct string_literals;
+
+template<>
+struct string_literals<char>
+{
+   static const char *String()
+      {  return "String";  }
+   static const char *Prefix()
+      {  return "Prefix";  }
+   static const char *Suffix()
+      {  return "Suffix";  }
+   static const char *LongString()
+      {  return "LongLongLongLongLongLongLongLongLongLongLongLongLongString";  }
+   static char Char()
+      {  return 'C';  }
+   static void sprintf_number(char *buf, int number)
+   {
+      std::sprintf(buf, "%i", number);
+   }
+};
+
+template<>
+struct string_literals<wchar_t>
+{
+   static const wchar_t *String()
+      {  return L"String";  }
+   static const wchar_t *Prefix()
+      {  return L"Prefix";  }
+   static const wchar_t *Suffix()
+      {  return L"Suffix";  }
+   static const wchar_t *LongString()
+      {  return L"LongLongLongLongLongLongLongLongLongLongLongLongLongString";  }
+   static wchar_t Char()
+      {  return L'C';  }
+   static void sprintf_number(wchar_t *buffer, unsigned int number)
+   {
+      //For compilers without wsprintf, print it backwards
+      const wchar_t *digits = L"0123456789";
+      wchar_t *buf = buffer;
+
+      while(1){
+         int rem = number % 10;
+         number  = number / 10;
+
+         *buf = digits[rem];
+         ++buf;
+         if(!number){
+            *buf = 0;
+            break;
+         }
+      }
+
+   }
+};
+
+template<class CharType>
+int string_test()
+{
+   typedef std::basic_string<CharType> StdString;
+   typedef vector<StdString>  StdStringVector;
+   typedef basic_string<CharType> BoostString;
+   typedef vector<BoostString> BoostStringVector;
+
+   const int MaxSize = 100;
+
+   {
+      BoostStringVector *boostStringVect = new BoostStringVector;
+      StdStringVector *stdStringVect = new StdStringVector;
+      BoostString auxBoostString;
+      StdString auxStdString(StdString(auxBoostString.begin(), auxBoostString.end() ));
+
+      CharType buffer [20];
+
+      //First, push back
+      for(int i = 0; i < MaxSize; ++i){
+         auxBoostString = string_literals<CharType>::String();
+         auxStdString = string_literals<CharType>::String();
+         string_literals<CharType>::sprintf_number(buffer, i);
+         auxBoostString += buffer;
+         auxStdString += buffer;
+         boostStringVect->push_back(auxBoostString);
+         stdStringVect->push_back(auxStdString);
+      }
+
+      if(auxBoostString.data() != const_cast<const BoostString&>(auxBoostString).data() &&
+         auxBoostString.data() != &auxBoostString[0])
+         return 1;
+
+      if(!CheckEqualStringVector(boostStringVect, stdStringVect)){
+         return 1;
+      }
+
+      //Now push back moving
+      for(int i = 0; i < MaxSize; ++i){
+         auxBoostString = string_literals<CharType>::String();
+         auxStdString = string_literals<CharType>::String();
+         string_literals<CharType>::sprintf_number(buffer, i);
+         auxBoostString += buffer;
+         auxStdString += buffer;
+         boostStringVect->push_back(boost::move(auxBoostString));
+         stdStringVect->push_back(auxStdString);
+      }
+
+      if(!CheckEqualStringVector(boostStringVect, stdStringVect)){
+         return 1;
+      }
+
+      //push front
+      for(int i = 0; i < MaxSize; ++i){
+         auxBoostString = string_literals<CharType>::String();
+         auxStdString = string_literals<CharType>::String();
+         string_literals<CharType>::sprintf_number(buffer, i);
+         auxBoostString += buffer;
+         auxStdString += buffer;
+         boostStringVect->insert(boostStringVect->begin(), auxBoostString);
+         stdStringVect->insert(stdStringVect->begin(), auxStdString);
+      }
+
+      if(!CheckEqualStringVector(boostStringVect, stdStringVect)){
+         return 1;
+      }
+
+      //Now push front moving
+      for(int i = 0; i < MaxSize; ++i){
+         auxBoostString = string_literals<CharType>::String();
+         auxStdString = string_literals<CharType>::String();
+         string_literals<CharType>::sprintf_number(buffer, i);
+         auxBoostString += buffer;
+         auxStdString += buffer;
+         boostStringVect->insert(boostStringVect->begin(), boost::move(auxBoostString));
+         stdStringVect->insert(stdStringVect->begin(), auxStdString);
+      }
+
+      if(!CheckEqualStringVector(boostStringVect, stdStringVect)){
+         return 1;
+      }
+
+      //Now test long and short representation swapping
+
+      //Short first
+      auxBoostString = string_literals<CharType>::String();
+      auxStdString = string_literals<CharType>::String();
+      BoostString boost_swapper;
+      StdString std_swapper;
+      boost_swapper.swap(auxBoostString);
+      std_swapper.swap(auxStdString);
+      if(!StringEqual()(auxBoostString, auxStdString))
+         return 1;
+      if(!StringEqual()(boost_swapper, std_swapper))
+         return 1;
+      boost_swapper.swap(auxBoostString);
+      std_swapper.swap(auxStdString);
+      if(!StringEqual()(auxBoostString, auxStdString))
+         return 1;
+      if(!StringEqual()(boost_swapper, std_swapper))
+         return 1;
+
+      //Shrink_to_fit
+      auxBoostString.shrink_to_fit();
+      StdString(auxStdString).swap(auxStdString);
+      if(!StringEqual()(auxBoostString, auxStdString))
+         return 1;
+
+      //Reserve + shrink_to_fit
+      auxBoostString.reserve(boost_swapper.size()*2+1);
+      auxStdString.reserve(std_swapper.size()*2+1);
+      if(!StringEqual()(auxBoostString, auxStdString))
+         return 1;
+
+      auxBoostString.shrink_to_fit();
+      StdString(auxStdString).swap(auxStdString);
+      if(!StringEqual()(auxBoostString, auxStdString))
+         return 1;
+
+      //Long string
+      auxBoostString = string_literals<CharType>::LongString();
+      auxStdString   = string_literals<CharType>::LongString();
+      boost_swapper = BoostString();
+      std_swapper = StdString();
+      boost_swapper.swap(auxBoostString);
+      std_swapper.swap(auxStdString);
+      if(!StringEqual()(auxBoostString, auxStdString))
+         return 1;
+      if(!StringEqual()(boost_swapper, std_swapper))
+         return 1;
+      boost_swapper.swap(auxBoostString);
+      std_swapper.swap(auxStdString);
+
+      //Shrink_to_fit
+      auxBoostString.shrink_to_fit();
+      StdString(auxStdString).swap(auxStdString);
+      if(!StringEqual()(auxBoostString, auxStdString))
+         return 1;
+
+      auxBoostString.clear();
+      auxStdString.clear();
+      auxBoostString.shrink_to_fit();
+      StdString(auxStdString).swap(auxStdString);
+      if(!StringEqual()(auxBoostString, auxStdString))
+         return 1;
+
+      //No sort
+      std::sort(boostStringVect->begin(), boostStringVect->end());
+      std::sort(stdStringVect->begin(), stdStringVect->end());
+      if(!CheckEqualStringVector(boostStringVect, stdStringVect)) return 1;
+
+      const CharType *prefix    = string_literals<CharType>::Prefix();
+      const int  prefix_size    = std::char_traits<CharType>::length(prefix);
+      const CharType *sufix      = string_literals<CharType>::Suffix();
+
+      for(int i = 0; i < MaxSize; ++i){
+         (*boostStringVect)[i].append(sufix);
+         (*stdStringVect)[i].append(sufix);
+         (*boostStringVect)[i].insert((*boostStringVect)[i].begin(),
+                                    prefix, prefix + prefix_size);
+         (*stdStringVect)[i].insert((*stdStringVect)[i].begin(),
+                                    prefix, prefix + prefix_size);
+      }
+
+      if(!CheckEqualStringVector(boostStringVect, stdStringVect)) return 1;
+
+      for(int i = 0; i < MaxSize; ++i){
+         std::reverse((*boostStringVect)[i].begin(), (*boostStringVect)[i].end());
+         std::reverse((*stdStringVect)[i].begin(), (*stdStringVect)[i].end());
+      }
+
+      if(!CheckEqualStringVector(boostStringVect, stdStringVect)) return 1;
+
+      for(int i = 0; i < MaxSize; ++i){
+         std::reverse((*boostStringVect)[i].begin(), (*boostStringVect)[i].end());
+         std::reverse((*stdStringVect)[i].begin(), (*stdStringVect)[i].end());
+      }
+
+      if(!CheckEqualStringVector(boostStringVect, stdStringVect)) return 1;
+
+      for(int i = 0; i < MaxSize; ++i){
+         std::sort(boostStringVect->begin(), boostStringVect->end());
+         std::sort(stdStringVect->begin(), stdStringVect->end());
+      }
+
+      if(!CheckEqualStringVector(boostStringVect, stdStringVect)) return 1;
+
+      for(int i = 0; i < MaxSize; ++i){
+         (*boostStringVect)[i].replace((*boostStringVect)[i].begin(),
+                                    (*boostStringVect)[i].end(),
+                                    string_literals<CharType>::String());
+         (*stdStringVect)[i].replace((*stdStringVect)[i].begin(),
+                                    (*stdStringVect)[i].end(),
+                                    string_literals<CharType>::String());
+      }
+
+      if(!CheckEqualStringVector(boostStringVect, stdStringVect)) return 1;
+
+      boostStringVect->erase(::unique(boostStringVect->begin(), boostStringVect->end()),
+                           boostStringVect->end());
+      stdStringVect->erase(::unique(stdStringVect->begin(), stdStringVect->end()),
+                           stdStringVect->end());
+      if(!CheckEqualStringVector(boostStringVect, stdStringVect)) return 1;
+
+      //Check addition
+      {
+         BoostString bs2 = string_literals<CharType>::String();
+         StdString   ss2 = string_literals<CharType>::String();
+         BoostString bs3 = string_literals<CharType>::Suffix();
+         StdString   ss3 = string_literals<CharType>::Suffix();
+         BoostString bs4 = bs2 + bs3;
+         StdString   ss4 = ss2 + ss3;
+         if(!StringEqual()(bs4, ss4)){
+            return 1;
+         }
+
+         bs4 = bs2 + BoostString();
+         ss4 = ss2 + StdString();
+         if(!StringEqual()(bs4, ss4)){
+            return 1;
+         }
+
+         bs4 = BoostString() + bs2;
+         ss4 = StdString() + ss2;
+         if(!StringEqual()(bs4, ss4)){
+            return 1;
+         }
+
+         bs4 = BoostString() + boost::move(bs2);
+         ss4 = StdString() + boost::move(ss2);
+         if(!StringEqual()(bs4, ss4)){
+            return 1;
+         }
+
+         bs2 = string_literals<CharType>::String();
+         ss2 = string_literals<CharType>::String();
+         bs4 = boost::move(bs2) + BoostString();
+         ss4 = boost::move(ss2) + StdString();
+         if(!StringEqual()(bs4, ss4)){
+            return 1;
+         }
+
+         bs2 = string_literals<CharType>::String();
+         ss2 = string_literals<CharType>::String();
+         bs4 = string_literals<CharType>::Prefix() + boost::move(bs2);
+         ss4 = string_literals<CharType>::Prefix() + boost::move(ss2);
+         if(!StringEqual()(bs4, ss4)){
+            return 1;
+         }
+
+         bs2 = string_literals<CharType>::String();
+         ss2 = string_literals<CharType>::String();
+         bs4 = boost::move(bs2) + string_literals<CharType>::Suffix();
+         ss4 = boost::move(ss2) + string_literals<CharType>::Suffix();
+         if(!StringEqual()(bs4, ss4)){
+            return 1;
+         }
+
+         bs2 = string_literals<CharType>::String();
+         ss2 = string_literals<CharType>::String();
+         bs4 = string_literals<CharType>::Prefix() + bs2;
+         ss4 = string_literals<CharType>::Prefix() + ss2;
+         if(!StringEqual()(bs4, ss4)){
+            return 1;
+         }
+
+         bs2 = string_literals<CharType>::String();
+         ss2 = string_literals<CharType>::String();
+         bs4 = bs2 + string_literals<CharType>::Suffix();
+         ss4 = ss2 + string_literals<CharType>::Suffix();
+         if(!StringEqual()(bs4, ss4)){
+            return 1;
+         }
+
+         bs2 = string_literals<CharType>::String();
+         ss2 = string_literals<CharType>::String();
+         bs4 = string_literals<CharType>::Char() + bs2;
+         ss4 = string_literals<CharType>::Char() + ss2;
+         if(!StringEqual()(bs4, ss4)){
+            return 1;
+         }
+
+         bs2 = string_literals<CharType>::String();
+         ss2 = string_literals<CharType>::String();
+         bs4 = bs2 + string_literals<CharType>::Char();
+         ss4 = ss2 + string_literals<CharType>::Char();
+         if(!StringEqual()(bs4, ss4)){
+            return 1;
+         }
+
+         //Check front/back/begin/end
+
+         if(bs4.front() != *ss4.begin())
+            return 1;
+
+         if(bs4.back() != *(ss4.end()-1))
+            return 1;
+
+         bs4.pop_back();
+         ss4.erase(ss4.end()-1);
+         if(!StringEqual()(bs4, ss4)){
+            return 1;
+         }
+
+         if(*bs4.begin() != *ss4.begin())
+            return 1;
+         if(*bs4.cbegin() != *ss4.begin())
+            return 1;
+         if(*bs4.rbegin() != *ss4.rbegin())
+            return 1;
+         if(*bs4.crbegin() != *ss4.rbegin())
+            return 1;
+         if(*(bs4.end()-1) != *(ss4.end()-1))
+            return 1;
+         if(*(bs4.cend()-1) != *(ss4.end()-1))
+            return 1;
+         if(*(bs4.rend()-1) != *(ss4.rend()-1))
+            return 1;
+         if(*(bs4.crend()-1) != *(ss4.rend()-1))
+            return 1;
+      }
+
+#ifndef BOOST_CONTAINER_NO_CXX17_CTAD
+      //Chect Constructor Template Auto Deduction
+      {
+         auto gold = StdString(string_literals<CharType>::String());
+         auto test = basic_string(gold.begin(), gold.end());
+         if(!StringEqual()(gold, test)) {
+            return 1;
+         }
+      }
+#endif
+
+
+      //When done, delete vector
+      delete boostStringVect;
+      delete stdStringVect;
+   }
+   return 0;
+}
+
+bool test_expand_bwd()
+{
+   //Now test all back insertion possibilities
+   typedef test::expand_bwd_test_allocator<char>
+      allocator_type;
+   typedef basic_string<char, std::char_traits<char>, allocator_type>
+      string_type;
+   return  test::test_all_expand_bwd<string_type>();
+}
+
+struct boost_container_string;
+
+namespace boost { namespace container {   namespace test {
+
+template<>
+struct alloc_propagate_base<boost_container_string>
+{
+   template <class T, class Allocator>
+   struct apply
+   {
+      typedef boost::container::basic_string<T, std::char_traits<T>, Allocator> type;
+   };
+};
+
+
+}}}   //namespace boost::container::test
+
+
+int main()
+{
+   if(string_test<char>()){
+      return 1;
+   }
+
+   if(string_test<wchar_t>()){
+      return 1;
+   }
+
+   ////////////////////////////////////
+   //    Backwards expansion test
+   ////////////////////////////////////
+   if(!test_expand_bwd())
+      return 1;
+
+   ////////////////////////////////////
+   //    Allocator propagation testing
+   ////////////////////////////////////
+   if(!boost::container::test::test_propagate_allocator<boost_container_string>())
+      return 1;
+
+   ////////////////////////////////////
+   //    Default init test
+   ////////////////////////////////////
+   if(!test::default_init_test< basic_string<char, std::char_traits<char>, test::default_init_allocator<char> > >()){
+      std::cerr << "Default init test failed" << std::endl;
+      return 1;
+   }
+
+   if(!test::default_init_test< basic_string<wchar_t, std::char_traits<wchar_t>, test::default_init_allocator<wchar_t> > >()){
+      std::cerr << "Default init test failed" << std::endl;
+      return 1;
+   }
+
+   ////////////////////////////////////
+   //    Iterator testing
+   ////////////////////////////////////
+   {
+      typedef boost::container::basic_string<char> cont_int;
+      cont_int a; a.push_back(char(1)); a.push_back(char(2)); a.push_back(char(3));
+      boost::intrusive::test::test_iterator_random< cont_int >(a);
+   }
+   {
+      typedef boost::container::basic_string<wchar_t> cont_int;
+      cont_int a; a.push_back(wchar_t(1)); a.push_back(wchar_t(2)); a.push_back(wchar_t(3));
+      boost::intrusive::test::test_iterator_random< cont_int >(a);
+   }
+
+   ////////////////////////////////////
+   //    Comparison testing
+   ////////////////////////////////////
+   {
+      if(!boost::container::test::test_container_comparisons<string>())
+         return 1;
+      if(!boost::container::test::test_container_comparisons<wstring>())
+         return 1;
+   }
+
+   ////////////////////////////////////
+   //    has_trivial_destructor_after_move testing
+   ////////////////////////////////////
+   // default allocator
+   {
+      typedef boost::container::basic_string<char> cont;
+      typedef cont::allocator_type allocator_type;
+      typedef boost::container::allocator_traits<allocator_type>::pointer pointer;
+      if (boost::has_trivial_destructor_after_move<cont>::value !=
+          boost::has_trivial_destructor_after_move<allocator_type>::value &&
+          boost::has_trivial_destructor_after_move<pointer>::value) {
+         std::cerr << "has_trivial_destructor_after_move(default allocator) test failed" << std::endl;
+         return 1;
+      }
+   }
+   // std::allocator
+   {
+      typedef boost::container::basic_string<char, std::char_traits<char>, std::allocator<char> > cont;
+      typedef cont::allocator_type allocator_type;
+      typedef boost::container::allocator_traits<allocator_type>::pointer pointer;
+      if (boost::has_trivial_destructor_after_move<cont>::value !=
+          boost::has_trivial_destructor_after_move<allocator_type>::value &&
+          boost::has_trivial_destructor_after_move<pointer>::value) {
+         std::cerr << "has_trivial_destructor_after_move(std::allocator) test failed" << std::endl;
+         return 1;
+      }
+   }
+
+   return boost::report_errors();
+}
+
+#include <boost/container/detail/config_end.hpp>
diff --git a/src/boost/libs/container/test/string_view_compat_test.cpp b/src/boost/libs/container/test/string_view_compat_test.cpp
new file mode 100644
index 000000000..f786b96c2
--- /dev/null
+++ b/src/boost/libs/container/test/string_view_compat_test.cpp
@@ -0,0 +1,275 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2007-2017. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/container for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#include <boost/container/string.hpp>
+#include <boost/utility/string_view.hpp>
+
+#include <boost/core/lightweight_test.hpp>
+
+void conversion_test()
+{
+   #ifndef BOOST_CONTAINER_TEMPLATED_CONVERSION_OPERATOR_BROKEN
+   {
+      const boost::container::string s = "some text";
+      boost::string_view sv(s);
+      BOOST_TEST(s.data() == sv.data() && s.size() == sv.size());
+      boost::string_view sv2;
+      sv2 = s;
+      BOOST_TEST(s.data() == sv2.data() && s.size() == sv2.size());
+      const boost::string_view csv(s);
+      BOOST_TEST(s.data() == sv.data() && s.size() == csv.size());
+   }
+   #endif
+}
+
+void to_view_test()
+{
+   const boost::container::string s = "some text";
+   boost::string_view sv(s.to_view<boost::string_view>());
+   BOOST_TEST(s.data() == sv.data() && s.size() == sv.size());
+   boost::string_view sv2;
+   sv2 = s.to_view<boost::string_view>();
+   BOOST_TEST(s.data() == sv2.data() && s.size() == sv2.size());
+   const boost::string_view csv(s.to_view<boost::string_view>());
+   BOOST_TEST(s.data() == csv.data() && s.size() == csv.size());
+}
+
+void equal_test()
+{
+   const boost::string_view sv = "same text";
+   const boost::string_view svd = "different text";
+   const boost::container::string s = "same text";
+   BOOST_TEST(sv == s);
+   BOOST_TEST(s == sv);
+   BOOST_TEST(!(svd == s));
+   BOOST_TEST(!(s == svd));
+}
+
+void unequal_test()
+{
+   const boost::string_view sv = "same text";
+   const boost::string_view svd = "different text";
+   const boost::container::string s = "same text";
+   BOOST_TEST(!(sv != s));
+   BOOST_TEST(!(s != sv));
+   BOOST_TEST(svd != s);
+   BOOST_TEST(s != svd);
+}
+
+void less_test()
+{
+   boost::string_view sv  = "0123456";
+   boost::container::string s = "0123459";
+   BOOST_TEST(sv < s);
+   BOOST_TEST(!(s < sv));
+
+   sv = "0123459";
+   s  = "0123456";
+   BOOST_TEST(!(sv < s));
+   BOOST_TEST(s < sv);
+
+   sv = "0123456";
+   BOOST_TEST(!(sv < s));
+   BOOST_TEST(!(s < sv));
+}
+
+void greater_test()
+{
+   boost::string_view sv  = "0123459";
+   boost::container::string s = "0123456";
+   BOOST_TEST(sv > s);
+   BOOST_TEST(!(s > sv));
+
+   sv = "0123456";
+   s  = "0123459";
+   BOOST_TEST(!(sv > s));
+   BOOST_TEST(s > sv);
+
+   sv = "0123459";
+   BOOST_TEST(!(sv > s));
+   BOOST_TEST(!(s > sv));
+}
+
+void less_equal_test()
+{
+   boost::string_view sv  = "0123456";
+   boost::container::string s = "0123459";
+   BOOST_TEST(sv <= s);
+   BOOST_TEST(!(s <= sv));
+
+   sv = "0123459";
+   s  = "0123456";
+   BOOST_TEST(!(sv <= s));
+   BOOST_TEST(s <= sv);
+
+   sv = "0123456";
+   BOOST_TEST(sv <= s);
+   BOOST_TEST(s <= sv);
+}
+
+void greater_equal_test()
+{
+   boost::string_view sv  = "0123459";
+   boost::container::string s = "0123456";
+   BOOST_TEST(sv >= s);
+   BOOST_TEST(!(s >= sv));
+
+   sv = "0123456";
+   s  = "0123459";
+   BOOST_TEST(!(sv >= s));
+   BOOST_TEST(s >= sv);
+
+   sv = "0123459";
+   BOOST_TEST(sv >= s);
+   BOOST_TEST(s >= sv);
+}
+
+void constructor_test()
+{
+   boost::string_view sv  = "0123459";
+   boost::container::string s(sv);
+   BOOST_TEST(sv == s);
+   boost::container::string s2(sv, s.get_allocator());
+   BOOST_TEST(sv == s);
+}
+
+void assignment_test()
+{
+   boost::string_view sv  = "0123459";
+   boost::container::string s;
+   s = sv;
+   BOOST_TEST(sv == s);
+}
+
+void assign_test()
+{
+   boost::string_view sv  = "0123459";
+   boost::container::string s;
+   s.assign(sv);
+   BOOST_TEST(sv == s);
+}
+
+void plus_equal_test()
+{
+   boost::string_view sv  = "23459";
+   boost::container::string s("01");
+   s += sv;
+   BOOST_TEST(s == "0123459");
+}
+
+void append_test()
+{
+   boost::string_view sv  = "23459";
+   boost::container::string s("01");
+   s.append(sv);
+   BOOST_TEST(s == "0123459");
+}
+
+void insert_test()
+{
+   boost::string_view sv  = "34";
+   boost::container::string s("01259");
+   s.insert(3u, sv);
+   BOOST_TEST(s == "0123459");
+}
+
+void replace_test()
+{
+   boost::string_view sv  = "5678";
+   boost::container::string s("01259");
+   s.replace(2u, 2u, sv);
+   BOOST_TEST(s == "0156789");
+   s.replace(s.begin()+3, s.begin()+6, sv);
+   BOOST_TEST(s == "01556789");
+   s.replace(5u, 3u, sv, 2u, 2u);
+   BOOST_TEST(s == "0155678");
+}
+
+void find_test()
+{
+   const boost::string_view sv  = "25";
+   boost::container::string s("0125925123");
+   BOOST_TEST(s.find(sv,4) == 5);
+}
+
+void rfind_test()
+{
+   const boost::string_view sv  = "25";
+   boost::container::string s("0125925123");
+   BOOST_TEST(s.rfind(sv,4) == 2);
+}
+
+void find_first_of_test()
+{
+   const boost::string_view sv  = "52";
+   boost::container::string s("0125925123");
+   BOOST_TEST(s.find_first_of(sv,4) == 5);
+}
+
+void find_last_of_test()
+{
+   const boost::string_view sv  = "52";
+   boost::container::string s("520125925123");
+   BOOST_TEST(s.find_last_of(sv,6) == 5);
+}
+
+void find_first_not_of_test()
+{
+   const boost::string_view sv  = "52";
+   boost::container::string s("0125925123");
+   BOOST_TEST(s.find_first_not_of(sv,2) == 4);
+}
+
+void find_last_not_of_test()
+{
+   const boost::string_view sv  = "52";
+   boost::container::string s("0125925123");
+   BOOST_TEST(s.find_last_not_of(sv,6) == 4);
+}
+
+void compare_test()
+{
+   const boost::string_view sv  = "52";
+   boost::container::string s("0125925123");
+   BOOST_TEST(s.compare(sv) < 0);
+   BOOST_TEST(s.compare(boost::string_view("0125925123")) == 0);
+   BOOST_TEST(s.compare(2u, s.size() - 2u, boost::string_view("25925123")) == 0);
+   boost::string_view sv2("5212592512389");
+   BOOST_TEST(s.compare(2u, s.size() - 2u, sv2, 3, sv2.size()-5u) == 0);
+}
+
+int main()
+{
+   conversion_test();
+   to_view_test();
+   equal_test();
+   unequal_test();
+   less_test();
+   greater_test();
+   less_equal_test();
+   greater_equal_test();
+   constructor_test();
+   assignment_test();
+   assign_test();
+   plus_equal_test();
+   append_test();
+   insert_test();
+   replace_test();
+   find_test();
+   rfind_test();
+   find_first_of_test();
+   find_last_of_test();
+   find_first_not_of_test();
+   find_last_not_of_test();
+   compare_test();
+
+   return boost::report_errors();
+}
+
diff --git a/src/boost/libs/container/test/synchronized_pool_resource_test.cpp b/src/boost/libs/container/test/synchronized_pool_resource_test.cpp
new file mode 100644
index 000000000..da1589a06
--- /dev/null
+++ b/src/boost/libs/container/test/synchronized_pool_resource_test.cpp
@@ -0,0 +1,19 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2015-2015. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/container for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#include <boost/container/pmr/synchronized_pool_resource.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include "pool_resource_test.hpp"
+
+int main()
+{
+   test_pool_resource<boost::container::pmr::synchronized_pool_resource>();
+   return ::boost::report_errors();
+}
diff --git a/src/boost/libs/container/test/throw_exception_test.cpp b/src/boost/libs/container/test/throw_exception_test.cpp
new file mode 100644
index 000000000..2cbabefcc
--- /dev/null
+++ b/src/boost/libs/container/test/throw_exception_test.cpp
@@ -0,0 +1,62 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2012-2013. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/container for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+#define BOOST_CONTAINER_USER_DEFINED_THROW_CALLBACKS
+
+#include <boost/container/detail/config_begin.hpp>
+
+#include <boost/container/throw_exception.hpp>
+#include <boost/core/lightweight_test.hpp>
+
+using namespace boost::container;
+
+static bool bad_alloc_called     = false;
+static bool out_of_range_called  = false;
+static bool length_error_called  = false;
+static bool logic_error_called   = false;
+static bool runtime_error_called = false;
+
+//User defined throw implementations
+namespace boost {
+namespace container {
+
+   void throw_bad_alloc()
+   {  bad_alloc_called = true;   }
+
+   void throw_out_of_range(const char* str)
+   {  (void)str; out_of_range_called = true;   }
+
+   void throw_length_error(const char* str)
+   {  (void)str; length_error_called = true;   }
+
+   void throw_logic_error(const char* str)
+   {  (void)str; logic_error_called = true; }
+
+   void throw_runtime_error(const char* str)
+   {  (void)str; runtime_error_called = true;  }
+
+}} //boost::container
+
+int main()
+{
+   //Check user-defined throw callbacks are called
+   throw_bad_alloc();
+   BOOST_TEST(bad_alloc_called == true);
+   throw_out_of_range("dummy");
+   BOOST_TEST(out_of_range_called == true);
+   throw_length_error("dummy");
+   BOOST_TEST(length_error_called == true);
+   throw_logic_error("dummy");
+   BOOST_TEST(logic_error_called == true);
+   throw_runtime_error("dummy");
+   BOOST_TEST(runtime_error_called == true);
+   return ::boost::report_errors();
+}
+
+#include <boost/container/detail/config_end.hpp>
diff --git a/src/boost/libs/container/test/tree_test.cpp b/src/boost/libs/container/test/tree_test.cpp
new file mode 100644
index 000000000..e07559677
--- /dev/null
+++ b/src/boost/libs/container/test/tree_test.cpp
@@ -0,0 +1,119 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2004-2013. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/container for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+#include <boost/container/detail/tree.hpp>
+#include <boost/container/adaptive_pool.hpp>
+#include <boost/container/new_allocator.hpp>
+#include <boost/move/traits.hpp>
+
+#include <iostream>
+
+#include "movable_int.hpp"
+#include "dummy_test_allocator.hpp"
+
+using namespace boost::container;
+
+typedef std::pair<const test::movable_and_copyable_int, test::movable_and_copyable_int> pair_t;
+
+namespace boost {
+namespace container {
+
+//Explicit instantiation to detect compilation errors
+
+namespace dtl {
+
+//Instantiate base class as previous instantiations don't instantiate inherited members
+template class tree
+   < pair_t
+   , select1st<test::movable_and_copyable_int>
+   , std::less<test::movable_and_copyable_int>
+   , test::simple_allocator<pair_t>
+   , tree_assoc_defaults
+   >;
+
+template class tree
+   < pair_t
+   , select1st<test::movable_and_copyable_int>
+   , std::less<test::movable_and_copyable_int>
+   , std::allocator<pair_t>
+   , tree_assoc_defaults
+   >;
+
+template class tree
+   < pair_t
+   , select1st<test::movable_and_copyable_int>
+   , std::less<test::movable_and_copyable_int>
+   , adaptive_pool<pair_t>
+   , tree_assoc_defaults
+   >;
+
+template class tree
+   < test::movable_and_copyable_int
+   , identity<test::movable_and_copyable_int>
+   , std::less<test::movable_and_copyable_int>
+   , test::simple_allocator<test::movable_and_copyable_int>
+   , tree_assoc_defaults
+   >;
+
+template class tree
+   < 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>
+   , tree_assoc_defaults
+   >;
+
+template class tree
+   < 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>
+   , tree_assoc_defaults
+   >;
+
+}  //dtl {
+
+}} //boost::container
+
+int main ()
+{
+   ////////////////////////////////////
+   //    has_trivial_destructor_after_move testing
+   ////////////////////////////////////
+   // default
+   {
+      typedef boost::container::dtl::tree<int, void, std::less<int>, void, void> tree;
+      typedef tree::allocator_type allocator_type;
+      typedef boost::container::allocator_traits<allocator_type>::pointer pointer;
+      typedef tree::key_compare key_compare;
+      if (boost::has_trivial_destructor_after_move<tree>::value !=
+          boost::has_trivial_destructor_after_move<allocator_type>::value &&
+          boost::has_trivial_destructor_after_move<pointer>::value &&
+          boost::has_trivial_destructor_after_move<key_compare>::value) {
+         std::cerr << "has_trivial_destructor_after_move(default allocator) test failed" << std::endl;
+         return 1;
+      }
+   }
+   // std::allocator
+   {
+      typedef boost::container::dtl::tree<int, void, std::less<int>, std::allocator<int>, void> tree;
+      typedef tree::allocator_type allocator_type;
+      typedef boost::container::allocator_traits<allocator_type>::pointer pointer;
+      typedef tree::key_compare key_compare;
+      if (boost::has_trivial_destructor_after_move<tree>::value !=
+          boost::has_trivial_destructor_after_move<allocator_type>::value &&
+          boost::has_trivial_destructor_after_move<pointer>::value &&
+          boost::has_trivial_destructor_after_move<key_compare>::value) {
+         std::cerr << "has_trivial_destructor_after_move(std::allocator) test failed" << std::endl;
+         return 1;
+      }
+   }
+
+   return 0;
+}
diff --git a/src/boost/libs/container/test/unsynchronized_pool_resource_test.cpp b/src/boost/libs/container/test/unsynchronized_pool_resource_test.cpp
new file mode 100644
index 000000000..298607a8b
--- /dev/null
+++ b/src/boost/libs/container/test/unsynchronized_pool_resource_test.cpp
@@ -0,0 +1,19 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2015-2015. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/container for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#include <boost/container/pmr/unsynchronized_pool_resource.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include "pool_resource_test.hpp"
+
+int main()
+{
+   test_pool_resource<boost::container::pmr::unsynchronized_pool_resource>();
+   return ::boost::report_errors();
+}
diff --git a/src/boost/libs/container/test/uses_allocator_test.cpp b/src/boost/libs/container/test/uses_allocator_test.cpp
new file mode 100644
index 000000000..39807f09e
--- /dev/null
+++ b/src/boost/libs/container/test/uses_allocator_test.cpp
@@ -0,0 +1,84 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2011-2013. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/container for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+#include <boost/container/detail/config_begin.hpp>
+#include <boost/container/uses_allocator_fwd.hpp>
+
+#include <boost/container/uses_allocator.hpp>
+#include "propagation_test_allocator.hpp"
+
+struct not_uses_allocator
+{};
+
+struct uses_allocator_and_not_convertible_to_int
+{
+   typedef uses_allocator_and_not_convertible_to_int allocator_type;
+};
+
+struct uses_allocator_and_convertible_to_int
+{
+   typedef char allocator_type;
+};
+
+struct uses_erased_type_allocator
+{
+   typedef boost::container::erased_type allocator_type;
+};
+
+
+int main()
+{
+   using namespace boost::container;
+   //Using dummy classes
+   BOOST_STATIC_ASSERT(( false == uses_allocator
+                           < not_uses_allocator, int>::value ));
+
+   BOOST_STATIC_ASSERT(( false == uses_allocator
+                           < uses_allocator_and_not_convertible_to_int, int>::value ));
+
+   BOOST_STATIC_ASSERT((  true == uses_allocator
+                           < uses_allocator_and_convertible_to_int, int>::value ));
+
+   BOOST_STATIC_ASSERT((  true == uses_allocator
+                           < uses_erased_type_allocator, int>::value ));
+
+   //Using an allocator-like class
+   BOOST_STATIC_ASSERT(( false == uses_allocator
+                           < allocator_argument_tester<NotUsesAllocator, 0>
+                           , propagation_test_allocator<float, 0>
+                           >::value ));
+   BOOST_STATIC_ASSERT((  true == uses_allocator
+                           < allocator_argument_tester<ConstructiblePrefix, 0>
+                           , propagation_test_allocator<float, 0>
+                           >::value ));
+   BOOST_STATIC_ASSERT((  true == uses_allocator
+                           < allocator_argument_tester<ConstructibleSuffix, 0>
+                           , propagation_test_allocator<float, 0>
+                           >::value ));
+   BOOST_STATIC_ASSERT((  true == uses_allocator
+                           < allocator_argument_tester<ErasedTypeSuffix, 0>
+                           , propagation_test_allocator<float, 0>
+                           >::value ));
+   BOOST_STATIC_ASSERT((  true == uses_allocator
+                           < allocator_argument_tester<ErasedTypePrefix, 0>
+                           , propagation_test_allocator<float, 0>
+                           >::value ));
+   BOOST_STATIC_ASSERT((  true == constructible_with_allocator_prefix
+                           < allocator_argument_tester<ConstructiblePrefix, 0> >::value ));
+
+   BOOST_STATIC_ASSERT((  true == constructible_with_allocator_suffix
+                           < allocator_argument_tester<ConstructibleSuffix, 0> >::value ));
+
+   BOOST_STATIC_ASSERT((  true == constructible_with_allocator_prefix
+                           < allocator_argument_tester<ErasedTypePrefix, 0> >::value ));
+
+   BOOST_STATIC_ASSERT((  true == constructible_with_allocator_suffix
+                           < allocator_argument_tester<ErasedTypeSuffix, 0> >::value ));
+   return 0;
+}
diff --git a/src/boost/libs/container/test/vector_options_test.cpp b/src/boost/libs/container/test/vector_options_test.cpp
new file mode 100644
index 000000000..9b414fb8d
--- /dev/null
+++ b/src/boost/libs/container/test/vector_options_test.cpp
@@ -0,0 +1,121 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2004-2013. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/container for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+#include <boost/container/vector.hpp>
+#include <boost/container/allocator.hpp>
+#include <boost/container/detail/next_capacity.hpp>
+#include <boost/core/lightweight_test.hpp>
+
+using namespace boost::container;
+
+template<class Unsigned, class VectorType>
+void test_stored_size_type_impl()
+{
+   VectorType v;
+   typedef typename VectorType::size_type    size_type;
+   typedef typename VectorType::value_type   value_type;
+   size_type const max = Unsigned(-1);
+   v.resize(5);
+   v.resize(max);
+   BOOST_TEST_THROWS(v.resize(max+1),                    std::exception);
+   BOOST_TEST_THROWS(v.push_back(value_type(1)),         std::exception);
+   BOOST_TEST_THROWS(v.insert(v.begin(), value_type(1)), std::exception);
+   BOOST_TEST_THROWS(v.emplace(v.begin(), value_type(1)),std::exception);
+   BOOST_TEST_THROWS(v.reserve(max+1),                   std::exception);
+   BOOST_TEST_THROWS(VectorType v2(max+1),               std::exception);
+}
+
+template<class Unsigned>
+void test_stored_size_type()
+{
+   #if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
+   using options_t = vector_options_t< stored_size<Unsigned> >;
+   #else
+   typedef typename vector_options
+      < stored_size<Unsigned> >::type options_t;
+   #endif
+
+   //Test first with a typical allocator
+   {
+      typedef vector<unsigned char, new_allocator<unsigned char>, options_t> vector_t;
+      test_stored_size_type_impl<Unsigned, vector_t>();
+   }
+   //Test with a V2 allocator
+   {
+      typedef vector<unsigned char, allocator<unsigned char>, options_t> vector_t;
+      test_stored_size_type_impl<Unsigned, vector_t>();
+   }
+}
+
+void test_growth_factor_50()
+{
+   #if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
+   using options_t = vector_options_t< growth_factor<growth_factor_50> >;
+   #else
+   typedef vector_options
+      < growth_factor<growth_factor_50> >::type options_t;
+   #endif
+
+   vector<int, new_allocator<int>, options_t> v;
+
+   v.resize(5);
+   v.resize(v.capacity());
+   std::size_t old_capacity = v.capacity();
+   v.push_back(0);
+   std::size_t new_capacity = v.capacity();
+   BOOST_TEST(new_capacity == old_capacity + old_capacity/2);
+}
+
+void test_growth_factor_60()
+{
+   #if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
+   using options_t = vector_options_t< growth_factor<growth_factor_60> >;
+   #else
+   typedef vector_options
+      < growth_factor<growth_factor_60> >::type options_t;
+   #endif
+
+   vector<int, new_allocator<int>, options_t> v;
+
+   v.resize(5);
+   v.resize(v.capacity());
+   std::size_t old_capacity = v.capacity();
+   v.push_back(0);
+   std::size_t new_capacity = v.capacity();
+   BOOST_TEST(new_capacity == old_capacity + 3*old_capacity/5);
+}
+
+void test_growth_factor_100()
+{
+   #if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
+   using options_t = vector_options_t< growth_factor<growth_factor_100> >;
+   #else
+   typedef vector_options
+      < growth_factor<growth_factor_100> >::type options_t;
+   #endif
+
+   vector<int, new_allocator<int>, options_t> v;
+
+   v.resize(5);
+   v.resize(v.capacity());
+   std::size_t old_capacity = v.capacity();
+   v.push_back(0);
+   std::size_t new_capacity = v.capacity();
+   BOOST_TEST(new_capacity == 2*old_capacity);
+}
+
+int main()
+{
+   test_growth_factor_50();
+   test_growth_factor_60();
+   test_growth_factor_100();
+   test_stored_size_type<unsigned char>();
+   test_stored_size_type<unsigned short>();
+   return ::boost::report_errors();
+}
diff --git a/src/boost/libs/container/test/vector_test.cpp b/src/boost/libs/container/test/vector_test.cpp
new file mode 100644
index 000000000..c9b82cc38
--- /dev/null
+++ b/src/boost/libs/container/test/vector_test.cpp
@@ -0,0 +1,364 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2004-2013. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/container for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+// the tests trigger deprecation warnings when compiled with msvc in C++17 mode
+#if defined(_MSVC_LANG) && _MSVC_LANG > 201402
+// warning STL4009: std::allocator<void> is deprecated in C++17
+# define _SILENCE_CXX17_ALLOCATOR_VOID_DEPRECATION_WARNING
+#endif
+
+#include <memory>
+#include <iostream>
+
+#include <boost/container/vector.hpp>
+#include <boost/container/allocator.hpp>
+
+#include <boost/move/utility_core.hpp>
+#include "check_equal_containers.hpp"
+#include "movable_int.hpp"
+#include "expand_bwd_test_allocator.hpp"
+#include "expand_bwd_test_template.hpp"
+#include "dummy_test_allocator.hpp"
+#include "propagate_allocator_test.hpp"
+#include "vector_test.hpp"
+#include "default_init_test.hpp"
+#include "../../intrusive/test/iterator_test.hpp"
+
+using namespace boost::container;
+
+int test_expand_bwd()
+{
+   //Now test all back insertion possibilities
+
+   //First raw ints
+   typedef test::expand_bwd_test_allocator<int>
+      int_allocator_type;
+   typedef vector<int, int_allocator_type>
+      int_vector;
+   if(!test::test_all_expand_bwd<int_vector>())
+      return 1;
+
+   //Now user defined copyable int
+   typedef test::expand_bwd_test_allocator<test::copyable_int>
+      copyable_int_allocator_type;
+   typedef vector<test::copyable_int, copyable_int_allocator_type>
+      copyable_int_vector;
+   if(!test::test_all_expand_bwd<copyable_int_vector>())
+      return 1;
+
+   return 0;
+}
+
+struct X;
+
+template<typename T>
+struct XRef
+{
+   explicit XRef(T* ptr)  : ptr(ptr) {}
+   operator T*() const { return ptr; }
+   T* ptr;
+};
+
+struct X
+{
+   XRef<X const> operator&() const { return XRef<X const>(this); }
+   XRef<X>       operator&()       { return XRef<X>(this); }
+};
+
+
+bool test_smart_ref_type()
+{
+   boost::container::vector<X> x(5);
+   return x.empty();
+}
+
+class recursive_vector
+{
+   public:
+   recursive_vector & operator=(const recursive_vector &x)
+   {  this->vector_ = x.vector_;   return *this; }
+
+   int id_;
+   vector<recursive_vector> vector_;
+   vector<recursive_vector>::iterator it_;
+   vector<recursive_vector>::const_iterator cit_;
+   vector<recursive_vector>::reverse_iterator rit_;
+   vector<recursive_vector>::const_reverse_iterator crit_;
+};
+
+void recursive_vector_test()//Test for recursive types
+{
+   vector<recursive_vector> recursive_vector_vector;
+}
+
+enum Test
+{
+   zero, one, two, three, four, five, six
+};
+
+template<class VoidAllocator>
+struct GetAllocatorCont
+{
+   template<class ValueType>
+   struct apply
+   {
+      typedef vector< ValueType
+                    , typename allocator_traits<VoidAllocator>
+                        ::template portable_rebind_alloc<ValueType>::type
+                    > type;
+   };
+};
+
+template<class VoidAllocator>
+int test_cont_variants()
+{
+   typedef typename GetAllocatorCont<VoidAllocator>::template apply<int>::type MyCont;
+   typedef typename GetAllocatorCont<VoidAllocator>::template apply<test::movable_int>::type MyMoveCont;
+   typedef typename GetAllocatorCont<VoidAllocator>::template apply<test::movable_and_copyable_int>::type MyCopyMoveCont;
+   typedef typename GetAllocatorCont<VoidAllocator>::template apply<test::copyable_int>::type MyCopyCont;
+
+   if(test::vector_test<MyCont>())
+      return 1;
+   if(test::vector_test<MyMoveCont>())
+      return 1;
+   if(test::vector_test<MyCopyMoveCont>())
+      return 1;
+   if(test::vector_test<MyCopyCont>())
+      return 1;
+
+   return 0;
+}
+
+struct boost_container_vector;
+
+namespace boost { namespace container {   namespace test {
+
+template<>
+struct alloc_propagate_base<boost_container_vector>
+{
+   template <class T, class Allocator>
+   struct apply
+   {
+      typedef boost::container::vector<T, Allocator> type;
+   };
+};
+
+}}}   //namespace boost::container::test
+
+template<typename T>
+class check_dealloc_allocator : public std::allocator<T>
+{
+   public:
+   bool allocate_zero_called_;
+   bool deallocate_called_without_allocate_;
+
+   check_dealloc_allocator()
+      : std::allocator<T>()
+      , allocate_zero_called_(false)
+      , deallocate_called_without_allocate_(false)
+   {}
+
+   T* allocate(std::size_t n)
+   {
+      if (n == 0) {
+         allocate_zero_called_ = true;
+      }
+      return std::allocator<T>::allocate(n);
+   }
+
+   void deallocate(T* p, std::size_t n)
+   {
+      if (n == 0 && !allocate_zero_called_) {
+         deallocate_called_without_allocate_ = true;
+      }
+      return std::allocator<T>::deallocate(p, n);
+   }
+};
+
+bool test_merge_empty_free()
+{
+   vector<int> source;
+   source.emplace_back(1);
+
+   vector< int, check_dealloc_allocator<int> > empty;
+   empty.merge(source.begin(), source.end());
+
+   return empty.get_stored_allocator().deallocate_called_without_allocate_;
+}
+
+int main()
+{
+   {
+      const std::size_t positions_length = 10;
+      std::size_t positions[positions_length];
+      vector<int> vector_int;
+      vector<int> vector_int2(positions_length);
+      for(std::size_t i = 0; i != positions_length; ++i){
+         positions[i] = 0u;
+      }
+      for(std::size_t i = 0, max = vector_int2.size(); i != max; ++i){
+         vector_int2[i] = (int)i;
+      }
+
+      vector_int.insert(vector_int.begin(), 999);
+
+      vector_int.insert_ordered_at(positions_length, positions + positions_length, vector_int2.end());
+
+      for(std::size_t i = 0, max = vector_int.size(); i != max; ++i){
+         std::cout << vector_int[i] << std::endl;
+      }
+   }
+   recursive_vector_test();
+   {
+      //Now test move semantics
+      vector<recursive_vector> original;
+      vector<recursive_vector> move_ctor(boost::move(original));
+      vector<recursive_vector> move_assign;
+      move_assign = boost::move(move_ctor);
+      move_assign.swap(original);
+   }
+
+   ////////////////////////////////////
+   //    Testing allocator implementations
+   ////////////////////////////////////
+   //       std:allocator
+   if(test_cont_variants< std::allocator<void> >()){
+      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;
+   }
+
+   {
+      typedef vector<Test, std::allocator<Test> > MyEnumCont;
+      MyEnumCont v;
+      Test t;
+      v.push_back(t);
+      v.push_back(::boost::move(t));
+      v.push_back(Test());
+   }
+
+   if (test_smart_ref_type())
+      return 1;
+
+   ////////////////////////////////////
+   //    Backwards expansion test
+   ////////////////////////////////////
+   if(test_expand_bwd())
+      return 1;
+
+   ////////////////////////////////////
+   //    Default init test
+   ////////////////////////////////////
+   if(!test::default_init_test< vector<int, test::default_init_allocator<int> > >()){
+      std::cerr << "Default init test failed" << std::endl;
+      return 1;
+   }
+
+   ////////////////////////////////////
+   //    Emplace testing
+   ////////////////////////////////////
+   const test::EmplaceOptions Options = (test::EmplaceOptions)(test::EMPLACE_BACK | test::EMPLACE_BEFORE);
+   if(!boost::container::test::test_emplace< vector<test::EmplaceInt>, Options>()){
+      return 1;
+   }
+
+   ////////////////////////////////////
+   //    Allocator propagation testing
+   ////////////////////////////////////
+   if(!boost::container::test::test_propagate_allocator<boost_container_vector>()){
+      return 1;
+   }
+
+   ////////////////////////////////////
+   //    Initializer lists testing
+   ////////////////////////////////////
+   if(!boost::container::test::test_vector_methods_with_initializer_list_as_argument_for<
+       boost::container::vector<int>
+   >()) {
+      return 1;
+   }
+
+   ////////////////////////////////////
+   //    Iterator testing
+   ////////////////////////////////////
+   {
+      typedef boost::container::vector<int> cont_int;
+      cont_int a; a.push_back(0); a.push_back(1); a.push_back(2);
+      boost::intrusive::test::test_iterator_random< cont_int >(a);
+      if(boost::report_errors() != 0) {
+         return 1;
+      }
+   }
+
+#ifndef BOOST_CONTAINER_NO_CXX17_CTAD
+   ////////////////////////////////////
+   //    Constructor Template Auto Deduction testing
+   ////////////////////////////////////
+   {
+      auto gold = std::vector{ 1, 2, 3 };
+      auto test = boost::container::vector(gold.begin(), gold.end());
+      if (test.size() != 3) {
+         return 1;
+      }
+      if (!(test[0] == 1 && test[1] == 2 && test[2] == 3)) {
+         return 1;
+      }
+   }
+   {
+      auto gold = std::vector{ 1, 2, 3 };
+      auto test = boost::container::vector(gold.begin(), gold.end(), boost::container::new_allocator<int>());
+      if (test.size() != 3) {
+         return 1;
+      }
+      if (!(test[0] == 1 && test[1] == 2 && test[2] == 3)) {
+         return 1;
+      }
+   }
+#endif
+
+   if (test_merge_empty_free()) {
+      std::cerr << "Merge into empty vector test failed" << std::endl;
+      return 1;
+   }
+
+   ////////////////////////////////////
+   //    has_trivial_destructor_after_move testing
+   ////////////////////////////////////
+   // default allocator
+   {
+      typedef boost::container::vector<int> cont;
+      typedef cont::allocator_type allocator_type;
+      typedef boost::container::allocator_traits<allocator_type>::pointer pointer;
+      if (boost::has_trivial_destructor_after_move<cont>::value !=
+          boost::has_trivial_destructor_after_move<allocator_type>::value &&
+          boost::has_trivial_destructor_after_move<pointer>::value) {
+         std::cerr << "has_trivial_destructor_after_move(default allocator) test failed" << std::endl;
+         return 1;
+      }
+   }
+   // std::allocator
+   {
+      typedef boost::container::vector<int, std::allocator<int> > cont;
+      typedef cont::allocator_type allocator_type;
+      typedef boost::container::allocator_traits<allocator_type>::pointer pointer;
+      if (boost::has_trivial_destructor_after_move<cont>::value !=
+          boost::has_trivial_destructor_after_move<allocator_type>::value &&
+          boost::has_trivial_destructor_after_move<pointer>::value) {
+         std::cerr << "has_trivial_destructor_after_move(std::allocator) test failed" << std::endl;
+         return 1;
+      }
+   }
+
+   return 0;
+}
diff --git a/src/boost/libs/container/test/vector_test.hpp b/src/boost/libs/container/test/vector_test.hpp
new file mode 100644
index 000000000..016da1a71
--- /dev/null
+++ b/src/boost/libs/container/test/vector_test.hpp
@@ -0,0 +1,563 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2004-2013. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/container for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#ifndef BOOST_CONTAINER_TEST_VECTOR_TEST_HEADER
+#define BOOST_CONTAINER_TEST_VECTOR_TEST_HEADER
+
+#include <boost/container/detail/config_begin.hpp>
+
+#include <vector>
+#include <iostream>
+#include <list>
+
+#include <boost/move/utility_core.hpp>
+#include <boost/container/detail/mpl.hpp>
+#include <boost/move/utility_core.hpp>
+#include <boost/move/iterator.hpp>
+#include <boost/move/make_unique.hpp>
+#include <boost/core/no_exceptions_support.hpp>
+#include <boost/static_assert.hpp>
+
+#include "print_container.hpp"
+#include "check_equal_containers.hpp"
+#include "movable_int.hpp"
+#include "emplace_test.hpp"
+#include "input_from_forward_iterator.hpp"
+#include "insert_test.hpp"
+#include "container_common_tests.hpp"
+
+#include <cstddef>
+#include <string>
+#include <vector>
+
+
+namespace boost{
+namespace container {
+namespace test{
+
+template<class Vector>
+struct vector_hash_function_capacity
+{
+   typedef typename Vector::size_type size_type;
+   template <typename U, size_type (U::*)() const> struct Check;
+   template <typename U> static char func(Check<U, &U::capacity> *);
+   template <typename U> static int func(...);
+
+   public:
+   static const bool value = sizeof(func<Vector>(0)) == sizeof(char);
+};
+
+template<class V1, class V2>
+bool vector_vector_hash_function_capacity_only(V1&, V2&, boost::container::dtl::false_type)
+{
+   return true;
+}
+
+template<class MyBoostVector, class MyStdVector>
+bool vector_vector_hash_function_capacity_only(MyBoostVector&boostvector, MyStdVector&stdvector, boost::container::dtl::true_type)
+{
+   //deque has no reserve
+   boostvector.reserve(boostvector.size()*2);
+   stdvector.reserve(stdvector.size()*2);
+   if(!test::CheckEqualContainers(boostvector, stdvector)) return false;
+
+   std::size_t cap = boostvector.capacity();
+   boostvector.reserve(cap*2);
+   stdvector.reserve(cap*2);
+   if(!test::CheckEqualContainers(boostvector, stdvector)) return false;
+   boostvector.resize(0);
+   stdvector.resize(0);
+   if(!test::CheckEqualContainers(boostvector, stdvector)) return false;
+
+   boostvector.resize(cap*2);
+   stdvector.resize(cap*2);
+   if(!test::CheckEqualContainers(boostvector, stdvector)) return false;
+
+   boostvector.resize(cap*2);
+   stdvector.resize(cap*2);
+   if(!test::CheckEqualContainers(boostvector, stdvector)) return false;
+
+   return true;
+}
+
+
+template<class V1, class V2>
+bool vector_copyable_only(V1&, V2&, boost::container::dtl::false_type)
+{
+   return true;
+}
+
+//Function to check if both sets are equal
+template<class MyBoostVector, class MyStdVector>
+bool vector_copyable_only(MyBoostVector &boostvector, MyStdVector &stdvector, boost::container::dtl::true_type)
+{
+   typedef typename MyBoostVector::value_type IntType;
+   std::size_t size = boostvector.size();
+   boostvector.insert(boostvector.end(), 50, IntType(1));
+   stdvector.insert(stdvector.end(), 50, 1);
+   if(!test::CheckEqualContainers(boostvector, stdvector)) return false;
+
+   {
+      IntType move_me(1);
+      boostvector.insert(boostvector.begin()+size/2, 50, boost::move(move_me));
+      stdvector.insert(stdvector.begin()+size/2, 50, 1);
+      if(!test::CheckEqualContainers(boostvector, stdvector)) return false;
+   }
+   {
+      IntType move_me(2);
+      boostvector.assign(boostvector.size()/2, boost::move(move_me));
+      stdvector.assign(stdvector.size()/2, 2);
+      if(!test::CheckEqualContainers(boostvector, stdvector)) return false;
+   }
+   {
+      IntType move_me(3);
+      boostvector.assign(boostvector.size()*3-1, boost::move(move_me));
+      stdvector.assign(stdvector.size()*3-1, 3);
+      if(!test::CheckEqualContainers(boostvector, stdvector)) return false;
+   }
+
+   {
+      IntType copy_me(3);
+      const IntType ccopy_me(3);
+      boostvector.push_back(copy_me);
+      stdvector.push_back(int(3));
+      boostvector.push_back(ccopy_me);
+      stdvector.push_back(int(3));
+      if(!test::CheckEqualContainers(boostvector, stdvector)) return false;
+   }
+   {  //Vector(const Vector &)
+      ::boost::movelib::unique_ptr<MyBoostVector> const pv1 =
+         ::boost::movelib::make_unique<MyBoostVector>(boostvector);
+      ::boost::movelib::unique_ptr<MyStdVector> const pv2 =
+         ::boost::movelib::make_unique<MyStdVector>(stdvector);
+
+      MyBoostVector &v1 = *pv1;
+      MyStdVector &v2 = *pv2;
+
+      boostvector.clear();
+      stdvector.clear();
+      boostvector.assign(v1.begin(), v1.end());
+      stdvector.assign(v2.begin(), v2.end());
+      if(!test::CheckEqualContainers(boostvector, stdvector)) return 1;
+   }
+   {  //Vector(const Vector &, alloc)
+      ::boost::movelib::unique_ptr<MyBoostVector> const pv1 =
+         ::boost::movelib::make_unique<MyBoostVector>(boostvector, typename MyBoostVector::allocator_type());
+      ::boost::movelib::unique_ptr<MyStdVector> const pv2 =
+         ::boost::movelib::make_unique<MyStdVector>(stdvector);
+
+      MyBoostVector &v1 = *pv1;
+      MyStdVector &v2 = *pv2;
+
+      boostvector.clear();
+      stdvector.clear();
+      boostvector.assign(v1.begin(), v1.end());
+      stdvector.assign(v2.begin(), v2.end());
+      if(!test::CheckEqualContainers(boostvector, stdvector)) return 1;
+   }
+   {  //Vector(n, T)
+      ::boost::movelib::unique_ptr<MyStdVector> const stdvectorp =
+         ::boost::movelib::make_unique<MyStdVector>(100, int(5));
+      ::boost::movelib::unique_ptr<MyBoostVector> const boostvectorp =
+         ::boost::movelib::make_unique<MyBoostVector>(100, IntType(5));
+      if(!test::CheckEqualContainers(*boostvectorp, *stdvectorp)) return 1;
+   }
+   {  //Vector(n, T, alloc)
+      ::boost::movelib::unique_ptr<MyStdVector> const stdvectorp =
+         ::boost::movelib::make_unique<MyStdVector>(100, int(5));
+      ::boost::movelib::unique_ptr<MyBoostVector> const boostvectorp =
+         ::boost::movelib::make_unique<MyBoostVector>(100, IntType(5), typename MyBoostVector::allocator_type());
+      if(!test::CheckEqualContainers(*boostvectorp, *stdvectorp)) return 1;
+   }
+   {  //Vector(It, It)
+      ::boost::movelib::unique_ptr<MyStdVector> const stdvectorp =
+         ::boost::movelib::make_unique<MyStdVector>(100);
+      ::boost::movelib::unique_ptr<MyBoostVector> const boostvectorp =
+         ::boost::movelib::make_unique<MyBoostVector>(100);
+      ::boost::movelib::unique_ptr<MyBoostVector> const boostvectorp2 =
+         ::boost::movelib::make_unique<MyBoostVector>(boostvectorp->begin(), boostvectorp->end());
+      if(!test::CheckEqualContainers(*boostvectorp2, *stdvectorp)) return 1;
+   }
+   {  //Vector(It, It, alloc)
+      ::boost::movelib::unique_ptr<MyStdVector> const stdvectorp =
+         ::boost::movelib::make_unique<MyStdVector>(100);
+      ::boost::movelib::unique_ptr<MyBoostVector> const boostvectorp =
+         ::boost::movelib::make_unique<MyBoostVector>(100);
+      ::boost::movelib::unique_ptr<MyBoostVector> const boostvectorp2 =
+         ::boost::movelib::make_unique<MyBoostVector>(boostvectorp->begin(), boostvectorp->end(), typename MyBoostVector::allocator_type());
+      if(!test::CheckEqualContainers(*boostvectorp2, *stdvectorp)) return 1;
+   }
+   {  //resize(n, T)
+      ::boost::movelib::unique_ptr<MyStdVector> const stdvectorp =
+         ::boost::movelib::make_unique<MyStdVector>();
+      ::boost::movelib::unique_ptr<MyBoostVector> const boostvectorp =
+         ::boost::movelib::make_unique<MyBoostVector>();
+      stdvectorp->resize(100, int(9));
+      boostvectorp->resize(100, IntType(9));
+      if(!test::CheckEqualContainers(*boostvectorp, *stdvectorp)) return 1;
+   }
+   //operator=
+   {
+      //Copy constructor test
+      MyBoostVector bcopy((const MyBoostVector&) boostvector);
+      MyStdVector   scopy((const MyStdVector&)   stdvector);
+      MyBoostVector bcopy2(boostvector);
+      MyStdVector   scopy2(stdvector);
+
+      if(!test::CheckEqualContainers(bcopy, scopy)) return false;
+      if(!test::CheckEqualContainers(bcopy2, scopy2)) return false;
+
+      //Assignment from a smaller vector
+      bcopy2.erase(bcopy2.begin() + bcopy2.size()/2, bcopy2.end());
+      scopy2.erase(scopy2.begin() + scopy2.size()/2, scopy2.end());
+      bcopy = bcopy2;
+      scopy = scopy2;
+      if(!test::CheckEqualContainers(bcopy, scopy)) return false;
+
+      //Assignment from a bigger vector with capacity
+      bcopy2  = boostvector;
+      scopy2  = stdvector;
+      if(!test::CheckEqualContainers(bcopy2, scopy2)) return false;
+
+      //Assignment from bigger vector with no capacity
+      bcopy2.erase(bcopy2.begin() + bcopy2.size()/2, bcopy2.end());
+      scopy2.erase(scopy2.begin() + scopy2.size()/2, scopy2.end());
+      bcopy2.shrink_to_fit();
+      MyStdVector(scopy2).swap(scopy2);
+
+      bcopy2 = boostvector;
+      scopy2 = stdvector;
+      if(!test::CheckEqualContainers(bcopy, scopy)) return false;
+
+      //Assignment with equal capacity
+      bcopy2 = boostvector;
+      scopy2 = stdvector;
+      if(!test::CheckEqualContainers(bcopy2, scopy2)) return false;
+   }
+
+   return true;
+}
+
+template<class MyBoostVector>
+int vector_test()
+{
+   typedef std::vector<int>                     MyStdVector;
+   typedef typename MyBoostVector::value_type   IntType;
+   const int max = 100;
+
+   if(!test_range_insertion<MyBoostVector>()){
+      return 1;
+   }
+   {  //Vector(n)
+      ::boost::movelib::unique_ptr<MyBoostVector> const boostvectorp =
+         ::boost::movelib::make_unique<MyBoostVector>(100);
+      ::boost::movelib::unique_ptr<MyStdVector> const stdvectorp =
+         ::boost::movelib::make_unique<MyStdVector>(100);
+      if(!test::CheckEqualContainers(*boostvectorp, *stdvectorp)) return 1;
+   }
+   {  //Vector(n, alloc)
+      ::boost::movelib::unique_ptr<MyBoostVector> const boostvectorp =
+         ::boost::movelib::make_unique<MyBoostVector>(100, typename MyBoostVector::allocator_type());
+      ::boost::movelib::unique_ptr<MyStdVector> const stdvectorp =
+         ::boost::movelib::make_unique<MyStdVector>(100);
+      if(!test::CheckEqualContainers(*boostvectorp, *stdvectorp)) return 1;
+   }
+   {  //Vector(Vector &&)
+      ::boost::movelib::unique_ptr<MyStdVector> const stdvectorp =
+         ::boost::movelib::make_unique<MyStdVector>(100);
+      ::boost::movelib::unique_ptr<MyBoostVector> const boostvectorp =
+         ::boost::movelib::make_unique<MyBoostVector>(100);
+      ::boost::movelib::unique_ptr<MyBoostVector> const boostvectorp2 =
+         ::boost::movelib::make_unique<MyBoostVector>(::boost::move(*boostvectorp));
+      if(!test::CheckEqualContainers(*boostvectorp2, *stdvectorp)) return 1;
+   }
+   {  //Vector(Vector &&, alloc)
+      ::boost::movelib::unique_ptr<MyStdVector> const stdvectorp =
+         ::boost::movelib::make_unique<MyStdVector>(100);
+      ::boost::movelib::unique_ptr<MyBoostVector> const boostvectorp =
+         ::boost::movelib::make_unique<MyBoostVector>(100);
+      ::boost::movelib::unique_ptr<MyBoostVector> const boostvectorp2 =
+         ::boost::movelib::make_unique<MyBoostVector>
+            (::boost::move(*boostvectorp), typename MyBoostVector::allocator_type());
+      if(!test::CheckEqualContainers(*boostvectorp2, *stdvectorp)) return 1;
+   }
+   {  //Vector operator=(Vector &&)
+      ::boost::movelib::unique_ptr<MyStdVector> const stdvectorp =
+         ::boost::movelib::make_unique<MyStdVector>(100);
+      ::boost::movelib::unique_ptr<MyBoostVector> const boostvectorp =
+         ::boost::movelib::make_unique<MyBoostVector>(100);
+      ::boost::movelib::unique_ptr<MyBoostVector> const boostvectorp2 =
+         ::boost::movelib::make_unique<MyBoostVector>();
+      *boostvectorp2 = ::boost::move(*boostvectorp);
+      if(!test::CheckEqualContainers(*boostvectorp2, *stdvectorp)) return 1;
+   }
+   {
+      ::boost::movelib::unique_ptr<MyBoostVector> const boostvectorp = ::boost::movelib::make_unique<MyBoostVector>();
+      ::boost::movelib::unique_ptr<MyStdVector> const stdvectorp = ::boost::movelib::make_unique<MyStdVector>();
+
+      MyBoostVector & boostvector = *boostvectorp;
+      MyStdVector & stdvector = *stdvectorp;
+
+      boostvector.resize(100);
+      stdvector.resize(100);
+      if(!test::CheckEqualContainers(boostvector, stdvector)) return 1;
+
+      boostvector.resize(200);
+      stdvector.resize(200);
+      if(!test::CheckEqualContainers(boostvector, stdvector)) return 1;
+
+      boostvector.resize(0);
+      stdvector.resize(0);
+      if(!test::CheckEqualContainers(boostvector, stdvector)) return 1;
+
+      for(int i = 0; i < max; ++i){
+         IntType new_int(i);
+         boostvector.insert(boostvector.end(), boost::move(new_int));
+         stdvector.insert(stdvector.end(), i);
+         if(!test::CheckEqualContainers(boostvector, stdvector)) return 1;
+      }
+      if(!test::CheckEqualContainers(boostvector, stdvector)) return 1;
+
+      typename MyBoostVector::iterator boostit(boostvector.begin());
+      typename MyStdVector::iterator stdit(stdvector.begin());
+      typename MyBoostVector::const_iterator cboostit = boostit;
+      (void)cboostit;
+      ++boostit; ++stdit;
+      boostvector.erase(boostit);
+      stdvector.erase(stdit);
+      if(!test::CheckEqualContainers(boostvector, stdvector)) return 1;
+
+      boostvector.erase(boostvector.begin());
+      stdvector.erase(stdvector.begin());
+      if(!test::CheckEqualContainers(boostvector, stdvector)) return 1;
+
+      {
+         //Initialize values
+         IntType aux_vect[50];
+         for(int i = 0; i < 50; ++i){
+            IntType new_int(-1);
+            BOOST_STATIC_ASSERT((boost::container::test::is_copyable<boost::container::test::movable_int>::value == false));
+            aux_vect[i] = boost::move(new_int);
+         }
+         int aux_vect2[50];
+         for(int i = 0; i < 50; ++i){
+            aux_vect2[i] = -1;
+         }
+         typename MyBoostVector::iterator insert_it =
+            boostvector.insert(boostvector.end()
+                           ,boost::make_move_iterator(&aux_vect[0])
+                           ,boost::make_move_iterator(aux_vect + 50));
+         if(std::size_t(boost::container::iterator_distance(insert_it, boostvector.end())) != 50) return 1;
+         stdvector.insert(stdvector.end(), aux_vect2, aux_vect2 + 50);
+         if(!test::CheckEqualContainers(boostvector, stdvector)) return 1;
+
+         for(int i = 0, j = static_cast<int>(boostvector.size()); i < j; ++i){
+            boostvector.erase(boostvector.begin());
+            stdvector.erase(stdvector.begin());
+         }
+         if(!test::CheckEqualContainers(boostvector, stdvector)) return 1;
+      }
+      {
+         boostvector.resize(100);
+         stdvector.resize(100);
+         if(!test::CheckEqualContainers(boostvector, stdvector)) return 1;
+
+         IntType aux_vect[50];
+         for(int i = 0; i < 50; ++i){
+            IntType new_int(-i);
+            aux_vect[i] = boost::move(new_int);
+         }
+         int aux_vect2[50];
+         for(int i = 0; i < 50; ++i){
+            aux_vect2[i] = -i;
+         }
+         typename MyBoostVector::size_type old_size = boostvector.size();
+         typename MyBoostVector::iterator insert_it =
+            boostvector.insert(boostvector.begin() + old_size/2
+                           ,boost::make_move_iterator(&aux_vect[0])
+                           ,boost::make_move_iterator(aux_vect + 50));
+         if(boostvector.begin() + old_size/2 != insert_it) return 1;
+         stdvector.insert(stdvector.begin() + old_size/2, aux_vect2, aux_vect2 + 50);
+         if(!test::CheckEqualContainers(boostvector, stdvector)) return 1;
+
+         for(int i = 0; i < 50; ++i){
+            IntType new_int(-i);
+            aux_vect[i] = boost::move(new_int);
+         }
+
+         for(int i = 0; i < 50; ++i){
+            aux_vect2[i] = -i;
+         }
+         old_size = boostvector.size();
+         //Now try with input iterators instead
+         insert_it = boostvector.insert(boostvector.begin() + old_size/2
+                           ,boost::make_move_iterator(make_input_from_forward_iterator(&aux_vect[0]))
+                           ,boost::make_move_iterator(make_input_from_forward_iterator(aux_vect + 50))
+                        );
+         if(boostvector.begin() + old_size/2 != insert_it) return 1;
+         stdvector.insert(stdvector.begin() + old_size/2, aux_vect2, aux_vect2 + 50);
+         if(!test::CheckEqualContainers(boostvector, stdvector)) return 1;
+      }
+
+      boostvector.shrink_to_fit();
+      MyStdVector(stdvector).swap(stdvector);
+      if(!test::CheckEqualContainers(boostvector, stdvector)) return 1;
+
+      boostvector.shrink_to_fit();
+      MyStdVector(stdvector).swap(stdvector);
+      if(!test::CheckEqualContainers(boostvector, stdvector)) return 1;
+
+      {  //push_back with not enough capacity
+      IntType push_back_this(1);
+      boostvector.push_back(boost::move(push_back_this));
+      stdvector.push_back(int(1));
+      boostvector.push_back(IntType(1));
+      stdvector.push_back(int(1));
+      if(!test::CheckEqualContainers(boostvector, stdvector)) return 1;
+      }
+
+      {  //test back()
+      const IntType test_this(1);
+      if(test_this != boostvector.back())   return 1;
+      }
+      {  //pop_back with enough capacity
+      boostvector.pop_back();
+      boostvector.pop_back();
+      stdvector.pop_back();
+      stdvector.pop_back();
+
+      IntType push_back_this(1);
+      boostvector.push_back(boost::move(push_back_this));
+      stdvector.push_back(int(1));
+      boostvector.push_back(IntType(1));
+      stdvector.push_back(int(1));
+      if(!test::CheckEqualContainers(boostvector, stdvector)) return 1;
+      }
+
+      if(!vector_copyable_only(boostvector, stdvector
+                     ,dtl::bool_<boost::container::test::is_copyable<IntType>::value>())){
+         return 1;
+      }
+
+      boostvector.erase(boostvector.begin());
+      stdvector.erase(stdvector.begin());
+      if(!test::CheckEqualContainers(boostvector, stdvector)) return 1;
+
+      for(int i = 0; i < max; ++i){
+         IntType insert_this(i);
+         boostvector.insert(boostvector.begin(), boost::move(insert_this));
+         stdvector.insert(stdvector.begin(), i);
+         boostvector.insert(boostvector.begin(), IntType(i));
+         stdvector.insert(stdvector.begin(), int(i));
+      }
+      if(!test::CheckEqualContainers(boostvector, stdvector)) return 1;
+
+      //some comparison operators
+      if(!(boostvector == boostvector))
+         return 1;
+      if(boostvector != boostvector)
+         return 1;
+      if(boostvector < boostvector)
+         return 1;
+      if(boostvector > boostvector)
+         return 1;
+      if(!(boostvector <= boostvector))
+         return 1;
+      if(!(boostvector >= boostvector))
+         return 1;
+
+      //Test insertion from list
+      {
+         std::list<int> l(50, int(1));
+         typename MyBoostVector::iterator it_insert =
+            boostvector.insert(boostvector.begin(), l.begin(), l.end());
+         if(boostvector.begin() != it_insert) return 1;
+         stdvector.insert(stdvector.begin(), l.begin(), l.end());
+         if(!test::CheckEqualContainers(boostvector, stdvector)) return 1;
+         boostvector.assign(l.begin(), l.end());
+         stdvector.assign(l.begin(), l.end());
+         if(!test::CheckEqualContainers(boostvector, stdvector)) return 1;
+
+         boostvector.clear();
+         stdvector.clear();
+         boostvector.assign(make_input_from_forward_iterator(l.begin()), make_input_from_forward_iterator(l.end()));
+         stdvector.assign(l.begin(), l.end());
+         if(!test::CheckEqualContainers(boostvector, stdvector)) return 1;
+      }
+   
+      if(!vector_vector_hash_function_capacity_only(boostvector, stdvector, dtl::bool_<vector_hash_function_capacity<MyBoostVector>::value>()))
+         return 1;
+
+      boostvector.clear();
+      stdvector.clear();
+      boostvector.shrink_to_fit();
+      MyStdVector(stdvector).swap(stdvector);
+      if(!test::CheckEqualContainers(boostvector, stdvector)) return false;
+
+      boostvector.resize(100);
+      if(!test_nth_index_of(boostvector))
+         return 1;
+
+   }
+   std::cout << std::endl << "Test OK!" << std::endl;
+   return 0;
+}
+
+template<typename VectorContainerType>
+bool test_vector_methods_with_initializer_list_as_argument_for()
+{
+#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
+   typedef typename VectorContainerType::allocator_type allocator_type;
+   {
+      const VectorContainerType testedVector = {1, 2, 3};
+      const std::vector<int> expectedVector = {1, 2, 3};
+      if(!test::CheckEqualContainers(testedVector, expectedVector)) return false;
+   }
+   {
+      const VectorContainerType testedVector( { 1, 2, 3 }, allocator_type() );
+      const std::vector<int> expectedVector = {1, 2, 3};
+      if(!test::CheckEqualContainers(testedVector, expectedVector)) return false;
+   }
+   {
+      VectorContainerType testedVector = {1, 2, 3};
+      testedVector = {11, 12, 13};
+
+      const std::vector<int> expectedVector = {11, 12, 13};
+      if(!test::CheckEqualContainers(testedVector, expectedVector)) return false;
+   }
+
+   {
+      VectorContainerType testedVector = {1, 2, 3};
+      testedVector.assign({5, 6, 7});
+
+      const std::vector<int> expectedVector = {5, 6, 7};
+      if(!test::CheckEqualContainers(testedVector, expectedVector)) return false;
+   }
+
+   {
+      VectorContainerType testedVector = {1, 2, 3};
+      testedVector.insert(testedVector.cend(), {5, 6, 7});
+
+      const std::vector<int> expectedVector = {1, 2, 3, 5, 6, 7};
+      if(!test::CheckEqualContainers(testedVector, expectedVector)) return false;
+   }
+   return true;
+#else
+   return true;
+#endif
+}
+
+}  //namespace test{
+}  //namespace container {
+}  //namespace boost{
+
+#include <boost/container/detail/config_end.hpp>
+
+#endif //BOOST_CONTAINER_TEST_VECTOR_TEST_HEADER