Expand flat_map testing coverage

test/flat_map_adaptor_test.cpp

@@ -17,7 +17,7 @@
 
 #include <boost/container/detail/container_or_allocator_rebind.hpp>
 
-#include "map_test.hpp"
+#include "flat_map_test.hpp"
 #include <map>
 
 using namespace boost::container;
@@ -54,58 +54,57 @@ int main()
       typedef std::map<int, int>                                     MyStdMap;
       typedef std::multimap<int, int>                                MyStdMultiMap;
 
-      if (0 != test::map_test
+      if (0 != test::flat_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;
+         std::cout << "Error in flat_map_test<vector<std::pair<int, int> > >" << std::endl;
          return 1;
       }
 
-      if (0 != test::map_test
+      if (0 != test::flat_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;
+         std::cout << "Error in flat_map_test<small_vector<std::pair<int, int>, 7> >" << std::endl;
          return 1;
       }
 
-       if (0 != test::map_test
+      if (0 != test::flat_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;
+         std::cout << "Error in flat_map_test<static_vector<std::pair<int, int>, MaxElem * 10> >" << std::endl;
          return 1;
       }
 
-      if (0 != test::map_test
+      if (0 != test::flat_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;
+         std::cout << "Error in flat_map_test<stable_vector<std::pair<int, int> > >" << std::endl;
          return 1;
       }
 
-
+      if (0 != test::flat_map_test
-      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;
+         std::cout << "Error in flat_map_test<deque<std::pair<int, int> > >" << std::endl;
          return 1;
       }
 
-      if (0 != test::map_test
+      if (0 != test::flat_map_test
          < GetMapContainer<devector<std::pair<int, int> > >::apply<int>::map_type
          , MyStdMap
          , GetMapContainer<devector<std::pair<int, int> > >::apply<int>::multimap_type
          , MyStdMultiMap>()) {
-         std::cout << "Error in map_test<vector<std::pair<int, int> > >" << std::endl;
+         std::cout << "Error in flat_map_test<vector<std::pair<int, int> > >" << std::endl;
          return 1;
       }
    }

test/flat_map_test.cpp

@@ -16,11 +16,12 @@
 #include "print_container.hpp"
 #include "dummy_test_allocator.hpp"
 #include "movable_int.hpp"
-#include "map_test.hpp"
+#include "flat_map_test.hpp"
 #include "propagate_allocator_test.hpp"
 #include "container_common_tests.hpp"
 #include "emplace_test.hpp"
 #include "../../intrusive/test/iterator_test.hpp"
+#include "flat_map_test.hpp"
 
 #include <map>
 #include <utility>
@@ -90,90 +91,6 @@ 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()
 {
 
@@ -274,124 +191,6 @@ bool constructor_template_auto_deduction_test()
    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));
-      }
-
-      const 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;
-      if (!CheckEqualContainers(fmap.sequence(), fmap_copy.sequence()))
-         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));
-      }
-
-      const 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;
-      if (!CheckEqualContainers(fmap.sequence(), fmap_copy.sequence()))
-         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));
-      }
-
-      const 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;
-      if (!CheckEqualContainers(fmmap.sequence(), fmmap_copy.sequence()))
-         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));
-      }
-
-      const 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;
-      if (!CheckEqualContainers(fmmap.sequence(), fmmap_copy.sequence()))
-         return false;
-   }
-
-   return true;
-}
-
 }}}
 
 template<class VoidAllocatorOrContainer>
@@ -415,6 +214,25 @@ struct GetMapContainer
    };
 };
 
+//To test default parameters
+template<>
+struct GetMapContainer<void>
+{
+   template<class ValueType>
+   struct apply
+   {
+      typedef std::pair<ValueType, ValueType> type_t;
+      typedef flat_map< ValueType
+         , ValueType
+      > map_type;
+
+      typedef flat_multimap< ValueType
+         , ValueType
+      > multimap_type;
+   };
+};
+
+
 struct boost_container_flat_map;
 struct boost_container_flat_multimap;
 
@@ -641,13 +459,6 @@ int main()
          return 1;
    }
 
