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 ///////////////////////////////////
test_set_difference_normal()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(range1, range1+5, range2, range2+10, out, 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
test_set_difference_range1_repeated()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(range1, range1+5, range2, range2+10, out, 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
test_set_difference_range1_unique()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(range1, range1+5, range2, range2+10, out, 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 ///////////////////////////////////
test_inplace_set_difference_normal()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(range1, range1+4, range2, range2+10, 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
test_inplace_set_difference_range1_repeated()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(range1, range1+4, range2, range2+10, 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
test_inplace_set_difference_range1_unique()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(range1, range1+4, range2, range2+10, 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
test_inplace_set_difference_range1_unique_long()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(range1, range1+11, range2, range2+10, 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
test_inplace_set_difference_range1_same_start()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(range1, range1+5, range2, range2+10, 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
test_inplace_set_difference_range1_same_end()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(range1, range1+5, range2, range2+10, 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 ///////////////////////////////////
test_set_unique_difference_normal()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(range1, range1+10, range2, range2+10, out, 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
test_set_unique_difference_range1_repeated()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(range1, range1+11, range2, range2+10, out, 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
test_set_unique_difference_range1_unique()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(range1, range1+7, range2, range2+10, out, 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 ///////////////////////////////////
test_inplace_set_unique_difference_normal()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(range1, range1+4, range2, range2+10, 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
test_inplace_set_unique_difference_range1_repeated()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(range1, range1+4, range2, range2+10, 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
test_inplace_set_unique_difference_range1_unique()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(range1, range1+8, range2, range2+10, 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
test_inplace_set_unique_difference_range1_unique_long()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(range1, range1+22, range2, range2+10, 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
test_inplace_set_unique_difference_range1_same_start()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(range1, range1+6, range2, range2+10, 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
test_inplace_set_unique_difference_range1_same_end()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(range1, range1+8, range2, range2+10, 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
main()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