libs/range/test/algorithm_test/mismatch.cpp

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