]>
Commit | Line | Data |
---|---|---|
7c673cae FG |
1 | // Boost.Assign library |
2 | // | |
3 | // Copyright Thorsten Ottosen 2003-2004. 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 | // For more information, see http://www.boost.org/libs/assign/ | |
9 | // | |
10 | ||
11 | ||
12 | #include <boost/detail/workaround.hpp> | |
13 | ||
14 | #if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) | |
b32b8144 | 15 | # pragma warn -8091 // suppress warning in Boost.Test |
7c673cae FG |
16 | # pragma warn -8057 // unused argument argc/argv in Boost.Test |
17 | #endif | |
18 | ||
19 | #include <boost/assign/list_of.hpp> | |
20 | #include <boost/test/test_tools.hpp> | |
21 | #include <boost/array.hpp> | |
22 | #include <algorithm> | |
23 | #include <vector> | |
24 | #include <list> | |
25 | #include <deque> | |
26 | #include <set> | |
27 | #include <map> | |
28 | #include <stack> | |
29 | #include <string> | |
30 | #include <cstdlib> | |
31 | #include <complex> | |
32 | ||
33 | struct nothing | |
34 | { | |
35 | template< class T > | |
36 | void operator()( T ) | |
37 | { } | |
38 | ||
39 | }; | |
40 | ||
41 | template< class Range > | |
42 | void for_each( const Range& r ) | |
43 | { | |
44 | std::for_each( r.begin(), r.end(), nothing() ); | |
45 | } | |
46 | ||
47 | namespace ba = boost::assign; | |
48 | ||
49 | template< class C > | |
50 | void test_sequence_list_of_string() | |
51 | { | |
52 | #if BOOST_WORKAROUND(BOOST_MSVC, <=1300) | |
53 | const C c = ba::list_of( "foo" )( "bar" ).to_container( c ); | |
54 | #else | |
55 | const C c = ba::list_of( "foo" )( "bar" ); | |
56 | #endif | |
57 | BOOST_CHECK_EQUAL( c.size(), 2u ); | |
58 | } | |
59 | ||
60 | struct parameter_list | |
61 | { | |
62 | int val; | |
63 | ||
64 | template< class T > | |
65 | parameter_list( T ) | |
66 | : val(0) | |
67 | { } | |
68 | ||
69 | template< class T > | |
70 | parameter_list( const T&, int ) | |
71 | : val(1) | |
72 | { } | |
73 | }; | |
74 | ||
75 | template< class C > | |
76 | void test_sequence_list_of_int() | |
77 | { | |
78 | using namespace std; | |
79 | #if BOOST_WORKAROUND(BOOST_MSVC, <=1300) | |
80 | ||
81 | const C c = ba::list_of<int>(1)(2)(3)(4).to_container( c ); | |
82 | const C c2 = ba::list_of(1)(2)(3)(4).to_container( c2 ); | |
83 | BOOST_CHECK_EQUAL( c.size(), 4u ); | |
84 | BOOST_CHECK_EQUAL( c2.size(), 4u ); | |
85 | C c3 = ba::list_of(1).repeat( 1, 2 )(3).to_container( c3 ); | |
86 | BOOST_CHECK_EQUAL( c3.size(), 3u ); | |
87 | ||
88 | c3 = ba::list_of(1).repeat_fun( 10, &rand )(2)(3).to_container( c3 ); | |
89 | BOOST_CHECK_EQUAL( c3.size(), 13u ); | |
90 | ||
91 | #else | |
92 | ||
93 | const C c = ba::list_of<int>(1)(2)(3)(4); | |
94 | const C c2 = ba::list_of(1)(2)(3)(4); | |
95 | BOOST_CHECK_EQUAL( c.size(), 4u ); | |
96 | BOOST_CHECK_EQUAL( c2.size(), 4u ); | |
97 | C c3 = ba::list_of(1).repeat( 1, 2 )(3); | |
98 | BOOST_CHECK_EQUAL( c3.size(), 3u ); | |
99 | ||
100 | #if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) | |
101 | // BCB fails to use operator=() directly, | |
102 | // it must be worked around using e.g. auxiliary variable | |
103 | C aux = ba::list_of(1).repeat_fun( 10, &rand )(2)(3); | |
104 | BOOST_CHECK_EQUAL( aux.size(), 13u ); | |
105 | c3 = aux; | |
106 | BOOST_CHECK_EQUAL( c3.size(), 13u ); | |
107 | #else | |
108 | c3 = ba::list_of(1).repeat_fun( 10, &rand )(2)(3); | |
109 | BOOST_CHECK_EQUAL( c3.size(), 13u ); | |
110 | #endif | |
111 | ||
112 | #endif | |
113 | ||
114 | parameter_list p( ba::list_of(1)(2), 3u ); | |
115 | BOOST_CHECK_EQUAL( p.val, 1 ); | |
116 | ||
117 | } | |
118 | ||
119 | template< class C > | |
120 | void test_map_list_of() | |
121 | { | |
122 | const C c = ba::list_of< std::pair<std::string,int> >( "foo", 1 )( "bar", 2 )( "buh", 3 )( "bah", 4 ); | |
123 | BOOST_CHECK_EQUAL( c.size(), 4u ); | |
124 | const C c2 = ba::map_list_of( "foo", 1 )( "bar", 2 )( "buh", 3 )( "bah", 4 ); | |
125 | BOOST_CHECK_EQUAL( c2.size(), 4u ); | |
126 | } | |
127 | ||
128 | void test_vector_matrix() | |
129 | { | |
130 | using namespace boost; | |
131 | using namespace boost::assign; | |
132 | using namespace std; | |
133 | using boost::array; | |
134 | ||
135 | #if BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB, == 1) || BOOST_WORKAROUND(BOOST_MSVC, <=1300) | |
136 | #else | |
137 | ||
138 | const int sz = 3; | |
139 | typedef array<int,sz> row3; | |
140 | typedef array<row3,sz> matrix3x3; | |
141 | ||
142 | ||
143 | matrix3x3 m = list_of( list_of(1)(2)(3) ) | |
144 | ( list_of(4)(5)(6) ) | |
145 | ( list_of(7)(8)(9) ); | |
146 | ||
147 | for( int i = 0; i != sz; ++i ) | |
148 | for( int j = 0; j != sz; ++j ) | |
149 | BOOST_CHECK_EQUAL( m[i][j], i*sz + j + 1 ); | |
150 | ||
151 | typedef vector<int> row; | |
152 | typedef vector<row> matrix; | |
153 | ||
154 | // | |
155 | // note: some libraries need a little help | |
156 | // with the conversion, hence the 'row' template parameter. | |
157 | // | |
158 | matrix m2 = list_of< row >( list_of(1)(2)(3) ) | |
159 | ( list_of(4)(5) ) | |
160 | ( list_of(6) ); | |
161 | ||
162 | for( int i = 0; i != sz; ++i ) | |
163 | for( int j = 0; j != sz - i; ++j ) | |
164 | BOOST_CHECK_EQUAL( m[i][j], i*sz + j + 1 ); | |
165 | ||
166 | #endif | |
167 | ||
168 | } | |
169 | ||
170 | void test_map_list_of() | |
171 | { | |
172 | /* | |
173 | maybe in the future... | |
174 | ||
175 | using namespace std; | |
176 | using namespace boost::assign; | |
177 | ||
178 | typedef vector<int> score_type; | |
179 | typedef map<string,score_type> team_score_map; | |
180 | ||
181 | team_score_map team_score = map_list_of | |
182 | ( "Team Foo", list_of(1)(1)(0) ) | |
183 | ( "Team Bar", list_of(0)(0)(0) ) | |
184 | ( "Team FooBar", list_of(0)(0)(1) ); | |
185 | BOOST_CHECK_EQUAL( team_score.size(), 3 ); | |
186 | BOOST_CHECK_EQUAL( team_score[ "Team Foo" ][1], 1 ); | |
187 | BOOST_CHECK_EQUAL( team_score[ "Team Bar" ][0], 0 ); | |
188 | */ | |
189 | ||
190 | } | |
191 | ||
192 | /* | |
193 | void test_complex_list_of() | |
194 | { | |
195 | typedef std::complex<float> complex_t; | |
196 | std::vector<complex_t> v; | |
197 | v = ba::list_of<complex_t>(1,2)(2,3)(4,5)(0). | |
198 | repeat_from_to( complex_t(0,0), complex_t(10,10), complex_t(1,1) ); | |
199 | } | |
200 | */ | |
201 | ||
202 | struct five | |
203 | { | |
204 | five( int, int, int, int, int ) | |
205 | { | |
206 | } | |
207 | }; | |
208 | ||
209 | void test_list_of() | |
210 | { | |
211 | ba::list_of< five >(1,2,3,4,5)(6,7,8,9,10); | |
212 | ||
213 | /* Maybe this could be usefull in a later version? | |
214 | ||
215 | // an anonymous lists, fulfills Range concept | |
216 | for_each( ba::list_of( T() )( T() )( T() ) ); | |
217 | ||
218 | // non-anonymous lists | |
219 | ba::generic_list<T> list_1 = ba::list_of( T() ); | |
220 | BOOST_CHECK_EQUAL( list_1.size(), 1 ); | |
221 | ba::generic_list<T> list_2 = list_1 + ba::list_of( T() )( T() ) + list_1; | |
222 | BOOST_CHECK_EQUAL( list_2.size(), 4 ); | |
223 | list_1 += list_2; | |
224 | BOOST_CHECK_EQUAL( list_1.size(), 5 ); | |
225 | */ | |
226 | } | |
227 | ||
228 | // | |
229 | // @remark: ADL is required here, but it is a bit wierd to | |
230 | // open up namespace std. Perhaps Boost.Test needs a | |
231 | // better configuration option. | |
232 | // | |
233 | namespace std | |
234 | { | |
235 | template< class T, class Elem, class Traits > | |
236 | inline std::basic_ostream<Elem,Traits>& | |
237 | operator<<( std::basic_ostream<Elem, Traits>& Os, | |
238 | const std::vector<T>& r ) | |
239 | { | |
240 | return Os << ::boost::make_iterator_range( r.begin(), r.end() ); | |
241 | } | |
242 | } | |
243 | ||
244 | template <class Seq> | |
245 | inline std::vector<int> as_seq( const Seq& s ) | |
246 | { | |
247 | std::vector<int> c; | |
248 | return s.to_container( c ); | |
249 | } | |
250 | ||
251 | void test_comparison_operations() | |
252 | { | |
253 | BOOST_CHECK_EQUAL( ba::list_of(0)(1)(2), as_seq(ba::list_of(0)(1)(2)) ); | |
254 | BOOST_CHECK_NE( ba::list_of(0)(1)(2), as_seq(ba::list_of(-1)(1)(2)) ); | |
255 | BOOST_CHECK_LT( ba::list_of(0)(1)(2), as_seq(ba::list_of(0)(1)(3)) ); | |
256 | BOOST_CHECK_LE( ba::list_of(0)(1)(2), as_seq(ba::list_of(0)(1)(2)) ); | |
257 | BOOST_CHECK_GT( ba::list_of(0)(1)(3), as_seq(ba::list_of(0)(1)(2)) ); | |
258 | BOOST_CHECK_GE( ba::list_of(0)(1)(2), as_seq(ba::list_of(0)(1)(2)) ); | |
259 | BOOST_CHECK_EQUAL( as_seq(ba::list_of(0)(1)(2)), ba::list_of(0)(1)(2) ); | |
260 | BOOST_CHECK_NE( as_seq(ba::list_of(0)(1)(2)), ba::list_of(-1)(1)(2) ); | |
261 | BOOST_CHECK_LT( as_seq(ba::list_of(0)(1)(2)), ba::list_of(0)(1)(3) ); | |
262 | BOOST_CHECK_LE( as_seq(ba::list_of(0)(1)(2)), ba::list_of(0)(1)(2) ); | |
263 | BOOST_CHECK_GT( as_seq(ba::list_of(0)(1)(3)), ba::list_of(0)(1)(2) ); | |
264 | BOOST_CHECK_GE( as_seq(ba::list_of(0)(1)(2)), ba::list_of(0)(1)(2) ); | |
265 | } | |
266 | ||
267 | void check_list_of() | |
268 | { | |
269 | test_sequence_list_of_int< std::vector<int> >(); | |
270 | test_sequence_list_of_int< std::list<int> >(); | |
271 | test_sequence_list_of_int< std::deque<int> >(); | |
272 | test_sequence_list_of_int< std::set<int> >(); | |
273 | test_sequence_list_of_int< std::multiset<int> >(); | |
274 | test_sequence_list_of_int< std::vector<float> >(); | |
275 | ||
276 | test_sequence_list_of_string< std::vector<std::string> >(); | |
277 | ||
278 | test_map_list_of< std::map<std::string,int> >(); | |
279 | test_map_list_of< std::multimap<std::string,int> >(); | |
280 | ||
281 | std::stack<std::string> s = ba::list_of( "Foo" )( "Bar" )( "FooBar" ).to_adapter( s ); | |
282 | test_list_of(); | |
283 | test_vector_matrix(); | |
284 | test_comparison_operations(); | |
285 | } | |
286 | ||
287 | ||
288 | ||
289 | #include <boost/test/unit_test.hpp> | |
290 | using boost::unit_test::test_suite; | |
291 | ||
292 | test_suite* init_unit_test_suite( int argc, char* argv[] ) | |
293 | { | |
294 | test_suite* test = BOOST_TEST_SUITE( "List Test Suite" ); | |
295 | ||
296 | test->add( BOOST_TEST_CASE( &check_list_of ) ); | |
297 | ||
298 | return test; | |
299 | } | |
300 | ||
301 |