-   ////////////////////////////////////
-   //    Ordered insertion test
-   ////////////////////////////////////
-   if(!flat_tree_ordered_insertion_test()){
-      return 1;
-   }
-
    ////////////////////////////////////
    //    Constructor Template Auto Deduction test
    ////////////////////////////////////
@@ -655,16 +466,6 @@ int main()
       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;
 
@@ -678,48 +479,66 @@ int main()
       typedef std::map<int, int>                                     MyStdMap;
       typedef std::multimap<int, int>                                MyStdMultiMap;
 
-      if (0 != test::map_test
+      if (0 != test::flat_map_test
+         < GetMapContainer<void>::apply<int>::map_type
+         , MyStdMap
+         , GetMapContainer<void>::apply<int>::multimap_type
+         , MyStdMultiMap>()) {
+         std::cout << "Error in flat_map_test<std::allocator<void> >" << std::endl;
+         return 1;
+      }
+
+      if (0 != test::flat_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;
+         std::cout << "Error in flat_map_test<std::allocator<void> >" << std::endl;
          return 1;
       }
 
-      if (0 != test::map_test
+      if (0 != test::flat_map_test
+         < GetMapContainer<void>::apply<int>::map_type
+         , MyStdMap
+         , GetMapContainer<void>::apply<int>::multimap_type
+         , MyStdMultiMap>()) {
+         std::cout << "Error in flat_map_test<new_allocator<void> >" << std::endl;
+         return 1;
+      }
+
+      if (0 != test::flat_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;
+         std::cout << "Error in flat_map_test<new_allocator<void> >" << std::endl;
          return 1;
       }
 
-      if (0 != test::map_test
+      if (0 != test::flat_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;
+         std::cout << "Error in flat_map_test<new_allocator<void> >" << std::endl;
          return 1;
       }
 
-      if (0 != test::map_test
+      if (0 != test::flat_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;
+         std::cout << "Error in flat_map_test<new_allocator<void> >" << std::endl;
          return 1;
       }
 
-      if (0 != test::map_test
+      if (0 != test::flat_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;
+         std::cout << "Error in flat_map_test<new_allocator<void> >" << std::endl;
          return 1;
       }
    }

test/flat_map_test.hpp

@@ -0,0 +1,269 @@
+////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2024. 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_FLAT_MAP_TEST_HEADER
+#define BOOST_CONTAINER_TEST_FLAT_MAP_TEST_HEADER
+
+#include <boost/container/detail/config_begin.hpp>
+#include "check_equal_containers.hpp"
+#include "print_container.hpp"
+#include <boost/move/iterator.hpp>
+#include <boost/move/utility_core.hpp>
+#include <boost/move/adl_move_swap.hpp>
+
+#include <map>
+#include "map_test.hpp"
+
+namespace boost{
+namespace container {
+namespace test {
+
+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]);
+      }
+   }
+}
+
+template<class IntFlatMap, class IntFlatMultimap>
+bool flat_tree_extract_adopt_test()
+{
+   using namespace boost::container;
+   const std::size_t NumElements = 100;
+
+   typedef typename IntFlatMap::sequence_type seq_t;
+
+   //extract/adopt map
+   {
+      //Construction insertion
+      IntFlatMap fmap, fmap_copy;
+
+      for(std::size_t i = 0; i != NumElements; ++i){
+         fmap.emplace(static_cast<int>(i), -static_cast<int>(i));
+         fmap_copy.emplace(static_cast<int>(i), -static_cast<int>(i));
+      }
+
+      seq_t seq((BOOST_RV_REF(seq_t))fmap.extract_sequence());
+      if(!fmap.empty())
+         return false;
+      if(!CheckEqualContainers(seq, fmap_copy))
+         return false;
+
+      #ifdef BOOST_CONTAINER_STD_PAIR_IS_MOVABLE
+      for(std::size_t i = 0; i != NumElements; ++i){
+         seq.emplace_back(static_cast<int>(i), -static_cast<int>(i));
+      }
+
+      boost::container::test::random_shuffle(seq.begin(), seq.end());
+      #endif
+
+      fmap.adopt_sequence(boost::move(seq));
+      if(!CheckEqualContainers(fmap, fmap_copy))
+         return false;
+      if (!CheckEqualContainers(fmap.sequence(), fmap_copy.sequence()))
+         return false;
+   }
+
+   //extract/adopt map, ordered_unique_range
+   {
+      //Construction insertion
+      IntFlatMap fmap, fmap_copy;
+
+      for(std::size_t i = 0; i != NumElements; ++i){
+         fmap.emplace(static_cast<int>(i), -static_cast<int>(i));
+         fmap_copy.emplace(static_cast<int>(i), -static_cast<int>(i));
+      }
+
+      seq_t seq((BOOST_RV_REF(seq_t))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;
+      if (!CheckEqualContainers(fmap.sequence(), fmap_copy.sequence()))
+         return false;
+   }
+
+   //extract/adopt multimap
+   {
+      //Construction insertion
+      IntFlatMultimap fmmap, fmmap_copy;
+
+      for(std::size_t i = 0; i != NumElements; ++i){
+         fmmap.emplace(static_cast<int>(i), -static_cast<int>(i));
+         fmmap_copy.emplace(static_cast<int>(i), -static_cast<int>(i));
+         fmmap.emplace(static_cast<int>(i), -static_cast<int>(i));
+         fmmap_copy.emplace(static_cast<int>(i), -static_cast<int>(i));
+      }
+
+      seq_t seq((BOOST_RV_REF(seq_t))fmmap.extract_sequence());
+      if(!fmmap.empty())
+         return false;
+      if(!CheckEqualContainers(seq, fmmap_copy))
+         return false;
+
+      #ifdef BOOST_CONTAINER_STD_PAIR_IS_MOVABLE
+      boost::container::test::random_shuffle(seq.begin(), seq.end());
+      #endif
+
+      fmmap.adopt_sequence(boost::move(seq));
+      if(!CheckEqualContainers(fmmap, fmmap_copy))
+         return false;
+      if (!CheckEqualContainers(fmmap.sequence(), fmmap_copy.sequence()))
+         return false;
+   }
+
+   //extract/adopt multimap, ordered_range
+   {
+      //Construction insertion
+      IntFlatMultimap fmmap, fmmap_copy;
+
+      for(std::size_t i = 0; i != NumElements; ++i){
+         fmmap.emplace(static_cast<int>(i), -static_cast<int>(i));
+         fmmap_copy.emplace(static_cast<int>(i), -static_cast<int>(i));
+         fmmap.emplace(static_cast<int>(i), -static_cast<int>(i));
+         fmmap_copy.emplace(static_cast<int>(i), -static_cast<int>(i));
+      }
+
+      seq_t seq((BOOST_RV_REF(seq_t))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;
+      if (!CheckEqualContainers(fmmap.sequence(), fmmap_copy.sequence()))
+         return false;
+   }
+   return true;
+}
+
+
+template<class IntFlatMap, class IntFlatMultimap>
+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
+      IntFlatMultimap 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
+      IntFlatMap 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;
+}
+
+template<class MyBoostFlatMap
+        ,class MyStdMap
+        ,class MyBoostFlatMultimap
+        ,class MyStdMultiMap>
+int flat_map_test()
+{
+   if(0 != map_test<MyBoostFlatMap, MyStdMap, MyBoostFlatMultimap, MyStdMultiMap>())
+      return 1;
+
+   if (!flat_tree_ordered_insertion_test<MyBoostFlatMap, MyBoostFlatMultimap>())
+      return 1;
+
+   if (!flat_tree_extract_adopt_test<MyBoostFlatMap, MyBoostFlatMultimap>())
+      return 1;
+   return 0;
+}
+
+}  //namespace test{
+}  //namespace container {
+}  //namespace boost{
+
+#include <boost/container/detail/config_end.hpp>
+
+#endif   //#ifndef BOOST_CONTAINER_TEST_FLAT_MAP_TEST_HEADER