ceph/src/boost/libs/range/test/algorithm_test/set_intersection.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/set_algorithm.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 Iterator, class Container2>
  28         void check_result(
  29             Container1& reference,
  30             Iterator    reference_result,
  31             Container2& test_cont,
  32             Iterator    test_result
  33             )
  34         {
  35             BOOST_CHECK_EQUAL(
  36                 std::distance<Iterator>(reference.begin(), reference_result),
  37                 std::distance<Iterator>(test_cont.begin(), test_result)
  38                 );
  39
  40             BOOST_CHECK_EQUAL_COLLECTIONS(
  41                 reference.begin(), reference.end(),
  42                 test_cont.begin(), test_cont.end()
  43                 );
  44         }
  45
  46         template<class Container1, class Container2>
  47         void test(Container1& cont1, Container2& cont2)
  48         {
  49             typedef BOOST_DEDUCED_TYPENAME Container1::value_type value_t;
  50             typedef BOOST_DEDUCED_TYPENAME std::vector<value_t>::iterator iterator_t;
  51
  52             std::vector<value_t> reference(cont1.size() + cont2.size());
  53             std::vector<value_t> test_cont(reference);
  54
  55             iterator_t reference_result
  56                 = std::set_intersection(cont1.begin(), cont1.end(),
  57                                         cont2.begin(), cont2.end(),
  58                                         reference.begin());
  59
  60             iterator_t test_result
  61                 = boost::set_intersection(cont1, cont2, test_cont.begin());
  62
  63             check_result(reference, reference_result,
  64                          test_cont, test_result);
  65
  66             test_result = boost::set_intersection(
  67                             boost::make_iterator_range(cont1), cont2,
  68                             test_cont.begin());
  69
  70             check_result(reference, reference_result,
  71                          test_cont, test_result);
  72
  73             test_result = boost::set_intersection(
  74                             cont1, boost::make_iterator_range(cont2),
  75                             test_cont.begin());
  76
  77             check_result(reference, reference_result,
  78                          test_cont, test_result);
  79
  80             test_result = boost::set_intersection(
  81                             boost::make_iterator_range(cont1),
  82                             boost::make_iterator_range(cont2),
  83                             test_cont.begin());
  84
  85             check_result(reference, reference_result,
  86                          test_cont, test_result);
  87         }
  88
  89         template<class Container, class BinaryPredicate>
  90         void sort_container(Container& cont, BinaryPredicate pred)
  91         {
  92             typedef BOOST_DEDUCED_TYPENAME Container::value_type value_t;
  93
  94             std::vector<value_t> temp(cont.begin(), cont.end());
  95             std::sort(temp.begin(), temp.end(), pred);
  96             cont.assign(temp.begin(), temp.end());
  97         }
  98
  99         template<class Container1,
 100                  class Container2,
 101                  class BinaryPredicate>
 102         void test_pred(Container1 cont1, Container2 cont2,
 103                        BinaryPredicate pred)
 104         {
 105             typedef BOOST_DEDUCED_TYPENAME Container1::value_type value_t;
 106             typedef BOOST_DEDUCED_TYPENAME std::vector<value_t>::iterator iterator_t;
 107
 108             sort_container(cont1, pred);
 109             sort_container(cont2, pred);
 110
 111             std::vector<value_t> reference(cont1.size() + cont2.size());
 112             std::vector<value_t> test_cont(reference);
 113
 114             iterator_t reference_result
 115                 = std::set_intersection(cont1.begin(), cont1.end(),
 116                                         cont2.begin(), cont2.end(),
 117                                         reference.begin(),
 118                                         pred);
 119
 120             iterator_t test_result
 121                 = boost::set_intersection(cont1, cont2, test_cont.begin(), pred);
 122
 123             check_result(reference, reference_result,
 124                          test_cont, test_result);
 125
 126             test_result = boost::set_intersection(
 127                             boost::make_iterator_range(cont1), cont2,
 128                             test_cont.begin(), pred);
 129
 130             check_result(reference, reference_result,
 131                          test_cont, test_result);
 132
 133             test_result = boost::set_intersection(
 134                             cont1, boost::make_iterator_range(cont2),
 135                             test_cont.begin(), pred);
 136
 137             check_result(reference, reference_result,
 138                          test_cont, test_result);
 139
 140             test_result = boost::set_intersection(
 141                             boost::make_iterator_range(cont1),
 142                             boost::make_iterator_range(cont2),
 143                             test_cont.begin(), pred);
 144
 145             check_result(reference, reference_result,
 146                          test_cont, test_result);
 147         }
 148
 149         template<class Container1, class Container2>
 150         void test_set_intersection_impl(
 151             Container1& cont1,
 152             Container2& cont2
 153             )
 154         {
 155             test(cont1, cont2);
 156             test_pred(cont1, cont2, std::less<int>());
 157             test_pred(cont1, cont2, std::greater<int>());
 158         }
 159
 160         template<class Container1, class Container2>
 161         void test_set_intersection_impl()
 162         {
 163             using namespace boost::assign;
 164
 165             Container1 cont1;
 166             Container2 cont2;
 167
 168             test_set_intersection_impl(cont1, cont2);
 169
 170             cont1.clear();
 171             cont2.clear();
 172             cont1 += 1;
 173             test_set_intersection_impl(cont1, cont2);
 174
 175             cont1.clear();
 176             cont2.clear();
 177             cont2 += 1;
 178             test_set_intersection_impl(cont1, cont2);
 179
 180             cont1.clear();
 181             cont2.clear();
 182             cont1 += 1,2,3,4,5,6,7,8,9;
 183             cont2 += 2,3,4;
 184             test_set_intersection_impl(cont1, cont2);
 185
 186             cont1.clear();
 187             cont2.clear();
 188             cont1 += 2,3,4;
 189             cont2 += 1,2,3,4,5,6,7,8,9;
 190             test_set_intersection_impl(cont1, cont2);
 191         }
 192
 193         void test_set_intersection()
 194         {
 195             test_set_intersection_impl< std::vector<int>, std::vector<int> >();
 196             test_set_intersection_impl< std::list<int>, std::list<int> >();
 197             test_set_intersection_impl< std::deque<int>, std::deque<int> >();
 198             test_set_intersection_impl< std::vector<int>, std::list<int> >();
 199             test_set_intersection_impl< std::list<int>, std::vector<int> >();
 200         }
 201     }
 202 }
 203
 204
 205 boost::unit_test::test_suite*
 206 init_unit_test_suite(int argc, char* argv[])
 207 {
 208     boost::unit_test::test_suite* test
 209         = BOOST_TEST_SUITE( "RangeTestSuite.algorithm.set_intersection" );
 210
 211     test->add( BOOST_TEST_CASE( &boost::test_set_intersection ) );
 212
 213     return test;
 214 }