← Back to branch summary

~ubuntu-branches/debian/sid/boost1.49/sid

« back to all changes in this revision

Viewing changes to libs/range/test/algorithm_test/mismatch.cpp

  • Committer: Package Import Robot
  • Author(s): Steve M. Robbins
  • Date: 2012-02-26 00:31:44 UTC
  • Revision ID: package-import@ubuntu.com-20120226003144-eaytp12cbf6ubpms
Tags: upstream-1.49.0
Import upstream version 1.49.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
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 iterator1_t;
 
164
            typedef BOOST_DEDUCED_TYPENAME Container1::const_iterator const_iterator1_t;
 
165
            typedef BOOST_DEDUCED_TYPENAME Container2::iterator iterator2_t;
 
166
            typedef BOOST_DEDUCED_TYPENAME Container2::const_iterator const_iterator2_t;
 
167
 
 
168
            typedef std::pair<iterator1_t,       iterator2_t>       pair_mmit_t;
 
169
            typedef std::pair<const_iterator1_t, iterator2_t>       pair_cmit_t;
 
170
            typedef std::pair<iterator1_t,       const_iterator2_t> pair_mcit_t;
 
171
            typedef std::pair<const_iterator1_t, const_iterator2_t> pair_ccit_t;
 
172
 
 
173
            eval_mismatch(cont1, cont2, cont1.end(), cont2.end());
 
174
            eval_mismatch(cont1, cont2, std::equal_to<int>(), cont1.end(), cont2.end());
 
175
            eval_mismatch(cref_cont1, cont2, cref_cont1.end(), cont2.end());
 
176
            eval_mismatch(cref_cont1, cont2, std::equal_to<int>(), cref_cont1.end(), cont2.end());
 
177
            eval_mismatch(cont1, cref_cont2, cont1.end(), cref_cont2.end());
 
178
            eval_mismatch(cont1, cref_cont2, std::equal_to<int>(), cont1.end(), cref_cont2.end());
 
179
            eval_mismatch(cref_cont1, cref_cont2, cref_cont1.end(), cref_cont2.end());
 
180
            eval_mismatch(cref_cont1, cref_cont2, std::equal_to<int>(), cref_cont1.end(), cref_cont2.end());
 
181
 
 
182
            cont1 += 1,2,3,4;
 
183
            cont2 += 1,2,3,4;
 
184
            eval_mismatch(cont1, cont2, cont1.end(), cont2.end());
 
185
            eval_mismatch(cont1, cont2, std::equal_to<int>(), cont1.end(), cont2.end());
 
186
            eval_mismatch(cref_cont1, cont2, cref_cont1.end(), cont2.end());
 
187
            eval_mismatch(cref_cont1, cont2, std::equal_to<int>(), cref_cont1.end(), cont2.end());
 
188
            eval_mismatch(cont1, cref_cont2, cont1.end(), cref_cont2.end());
 
189
            eval_mismatch(cont1, cref_cont2, std::equal_to<int>(), cont1.end(), cref_cont2.end());
 
190
            eval_mismatch(cref_cont1, cref_cont2, cref_cont1.end(), cref_cont2.end());
 
191
            eval_mismatch(cref_cont1, cref_cont2, std::equal_to<int>(), cref_cont1.end(), cref_cont2.end());
 
192
 
 
193
            cont1.clear();
 
194
            cont2.clear();
 
195
            cont1 += 1,2,3,4;
 
196
            cont2 += 1,2,5,4;
 
197
            eval_mismatch(cont1, cont2, 3, 5);
 
198
            eval_mismatch(cont1, cont2, std::equal_to<int>(), 3, 5);
 
199
            eval_mismatch(cont1, cont2, std::not_equal_to<int>(), cont1.begin(), cont2.begin());
 
200
            eval_mismatch(cref_cont1, cont2, 3, 5);
 
201
            eval_mismatch(cref_cont1, cont2, std::equal_to<int>(), 3, 5);
 
202
            eval_mismatch(cref_cont1, cont2, std::not_equal_to<int>(), cref_cont1.begin(), cont2.begin());
 
203
            eval_mismatch(cont1, cref_cont2, 3, 5);
 
204
            eval_mismatch(cont1, cref_cont2, std::equal_to<int>(), 3, 5);
 
205
            eval_mismatch(cont1, cref_cont2, std::not_equal_to<int>(), cont1.begin(), cref_cont2.begin());
 
206
            eval_mismatch(cref_cont1, cref_cont2, 3, 5);
 
207
            eval_mismatch(cref_cont1, cref_cont2, std::equal_to<int>(), 3, 5);
 
208
            eval_mismatch(cref_cont1, cref_cont2, std::not_equal_to<int>(), cref_cont1.begin(), cref_cont2.begin());
 
209
        }
 
210
 
 
211
        void test_mismatch()
 
212
        {
 
213
            test_mismatch_impl< std::list<int>, std::list<int> >();
 
214
            test_mismatch_impl< const std::list<int>, std::list<int> >();
 
215
            test_mismatch_impl< std::list<int>, const std::list<int> >();
 
216
            test_mismatch_impl< const std::list<int>, const std::list<int> >();
 
217
 
 
218
            test_mismatch_impl< std::vector<int>, std::list<int> >();
 
219
            test_mismatch_impl< const std::vector<int>, std::list<int> >();
 
220
            test_mismatch_impl< std::vector<int>, const std::list<int> >();
 
221
            test_mismatch_impl< const std::vector<int>, const std::list<int> >();
 
222
 
 
223
            test_mismatch_impl< std::list<int>, std::vector<int> >();
 
224
            test_mismatch_impl< const std::list<int>, std::vector<int> >();
 
225
            test_mismatch_impl< std::list<int>, const std::vector<int> >();
 
226
            test_mismatch_impl< const std::list<int>, const std::vector<int> >();
 
227
        }
 
228
    }
 
229
}
 
230
 
 
231
boost::unit_test::test_suite*
 
232
init_unit_test_suite(int argc, char* argv[])
 
233
{
 
234
    boost::unit_test::test_suite* test
 
235
        = BOOST_TEST_SUITE( "RangeTestSuite.algorithm.mismatch" );
 
236
 
 
237
    test->add( BOOST_TEST_CASE( &boost::test_mismatch ) );
 
238
 
 
239
    return test;
 
240
}