1 | ////////////////////////////////////////////////////////////////////////////// |
2 | // |
3 | // (C) Copyright Ion Gaztanaga 2007-2017. |
4 | // Distributed under the Boost Software License, Version 1.0. |
5 | // (See accompanying file LICENSE_1_0.txt or copy at |
6 | // http://www.boost.org/LICENSE_1_0.txt) |
7 | // |
8 | // See http://www.boost.org/libs/move for documentation. |
9 | // |
10 | ////////////////////////////////////////////////////////////////////////////// |
11 | #include <boost/move/algo/detail/set_difference.hpp> |
12 | #include "order_type.hpp" |
13 | #include <boost/core/lightweight_test.hpp> |
14 | #include <cstddef> |
15 | /* |
16 | /////////////////////////////////// |
17 | // |
18 | // set_difference |
19 | // |
20 | /////////////////////////////////// |
21 | void test_set_difference_normal() |
22 | { |
23 | order_perf_type range2[10]; |
24 | for(std::size_t i = 0; i != sizeof(range2)/sizeof(*range2); ++i){ |
25 | range2[i].key = i*2; |
26 | range2[i].val = 0u; |
27 | } |
28 | |
29 | order_perf_type range1[4]; |
30 | range1[0].key = 0u; |
31 | range1[0].val = 1u; |
32 | range1[1].key = 1u; |
33 | range1[1].val = 1u; |
34 | range1[2].key = 3u; |
35 | range1[2].val = 1u; |
36 | range1[3].key = 4u; |
37 | range1[3].val = 1u; |
38 | |
39 | order_perf_type out[20]; |
40 | out[2].key = 998; |
41 | out[2].val = 999; |
42 | boost::movelib::set_difference(range1, range1+4, range2, range2+10, out, order_type_less()); |
43 | BOOST_TEST(out[0].key == 1u); |
44 | BOOST_TEST(out[0].val == 1u); |
45 | BOOST_TEST(out[1].key == 3u); |
46 | BOOST_TEST(out[1].val == 1u); |
47 | BOOST_TEST(out[2].key == 998); |
48 | BOOST_TEST(out[2].val == 999); |
49 | } |
50 | |
51 | void test_set_difference_range1_repeated() |
52 | { |
53 | order_perf_type range2[10]; |
54 | for(std::size_t i = 0; i != sizeof(range2)/sizeof(*range2); ++i){ |
55 | range2[i].key = i*2; |
56 | range2[i].val = 0u; |
57 | } |
58 | |
59 | order_perf_type range1[4]; |
60 | range1[0].key = 0u; |
61 | range1[0].val = 1u; |
62 | range1[1].key = 2u; |
63 | range1[1].val = 1u; |
64 | range1[2].key = 4u; |
65 | range1[2].val = 1u; |
66 | range1[3].key = 6u; |
67 | range1[3].val = 1u; |
68 | |
69 | order_perf_type out[20]; |
70 | out[0].key = 998; |
71 | out[0].val = 999; |
72 | boost::movelib::set_difference(range1, range1+4, range2, range2+10, out, order_type_less()); |
73 | BOOST_TEST(out[0].key == 998); |
74 | BOOST_TEST(out[0].val == 999); |
75 | } |
76 | |
77 | void test_set_difference_range1_unique() |
78 | { |
79 | order_perf_type range2[10]; |
80 | for(std::size_t i = 0; i != sizeof(range2)/sizeof(*range2); ++i){ |
81 | range2[i].key = i*2; |
82 | range2[i].val = 0u; |
83 | } |
84 | |
85 | order_perf_type range1[4]; |
86 | range1[0].key = 1u; |
87 | range1[0].val = 1u; |
88 | range1[1].key = 3u; |
89 | range1[1].val = 1u; |
90 | range1[2].key = 5u; |
91 | range1[2].val = 1u; |
92 | range1[3].key = 7u; |
93 | range1[3].val = 1u; |
94 | |
95 | order_perf_type out[20]; |
96 | out[4].key = 998; |
97 | out[4].val = 999; |
98 | boost::movelib::set_difference(range1, range1+4, range2, range2+10, out, order_type_less()); |
99 | BOOST_TEST(out[0].key == 1u); |
100 | BOOST_TEST(out[0].val == 1u); |
101 | BOOST_TEST(out[1].key == 3u); |
102 | BOOST_TEST(out[1].val == 1u); |
103 | BOOST_TEST(out[2].key == 5u); |
104 | BOOST_TEST(out[3].val == 1u); |
105 | BOOST_TEST(out[3].key == 7u); |
106 | BOOST_TEST(out[3].val == 1u); |
107 | BOOST_TEST(out[4].key == 998); |
108 | BOOST_TEST(out[4].val == 999); |
109 | } |
110 | */ |
111 | |
112 | /////////////////////////////////// |
113 | // |
114 | // set_difference |
115 | // |
116 | /////////////////////////////////// |
117 | void test_set_difference_normal() |
118 | { |
119 | order_perf_type range2[10]; |
120 | for(std::size_t i = 0; i != sizeof(range2)/sizeof(*range2); ++i){ |
121 | range2[i].key = i*2; |
122 | range2[i].val = 0u; |
123 | } |
124 | |
125 | order_perf_type range1[5]; |
126 | range1[0].key = 0u; |
127 | range1[0].val = 1u; |
128 | range1[1].key = 1u; |
129 | range1[1].val = 1u; |
130 | range1[2].key = 1u; |
131 | range1[2].val = 2u; |
132 | range1[3].key = 3u; |
133 | range1[3].val = 1u; |
134 | range1[4].key = 4u; |
135 | range1[4].val = 1u; |
136 | |
137 | order_perf_type out[20]; |
138 | out[3].key = 998; |
139 | out[3].val = 999; |
140 | order_perf_type *r = |
141 | boost::movelib::set_difference(first1: range1, last1: range1+5, first2: range2, last2: range2+10, result: out, comp: order_type_less()); |
142 | BOOST_TEST(&out[3] == r); |
143 | BOOST_TEST(out[0].key == 1u); |
144 | BOOST_TEST(out[0].val == 1u); |
145 | BOOST_TEST(out[1].key == 1u); |
146 | BOOST_TEST(out[1].val == 2u); |
147 | BOOST_TEST(out[2].key == 3u); |
148 | BOOST_TEST(out[2].val == 1u); |
149 | BOOST_TEST(out[3].key == 998); |
150 | BOOST_TEST(out[3].val == 999); |
151 | } |
152 | |
153 | void test_set_difference_range1_repeated() |
154 | { |
155 | order_perf_type range2[10]; |
156 | for(std::size_t i = 0; i != sizeof(range2)/sizeof(*range2); ++i){ |
157 | range2[i].key = i*2; |
158 | range2[i].val = 0u; |
159 | } |
160 | |
161 | order_perf_type range1[5]; |
162 | range1[0].key = 0u; |
163 | range1[0].val = 1u; |
164 | range1[1].key = 2u; |
165 | range1[1].val = 1u; |
166 | range1[2].key = 2u; |
167 | range1[2].val = 2u; |
168 | range1[3].key = 4u; |
169 | range1[3].val = 1u; |
170 | range1[4].key = 6u; |
171 | range1[4].val = 1u; |
172 | |
173 | order_perf_type out[20]; |
174 | out[0].key = 998; |
175 | out[0].val = 999; |
176 | order_perf_type *r = |
177 | boost::movelib::set_difference(first1: range1, last1: range1+5, first2: range2, last2: range2+10, result: out, comp: order_type_less()); |
178 | BOOST_TEST(&out[1] == r); |
179 | BOOST_TEST(out[0].key == 2); |
180 | BOOST_TEST(out[0].val == 2); |
181 | } |
182 | |
183 | void test_set_difference_range1_unique() |
184 | { |
185 | order_perf_type range2[10]; |
186 | for(std::size_t i = 0; i != sizeof(range2)/sizeof(*range2); ++i){ |
187 | range2[i].key = i*2; |
188 | range2[i].val = 0u; |
189 | } |
190 | |
191 | order_perf_type range1[5]; |
192 | range1[0].key = 1u; |
193 | range1[0].val = 1u; |
194 | range1[1].key = 3u; |
195 | range1[1].val = 1u; |
196 | range1[2].key = 5u; |
197 | range1[2].val = 1u; |
198 | range1[3].key = 7u; |
199 | range1[3].val = 1u; |
200 | range1[4].key = 7u; |
201 | range1[4].val = 2u; |
202 | |
203 | order_perf_type out[20]; |
204 | out[5].key = 998; |
205 | out[5].val = 999; |
206 | order_perf_type *r = |
207 | boost::movelib::set_difference(first1: range1, last1: range1+5, first2: range2, last2: range2+10, result: out, comp: order_type_less()); |
208 | BOOST_TEST(&out[5] == r); |
209 | BOOST_TEST(out[0].key == 1u); |
210 | BOOST_TEST(out[0].val == 1u); |
211 | BOOST_TEST(out[1].key == 3u); |
212 | BOOST_TEST(out[1].val == 1u); |
213 | BOOST_TEST(out[2].key == 5u); |
214 | BOOST_TEST(out[2].val == 1u); |
215 | BOOST_TEST(out[3].key == 7u); |
216 | BOOST_TEST(out[3].val == 1u); |
217 | BOOST_TEST(out[4].key == 7u); |
218 | BOOST_TEST(out[4].val == 2u); |
219 | BOOST_TEST(out[5].key == 998); |
220 | BOOST_TEST(out[5].val == 999); |
221 | } |
222 | |
223 | /* |
224 | /////////////////////////////////// |
225 | // |
226 | // inplace_set_difference |
227 | // |
228 | /////////////////////////////////// |
229 | void test_inplace_set_difference_normal() |
230 | { |
231 | order_move_type range2[10]; |
232 | for(std::size_t i = 0; i != sizeof(range2)/sizeof(*range2); ++i){ |
233 | range2[i].key = i*2; |
234 | range2[i].val = 0u; |
235 | } |
236 | |
237 | order_move_type range1[4]; |
238 | range1[0].key = 0u; |
239 | range1[0].val = 1u; |
240 | range1[1].key = 1u; |
241 | range1[1].val = 1u; |
242 | range1[2].key = 3u; |
243 | range1[2].val = 1u; |
244 | range1[3].key = 4u; |
245 | range1[3].val = 1u; |
246 | |
247 | order_move_type *ret = boost::movelib::inplace_set_difference(range1, range1+4, range2, range2+10, order_type_less()); |
248 | BOOST_TEST(ret == range1+2); |
249 | BOOST_TEST(range1[0].key == 1u); |
250 | BOOST_TEST(range1[0].val == 1u); |
251 | BOOST_TEST(range1[1].key == 3u); |
252 | BOOST_TEST(range1[1].val == 1u); |
253 | BOOST_TEST(range1[2].key == order_move_type::moved_assign_mark); |
254 | BOOST_TEST(range1[2].val == order_move_type::moved_assign_mark); |
255 | } |
256 | |
257 | void test_inplace_set_difference_range1_repeated() |
258 | { |
259 | order_move_type range2[10]; |
260 | for(std::size_t i = 0; i != sizeof(range2)/sizeof(*range2); ++i){ |
261 | range2[i].key = i*2; |
262 | range2[i].val = 0u; |
263 | } |
264 | |
265 | order_move_type range1[5]; |
266 | range1[0].key = 0u; |
267 | range1[0].val = 1u; |
268 | range1[1].key = 2u; |
269 | range1[1].val = 1u; |
270 | range1[2].key = 4u; |
271 | range1[2].val = 1u; |
272 | range1[3].key = 6u; |
273 | range1[3].val = 1u; |
274 | range1[4].key = order_move_type::moved_assign_mark; |
275 | range1[4].val = order_move_type::moved_assign_mark; |
276 | |
277 | order_move_type *ret = boost::movelib::inplace_set_difference(range1, range1+4, range2, range2+10, order_type_less()); |
278 | BOOST_TEST(ret == range1+0); |
279 | BOOST_TEST(range1[0].key == 0u); |
280 | BOOST_TEST(range1[0].val == 1u); |
281 | BOOST_TEST(range1[1].key == 2u); |
282 | BOOST_TEST(range1[1].val == 1u); |
283 | BOOST_TEST(range1[2].key == 4u); |
284 | BOOST_TEST(range1[3].val == 1u); |
285 | BOOST_TEST(range1[3].key == 6u); |
286 | BOOST_TEST(range1[3].val == 1u); |
287 | BOOST_TEST(range1[4].key == order_move_type::moved_assign_mark); |
288 | BOOST_TEST(range1[4].val == order_move_type::moved_assign_mark); |
289 | } |
290 | |
291 | void test_inplace_set_difference_range1_unique() |
292 | { |
293 | order_move_type range2[10]; |
294 | for(std::size_t i = 0; i != sizeof(range2)/sizeof(*range2); ++i){ |
295 | range2[i].key = i*2; |
296 | range2[i].val = 0u; |
297 | } |
298 | |
299 | order_move_type range1[5]; |
300 | range1[0].key = 1u; |
301 | range1[0].val = 1u; |
302 | range1[1].key = 3u; |
303 | range1[1].val = 1u; |
304 | range1[2].key = 5u; |
305 | range1[2].val = 1u; |
306 | range1[3].key = 7u; |
307 | range1[3].val = 1u; |
308 | range1[4].key = order_move_type::moved_assign_mark; |
309 | range1[4].val = order_move_type::moved_assign_mark; |
310 | |
311 | order_move_type *ret = boost::movelib::inplace_set_difference(range1, range1+4, range2, range2+10, order_type_less()); |
312 | BOOST_TEST(ret == range1+4); |
313 | BOOST_TEST(range1[0].key == 1u); |
314 | BOOST_TEST(range1[0].val == 1u); |
315 | BOOST_TEST(range1[1].key == 3u); |
316 | BOOST_TEST(range1[1].val == 1u); |
317 | BOOST_TEST(range1[2].key == 5u); |
318 | BOOST_TEST(range1[3].val == 1u); |
319 | BOOST_TEST(range1[3].key == 7u); |
320 | BOOST_TEST(range1[3].val == 1u); |
321 | BOOST_TEST(range1[4].key == order_move_type::moved_assign_mark); |
322 | BOOST_TEST(range1[4].val == order_move_type::moved_assign_mark); |
323 | } |
324 | |
325 | void test_inplace_set_difference_range1_unique_long() |
326 | { |
327 | order_move_type range2[10]; |
328 | for(std::size_t i = 0; i != sizeof(range2)/sizeof(*range2); ++i){ |
329 | range2[i].key = i*2; |
330 | range2[i].val = 0u; |
331 | } |
332 | |
333 | order_move_type range1[11]; |
334 | for(std::size_t i = 0; i != sizeof(range1)/sizeof(*range1); ++i){ |
335 | range1[i].key = i*2+1; |
336 | range1[i].val = 1u; |
337 | } |
338 | |
339 | order_move_type *ret = boost::movelib::inplace_set_difference(range1, range1+11, range2, range2+10, order_type_less()); |
340 | BOOST_TEST(ret == range1+11); |
341 | for(std::size_t i = 0; i != sizeof(range1)/sizeof(*range1); ++i){ |
342 | BOOST_TEST(range1[i].key == i*2+1); |
343 | BOOST_TEST(range1[i].val == 1u); |
344 | } |
345 | } |
346 | |
347 | void test_inplace_set_difference_range1_same_start() |
348 | { |
349 | order_move_type range2[10]; |
350 | for(std::size_t i = 0; i != sizeof(range2)/sizeof(*range2); ++i){ |
351 | range2[i].key = i*2; |
352 | range2[i].val = 0u; |
353 | } |
354 | |
355 | order_move_type range1[5]; |
356 | range1[0].key = 0u; |
357 | range1[0].val = 1u; |
358 | range1[1].key = 2u; |
359 | range1[1].val = 1u; |
360 | range1[2].key = 4u; |
361 | range1[2].val = 1u; |
362 | range1[3].key = 5u; |
363 | range1[3].val = 1u; |
364 | range1[4].key = 7u; |
365 | range1[4].val = 1u; |
366 | |
367 | order_move_type *ret = boost::movelib::inplace_set_difference(range1, range1+5, range2, range2+10, order_type_less()); |
368 | BOOST_TEST(ret == range1+2); |
369 | BOOST_TEST(range1[0].key == 5u); |
370 | BOOST_TEST(range1[0].val == 1u); |
371 | BOOST_TEST(range1[1].key == 7u); |
372 | BOOST_TEST(range1[1].val == 1u); |
373 | } |
374 | |
375 | void test_inplace_set_difference_range1_same_end() |
376 | { |
377 | order_move_type range2[10]; |
378 | for(std::size_t i = 0; i != sizeof(range2)/sizeof(*range2); ++i){ |
379 | range2[i].key = i*2; |
380 | range2[i].val = 0u; |
381 | } |
382 | |
383 | order_move_type range1[5]; |
384 | range1[0].key = 1u; |
385 | range1[0].val = 1u; |
386 | range1[1].key = 3u; |
387 | range1[1].val = 1u; |
388 | range1[2].key = 4u; |
389 | range1[2].val = 1u; |
390 | range1[3].key = 6u; |
391 | range1[3].val = 1u; |
392 | range1[4].key = 8u; |
393 | range1[4].val = 1u; |
394 | |
395 | order_move_type *ret = boost::movelib::inplace_set_difference(range1, range1+5, range2, range2+10, order_type_less()); |
396 | BOOST_TEST(ret == range1+2); |
397 | BOOST_TEST(range1[0].key == 1u); |
398 | BOOST_TEST(range1[0].val == 1u); |
399 | BOOST_TEST(range1[1].key == 3u); |
400 | BOOST_TEST(range1[1].val == 1u); |
401 | BOOST_TEST(range1[2].key == 4u); |
402 | BOOST_TEST(range1[2].val == 1u); |
403 | BOOST_TEST(range1[3].key == 6u); |
404 | BOOST_TEST(range1[3].val == 1u); |
405 | } |
406 | */ |
407 | |
408 | /////////////////////////////////// |
409 | // |
410 | // inplace_set_difference |
411 | // |
412 | /////////////////////////////////// |
413 | void test_inplace_set_difference_normal() |
414 | { |
415 | order_move_type range2[10]; |
416 | for(std::size_t i = 0; i != sizeof(range2)/sizeof(*range2); ++i){ |
417 | range2[i].key = i*2; |
418 | range2[i].val = 0u; |
419 | } |
420 | |
421 | order_move_type range1[4]; |
422 | range1[0].key = 0u; |
423 | range1[0].val = 1u; |
424 | range1[1].key = 1u; |
425 | range1[1].val = 1u; |
426 | range1[2].key = 3u; |
427 | range1[2].val = 1u; |
428 | range1[3].key = 4u; |
429 | range1[3].val = 1u; |
430 | |
431 | order_move_type *ret = boost::movelib::inplace_set_difference(first1: range1, last1: range1+4, first2: range2, last2: range2+10, comp: order_type_less()); |
432 | BOOST_TEST(ret == range1+2); |
433 | BOOST_TEST(range1[0].key == 1u); |
434 | BOOST_TEST(range1[0].val == 1u); |
435 | BOOST_TEST(range1[1].key == 3u); |
436 | BOOST_TEST(range1[1].val == 1u); |
437 | BOOST_TEST(range1[2].key == order_move_type::moved_assign_mark); |
438 | BOOST_TEST(range1[2].val == order_move_type::moved_assign_mark); |
439 | } |
440 | |
441 | void test_inplace_set_difference_range1_repeated() |
442 | { |
443 | order_move_type range2[10]; |
444 | for(std::size_t i = 0; i != sizeof(range2)/sizeof(*range2); ++i){ |
445 | range2[i].key = i*2; |
446 | range2[i].val = 0u; |
447 | } |
448 | |
449 | order_move_type range1[5]; |
450 | range1[0].key = 0u; |
451 | range1[0].val = 1u; |
452 | range1[1].key = 2u; |
453 | range1[1].val = 1u; |
454 | range1[2].key = 4u; |
455 | range1[2].val = 1u; |
456 | range1[3].key = 6u; |
457 | range1[3].val = 1u; |
458 | range1[4].key = order_move_type::moved_assign_mark; |
459 | range1[4].val = order_move_type::moved_assign_mark; |
460 | |
461 | order_move_type *ret = boost::movelib::inplace_set_difference(first1: range1, last1: range1+4, first2: range2, last2: range2+10, comp: order_type_less()); |
462 | BOOST_TEST(ret == range1+0); |
463 | BOOST_TEST(range1[0].key == 0u); |
464 | BOOST_TEST(range1[0].val == 1u); |
465 | BOOST_TEST(range1[1].key == 2u); |
466 | BOOST_TEST(range1[1].val == 1u); |
467 | BOOST_TEST(range1[2].key == 4u); |
468 | BOOST_TEST(range1[3].val == 1u); |
469 | BOOST_TEST(range1[3].key == 6u); |
470 | BOOST_TEST(range1[3].val == 1u); |
471 | BOOST_TEST(range1[4].key == order_move_type::moved_assign_mark); |
472 | BOOST_TEST(range1[4].val == order_move_type::moved_assign_mark); |
473 | } |
474 | |
475 | void test_inplace_set_difference_range1_unique() |
476 | { |
477 | order_move_type range2[10]; |
478 | for(std::size_t i = 0; i != sizeof(range2)/sizeof(*range2); ++i){ |
479 | range2[i].key = i*2; |
480 | range2[i].val = 0u; |
481 | } |
482 | |
483 | order_move_type range1[5]; |
484 | range1[0].key = 1u; |
485 | range1[0].val = 1u; |
486 | range1[1].key = 3u; |
487 | range1[1].val = 1u; |
488 | range1[2].key = 5u; |
489 | range1[2].val = 1u; |
490 | range1[3].key = 7u; |
491 | range1[3].val = 1u; |
492 | range1[4].key = order_move_type::moved_assign_mark; |
493 | range1[4].val = order_move_type::moved_assign_mark; |
494 | |
495 | order_move_type *ret = boost::movelib::inplace_set_difference(first1: range1, last1: range1+4, first2: range2, last2: range2+10, comp: order_type_less()); |
496 | BOOST_TEST(ret == range1+4); |
497 | BOOST_TEST(range1[0].key == 1u); |
498 | BOOST_TEST(range1[0].val == 1u); |
499 | BOOST_TEST(range1[1].key == 3u); |
500 | BOOST_TEST(range1[1].val == 1u); |
501 | BOOST_TEST(range1[2].key == 5u); |
502 | BOOST_TEST(range1[3].val == 1u); |
503 | BOOST_TEST(range1[3].key == 7u); |
504 | BOOST_TEST(range1[3].val == 1u); |
505 | BOOST_TEST(range1[4].key == order_move_type::moved_assign_mark); |
506 | BOOST_TEST(range1[4].val == order_move_type::moved_assign_mark); |
507 | } |
508 | |
509 | void test_inplace_set_difference_range1_unique_long() |
510 | { |
511 | order_move_type range2[10]; |
512 | for(std::size_t i = 0; i != sizeof(range2)/sizeof(*range2); ++i){ |
513 | range2[i].key = i*2; |
514 | range2[i].val = 0u; |
515 | } |
516 | |
517 | order_move_type range1[11]; |
518 | for(std::size_t i = 0; i != sizeof(range1)/sizeof(*range1); ++i){ |
519 | range1[i].key = i*2+1; |
520 | range1[i].val = 1u; |
521 | } |
522 | |
523 | order_move_type *ret = boost::movelib::inplace_set_difference(first1: range1, last1: range1+11, first2: range2, last2: range2+10, comp: order_type_less()); |
524 | BOOST_TEST(ret == range1+11); |
525 | for(std::size_t i = 0; i != sizeof(range1)/sizeof(*range1); ++i){ |
526 | BOOST_TEST(range1[i].key == i*2+1); |
527 | BOOST_TEST(range1[i].val == 1u); |
528 | } |
529 | } |
530 | |
531 | void test_inplace_set_difference_range1_same_start() |
532 | { |
533 | order_move_type range2[10]; |
534 | for(std::size_t i = 0; i != sizeof(range2)/sizeof(*range2); ++i){ |
535 | range2[i].key = i*2; |
536 | range2[i].val = 0u; |
537 | } |
538 | |
539 | order_move_type range1[5]; |
540 | range1[0].key = 0u; |
541 | range1[0].val = 1u; |
542 | range1[1].key = 2u; |
543 | range1[1].val = 1u; |
544 | range1[2].key = 4u; |
545 | range1[2].val = 1u; |
546 | range1[3].key = 5u; |
547 | range1[3].val = 1u; |
548 | range1[4].key = 7u; |
549 | range1[4].val = 1u; |
550 | |
551 | order_move_type *ret = boost::movelib::inplace_set_difference(first1: range1, last1: range1+5, first2: range2, last2: range2+10, comp: order_type_less()); |
552 | BOOST_TEST(ret == range1+2); |
553 | BOOST_TEST(range1[0].key == 5u); |
554 | BOOST_TEST(range1[0].val == 1u); |
555 | BOOST_TEST(range1[1].key == 7u); |
556 | BOOST_TEST(range1[1].val == 1u); |
557 | } |
558 | |
559 | void test_inplace_set_difference_range1_same_end() |
560 | { |
561 | order_move_type range2[10]; |
562 | for(std::size_t i = 0; i != sizeof(range2)/sizeof(*range2); ++i){ |
563 | range2[i].key = i*2; |
564 | range2[i].val = 0u; |
565 | } |
566 | |
567 | order_move_type range1[5]; |
568 | range1[0].key = 1u; |
569 | range1[0].val = 1u; |
570 | range1[1].key = 3u; |
571 | range1[1].val = 1u; |
572 | range1[2].key = 4u; |
573 | range1[2].val = 1u; |
574 | range1[3].key = 6u; |
575 | range1[3].val = 1u; |
576 | range1[4].key = 8u; |
577 | range1[4].val = 1u; |
578 | |
579 | order_move_type *ret = boost::movelib::inplace_set_difference(first1: range1, last1: range1+5, first2: range2, last2: range2+10, comp: order_type_less()); |
580 | BOOST_TEST(ret == range1+2); |
581 | BOOST_TEST(range1[0].key == 1u); |
582 | BOOST_TEST(range1[0].val == 1u); |
583 | BOOST_TEST(range1[1].key == 3u); |
584 | BOOST_TEST(range1[1].val == 1u); |
585 | BOOST_TEST(range1[2].key == 4u); |
586 | BOOST_TEST(range1[2].val == 1u); |
587 | BOOST_TEST(range1[3].key == 6u); |
588 | BOOST_TEST(range1[3].val == 1u); |
589 | } |
590 | |
591 | |
592 | /////////////////////////////////// |
593 | // |
594 | // set_unique_difference |
595 | // |
596 | /////////////////////////////////// |
597 | void test_set_unique_difference_normal() |
598 | { |
599 | order_perf_type range2[10]; |
600 | for(std::size_t i = 0; i != sizeof(range2)/sizeof(*range2); ++i){ |
601 | range2[i].key = i*2; |
602 | range2[i].val = 0u; |
603 | } |
604 | |
605 | order_perf_type range1[10]; |
606 | range1[0].key = 0u; |
607 | range1[0].val = 1u; |
608 | range1[1].key = 1u; |
609 | range1[1].val = 1u; |
610 | range1[2].key = 1u; |
611 | range1[2].val = 2u; |
612 | range1[3].key = 3u; |
613 | range1[3].val = 1u; |
614 | range1[4].key = 4u; |
615 | range1[4].val = 1u; |
616 | range1[5].key = 4u; |
617 | range1[5].val = 2u; |
618 | range1[6].key = 21u; |
619 | range1[6].val = 1u; |
620 | range1[7].key = 21u; |
621 | range1[7].val = 2u; |
622 | range1[8].key = 23u; |
623 | range1[8].val = 1u; |
624 | range1[9].key = 23u; |
625 | range1[9].val = 2u; |
626 | |
627 | order_perf_type out[20]; |
628 | out[4].key = 998; |
629 | out[4].val = 999; |
630 | order_perf_type * r = |
631 | boost::movelib::set_unique_difference(first1: range1, last1: range1+10, first2: range2, last2: range2+10, result: out, comp: order_type_less()); |
632 | BOOST_TEST(&out[4] == r); |
633 | BOOST_TEST(out[0].key == 1u); |
634 | BOOST_TEST(out[0].val == 1u); |
635 | BOOST_TEST(out[1].key == 3u); |
636 | BOOST_TEST(out[1].val == 1u); |
637 | BOOST_TEST(out[2].key == 21u); |
638 | BOOST_TEST(out[2].val == 1u); |
639 | BOOST_TEST(out[3].key == 23u); |
640 | BOOST_TEST(out[3].val == 1u); |
641 | BOOST_TEST(out[4].key == 998); |
642 | BOOST_TEST(out[4].val == 999); |
643 | } |
644 | |
645 | void test_set_unique_difference_range1_repeated() |
646 | { |
647 | order_perf_type range2[10]; |
648 | for(std::size_t i = 0; i != sizeof(range2)/sizeof(*range2); ++i){ |
649 | range2[i].key = i*2; |
650 | range2[i].val = 0u; |
651 | } |
652 | |
653 | order_perf_type range1[11]; |
654 | range1[0].key = 0u; |
655 | range1[0].val = 1u; |
656 | range1[1].key = 0u; |
657 | range1[1].val = 2u; |
658 | range1[2].key = 0u; |
659 | range1[2].val = 2u; |
660 | range1[3].key = 2u; |
661 | range1[3].val = 1u; |
662 | range1[4].key = 2u; |
663 | range1[4].val = 2u; |
664 | range1[5].key = 4u; |
665 | range1[5].val = 1u; |
666 | range1[6].key = 6u; |
667 | range1[6].val = 1u; |
668 | range1[7].key = 6u; |
669 | range1[7].val = 2u; |
670 | range1[8].key = 6u; |
671 | range1[8].val = 3u; |
672 | range1[9].key = 6u; |
673 | range1[9].val = 4u; |
674 | range1[10].key = 6u; |
675 | range1[10].val = 5u; |
676 | |
677 | order_perf_type out[20]; |
678 | out[0].key = 998; |
679 | out[0].val = 999; |
680 | order_perf_type * r = |
681 | boost::movelib::set_unique_difference(first1: range1, last1: range1+11, first2: range2, last2: range2+10, result: out, comp: order_type_less()); |
682 | BOOST_TEST(&out[0] == r); |
683 | BOOST_TEST(out[0].key == 998); |
684 | BOOST_TEST(out[0].val == 999); |
685 | } |
686 | |
687 | void test_set_unique_difference_range1_unique() |
688 | { |
689 | order_perf_type range2[10]; |
690 | for(std::size_t i = 0; i != sizeof(range2)/sizeof(*range2); ++i){ |
691 | range2[i].key = i*2; |
692 | range2[i].val = 0u; |
693 | } |
694 | |
695 | order_perf_type range1[7]; |
696 | range1[0].key = 1u; |
697 | range1[0].val = 1u; |
698 | range1[1].key = 3u; |
699 | range1[1].val = 1u; |
700 | range1[2].key = 3u; |
701 | range1[2].val = 2u; |
702 | range1[3].key = 5u; |
703 | range1[3].val = 1u; |
704 | range1[4].key = 7u; |
705 | range1[4].val = 1u; |
706 | range1[5].key = 7u; |
707 | range1[5].val = 2u; |
708 | range1[6].key = 7u; |
709 | range1[6].val = 3u; |
710 | |
711 | order_perf_type out[20]; |
712 | out[4].key = 998; |
713 | out[4].val = 999; |
714 | order_perf_type * r = |
715 | boost::movelib::set_unique_difference(first1: range1, last1: range1+7, first2: range2, last2: range2+10, result: out, comp: order_type_less()); |
716 | BOOST_TEST(&out[4] == r); |
717 | BOOST_TEST(out[0].key == 1u); |
718 | BOOST_TEST(out[0].val == 1u); |
719 | BOOST_TEST(out[1].key == 3u); |
720 | BOOST_TEST(out[1].val == 1u); |
721 | BOOST_TEST(out[2].key == 5u); |
722 | BOOST_TEST(out[2].val == 1u); |
723 | BOOST_TEST(out[3].key == 7u); |
724 | BOOST_TEST(out[3].val == 1u); |
725 | BOOST_TEST(out[4].key == 998); |
726 | BOOST_TEST(out[4].val == 999); |
727 | } |
728 | |
729 | /////////////////////////////////// |
730 | // |
731 | // inplace_set_unique_difference |
732 | // |
733 | /////////////////////////////////// |
734 | void test_inplace_set_unique_difference_normal() |
735 | { |
736 | order_move_type range2[10]; |
737 | for(std::size_t i = 0; i != sizeof(range2)/sizeof(*range2); ++i){ |
738 | range2[i].key = i*2; |
739 | range2[i].val = 0u; |
740 | } |
741 | |
742 | order_move_type range1[4]; |
743 | range1[0].key = 0u; |
744 | range1[0].val = 1u; |
745 | range1[1].key = 1u; |
746 | range1[1].val = 1u; |
747 | range1[2].key = 3u; |
748 | range1[2].val = 1u; |
749 | range1[3].key = 4u; |
750 | range1[3].val = 1u; |
751 | |
752 | order_move_type *ret = boost::movelib::inplace_set_unique_difference(first1: range1, last1: range1+4, first2: range2, last2: range2+10, comp: order_type_less()); |
753 | BOOST_TEST(ret == range1+2); |
754 | BOOST_TEST(range1[0].key == 1u); |
755 | BOOST_TEST(range1[0].val == 1u); |
756 | BOOST_TEST(range1[1].key == 3u); |
757 | BOOST_TEST(range1[1].val == 1u); |
758 | BOOST_TEST(range1[2].key == order_move_type::moved_assign_mark); |
759 | BOOST_TEST(range1[2].val == order_move_type::moved_assign_mark); |
760 | } |
761 | |
762 | void test_inplace_set_unique_difference_range1_repeated() |
763 | { |
764 | order_move_type range2[10]; |
765 | for(std::size_t i = 0; i != sizeof(range2)/sizeof(*range2); ++i){ |
766 | range2[i].key = i*2; |
767 | range2[i].val = 0u; |
768 | } |
769 | |
770 | order_move_type range1[5]; |
771 | range1[0].key = 0u; |
772 | range1[0].val = 1u; |
773 | range1[1].key = 2u; |
774 | range1[1].val = 1u; |
775 | range1[2].key = 4u; |
776 | range1[2].val = 1u; |
777 | range1[3].key = 6u; |
778 | range1[3].val = 1u; |
779 | range1[4].key = order_move_type::moved_assign_mark; |
780 | range1[4].val = order_move_type::moved_assign_mark; |
781 | |
782 | order_move_type *ret = boost::movelib::inplace_set_unique_difference(first1: range1, last1: range1+4, first2: range2, last2: range2+10, comp: order_type_less()); |
783 | BOOST_TEST(ret == range1+0); |
784 | BOOST_TEST(range1[0].key == 0u); |
785 | BOOST_TEST(range1[0].val == 1u); |
786 | BOOST_TEST(range1[1].key == 2u); |
787 | BOOST_TEST(range1[1].val == 1u); |
788 | BOOST_TEST(range1[2].key == 4u); |
789 | BOOST_TEST(range1[3].val == 1u); |
790 | BOOST_TEST(range1[3].key == 6u); |
791 | BOOST_TEST(range1[3].val == 1u); |
792 | BOOST_TEST(range1[4].key == order_move_type::moved_assign_mark); |
793 | BOOST_TEST(range1[4].val == order_move_type::moved_assign_mark); |
794 | } |
795 | |
796 | void test_inplace_set_unique_difference_range1_unique() |
797 | { |
798 | order_move_type range2[10]; |
799 | for(std::size_t i = 0; i != sizeof(range2)/sizeof(*range2); ++i){ |
800 | range2[i].key = i*2; |
801 | range2[i].val = 0u; |
802 | } |
803 | |
804 | order_move_type range1[9]; |
805 | range1[0].key = 1u; |
806 | range1[0].val = 1u; |
807 | range1[1].key = 1u; |
808 | range1[1].val = 2u; |
809 | range1[2].key = 3u; |
810 | range1[2].val = 1u; |
811 | range1[3].key = 3u; |
812 | range1[3].val = 2u; |
813 | range1[4].key = 5u; |
814 | range1[4].val = 1u; |
815 | range1[5].key = 7u; |
816 | range1[5].val = 1u; |
817 | range1[6].key = 7u; |
818 | range1[6].val = 2u; |
819 | range1[7].key = 7u; |
820 | range1[7].val = 3u; |
821 | range1[8].val = 3u; |
822 | range1[8].key = order_move_type::moved_assign_mark; |
823 | range1[8].val = order_move_type::moved_assign_mark; |
824 | |
825 | order_move_type *ret = |
826 | boost::movelib::inplace_set_unique_difference(first1: range1, last1: range1+8, first2: range2, last2: range2+10, comp: order_type_less()); |
827 | BOOST_TEST(ret == range1+4); |
828 | BOOST_TEST(range1[0].key == 1u); |
829 | BOOST_TEST(range1[0].val == 1u); |
830 | BOOST_TEST(range1[1].key == 3u); |
831 | BOOST_TEST(range1[1].val == 1u); |
832 | BOOST_TEST(range1[2].key == 5u); |
833 | BOOST_TEST(range1[3].val == 1u); |
834 | BOOST_TEST(range1[3].key == 7u); |
835 | BOOST_TEST(range1[3].val == 1u); |
836 | } |
837 | |
838 | void test_inplace_set_unique_difference_range1_unique_long() |
839 | { |
840 | order_move_type range2[10]; |
841 | for(std::size_t i = 0; i != sizeof(range2)/sizeof(*range2); ++i){ |
842 | range2[i].key = i*2; |
843 | range2[i].val = 0u; |
844 | } |
845 | |
846 | order_move_type range1[22]; |
847 | for(std::size_t i = 0; i != sizeof(range1)/sizeof(*range1); ++i){ |
848 | range1[i].key = (i/2)*2+1; |
849 | range1[i].val = i%2; |
850 | } |
851 | |
852 | order_move_type *ret = |
853 | boost::movelib::inplace_set_unique_difference(first1: range1, last1: range1+22, first2: range2, last2: range2+10, comp: order_type_less()); |
854 | BOOST_TEST(ret == range1+11); |
855 | for(std::size_t i = 0; i != 11; ++i){ |
856 | BOOST_TEST(range1[i].key == i*2+1); |
857 | BOOST_TEST(range1[i].val == 0u); |
858 | } |
859 | } |
860 | |
861 | void test_inplace_set_unique_difference_range1_same_start() |
862 | { |
863 | order_move_type range2[10]; |
864 | for(std::size_t i = 0; i != sizeof(range2)/sizeof(*range2); ++i){ |
865 | range2[i].key = i*2; |
866 | range2[i].val = 0u; |
867 | } |
868 | |
869 | order_move_type range1[6]; |
870 | range1[0].key = 0u; |
871 | range1[0].val = 1u; |
872 | range1[1].key = 2u; |
873 | range1[1].val = 1u; |
874 | range1[2].key = 4u; |
875 | range1[2].val = 1u; |
876 | range1[3].key = 4u; |
877 | range1[3].val = 2u; |
878 | range1[4].key = 5u; |
879 | range1[4].val = 1u; |
880 | range1[5].key = 7u; |
881 | range1[5].val = 1u; |
882 | |
883 | order_move_type *ret = |
884 | boost::movelib::inplace_set_unique_difference(first1: range1, last1: range1+6, first2: range2, last2: range2+10, comp: order_type_less()); |
885 | BOOST_TEST(ret == range1+2); |
886 | BOOST_TEST(range1[0].key == 5u); |
887 | BOOST_TEST(range1[0].val == 1u); |
888 | BOOST_TEST(range1[1].key == 7u); |
889 | BOOST_TEST(range1[1].val == 1u); |
890 | } |
891 | |
892 | void test_inplace_set_unique_difference_range1_same_end() |
893 | { |
894 | order_move_type range2[10]; |
895 | for(std::size_t i = 0; i != sizeof(range2)/sizeof(*range2); ++i){ |
896 | range2[i].key = i*2; |
897 | range2[i].val = 0u; |
898 | } |
899 | |
900 | order_move_type range1[8]; |
901 | range1[0].key = 1u; |
902 | range1[0].val = 1u; |
903 | range1[1].key = 3u; |
904 | range1[1].val = 1u; |
905 | range1[2].key = 4u; |
906 | range1[2].val = 1u; |
907 | range1[3].key = 4u; |
908 | range1[3].val = 2u; |
909 | range1[4].key = 6u; |
910 | range1[4].val = 1u; |
911 | range1[5].key = 8u; |
912 | range1[5].val = 1u; |
913 | range1[6].key = 8u; |
914 | range1[6].val = 2u; |
915 | range1[7].key = 8u; |
916 | range1[7].val = 3u; |
917 | |
918 | order_move_type *ret = |
919 | boost::movelib::inplace_set_unique_difference(first1: range1, last1: range1+8, first2: range2, last2: range2+10, comp: order_type_less()); |
920 | BOOST_TEST(ret == range1+2); |
921 | BOOST_TEST(range1[0].key == 1u); |
922 | BOOST_TEST(range1[0].val == 1u); |
923 | BOOST_TEST(range1[1].key == 3u); |
924 | BOOST_TEST(range1[1].val == 1u); |
925 | } |
926 | |
927 | int main() |
928 | { |
929 | //set_difference |
930 | test_set_difference_normal(); |
931 | test_set_difference_range1_repeated(); |
932 | test_set_difference_range1_unique(); |
933 | //inplace_set_difference |
934 | test_inplace_set_difference_normal(); |
935 | test_inplace_set_difference_range1_repeated(); |
936 | test_inplace_set_difference_range1_unique(); |
937 | test_inplace_set_difference_range1_unique_long(); |
938 | test_inplace_set_difference_range1_same_start(); |
939 | test_inplace_set_difference_range1_same_end(); |
940 | //set_unique_difference |
941 | test_set_unique_difference_normal(); |
942 | test_set_unique_difference_range1_repeated(); |
943 | test_set_unique_difference_range1_unique(); |
944 | //inplace_set_unique_difference |
945 | test_inplace_set_unique_difference_normal(); |
946 | test_inplace_set_unique_difference_range1_repeated(); |
947 | test_inplace_set_unique_difference_range1_unique(); |
948 | test_inplace_set_unique_difference_range1_unique_long(); |
949 | test_inplace_set_unique_difference_range1_same_start(); |
950 | test_inplace_set_unique_difference_range1_same_end(); |
951 | |
952 | return boost::report_errors(); |
953 | } |
954 | |