ceph/src/boost/libs/range/test/algorithm_test/merge.cpp

   1 //  Copyright Neil Groves 2009. Use, modification and
   2 //  distribution is subject to the Boost Software License, Version
   3 //  1.0. (See accompanying file LICENSE_1_0.txt or copy at
   4 //  http://www.boost.org/LICENSE_1_0.txt)
   5 //
   6 //
   7 // For more information, see http://www.boost.org/libs/range/
   8 //
   9 #include <boost/range/algorithm/merge.hpp>
  10
  11 #include <boost/test/test_tools.hpp>
  12 #include <boost/test/unit_test.hpp>
  13
  14 #include <boost/assign.hpp>
  15 #include <boost/bind.hpp>
  16 #include <algorithm>
  17 #include <functional>
  18 #include <list>
  19 #include <numeric>
  20 #include <deque>
  21 #include <vector>
  22
  23 namespace boost
  24 {
  25     namespace
  26     {
  27         template<class Container1, class Container2>
  28         void test(Container1& cont1, Container2& cont2)
  29         {
  30             typedef BOOST_DEDUCED_TYPENAME Container1::value_type value_t;
  31             typedef BOOST_DEDUCED_TYPENAME std::vector<value_t>::iterator iterator_t;
  32
  33             std::vector<value_t> reference_target( cont1.size() + cont2.size() );
  34
  35             iterator_t reference_it
  36                 = std::merge(cont1.begin(), cont1.end(),
  37                              cont2.begin(), cont2.end(),
  38                              reference_target.begin());
  39
  40             std::vector<value_t> test_target( cont1.size() + cont2.size() );
  41
  42             iterator_t test_it
  43                 = boost::merge(cont1, cont2, test_target.begin());
  44
  45             BOOST_CHECK_EQUAL(
  46                 std::distance<iterator_t>(reference_target.begin(), reference_it),
  47                 std::distance<iterator_t>(test_target.begin(), test_it)
  48                 );
  49
  50             BOOST_CHECK_EQUAL_COLLECTIONS(
  51                 reference_target.begin(), reference_target.end(),
  52                 test_target.begin(), test_target.end()
  53                 );
  54
  55             test_it = boost::merge(boost::make_iterator_range(cont1),
  56                                    cont2, test_target.begin());
  57
  58             BOOST_CHECK_EQUAL(
  59                 std::distance<iterator_t>(reference_target.begin(), reference_it),
  60                 std::distance<iterator_t>(test_target.begin(), test_it)
  61                 );
  62
  63             BOOST_CHECK_EQUAL_COLLECTIONS(
  64                 reference_target.begin(), reference_target.end(),
  65                 test_target.begin(), test_target.end()
  66                 );
  67
  68             test_it = boost::merge(cont1, boost::make_iterator_range(cont2),
  69                                    test_target.begin());
  70
  71             BOOST_CHECK_EQUAL(
  72                 std::distance<iterator_t>(reference_target.begin(), reference_it),
  73                 std::distance<iterator_t>(test_target.begin(), test_it)
  74                 );
  75
  76             BOOST_CHECK_EQUAL_COLLECTIONS(
  77                 reference_target.begin(), reference_target.end(),
  78                 test_target.begin(), test_target.end()
  79                 );
  80
  81             test_it = boost::merge(boost::make_iterator_range(cont1),
  82                                    boost::make_iterator_range(cont2),
  83                                    test_target.begin());
  84
  85             BOOST_CHECK_EQUAL(
  86                 std::distance<iterator_t>(reference_target.begin(), reference_it),
  87                 std::distance<iterator_t>(test_target.begin(), test_it)
  88                 );
  89
  90             BOOST_CHECK_EQUAL_COLLECTIONS(
  91                 reference_target.begin(), reference_target.end(),
  92                 test_target.begin(), test_target.end()
  93                 );
  94         }
  95
  96         template<class Container, class BinaryPredicate>
  97         void sort_container(Container& cont, BinaryPredicate pred)
  98         {
  99             typedef BOOST_DEDUCED_TYPENAME Container::value_type value_t;
 100
 101             std::vector<value_t> temp(cont.begin(), cont.end());
 102             std::sort(temp.begin(), temp.end(), pred);
 103             cont.assign(temp.begin(), temp.end());
 104         }
 105
 106         template<class Container1,
 107                  class Container2,
 108                  class BinaryPredicate>
 109         void test_pred(Container1 cont1, Container2 cont2, BinaryPredicate pred)
 110         {
 111             typedef BOOST_DEDUCED_TYPENAME Container1::value_type value_t;
 112             typedef BOOST_DEDUCED_TYPENAME std::vector<value_t>::iterator iterator_t;
 113
 114             sort_container(cont1, pred);
 115             sort_container(cont2, pred);
 116
 117             std::vector<value_t> reference_target( cont1.size() + cont2.size() );
 118
 119             iterator_t reference_it
 120                 = std::merge(cont1.begin(), cont1.end(),
 121                              cont2.begin(), cont2.end(),
 122                              reference_target.begin(), pred);
 123
 124             std::vector<value_t> test_target( cont1.size() + cont2.size() );
 125
 126             iterator_t test_it
 127                 = boost::merge(cont1, cont2, test_target.begin(), pred);
 128
 129             BOOST_CHECK_EQUAL(
 130                 std::distance(reference_target.begin(), reference_it),
 131                 std::distance(test_target.begin(), test_it)
 132                 );
 133
 134             BOOST_CHECK_EQUAL_COLLECTIONS(
 135                 reference_target.begin(), reference_target.end(),
 136                 test_target.begin(), test_target.end()
 137                 );
 138
 139             test_it = boost::merge(boost::make_iterator_range(cont1), cont2,
 140                                    test_target.begin(), pred);
 141
 142             BOOST_CHECK_EQUAL(
 143                 std::distance(reference_target.begin(), reference_it),
 144                 std::distance(test_target.begin(), test_it)
 145                 );
 146
 147             BOOST_CHECK_EQUAL_COLLECTIONS(
 148                 reference_target.begin(), reference_target.end(),
 149                 test_target.begin(), test_target.end()
 150                 );
 151
 152             test_it = boost::merge(cont1, boost::make_iterator_range(cont2),
 153                                    test_target.begin(), pred);
 154
 155             BOOST_CHECK_EQUAL(
 156                 std::distance(reference_target.begin(), reference_it),
 157                 std::distance(test_target.begin(), test_it)
 158                 );
 159
 160             BOOST_CHECK_EQUAL_COLLECTIONS(
 161                 reference_target.begin(), reference_target.end(),
 162                 test_target.begin(), test_target.end()
 163                 );
 164
 165             test_it = boost::merge(boost::make_iterator_range(cont1),
 166                                    boost::make_iterator_range(cont2),
 167                                    test_target.begin(), pred);
 168
 169             BOOST_CHECK_EQUAL(
 170                 std::distance(reference_target.begin(), reference_it),
 171                 std::distance(test_target.begin(), test_it)
 172                 );
 173
 174             BOOST_CHECK_EQUAL_COLLECTIONS(
 175                 reference_target.begin(), reference_target.end(),
 176                 test_target.begin(), test_target.end()
 177                 );
 178         }
 179
 180         template<class Container1, class Container2>
 181         void test_merge_impl(Container1& cont1, Container2& cont2)
 182         {
 183             test(cont1, cont2);
 184             test_pred(cont1, cont2, std::less<int>());
 185             test_pred(cont1, cont2, std::greater<int>());
 186         }
 187
 188         template<class Container1, class Container2>
 189         void test_merge_impl()
 190         {
 191             using namespace boost::assign;
 192
 193             Container1 cont1;
 194             Container2 cont2;
 195
 196             test_merge_impl(cont1, cont2);
 197
 198             cont1.clear();
 199             cont2.clear();
 200             cont1 += 1;
 201             test_merge_impl(cont1, cont2);
 202
 203             cont1.clear();
 204             cont2.clear();
 205             cont2 += 1;
 206             test_merge_impl(cont1, cont2);
 207
 208             cont1.clear();
 209             cont2.clear();
 210             cont1 += 1,3,5,7,9,11,13,15,17,19;
 211             cont2 += 2,4,6,8,10,12,14,16,18,20;
 212             test_merge_impl(cont1, cont2);
 213         }
 214
 215         void test_merge()
 216         {
 217             test_merge_impl< std::vector<int>, std::vector<int> >();
 218             test_merge_impl< std::list<int>, std::list<int> >();
 219             test_merge_impl< std::deque<int>, std::deque<int> >();
 220
 221             test_merge_impl< std::list<int>, std::vector<int> >();
 222             test_merge_impl< std::vector<int>, std::list<int> >();
 223         }
 224     }
 225 }
 226
 227
 228 boost::unit_test::test_suite*
 229 init_unit_test_suite(int argc, char* argv[])
 230 {
 231     boost::unit_test::test_suite* test
 232         = BOOST_TEST_SUITE( "RangeTestSuite.algorithm.merge" );
 233
 234     test->add( BOOST_TEST_CASE( &boost::test_merge ) );
 235
 236     return test;
 237 }