ceph/src/boost/libs/icl/test/test_interval_set_mixed.hpp

   1 /*-----------------------------------------------------------------------------+
   2 Copyright (c) 2008-2009: Joachim Faulhaber
   3 +------------------------------------------------------------------------------+
   4    Distributed under the Boost Software License, Version 1.0.
   5       (See accompanying file LICENCE.txt or copy at
   6            http://www.boost.org/LICENSE_1_0.txt)
   7 +-----------------------------------------------------------------------------*/
   8 #ifndef LIBS_ICL_TEST_TEST_INTERVAL_SET_MIXED_HPP_JOFA_090702
   9 #define LIBS_ICL_TEST_TEST_INTERVAL_SET_MIXED_HPP_JOFA_090702
  10
  11 template <class T>
  12 void interval_set_mixed_ctor_4_ordered_types()
  13 {
  14     typedef interval_set<T> IntervalSetT;
  15     typedef typename IntervalSetT::interval_type IntervalT;
  16
  17     T v0 = boost::icl::identity_element<T>::value();
  18
  19     split_interval_set<T>    split_set(v0);
  20     separate_interval_set<T> sep_set(split_set);
  21     interval_set<T>          join_set(sep_set);
  22
  23     BOOST_CHECK_EQUAL( hull(split_set).lower(), hull(sep_set).lower() );
  24     BOOST_CHECK_EQUAL( hull(split_set).lower(), hull(join_set).lower() );
  25 }
  26
  27 template <class T>
  28 void interval_set_mixed_equal_4_ordered_types()
  29 {
  30     typedef interval_set<T> IntervalSetT;
  31     typedef typename IntervalSetT::interval_type IntervalT;
  32
  33     T v0 = boost::icl::identity_element<T>::value();
  34
  35     split_interval_set<T>    split_empty, split_single(v0);
  36     separate_interval_set<T> sep_empty, sep_single(v0);
  37     interval_set<T>          join_empty, join_single(v0);
  38
  39     // mixed ==-equality is a strange thing. Most times is does not
  40     // make sense. It is better to allow only for same type == equality.
  41     BOOST_CHECK_EQUAL( split_empty == split_empty, true );
  42     BOOST_CHECK_EQUAL( sep_empty   == sep_empty,   true );
  43     BOOST_CHECK_EQUAL( join_empty  == join_empty,  true );
  44
  45     // There were Problems with operator== and emtpy sets.
  46     BOOST_CHECK_EQUAL( split_empty == split_single, false );
  47     BOOST_CHECK_EQUAL( sep_empty   == sep_single,   false );
  48     BOOST_CHECK_EQUAL( join_empty  == join_single,  false );
  49
  50     BOOST_CHECK_EQUAL( split_single == split_empty, false );
  51     BOOST_CHECK_EQUAL( sep_single   == sep_empty,   false );
  52     BOOST_CHECK_EQUAL( join_single  == join_empty,  false );
  53
  54     BOOST_CHECK_EQUAL( is_element_equal(split_empty, split_empty), true );
  55     BOOST_CHECK_EQUAL( is_element_equal(split_empty, sep_empty),   true );
  56     BOOST_CHECK_EQUAL( is_element_equal(split_empty, join_empty),  true );
  57
  58     BOOST_CHECK_EQUAL( is_element_equal(sep_empty, split_empty), true );
  59     BOOST_CHECK_EQUAL( is_element_equal(sep_empty, sep_empty),   true );
  60     BOOST_CHECK_EQUAL( is_element_equal(sep_empty, join_empty),  true );
  61
  62     BOOST_CHECK_EQUAL( is_element_equal(join_empty, split_empty), true );
  63     BOOST_CHECK_EQUAL( is_element_equal(join_empty, sep_empty),   true );
  64     BOOST_CHECK_EQUAL( is_element_equal(join_empty, join_empty),  true );
  65
  66     //--------------------------------------------------------------------------
  67     BOOST_CHECK_EQUAL( is_element_equal(split_empty, split_single), false );
  68     BOOST_CHECK_EQUAL( is_element_equal(split_empty, sep_single),   false );
  69     BOOST_CHECK_EQUAL( is_element_equal(split_empty, join_single),  false );
  70
  71     BOOST_CHECK_EQUAL( is_element_equal(sep_empty, split_single), false );
  72     BOOST_CHECK_EQUAL( is_element_equal(sep_empty, sep_single),   false );
  73     BOOST_CHECK_EQUAL( is_element_equal(sep_empty, join_single),  false );
  74
  75     BOOST_CHECK_EQUAL( is_element_equal(join_empty, split_single), false );
  76     BOOST_CHECK_EQUAL( is_element_equal(join_empty, sep_single),   false );
  77     BOOST_CHECK_EQUAL( is_element_equal(join_empty, join_single),  false );
  78
  79     //--------------------------------------------------------------------------
  80     BOOST_CHECK_EQUAL( is_element_equal(split_single, split_empty), false );
  81     BOOST_CHECK_EQUAL( is_element_equal(split_single, sep_empty),   false );
  82     BOOST_CHECK_EQUAL( is_element_equal(split_single, join_empty),  false );
  83
  84     BOOST_CHECK_EQUAL( is_element_equal(sep_single, split_empty), false );
  85     BOOST_CHECK_EQUAL( is_element_equal(sep_single, sep_empty),   false );
  86     BOOST_CHECK_EQUAL( is_element_equal(sep_single, join_empty),  false );
  87
  88     BOOST_CHECK_EQUAL( is_element_equal(join_single, split_empty), false );
  89     BOOST_CHECK_EQUAL( is_element_equal(join_single, sep_empty),   false );
  90     BOOST_CHECK_EQUAL( is_element_equal(join_single, join_empty),  false );
  91
  92 }
  93
  94 template <class T>
  95 void interval_set_mixed_assign_4_ordered_types()
  96 {
  97     typedef interval_set<T> IntervalSetT;
  98     typedef typename IntervalSetT::interval_type IntervalT;
  99
 100     T v0 = boost::icl::identity_element<T>::value();
 101     T v1 = unit_element<T>::value();
 102
 103     split_interval_set<T>    split_set;
 104     separate_interval_set<T> sep_set;
 105     interval_set<T>          join_set;
 106     split_set.add(v0);
 107     sep_set = split_set;
 108     join_set = sep_set;
 109
 110     BOOST_CHECK_EQUAL( hull(split_set).lower(), hull(sep_set).lower() );
 111     BOOST_CHECK_EQUAL( hull(split_set).lower(), hull(join_set).lower() );
 112
 113     split_interval_set<T>    split_self = split_interval_set<T>().add(v0);
 114     separate_interval_set<T> sep_self   = separate_interval_set<T>().add(v0).add(v1);
 115     interval_set<T>          join_self  = interval_set<T>().add(v1);
 116
 117     split_self = split_self;
 118     sep_self = sep_self;
 119     join_self = join_self;
 120
 121     BOOST_CHECK_EQUAL( split_self, split_self );
 122     BOOST_CHECK_EQUAL( sep_self, sep_self );
 123     BOOST_CHECK_EQUAL( join_self, join_self );
 124 }
 125
 126 template <class T>
 127 void interval_set_mixed_ctor_4_bicremental_types()
 128 {
 129     typedef interval_set<T> IntervalSetT;
 130     typedef typename IntervalSetT::interval_type IntervalT;
 131
 132     T v1 = make<T>(1);
 133     T v2 = make<T>(2);
 134     T v3 = make<T>(3);
 135     T v4 = make<T>(4);
 136     T v5 = make<T>(5);
 137
 138     IntervalT I1_3D = IntervalT::right_open(v1,v3);
 139     IntervalT I2_4D = IntervalT::right_open(v2,v4);
 140     IntervalT I4_5D = IntervalT::right_open(v4,v5);
 141
 142     split_interval_set<T> split_set;
 143     split_set.add(I1_3D).add(I2_4D).add(I4_5D);
 144     BOOST_CHECK_EQUAL( split_set.iterative_size(), 4 );
 145     separate_interval_set<T> sep_set(split_set);
 146     BOOST_CHECK_EQUAL( sep_set.iterative_size(), 4 );
 147     interval_set<T> join_set(split_set);
 148     BOOST_CHECK_EQUAL( join_set.iterative_size(), 1 );
 149
 150     separate_interval_set<T> sep_set2;
 151     sep_set2.add(I1_3D).add(I2_4D).add(I4_5D);
 152     BOOST_CHECK_EQUAL( sep_set2.iterative_size(), 2 );
 153     split_interval_set<T> split_set2(sep_set2);
 154     BOOST_CHECK_EQUAL( split_set2.iterative_size(), 2 );
 155     interval_set<T> join_set2(sep_set2);
 156     BOOST_CHECK_EQUAL( join_set2.iterative_size(), 1 );
 157 }
 158
 159 template <class T>
 160 void interval_set_mixed_assign_4_bicremental_types()
 161 {
 162     typedef interval_set<T> IntervalSetT;
 163     typedef typename IntervalSetT::interval_type IntervalT;
 164
 165     T v1 = make<T>(1);
 166     T v2 = make<T>(2);
 167     T v3 = make<T>(3);
 168     T v4 = make<T>(4);
 169     T v5 = make<T>(5);
 170
 171     IntervalT I1_3D = IntervalT::right_open(v1,v3);
 172     IntervalT I2_4D = IntervalT::right_open(v2,v4);
 173     IntervalT I4_5D = IntervalT::right_open(v4,v5);
 174
 175     split_interval_set<T> split_set;
 176     split_set.add(I1_3D).add(I2_4D).add(I4_5D);
 177     BOOST_CHECK_EQUAL( split_set.iterative_size(), 4 );
 178     separate_interval_set<T> sep_set;
 179     sep_set = split_set;
 180     BOOST_CHECK_EQUAL( sep_set.iterative_size(), 4 );
 181     interval_set<T> join_set;
 182     join_set = split_set;
 183     BOOST_CHECK_EQUAL( join_set.iterative_size(), 1 );
 184
 185     separate_interval_set<T> sep_set2;
 186     sep_set2.add(I1_3D).add(I2_4D).add(I4_5D);
 187     BOOST_CHECK_EQUAL( sep_set2.iterative_size(), 2 );
 188     split_interval_set<T> split_set2;
 189     split_set2 = sep_set2;
 190     BOOST_CHECK_EQUAL( split_set2.iterative_size(), 2 );
 191     interval_set<T> join_set2;
 192     join_set2 = sep_set2;
 193     BOOST_CHECK_EQUAL( join_set2.iterative_size(), 1 );
 194 }
 195
 196
 197 template <class T>
 198 void interval_set_mixed_equal_4_bicremental_types()
 199 {
 200     typedef interval_set<T> IntervalSetT;
 201     typedef typename IntervalSetT::interval_type IntervalT;
 202
 203     T v1 = make<T>(1);
 204     T v2 = make<T>(2);
 205     T v3 = make<T>(3);
 206     T v4 = make<T>(4);
 207     T v5 = make<T>(5);
 208
 209     IntervalT I1_3D = IntervalT::right_open(v1,v3);
 210     IntervalT I2_4D = IntervalT::right_open(v2,v4);
 211     IntervalT I4_5D = IntervalT::right_open(v4,v5);
 212
 213     interval_set<T> join_set;
 214     join_set.add(I1_3D).add(I2_4D).add(I4_5D);
 215     interval_set<T> join_set2 = join_set;
 216     BOOST_CHECK_EQUAL( join_set, join_set2 );
 217     BOOST_CHECK_EQUAL( is_element_equal(join_set, join_set2), true );
 218
 219     separate_interval_set<T> sep_set;
 220     sep_set.add(I1_3D).add(I2_4D).add(I4_5D);
 221
 222     separate_interval_set<T> sep_set2 = sep_set;
 223     BOOST_CHECK_EQUAL( sep_set, sep_set2 );
 224     BOOST_CHECK_EQUAL( is_element_equal(sep_set2, sep_set), true );
 225
 226     split_interval_set<T> split_set;
 227     split_set.add(I1_3D).add(I2_4D).add(I4_5D);
 228     split_interval_set<T> split_set2 = split_set;
 229     BOOST_CHECK_EQUAL( split_set, split_set2 );
 230     BOOST_CHECK_EQUAL( is_element_equal(split_set2, split_set), true );
 231
 232     BOOST_CHECK_EQUAL( is_element_equal(split_set, join_set),  true );
 233     BOOST_CHECK_EQUAL( is_element_equal(split_set, sep_set),   true );
 234     BOOST_CHECK_EQUAL( is_element_equal(join_set,  sep_set),   true );
 235     BOOST_CHECK_EQUAL( is_element_equal(join_set,  split_set), true );
 236     BOOST_CHECK_EQUAL( is_element_equal(sep_set,   join_set),  true );
 237     BOOST_CHECK_EQUAL( is_element_equal(sep_set,   split_set), true );
 238 }
 239
 240 template <class T>
 241 void interval_set_mixed_contains_4_bicremental_types()
 242 {
 243     typedef interval_set<T> IntervalSetT;
 244     typedef typename IntervalSetT::interval_type IntervalT;
 245
 246     split_interval_set<T> split_set;
 247     split_set.add(I_D(0,4)).add(I_D(4,8));
 248     BOOST_CHECK_EQUAL( icl::contains(split_set, MK_v(4)), true );
 249     BOOST_CHECK_EQUAL( icl::contains(split_set, C_D(2,5)), true );
 250
 251     interval_set<T> join_set_gap4(split_set.erase(MK_v(4)));
 252     BOOST_CHECK_EQUAL( icl::contains(join_set_gap4, MK_v(4)), false );
 253     BOOST_CHECK_EQUAL( icl::contains(join_set_gap4, C_D(2,5)), false );
 254
 255     BOOST_CHECK_EQUAL( icl::contains(split_set, split_set), true );
 256     BOOST_CHECK_EQUAL( icl::contains(split_set, join_set_gap4), true );
 257
 258 }
 259
 260 template <class T>
 261 void interval_set_mixed_add_4_bicremental_types()
 262 {
 263     typedef interval_set<T> IntervalSetT;
 264     typedef typename IntervalSetT::interval_type IntervalT;
 265
 266     T v1 = make<T>(1);
 267     T v2 = make<T>(2);
 268     T v3 = make<T>(3);
 269     T v4 = make<T>(4);
 270     T v5 = make<T>(5);
 271
 272     IntervalT I1_3D = IntervalT::right_open(v1,v3);
 273     IntervalT I2_4D = IntervalT::right_open(v2,v4);
 274     IntervalT I4_5D = IntervalT::right_open(v4,v5);
 275
 276     split_interval_set<T> split_set;
 277     split_set.add(I1_3D).add(I2_4D);
 278     split_set += I4_5D;
 279     BOOST_CHECK_EQUAL( split_set.iterative_size(), 4 );
 280     separate_interval_set<T> sep_set;
 281     sep_set += split_set;
 282     BOOST_CHECK_EQUAL( sep_set.iterative_size(), 4 );
 283     interval_set<T> join_set;
 284     join_set += split_set;
 285     BOOST_CHECK_EQUAL( join_set.iterative_size(), 1 );
 286
 287     separate_interval_set<T> sep_set2;
 288     sep_set2.add(I1_3D).add(I2_4D);
 289     sep_set2 += I4_5D;
 290     BOOST_CHECK_EQUAL( sep_set2.iterative_size(), 2 );
 291     split_interval_set<T> split_set2;
 292     split_set2 += sep_set2;
 293     BOOST_CHECK_EQUAL( split_set2.iterative_size(), 2 );
 294     interval_set<T> join_set2;
 295     join_set2 += sep_set2;
 296     BOOST_CHECK_EQUAL( join_set2.iterative_size(), 1 );
 297
 298     interval_set<T> join_set3;
 299     join_set3.add(v1).add(v3);
 300     join_set3 += v5;
 301     BOOST_CHECK_EQUAL( join_set3.iterative_size(), 3 );
 302     split_interval_set<T> split_set3;
 303     split_set3 += join_set3;
 304     BOOST_CHECK_EQUAL( split_set3.iterative_size(), 3 );
 305     separate_interval_set<T> sep_set3;
 306     sep_set3 += join_set3;
 307     BOOST_CHECK_EQUAL( join_set3.iterative_size(), 3 );
 308 }
 309
 310 template <class T>
 311 void interval_set_mixed_subtract_4_bicremental_types()
 312 {
 313     typedef interval_set<T> IntervalSetT;
 314     typedef typename IntervalSetT::interval_type IntervalT;
 315
 316     T v0 = make<T>(0);
 317     T v2 = make<T>(2);
 318     T v3 = make<T>(3);
 319     T v4 = make<T>(4);
 320     T v5 = make<T>(5);
 321     T v6 = make<T>(6);
 322     T v7 = make<T>(7);
 323     T v8 = make<T>(8);
 324     T v9 = make<T>(9);
 325
 326     IntervalT I0_4D = IntervalT::right_open(v0,v4);
 327     IntervalT I2_6D = IntervalT::right_open(v2,v6);
 328     IntervalT I3_6D = IntervalT::right_open(v3,v6);
 329     IntervalT I5_7D = IntervalT::right_open(v5,v7);
 330     IntervalT I7_8D = IntervalT::right_open(v7,v8);
 331     IntervalT I8_9D = IntervalT::right_open(v8,v9);
 332     IntervalT I8_9I =    IntervalT::closed(v8,v9);
 333
 334     split_interval_set<T> split_set;
 335     split_set.add(I0_4D).add(I2_6D).add(I5_7D).add(I7_8D).add(I8_9I);
 336     BOOST_CHECK_EQUAL( split_set.iterative_size(), 7 );
 337
 338     separate_interval_set<T> sep_set;
 339     sep_set.add(I0_4D).add(I2_6D).add(I5_7D).add(I7_8D).add(I8_9I);
 340     BOOST_CHECK_EQUAL( sep_set.iterative_size(), 3 );
 341
 342     interval_set<T> join_set;
 343     join_set.add(I0_4D).add(I2_6D).add(I5_7D).add(I7_8D).add(I8_9I);
 344     BOOST_CHECK_EQUAL( join_set.iterative_size(), 1 );
 345
 346     // Make sets to be subtracted
 347     split_interval_set<T> split_sub;
 348     split_sub.add(I3_6D).add(I8_9D);
 349
 350     separate_interval_set<T> sep_sub;
 351     sep_sub.add(I3_6D).add(I8_9D);
 352
 353     interval_set<T> join_sub;
 354     join_sub.add(I3_6D).add(I8_9D);
 355
 356     //--------------------------------------------------------------------------
 357     // Test for split_interval_set
 358     split_interval_set<T>    split_diff = split_set;
 359     separate_interval_set<T> sep_diff   = sep_set;
 360     interval_set<T>          join_diff  = join_set;
 361
 362     //subtraction combinations
 363     split_diff -= split_sub;
 364     sep_diff   -= split_sub;
 365     join_diff  -= split_sub;
 366
 367     BOOST_CHECK_EQUAL( split_diff.iterative_size(), 5 );
 368     BOOST_CHECK_EQUAL( sep_diff.iterative_size(),   4 );
 369     BOOST_CHECK_EQUAL( join_diff.iterative_size(),  3 );
 370
 371     BOOST_CHECK_EQUAL( is_element_equal(split_diff, split_diff), true );
 372     BOOST_CHECK_EQUAL( is_element_equal(split_diff, sep_diff),   true );
 373     BOOST_CHECK_EQUAL( is_element_equal(split_diff, join_diff),  true );
 374     BOOST_CHECK_EQUAL( is_element_equal(sep_diff,   split_diff), true );
 375     BOOST_CHECK_EQUAL( is_element_equal(join_diff,  split_diff), true );
 376
 377     //--------------------------------------------------------------------------
 378     // Test for separate_interval_set. Reinitialize
 379     split_diff = split_set;
 380     sep_diff   = sep_set;
 381     join_diff  = join_set;
 382
 383     //subtraction combinations
 384     split_diff -= sep_sub;
 385     sep_diff   -= sep_sub;
 386     join_diff  -= sep_sub;
 387
 388     BOOST_CHECK_EQUAL( split_diff.iterative_size(), 5 );
 389     BOOST_CHECK_EQUAL( sep_diff.iterative_size(),   4 );
 390     BOOST_CHECK_EQUAL( join_diff.iterative_size(),  3 );
 391
 392     BOOST_CHECK_EQUAL( is_element_equal(sep_diff,   sep_diff),   true );
 393     BOOST_CHECK_EQUAL( is_element_equal(sep_diff,   split_diff), true );
 394     BOOST_CHECK_EQUAL( is_element_equal(sep_diff,   join_diff),  true );
 395     BOOST_CHECK_EQUAL( is_element_equal(split_diff, sep_diff),   true );
 396     BOOST_CHECK_EQUAL( is_element_equal(join_diff,  sep_diff),   true );
 397
 398     //--------------------------------------------------------------------------
 399     // Test for interval_set. Reinitialize
 400     split_diff = split_set;
 401     sep_diff   = sep_set;
 402     join_diff  = join_set;
 403
 404     //subtraction combinations
 405     split_diff -= join_sub;
 406     sep_diff   -= join_sub;
 407     join_diff  -= join_sub;
 408
 409     BOOST_CHECK_EQUAL( split_diff.iterative_size(), 5 );
 410     BOOST_CHECK_EQUAL( sep_diff.iterative_size(),   4 );
 411     BOOST_CHECK_EQUAL( join_diff.iterative_size(),  3 );
 412
 413     BOOST_CHECK_EQUAL( is_element_equal(join_diff,  join_diff),   true );
 414     BOOST_CHECK_EQUAL( is_element_equal(join_diff,  split_diff),  true );
 415     BOOST_CHECK_EQUAL( is_element_equal(join_diff,  sep_diff),    true );
 416     BOOST_CHECK_EQUAL( is_element_equal(sep_diff,   join_diff),   true );
 417     BOOST_CHECK_EQUAL( is_element_equal(join_diff,  join_diff),   true );
 418 }
 419
 420
 421 template <class T>
 422 void interval_set_mixed_erase_4_bicremental_types()
 423 {
 424     typedef interval_set<T> IntervalSetT;
 425     typedef typename IntervalSetT::interval_type IntervalT;
 426
 427     T v0 = make<T>(0);
 428     T v2 = make<T>(2);
 429     T v3 = make<T>(3);
 430     T v4 = make<T>(4);
 431     T v5 = make<T>(5);
 432     T v6 = make<T>(6);
 433     T v7 = make<T>(7);
 434     T v8 = make<T>(8);
 435     T v9 = make<T>(9);
 436
 437     IntervalT I0_4D = IntervalT::right_open(v0,v4);
 438     IntervalT I2_6D = IntervalT::right_open(v2,v6);
 439     IntervalT I3_6D = IntervalT::right_open(v3,v6);
 440     IntervalT I5_7D = IntervalT::right_open(v5,v7);
 441     IntervalT I7_8D = IntervalT::right_open(v7,v8);
 442     IntervalT I8_9D = IntervalT::right_open(v8,v9);
 443     IntervalT I8_9I =    IntervalT::closed(v8,v9);
 444
 445     split_interval_set<T> split_set;
 446     split_set.add(I0_4D).add(I2_6D).add(I5_7D).add(I7_8D).add(I8_9I);
 447     BOOST_CHECK_EQUAL( split_set.iterative_size(), 7 );
 448
 449     separate_interval_set<T> sep_set;
 450     sep_set.add(I0_4D).add(I2_6D).add(I5_7D).add(I7_8D).add(I8_9I);
 451     BOOST_CHECK_EQUAL( sep_set.iterative_size(), 3 );
 452
 453     interval_set<T> join_set;
 454     join_set.add(I0_4D).add(I2_6D).add(I5_7D).add(I7_8D).add(I8_9I);
 455     BOOST_CHECK_EQUAL( join_set.iterative_size(), 1 );
 456
 457     // Make sets to be subtracted
 458     split_interval_set<T> split_sub;
 459     split_sub.add(I3_6D).add(I8_9D);
 460
 461     separate_interval_set<T> sep_sub;
 462     sep_sub.add(I3_6D).add(I8_9D);
 463
 464     interval_set<T> join_sub;
 465     join_sub.add(I3_6D).add(I8_9D);
 466
 467     //--------------------------------------------------------------------------
 468     // Test for split_interval_set
 469     split_interval_set<T>    split_diff = split_set;
 470     separate_interval_set<T> sep_diff   = sep_set;
 471     interval_set<T>          join_diff  = join_set;
 472
 473     //subtraction combinations
 474     erase(split_diff, split_sub);
 475     erase(sep_diff,   split_sub);
 476     erase(join_diff,  split_sub);
 477
 478     BOOST_CHECK_EQUAL( split_diff.iterative_size(), 5 );
 479     BOOST_CHECK_EQUAL( sep_diff.iterative_size(),   4 );
 480     BOOST_CHECK_EQUAL( join_diff.iterative_size(),  3 );
 481
 482     BOOST_CHECK_EQUAL( is_element_equal(split_diff, split_diff), true );
 483     BOOST_CHECK_EQUAL( is_element_equal(split_diff, sep_diff),   true );
 484     BOOST_CHECK_EQUAL( is_element_equal(split_diff, join_diff),  true );
 485     BOOST_CHECK_EQUAL( is_element_equal(sep_diff,   split_diff), true );
 486     BOOST_CHECK_EQUAL( is_element_equal(join_diff,  split_diff), true );
 487
 488     //--------------------------------------------------------------------------
 489     // Test for separate_interval_set. Reinitialize
 490     split_diff = split_set;
 491     sep_diff   = sep_set;
 492     join_diff  = join_set;
 493
 494     //subtraction combinations
 495     erase(split_diff, sep_sub);
 496     erase(sep_diff, sep_sub);
 497     erase(join_diff, sep_sub);
 498
 499     BOOST_CHECK_EQUAL( split_diff.iterative_size(), 5 );
 500     BOOST_CHECK_EQUAL( sep_diff.iterative_size(),   4 );
 501     BOOST_CHECK_EQUAL( join_diff.iterative_size(),  3 );
 502
 503     BOOST_CHECK_EQUAL( is_element_equal(sep_diff,   sep_diff),   true );
 504     BOOST_CHECK_EQUAL( is_element_equal(sep_diff,   split_diff), true );
 505     BOOST_CHECK_EQUAL( is_element_equal(sep_diff,   join_diff),  true );
 506     BOOST_CHECK_EQUAL( is_element_equal(split_diff, sep_diff),   true );
 507     BOOST_CHECK_EQUAL( is_element_equal(join_diff,  sep_diff),   true );
 508
 509     //--------------------------------------------------------------------------
 510     // Test for interval_set. Reinitialize
 511     split_diff = split_set;
 512     sep_diff   = sep_set;
 513     join_diff  = join_set;
 514
 515     //subtraction combinations
 516     erase(split_diff, join_sub);
 517     erase(sep_diff, join_sub);
 518     erase(join_diff, join_sub);
 519
 520     BOOST_CHECK_EQUAL( split_diff.iterative_size(), 5 );
 521     BOOST_CHECK_EQUAL( sep_diff.iterative_size(),   4 );
 522     BOOST_CHECK_EQUAL( join_diff.iterative_size(),  3 );
 523
 524     BOOST_CHECK_EQUAL( is_element_equal(join_diff,  join_diff),   true );
 525     BOOST_CHECK_EQUAL( is_element_equal(join_diff,  split_diff),  true );
 526     BOOST_CHECK_EQUAL( is_element_equal(join_diff,  sep_diff),    true );
 527     BOOST_CHECK_EQUAL( is_element_equal(sep_diff,   join_diff),   true );
 528     BOOST_CHECK_EQUAL( is_element_equal(join_diff,  join_diff),   true );
 529 }
 530
 531 template <class T>
 532 void interval_set_mixed_basic_intersect_4_bicremental_types()
 533 {
 534     typedef interval_set<T> IntervalSetT;
 535     typedef typename IntervalSetT::interval_type IntervalT;
 536
 537     T v0 = make<T>(0);
 538     T v1 = make<T>(1);
 539     T v2 = make<T>(2);
 540     T v3 = make<T>(3);
 541     T v6 = make<T>(6);
 542     T v7 = make<T>(7);
 543     T v8 = make<T>(8);
 544     T v9 = make<T>(9);
 545
 546     IntervalT I0_3D = IntervalT::right_open(v0,v3);
 547     IntervalT I1_3D = IntervalT::right_open(v1,v3);
 548     IntervalT I1_8D = IntervalT::right_open(v1,v8);
 549     IntervalT I2_7D = IntervalT::right_open(v2,v7);
 550     IntervalT I2_3D = IntervalT::right_open(v2,v3);
 551     IntervalT I6_7D = IntervalT::right_open(v6,v7);
 552     IntervalT I6_8D = IntervalT::right_open(v6,v8);
 553     IntervalT I6_9D = IntervalT::right_open(v6,v9);
 554
 555     //--------------------------------------------------------------------------
 556     // split_interval_set
 557     //--------------------------------------------------------------------------
 558     //split_A      [0       3)       [6    9)
 559     //         &=      [1                8)
 560     //split_AB ->      [1   3)       [6  8)
 561     //         &=        [2             7)
 562     //         ->        [2 3)       [6 7)
 563     split_interval_set<T>    split_A, split_B, split_AB, split_ab, split_ab2;
 564
 565     split_A.add(I0_3D).add(I6_9D);
 566     split_AB = split_A;
 567     split_AB &= I1_8D;
 568     split_ab.add(I1_3D).add(I6_8D);
 569
 570     BOOST_CHECK_EQUAL( split_AB, split_ab );
 571
 572     split_AB = split_A;
 573     (split_AB &= I1_8D) &= I2_7D;
 574     split_ab2.add(I2_3D).add(I6_7D);
 575
 576     BOOST_CHECK_EQUAL( split_AB, split_ab2 );
 577
 578
 579     //--------------------------------------------------------------------------
 580     //split_A      [0       3)       [6    9)
 581     //         &=       1
 582     //split_AB ->      [1]
 583     //         +=         (1             7)
 584     //         ->      [1](1             7)
 585     split_A.add(I0_3D).add(I6_9D);
 586     split_AB = split_A;
 587     split_AB &= v1;
 588     split_ab.clear();
 589     split_ab.add(v1);
 590
 591     BOOST_CHECK_EQUAL( split_AB, split_ab );
 592
 593     split_AB = split_A;
 594     (split_AB &= v1) += IntervalT::open(v1,v7);
 595     split_ab2.clear();
 596     split_ab2 += IntervalT::right_open(v1,v7);
 597
 598     BOOST_CHECK_EQUAL( is_element_equal(split_AB, split_ab2), true );
 599 }
 600
 601 template <class T>
 602 void interval_set_mixed_intersect_4_bicremental_types()
 603 {
 604     typedef interval_set<T> IntervalSetT;
 605     typedef typename IntervalSetT::interval_type IntervalT;
 606
 607     T v0 = make<T>(0);
 608     T v1 = make<T>(1);
 609     T v2 = make<T>(2);
 610     T v3 = make<T>(3);
 611     T v4 = make<T>(4);
 612     T v5 = make<T>(5);
 613     T v6 = make<T>(6);
 614
 615     T v8 = make<T>(8);
 616     T v9 = make<T>(9);
 617
 618     IntervalT I0_3D = IntervalT::right_open(v0,v3);
 619     IntervalT I1_2D = IntervalT::right_open(v1,v2);
 620     IntervalT I1_3D = IntervalT::right_open(v1,v3);
 621     IntervalT I2_3D = IntervalT::right_open(v2,v3);
 622     IntervalT I2_4D = IntervalT::right_open(v2,v4);
 623     IntervalT I5_8D = IntervalT::right_open(v5,v8);
 624     IntervalT I6_8D = IntervalT::right_open(v6,v8);
 625     IntervalT I6_9D = IntervalT::right_open(v6,v9);
 626
 627     //--------------------------------------------------------------------------
 628     // split_interval_set
 629     //--------------------------------------------------------------------------
 630     //split_A      [0          3)       [6   9)
 631     //split_B  &=      [1 2)[2    4) [5    8)
 632     //split_AB ->      [1 2)[2 3)       [6 8)
 633     split_interval_set<T>    split_A, split_B, split_AB, split_ab, split_ab_jn;
 634     separate_interval_set<T> sep_A,   sep_B,   sep_AB,   sep_ab;
 635     interval_set<T>          join_A,  join_B,  join_AB,  join_ab;
 636
 637     split_A.add(I0_3D).add(I6_9D);
 638     split_B.add(I1_2D).add(I2_4D).add(I5_8D);
 639     split_ab.add(I1_2D).add(I2_3D).add(I6_8D);
 640     split_ab_jn.add(I1_3D).add(I6_8D);
 641     split_AB = split_A;
 642     split_AB &= split_B;
 643     BOOST_CHECK_EQUAL( split_AB.iterative_size(), 3 );
 644     BOOST_CHECK_EQUAL( split_AB, split_ab );
 645
 646     //split_A      [0          3)       [6   9)
 647     //sep_B    &=      [1 2)[2    4) [5    8)
 648     //split_AB ->      [1 2)[2 3)       [6 8)
 649     split_AB = split_A;
 650     sep_B = split_B;
 651     split_AB &= sep_B;
 652     BOOST_CHECK_EQUAL( split_AB.iterative_size(), 3 );
 653     BOOST_CHECK_EQUAL( split_AB, split_ab );
 654
 655     //split_A      [0          3)       [6   9)
 656     //join_B   &=      [1         4) [5    8)
 657     //split_AB ->      [1      3)       [6 8)
 658     split_AB = split_A;
 659     join_B = split_B;
 660     split_AB &= join_B;
 661
 662     BOOST_CHECK_EQUAL( split_AB.iterative_size(), 2 );
 663     BOOST_CHECK_EQUAL( split_AB, split_ab_jn );
 664
 665     //--------------------------------------------------------------------------
 666     // separate_interval_set
 667     //--------------------------------------------------------------------------
 668     //sep_A      [0          3)       [6   9)
 669     //sep_B  &=      [1 2)[2    4) [5    8)
 670     //sep_AB ->      [1 2)[2 3)       [6 8)
 671     sep_ab = split_ab;
 672     BOOST_CHECK_EQUAL( sep_ab.iterative_size(), 3 );
 673
 674     sep_AB = split_A;
 675     sep_B  = split_B;
 676     sep_AB &= sep_B;
 677
 678     BOOST_CHECK_EQUAL( sep_AB.iterative_size(), 3 );
 679     BOOST_CHECK_EQUAL( sep_AB, sep_ab );
 680
 681     //sep_A       [0          3)       [6   9)
 682     //split_B &=      [1 2)[2    4) [5    8)
 683     //sep_AB  ->      [1 2)[2 3)       [6 8)
 684     sep_AB = split_A;
 685     sep_AB &= split_B;
 686
 687     BOOST_CHECK_EQUAL( sep_AB.iterative_size(), 3 );
 688     BOOST_CHECK_EQUAL( sep_AB, sep_ab );
 689
 690     //sep_A       [0         3)        [6   9)
 691     //join_B &=      [1          4) [5    8)
 692     //sep_AB ->      [1      3)        [6 8)
 693     separate_interval_set<T> sep_ab_jn = split_ab_jn;
 694     sep_AB = split_A;
 695     join_B = split_B;
 696     sep_AB &= join_B;
 697
 698     BOOST_CHECK_EQUAL( sep_AB.iterative_size(), 2 );
 699     BOOST_CHECK_EQUAL( sep_AB, sep_ab_jn );
 700
 701     //--------------------------------------------------------------------------
 702     // separate_interval_set
 703     //--------------------------------------------------------------------------
 704     //join_A      [0          3)       [6   9)
 705     //join_B  &=      [1         4) [5    8)
 706     //join_AB ->      [1      3)       [6 8)
 707     join_ab = split_ab;
 708     BOOST_CHECK_EQUAL( join_ab.iterative_size(), 2 );
 709
 710     join_AB = split_A;
 711     join_B  = split_B;
 712     join_AB &= sep_B;
 713
 714     BOOST_CHECK_EQUAL( join_AB.iterative_size(), 2 );
 715     BOOST_CHECK_EQUAL( join_AB, join_ab );
 716
 717     //join_A      [0          3)       [6   9)
 718     //split_B  &=     [1 2)[2    4) [5    8)
 719     //join_AB  ->     [1      3)       [6 8)
 720     join_AB = split_A;
 721     join_AB &= split_B;
 722
 723     BOOST_CHECK_EQUAL( join_AB.iterative_size(), 2 );
 724     BOOST_CHECK_EQUAL( join_AB, join_ab );
 725
 726     //join_A      [0          3)       [6   9)
 727     //sep_B    &=     [1 2)[2    4) [5    8)
 728     //join_AB  ->     [1      3)       [6 8)
 729     join_AB = split_A;
 730     join_AB &= sep_B;
 731
 732     BOOST_CHECK_EQUAL( join_AB.iterative_size(), 2 );
 733     BOOST_CHECK_EQUAL( join_AB, join_ab );
 734
 735 }
 736
 737
 738 template <class T>
 739 void interval_set_mixed_disjoint_4_bicremental_types()
 740 {
 741     typedef interval_set<T> IntervalSetT;
 742     typedef typename IntervalSetT::interval_type IntervalT;
 743
 744     T v0 = make<T>(0);
 745     T v2 = make<T>(2);
 746     T v3 = make<T>(3);
 747     T v4 = make<T>(4);
 748     T v6 = make<T>(6);
 749
 750     IntervalT I0_2D = IntervalT::right_open(v0,v2);
 751     IntervalT I2_3D = IntervalT::right_open(v2,v3);
 752     IntervalT I3_4D = IntervalT::right_open(v3,v4);
 753     IntervalT I4_4I = IntervalT::closed(v4,v4);
 754     IntervalT C4_6D = IntervalT::open(v4,v6);
 755     IntervalT I6_6I = IntervalT::closed(v6,v6);
 756
 757     //--------------------------------------------------------------------------
 758     //split_A: [0  2)          [4 4]      [6 6]
 759     //split_B:       [2 3)[3 4)     (4  6)
 760     split_interval_set<T> split_A, split_B;
 761
 762     split_A.add(I0_2D).add(I4_4I).add(I6_6I);
 763     split_B.add(I2_3D).add(I3_4D).add(C4_6D);
 764
 765     separate_interval_set<T> sep_A(split_A), sep_B(split_B);
 766     interval_set<T> join_A(split_A), join_B(split_B);
 767
 768     BOOST_CHECK_EQUAL( disjoint(split_A, split_B), true );
 769     BOOST_CHECK_EQUAL( disjoint(split_A, sep_B),   true );
 770     BOOST_CHECK_EQUAL( disjoint(split_A, join_B),  true );
 771
 772     BOOST_CHECK_EQUAL( disjoint(sep_A,   split_B), true );
 773     BOOST_CHECK_EQUAL( disjoint(sep_A,   sep_B),   true );
 774     BOOST_CHECK_EQUAL( disjoint(sep_A,   join_B),  true );
 775
 776     BOOST_CHECK_EQUAL( disjoint(join_A,  split_B), true );
 777     BOOST_CHECK_EQUAL( disjoint(join_A,  sep_B),   true );
 778     BOOST_CHECK_EQUAL( disjoint(join_A,  join_B),  true );
 779 }
 780
 781 template <class T>
 782 void interval_set_mixed_infix_plus_overload_4_bicremental_types()
 783 {
 784     typedef interval_set<T> IntervalSetT;
 785     typedef typename IntervalSetT::interval_type IntervalT;
 786
 787     interval_set<T>          join_a;
 788     separate_interval_set<T> sep_a;
 789     split_interval_set<T>    split_a;
 790
 791     join_a.add(I_D(0,4)) .add(I_I(4,6)).add(I_D(5,9));
 792     sep_a .add(I_D(0,4)) .add(I_I(4,6)).add(I_D(5,11));
 793     split_a.add(I_I(0,0)).add(I_D(8,7)).add(I_I(6,11));
 794
 795     BOOST_CHECK_EQUAL(split_a + sep_a,  sep_a  + split_a );
 796     BOOST_CHECK_EQUAL(split_a + join_a, join_a + split_a);
 797     BOOST_CHECK_EQUAL(sep_a   + join_a, join_a + sep_a  );
 798 }
 799
 800 template <class T> void interval_set_mixed_infix_pipe_overload_4_bicremental_types()
 801 {
 802     typedef interval_set<T> IntervalSetT;
 803     typedef typename IntervalSetT::interval_type IntervalT;
 804
 805     interval_set<T>          join_a;
 806     separate_interval_set<T> sep_a;
 807     split_interval_set<T>    split_a;
 808
 809     join_a.add(I_D(0,4)) .add(I_I(4,6)).add(I_D(5,9));
 810     sep_a .add(I_D(0,4)) .add(I_I(4,6)).add(I_D(5,11));
 811     split_a.add(I_I(0,0)).add(I_D(8,7)).add(I_I(6,11));
 812
 813     BOOST_CHECK_EQUAL(split_a | sep_a,  sep_a  | split_a );
 814     BOOST_CHECK_EQUAL(split_a | join_a, join_a | split_a);
 815     BOOST_CHECK_EQUAL(sep_a   | join_a, join_a | sep_a  );
 816 }
 817
 818 template <class T>
 819 void interval_set_mixed_infix_minus_overload_4_bicremental_types()
 820 {
 821     typedef interval_set<T> IntervalSetT;
 822     typedef typename IntervalSetT::interval_type IntervalT;
 823
 824     interval_set<T>          join_a,  join_b;
 825     separate_interval_set<T> sep_a,   sep_b;
 826     split_interval_set<T>    split_a, split_b;
 827
 828     join_a.add(I_D(0,4)) .add(I_I(4,6)).add(I_D(5,9));
 829     sep_a .add(I_D(0,4)) .add(I_I(4,6)).add(I_D(5,11));
 830     split_a.add(I_I(0,0)).add(I_D(8,7)).add(I_I(6,11));
 831
 832     BOOST_CHECK_EQUAL(split_a - sep_a,   (split_b = split_a) -= sep_a  );
 833     BOOST_CHECK_EQUAL(split_a - join_a,  (split_b = split_a) -= join_a );
 834     BOOST_CHECK_EQUAL(sep_a   - join_a,  (sep_b   = sep_a)   -= join_a );
 835
 836     BOOST_CHECK_EQUAL(sep_a   - split_a, (sep_b  = sep_a)    -= split_a);
 837     BOOST_CHECK_EQUAL(join_a  - split_a, (join_b = join_a)   -= split_a);
 838     BOOST_CHECK_EQUAL(join_a  - sep_a,   (join_b = join_a)   -= sep_a  );
 839 }
 840
 841 template <class T> void interval_set_mixed_infix_et_overload_4_bicremental_types()
 842 {
 843     typedef interval_set<T> IntervalSetT;
 844     typedef typename IntervalSetT::interval_type IntervalT;
 845
 846     interval_set<T>          join_a;
 847     separate_interval_set<T> sep_a;
 848     split_interval_set<T>    split_a;
 849
 850     join_a.add(I_D(0,4)) .add(I_I(4,6)).add(I_D(5,9));
 851     sep_a .add(I_D(0,4)) .add(I_I(4,6)).add(I_D(5,11));
 852     split_a.add(I_I(0,0)).add(I_D(8,7)).add(I_I(6,11));
 853
 854     BOOST_CHECK_EQUAL(split_a & sep_a,  sep_a  & split_a );
 855     BOOST_CHECK_EQUAL(split_a & join_a, join_a & split_a);
 856     BOOST_CHECK_EQUAL(sep_a   & join_a, join_a & sep_a  );
 857 }
 858
 859 template <class T> void interval_set_mixed_infix_caret_overload_4_bicremental_types()
 860 {
 861     typedef interval_set<T> IntervalSetT;
 862     typedef typename IntervalSetT::interval_type IntervalT;
 863
 864     interval_set<T>          join_a;
 865     separate_interval_set<T> sep_a;
 866     split_interval_set<T>    split_a;
 867
 868     join_a.add(I_D(0,4)) .add(I_I(4,6)).add(I_D(5,9));
 869     sep_a .add(I_D(0,4)) .add(I_I(4,6)).add(I_D(5,11));
 870     split_a.add(I_I(0,0)).add(I_D(8,7)).add(I_I(6,11));
 871
 872     BOOST_CHECK_EQUAL(split_a ^ sep_a,  sep_a  ^ split_a );
 873     BOOST_CHECK_EQUAL(split_a ^ join_a, join_a ^ split_a);
 874     BOOST_CHECK_EQUAL(sep_a   ^ join_a, join_a ^ sep_a  );
 875 }
 876
 877 #endif // LIBS_ICL_TEST_TEST_INTERVAL_SET_MIXED_HPP_JOFA_090702