interval_set: Fix test_interval_set.cc

Here we duplicate all the original tests which used "insert" to verify they also pass with "union_insert". All new tests are modified to use "union_of" and "union_insert"

Signed-off-by: Alex Ainscow <aainscow@uk.ibm.com>

diff --git a/src/test/common/test_interval_set.cc b/src/test/common/test_interval_set.cc
index f9c97e0775d0075aafbd04759970071d1b47b177..79393d48e6749b8463385f9f1a7b15b85eafd5b6 100644 (file)
--- a/src/test/common/test_interval_set.cc
+++ b/src/test/common/test_interval_set.cc
@@ -599,72 +599,613 @@ TYPED_TEST(IntervalSetTest, span_of) {
   ASSERT_EQ( iset1.size(), 0);
 }
 
+TYPED_TEST(IntervalSetTest, compare_union) {
+  typedef typename TestFixture::ISet ISet;
+  ISet iset1, iset2;
+  ASSERT_TRUE(iset1 == iset1);
+  ASSERT_TRUE(iset1 == iset2);
+
+  iset1.insert(1);
+  ASSERT_FALSE(iset1 == iset2);
+
+  iset2.insert(1);
+  ASSERT_TRUE(iset1 == iset2);
+
+  iset1.union_insert(2, 3);
+  iset2.union_insert(2, 4);
+  ASSERT_FALSE(iset1 == iset2);
+
+  iset2.erase(2, 4);
+  iset2.erase(1);
+  iset2.union_insert(2, 3);
+  iset2.insert(1);
+  ASSERT_TRUE(iset1 == iset2);
+
+  iset1.union_insert(100, 10);
+  iset2.union_insert(100, 5);
+  ASSERT_FALSE(iset1 == iset2);
+  iset2.union_insert(105, 5);
+  ASSERT_TRUE(iset1 == iset2);
+
+  iset1.union_insert(200, 10);
+  iset2.union_insert(205, 5);
+  ASSERT_FALSE(iset1 == iset2);
+  iset2.union_insert(200, 1);
+  iset2.union_insert(202, 3);
+  ASSERT_FALSE(iset1 == iset2);
+  iset2.union_insert(201, 1);
+  ASSERT_TRUE(iset1 == iset2);
+
+  iset1.clear();
+  ASSERT_FALSE(iset1 == iset2);
+  iset2.clear();
+  ASSERT_TRUE(iset1 == iset2);
+}
+
+TYPED_TEST(IntervalSetTest, contains_union) {
+  typedef typename TestFixture::ISet ISet;
+  ISet iset1;
+  ASSERT_FALSE(iset1.contains( 1 ));
+  ASSERT_FALSE(iset1.contains( 0, 1 ));
+
+  iset1.insert(1);
+  ASSERT_TRUE(iset1.contains( 1 ));
+  ASSERT_FALSE(iset1.contains( 0 ));
+  ASSERT_FALSE(iset1.contains( 2 ));
+  ASSERT_FALSE(iset1.contains( 0, 1 ));
+  ASSERT_FALSE(iset1.contains( 0, 2 ));
+  ASSERT_TRUE(iset1.contains( 1, 1 ));
+  ASSERT_FALSE(iset1.contains( 1, 2 ));
+
+  iset1.union_insert(2, 3);
+  ASSERT_TRUE(iset1.contains( 1 ));
+  ASSERT_FALSE(iset1.contains( 0 ));
+  ASSERT_TRUE(iset1.contains( 2 ));
+  ASSERT_FALSE(iset1.contains( 0, 1 ));
+  ASSERT_FALSE(iset1.contains( 0, 2 ));
+  ASSERT_TRUE(iset1.contains( 1, 1 ));
+  ASSERT_TRUE(iset1.contains( 1, 2 ));
+  ASSERT_TRUE(iset1.contains( 1, 3 ));
+  ASSERT_TRUE(iset1.contains( 1, 4 ));
+  ASSERT_FALSE(iset1.contains( 1, 5 ));
+  ASSERT_TRUE(iset1.contains( 2, 1 ));
+  ASSERT_TRUE(iset1.contains( 2, 2 ));
+  ASSERT_TRUE(iset1.contains( 2, 3 ));
+  ASSERT_FALSE(iset1.contains( 2, 4 ));
+  ASSERT_TRUE(iset1.contains( 3, 2 ));
+  ASSERT_TRUE(iset1.contains( 4, 1 ));
+  ASSERT_FALSE(iset1.contains( 4, 2 ));
+
+  iset1.union_insert(10, 10);
+  ASSERT_TRUE(iset1.contains( 1, 4 ));
+  ASSERT_FALSE(iset1.contains( 1, 5 ));
+  ASSERT_TRUE(iset1.contains( 2, 2 ));
+  ASSERT_FALSE(iset1.contains( 2, 4 ));
+
+  ASSERT_FALSE(iset1.contains( 1, 10 ));
+  ASSERT_FALSE(iset1.contains( 9, 1 ));
+  ASSERT_FALSE(iset1.contains( 9 ));
+  ASSERT_FALSE(iset1.contains( 9, 11 ));
+  ASSERT_TRUE(iset1.contains( 10, 1 ));
+  ASSERT_TRUE(iset1.contains( 11, 9 ));
+  ASSERT_TRUE(iset1.contains( 11, 2 ));
+  ASSERT_TRUE(iset1.contains( 18, 2 ));
+  ASSERT_TRUE(iset1.contains( 18, 2 ));
+  ASSERT_TRUE(iset1.contains( 10 ));
+  ASSERT_TRUE(iset1.contains( 19 ));
+  ASSERT_FALSE(iset1.contains( 20 ));
+  ASSERT_FALSE(iset1.contains( 21 ));
+
+  ASSERT_FALSE(iset1.contains( 11, 11 ));
+  ASSERT_FALSE(iset1.contains( 18, 9 ));
+
+  iset1.clear();
+  ASSERT_FALSE(iset1.contains( 1 ));
+  ASSERT_FALSE(iset1.contains( 0 ));
+  ASSERT_FALSE(iset1.contains( 2 ));
+  ASSERT_FALSE(iset1.contains( 0, 1 ));
+  ASSERT_FALSE(iset1.contains( 0, 2 ));
+  ASSERT_FALSE(iset1.contains( 1, 1 ));
+  ASSERT_FALSE(iset1.contains( 10, 2 ));
+}
+
+TYPED_TEST(IntervalSetTest, intersects_union) {
+  typedef typename TestFixture::ISet ISet;
+  ISet iset1;
+  ASSERT_FALSE(iset1.intersects( 1, 1 ));
+  ASSERT_FALSE(iset1.intersects( 0, 1 ));
+  ASSERT_FALSE(iset1.intersects( 0, 10 ));
+
+  iset1.insert(1);
+  ASSERT_TRUE(iset1.intersects( 1, 1 ));
+  ASSERT_FALSE(iset1.intersects( 0, 1 ));
+  ASSERT_FALSE(iset1.intersects( 2, 1 ));
+  ASSERT_TRUE(iset1.intersects( 0, 2 ));
+  ASSERT_TRUE(iset1.intersects( 0, 20 ));
+  ASSERT_TRUE(iset1.intersects( 1, 2 ));
+  ASSERT_TRUE(iset1.intersects( 1, 20 ));
+
+  iset1.union_insert(2, 3);
+  ASSERT_FALSE(iset1.intersects( 0, 1 ));
+  ASSERT_TRUE(iset1.intersects( 0, 2 ));
+  ASSERT_TRUE(iset1.intersects( 0, 200 ));
+  ASSERT_TRUE(iset1.intersects( 1, 1 ));
+  ASSERT_TRUE(iset1.intersects( 1, 4 ));
+  ASSERT_TRUE(iset1.intersects( 1, 5 ));
+  ASSERT_TRUE(iset1.intersects( 2, 1 ));
+  ASSERT_TRUE(iset1.intersects( 2, 2 ));
+  ASSERT_TRUE(iset1.intersects( 2, 3 ));
+  ASSERT_TRUE(iset1.intersects( 2, 4 ));
+  ASSERT_TRUE(iset1.intersects( 3, 2 ));
+  ASSERT_TRUE(iset1.intersects( 4, 1 ));
+  ASSERT_TRUE(iset1.intersects( 4, 2 ));
+  ASSERT_FALSE(iset1.intersects( 5, 2 ));
+
+  iset1.union_insert(10, 10);
+  ASSERT_TRUE(iset1.intersects( 1, 4 ));
+  ASSERT_TRUE(iset1.intersects( 1, 5 ));
+  ASSERT_TRUE(iset1.intersects( 1, 10 ));
+  ASSERT_TRUE(iset1.intersects( 2, 2 ));
+  ASSERT_TRUE(iset1.intersects( 2, 4 ));
+  ASSERT_FALSE(iset1.intersects( 5, 1 ));
+  ASSERT_FALSE(iset1.intersects( 5, 2 ));
+  ASSERT_FALSE(iset1.intersects( 5, 5 ));
+  ASSERT_TRUE(iset1.intersects( 5, 12 ));
+  ASSERT_TRUE(iset1.intersects( 5, 20 ));
+
+  ASSERT_FALSE(iset1.intersects( 9, 1 ));
+  ASSERT_TRUE(iset1.intersects( 9, 2 ));
+
+  ASSERT_TRUE(iset1.intersects( 9, 11 ));
+  ASSERT_TRUE(iset1.intersects( 10, 1 ));
+  ASSERT_TRUE(iset1.intersects( 11, 9 ));
+  ASSERT_TRUE(iset1.intersects( 11, 2 ));
+  ASSERT_TRUE(iset1.intersects( 11, 11 ));
+  ASSERT_TRUE(iset1.intersects( 18, 2 ));
+  ASSERT_TRUE(iset1.intersects( 18, 9 ));
+  ASSERT_FALSE(iset1.intersects( 20, 1 ));
+  ASSERT_FALSE(iset1.intersects( 21, 12 ));
+
+  iset1.clear();
+  ASSERT_FALSE(iset1.intersects( 0, 1 ));
+  ASSERT_FALSE(iset1.intersects( 0, 2 ));
+  ASSERT_FALSE(iset1.intersects( 1, 1 ));
+  ASSERT_FALSE(iset1.intersects( 5, 2 ));
+  ASSERT_FALSE(iset1.intersects( 10, 2 ));
+}
+
+TYPED_TEST(IntervalSetTest, insert_erase_union) {
+  typedef typename TestFixture::ISet ISet;
+  ISet iset1, iset2;
+
+  iset1.union_insert(3, 5);
+  ASSERT_EQ(1, iset1.num_intervals());
+  ASSERT_EQ(5, iset1.size());
+
+  //adding standalone interval
+  iset1.union_insert(15, 10);
+  ASSERT_EQ(2, iset1.num_intervals());
+  ASSERT_EQ(15, iset1.size());
+
+  //adding leftmost standalone interval
+  iset1.union_insert(1, 1);
+  ASSERT_EQ(3, iset1.num_intervals());
+  ASSERT_EQ(16, iset1.size());
+
+  //adding leftmost adjucent interval
+  iset1.union_insert(0, 1);
+  ASSERT_EQ(3, iset1.num_intervals());
+  ASSERT_EQ(17, iset1.size());
+
+  //adding interim interval that merges leftmost and subseqent intervals
+  iset1.union_insert(2, 1);
+  ASSERT_EQ(2, iset1.num_intervals());
+  ASSERT_EQ(18, iset1.size());
+
+  //adding rigtmost standalone interval 
+  iset1.union_insert(30, 5);
+  ASSERT_EQ(3, iset1.num_intervals());
+  ASSERT_EQ(23, iset1.size());
+
+  //adding rigtmost adjusent interval 
+  iset1.union_insert(35, 10);
+  ASSERT_EQ(3, iset1.num_intervals());
+  ASSERT_EQ(33, iset1.size());
+
+  //adding interim interval that merges with the interval preceeding the rightmost
+  iset1.union_insert(25, 1);
+  ASSERT_EQ(3, iset1.num_intervals());
+  ASSERT_EQ(34, iset1.size());
+
+  //adding interim interval that merges with the rightmost and preceeding intervals
+  iset1.union_insert(26, 4);
+  ASSERT_EQ(2, iset1.num_intervals());
+  ASSERT_EQ(38, iset1.size());
+
+  //and finally build single interval filling the gap at  8-15 using different interval set
+  iset2.union_insert( 8, 1 );
+  iset2.union_insert( 14, 1 );
+  iset2.union_insert( 9, 4 );
+  iset1.union_of( iset2 );
+  iset1.union_insert(13, 1);
+  ASSERT_EQ(1, iset1.num_intervals());
+  ASSERT_EQ(45, iset1.size());
+
+  //now reverses the process using subtract & erase
+  iset1.subtract( iset2 );
+  iset1.erase(13, 1);
+  ASSERT_EQ( 2, iset1.num_intervals() );
+  ASSERT_EQ(38, iset1.size());
+  ASSERT_TRUE( iset1.contains( 7, 1 ));
+  ASSERT_FALSE( iset1.contains( 8, 7 ));
+  ASSERT_TRUE( iset1.contains( 15, 1 ));
+  ASSERT_TRUE( iset1.contains( 26, 4 ));
+
+  iset1.erase(26, 4);
+  ASSERT_EQ(3, iset1.num_intervals());
+  ASSERT_EQ(34, iset1.size());
+  ASSERT_TRUE( iset1.contains( 7, 1 ));
+  ASSERT_FALSE( iset1.intersects( 8, 7 ));
+  ASSERT_TRUE( iset1.contains( 15, 1 ));
+  ASSERT_TRUE( iset1.contains( 25, 1 ));
+  ASSERT_FALSE( iset1.contains( 26, 4 ));
+  ASSERT_TRUE( iset1.contains( 30, 1 ));
+
+  iset1.erase(25, 1);
+  ASSERT_EQ(3, iset1.num_intervals());
+  ASSERT_EQ(33, iset1.size());
+  ASSERT_TRUE( iset1.contains( 24, 1 ));
+  ASSERT_FALSE( iset1.contains( 25, 1 ));
+  ASSERT_FALSE( iset1.intersects( 26, 4 ));
+  ASSERT_TRUE( iset1.contains( 30, 1 ));
+  ASSERT_TRUE( iset1.contains( 35, 10 ));
+
+  iset1.erase(35, 10);
+  ASSERT_EQ(3, iset1.num_intervals());
+  ASSERT_EQ(23, iset1.size());
+  ASSERT_TRUE( iset1.contains( 30, 5 ));
+  ASSERT_TRUE( iset1.contains( 34, 1 ));
+  ASSERT_FALSE( iset1.contains( 35, 10 ));
+  ASSERT_FALSE(iset1.contains( 45, 1 ));
+
+  iset1.erase(30, 5);
+  ASSERT_EQ(2, iset1.num_intervals());
+  ASSERT_EQ(18, iset1.size());
+  ASSERT_TRUE( iset1.contains( 2, 1 ));
+  ASSERT_TRUE( iset1.contains( 24, 1 ));
+  ASSERT_FALSE( iset1.contains( 25, 1 ));
+  ASSERT_FALSE( iset1.contains( 29, 1 ));
+  ASSERT_FALSE( iset1.contains( 30, 5 ));
+  ASSERT_FALSE( iset1.contains( 35, 1 ));
+
+  iset1.erase(2, 1);
+  ASSERT_EQ(3, iset1.num_intervals());
+  ASSERT_EQ( iset1.size(), 17 );
+  ASSERT_TRUE( iset1.contains( 0, 1 ));
+  ASSERT_TRUE( iset1.contains( 1, 1 ));
+  ASSERT_FALSE( iset1.contains( 2, 1 ));
+  ASSERT_TRUE( iset1.contains( 3, 1 ));
+  ASSERT_TRUE( iset1.contains( 15, 1 ));
+  ASSERT_FALSE( iset1.contains( 25, 1 ));
+
+  iset1.erase( 0, 1);
+  ASSERT_EQ(3, iset1.num_intervals());
+  ASSERT_EQ(16, iset1.size());
+  ASSERT_FALSE( iset1.contains( 0, 1 ));
+  ASSERT_TRUE( iset1.contains( 1, 1 ));
+  ASSERT_FALSE( iset1.contains( 2, 1 ));
+  ASSERT_TRUE( iset1.contains( 3, 1 ));
+  ASSERT_TRUE( iset1.contains( 15, 1 ));
+
+  iset1.erase(1, 1);
+  ASSERT_EQ(2, iset1.num_intervals());
+  ASSERT_EQ(15, iset1.size());
+  ASSERT_FALSE( iset1.contains( 1, 1 ));
+  ASSERT_TRUE( iset1.contains( 15, 10 ));
+  ASSERT_TRUE( iset1.contains( 3, 5 ));
+
+  iset1.erase(15, 10);
+  ASSERT_EQ(1, iset1.num_intervals());
+  ASSERT_EQ(5, iset1.size());
+  ASSERT_FALSE( iset1.contains( 1, 1 ));
+  ASSERT_FALSE( iset1.contains( 15, 10 ));
+  ASSERT_FALSE( iset1.contains( 25, 1 ));
+  ASSERT_TRUE( iset1.contains( 3, 5 ));
+
+  iset1.erase( 3, 1);
+  ASSERT_EQ(1, iset1.num_intervals());
+  ASSERT_EQ(4, iset1.size());
+  ASSERT_FALSE( iset1.contains( 1, 1 ));
+  ASSERT_FALSE( iset1.contains( 15, 10 ));
+  ASSERT_FALSE( iset1.contains( 25, 1 ));
+  ASSERT_TRUE( iset1.contains( 4, 4 ));
+  ASSERT_FALSE( iset1.contains( 3, 5 ));
+
+  iset1.erase( 4, 4);
+  ASSERT_EQ(0, iset1.num_intervals());
+  ASSERT_EQ(0, iset1.size());
+  ASSERT_FALSE( iset1.contains( 1, 1 ));
+  ASSERT_FALSE( iset1.contains( 15, 10 ));
+  ASSERT_FALSE( iset1.contains( 25, 1 ));
+  ASSERT_FALSE( iset1.contains( 3, 4 ));
+  ASSERT_FALSE( iset1.contains( 3, 5 ));
+  ASSERT_FALSE( iset1.contains( 4, 4 ));
+
+
+}
+
+TYPED_TEST(IntervalSetTest, intersect_of_union) {
+  typedef typename TestFixture::ISet ISet;
+  ISet iset1, iset2, iset3;
+
+  iset1.intersection_of( iset2, iset3 );
+  ASSERT_TRUE( iset1.num_intervals() == 0);
+  ASSERT_TRUE( iset1.size() == 0);
+
+  iset2.union_insert( 0, 1 );
+  iset2.union_insert( 5, 10 );
+  iset2.union_insert( 30, 10 );
+
+  iset3.union_insert( 0, 2 );
+  iset3.union_insert( 15, 1 );
+  iset3.union_insert( 20, 5 );
+  iset3.union_insert( 29, 3 );
+  iset3.union_insert( 35, 3 );
+  iset3.union_insert( 39, 3 );
+
+  iset1.intersection_of( iset2, iset3 );
+  ASSERT_TRUE( iset1.num_intervals() == 4);
+  ASSERT_TRUE( iset1.size() == 7);
+
+  ASSERT_TRUE( iset1.contains( 0, 1 ));
+  ASSERT_FALSE( iset1.contains( 0, 2 ));
+
+  ASSERT_FALSE( iset1.contains( 5, 11 ));
+  ASSERT_FALSE( iset1.contains( 4, 1 ));
+  ASSERT_FALSE( iset1.contains( 16, 1 ));
+  
+  ASSERT_FALSE( iset1.contains( 20, 5 ));
+
+  ASSERT_FALSE( iset1.contains( 29, 1 ));
+  ASSERT_FALSE( iset1.contains( 30, 10 ));
+
+  ASSERT_TRUE( iset1.contains( 30, 2 ));
+  ASSERT_TRUE( iset1.contains( 35, 3 ));
+  ASSERT_FALSE( iset1.contains( 35, 4 ));
+
+  ASSERT_TRUE( iset1.contains( 39, 1 ));
+  ASSERT_FALSE( iset1.contains( 38, 2 ));
+  ASSERT_FALSE( iset1.contains( 39, 2 ));
+
+  iset3=iset1;
+  iset1.intersection_of(iset2);
+  ASSERT_TRUE( iset1 == iset3);
+
+  iset2.clear();
+  iset2.union_insert(0,1);
+  iset1.intersection_of(iset2);
+  ASSERT_TRUE( iset1.num_intervals() == 1);
+  ASSERT_TRUE( iset1.size() == 1);
+
+  iset1 = iset3;
+  iset2.clear();
+  iset1.intersection_of(iset2);
+  ASSERT_TRUE( iset1.num_intervals() == 0);
+  ASSERT_TRUE( iset1.size() == 0);
+
+}
+
+TYPED_TEST(IntervalSetTest, union_of_union) {
+  typedef typename TestFixture::ISet ISet;
+  ISet iset1, iset2, iset3;
+
+  iset1.union_of( iset2, iset3 );
+  ASSERT_TRUE( iset1.num_intervals() == 0);
+  ASSERT_TRUE( iset1.size() == 0);
+
+  iset2.union_insert( 0, 1 );
+  iset2.union_insert( 5, 10 );
+  iset2.union_insert( 30, 10 );
+
+  iset3.union_insert( 0, 2 );
+  iset3.union_insert( 15, 1 );
+  iset3.union_insert( 20, 5 );
+  iset3.union_insert( 29, 3 );
+  iset3.union_insert( 39, 3 );
+
+  iset1.union_of( iset2, iset3 );
+  ASSERT_TRUE( iset1.num_intervals() == 4);
+  ASSERT_EQ( iset1.size(), 31);
+  ASSERT_TRUE( iset1.contains( 0, 2 ));
+  ASSERT_FALSE( iset1.contains( 0, 3 ));
+
+  ASSERT_TRUE( iset1.contains( 5, 11 ));
+  ASSERT_FALSE( iset1.contains( 4, 1 ));
+  ASSERT_FALSE( iset1.contains( 16, 1 ));
+  
+  ASSERT_TRUE( iset1.contains( 20, 5 ));
+
+  ASSERT_TRUE( iset1.contains( 30, 10 ));
+  ASSERT_TRUE( iset1.contains( 29, 13 ));
+  ASSERT_FALSE( iset1.contains( 29, 14 ));
+  ASSERT_FALSE( iset1.contains( 42, 1 ));
+
+  iset2.clear();
+  iset1.union_of(iset2);
+  ASSERT_TRUE( iset1.num_intervals() == 4);
+  ASSERT_EQ( iset1.size(), 31);
+
+  iset3.clear();
+  iset3.union_insert( 29, 3 );
+  iset3.union_insert( 39, 2 );
+  iset1.union_of(iset3);
+
+  ASSERT_TRUE( iset1.num_intervals() == 4);
+  ASSERT_EQ( iset1.size(), 31); //actually we added nothing
+  ASSERT_TRUE( iset1.contains( 29, 13 ));
+  ASSERT_FALSE( iset1.contains( 29, 14 ));
+  ASSERT_FALSE( iset1.contains( 42, 1 ));
+
+}
+
+TYPED_TEST(IntervalSetTest, subset_of_union) {
+  typedef typename TestFixture::ISet ISet;
+  ISet iset1, iset2;
+
+  ASSERT_TRUE(iset1.subset_of(iset2));
+
+  iset1.union_insert(5,10);
+  ASSERT_FALSE(iset1.subset_of(iset2));
+
+  iset2.union_insert(6,8);
+  ASSERT_FALSE(iset1.subset_of(iset2));
+
+  iset2.union_insert(5,1);
+  ASSERT_FALSE(iset1.subset_of(iset2));
+
+  iset2.union_insert(14,10);
+  ASSERT_TRUE(iset1.subset_of(iset2));
+
+  iset1.union_insert( 20, 4);
+  ASSERT_TRUE(iset1.subset_of(iset2));
+
+  iset1.union_insert( 24, 1);
+  ASSERT_FALSE(iset1.subset_of(iset2));
+
+  iset2.union_insert( 24, 1);
+  ASSERT_TRUE(iset1.subset_of(iset2));
+
+  iset1.union_insert( 30, 5);
+  ASSERT_FALSE(iset1.subset_of(iset2));
+
+  iset2.union_insert( 30, 5);
+  ASSERT_TRUE(iset1.subset_of(iset2));
+
+  iset2.erase( 30, 1);
+  ASSERT_FALSE(iset1.subset_of(iset2));
+
+  iset1.erase( 30, 1);
+  ASSERT_TRUE(iset1.subset_of(iset2));
+
+  iset2.erase( 34, 1);
+  ASSERT_FALSE(iset1.subset_of(iset2));
+
+  iset1.erase( 34, 1);
+  ASSERT_TRUE(iset1.subset_of(iset2));
+
+  iset1.union_insert( 40, 5);
+  ASSERT_FALSE(iset1.subset_of(iset2));
+
+  iset2.union_insert( 39, 7);
+  ASSERT_TRUE(iset1.subset_of(iset2));
+
+  iset1.union_insert( 50, 5);
+  iset2.union_insert( 55, 2);
+  ASSERT_FALSE(iset1.subset_of(iset2));
+}
+
+TYPED_TEST(IntervalSetTest, span_of_union) {
+  typedef typename TestFixture::ISet ISet;
+  ISet iset1, iset2;
+
+  iset2.union_insert(5,5);
+  iset2.union_insert(20,5);
+
+  iset1.span_of( iset2, 8, 5 );
+  ASSERT_EQ( iset1.num_intervals(), 2);
+  ASSERT_EQ( iset1.size(), 5);
+  ASSERT_TRUE( iset1.contains( 8, 2 ));
+  ASSERT_TRUE( iset1.contains( 20, 3 ));
+  
+  iset1.span_of( iset2, 3, 5 );
+  ASSERT_EQ( iset1.num_intervals(), 1);
+  ASSERT_EQ( iset1.size(), 5);
+  ASSERT_TRUE( iset1.contains( 5, 5 ));
+
+  iset1.span_of( iset2, 10, 7 );
+  ASSERT_EQ( iset1.num_intervals(), 1);
+  ASSERT_EQ( iset1.size(), 5);
+  ASSERT_TRUE( iset1.contains( 20, 5 ));
+  ASSERT_FALSE( iset1.contains( 20, 6 ));
+
+  iset1.span_of( iset2, 5, 10);
+  ASSERT_EQ( iset1.num_intervals(), 2);
+  ASSERT_EQ( iset1.size(), 10);
+  ASSERT_TRUE( iset1.contains( 5, 5 ));
+  ASSERT_TRUE( iset1.contains( 20, 5 ));
+
+  iset1.span_of( iset2, 100, 5 );
+  ASSERT_EQ( iset1.num_intervals(), 0);
+  ASSERT_EQ( iset1.size(), 0);
+}
+
+
 TYPED_TEST(IntervalSetTest, align) {
   typedef typename TestFixture::ISet ISet;
   {
     ISet iset1, iset2;
 
-    iset1.insert(1, 2);
+    iset1.union_insert(1, 2);
     iset1.align(8);
-    iset2.insert(0,8);
+    iset2.union_insert(0,8);
     ASSERT_TRUE(iset1 == iset2);
   }
 
   {
     ISet iset1, iset2;
 
-    iset1.insert(1, 2);
-    iset1.insert(4, 2);
+    iset1.union_insert(1, 2);
+    iset1.union_insert(4, 2);
 
     iset1.align(8);
-    iset2.insert(0,8);
+    iset2.union_insert(0,8);
     ASSERT_TRUE(iset1 == iset2);
   }
 
   {
     ISet iset1, iset2;
 
-    iset1.insert(7, 2);
-    iset1.insert(15, 2);
+    iset1.union_insert(7, 2);
+    iset1.union_insert(15, 2);
 
     iset1.align(8);
-    iset2.insert(0,24);
+    iset2.union_insert(0,24);
     ASSERT_TRUE(iset1 == iset2);
   }
 
   {
     ISet iset1, iset2;
 
-    iset1.insert(8, 2);
-    iset1.insert(12, 2);
+    iset1.union_insert(8, 2);
+    iset1.union_insert(12, 2);
 
     iset1.align(8);
-    iset2.insert(8,8);
+    iset2.union_insert(8,8);
     ASSERT_TRUE(iset1 == iset2);
   }
 
   {
     ISet iset1, iset2;
 
-    iset1.insert(8, 2);
-    iset1.insert(12, 2);
+    iset1.union_insert(8, 2);
+    iset1.union_insert(12, 2);
 
     iset1.align(8);
-    iset2.insert(8,8);
+    iset2.union_insert(8,8);
     ASSERT_TRUE(iset1 == iset2);
   }
 
   {
     ISet iset1, iset2;
 
-    iset1.insert(0, 1);
-    iset1.insert(23, 1);
-    iset1.insert(40, 1);
+    iset1.union_insert(0, 1);
+    iset1.union_insert(23, 1);
+    iset1.union_insert(40, 1);
 
     iset1.align(8);
-    iset2.insert(0, 8);
-    iset2.insert(16, 8);
-    iset2.insert(40, 8);
+    iset2.union_insert(0, 8);
+    iset2.union_insert(16, 8);
+    iset2.union_insert(40, 8);
 
     ASSERT_TRUE(iset1 == iset2);
   }
@@ -672,11 +1213,11 @@ TYPED_TEST(IntervalSetTest, align) {
   {
     ISet iset1, iset2;
 
-    iset1.insert(4, 2);
-    iset1.insert(12, 2);
+    iset1.union_insert(4, 2);
+    iset1.union_insert(12, 2);
 
     iset1.align(8);
-    iset2.insert(0,16);
+    iset2.union_insert(0,16);
     ASSERT_TRUE(iset1 == iset2);
   }
 
@@ -685,16 +1226,16 @@ TYPED_TEST(IntervalSetTest, align) {
   {
     ISet iset1, iset2;
 
-    iset1.insert(4, 1);
-    iset1.insert(8, 10);
+    iset1.union_insert(4, 1);
+    iset1.union_insert(8, 10);
 
     iset1.align(10);
-    iset2.insert(0,20);
+    iset2.union_insert(0,20);
     ASSERT_TRUE(iset1 == iset2);
   }
 }
 
-TYPED_TEST(IntervalSetTest, insert) {
+TYPED_TEST(IntervalSetTest, union_insert) {
   // Tests targetted at refactor allowing over-lapping inserts.
   typedef typename TestFixture::ISet ISet;
 
@@ -702,9 +1243,9 @@ TYPED_TEST(IntervalSetTest, insert) {
   {
     ISet iset1, iset2;
 
-    iset1.insert(1, 4);
-    iset1.insert(1, 4);
-    iset2.insert(1, 4);
+    iset1.union_insert(1, 4);
+    iset1.union_insert(1, 4);
+    iset2.union_insert(1, 4);
 
     ASSERT_TRUE(iset1 == iset2);
   }
@@ -713,9 +1254,9 @@ TYPED_TEST(IntervalSetTest, insert) {
   {
     ISet iset1, iset2;
 
-    iset1.insert(3, 4);
-    iset1.insert(1, 2);
-    iset2.insert(1, 6);
+    iset1.union_insert(3, 4);
+    iset1.union_insert(1, 2);
+    iset2.union_insert(1, 6);
 
     ASSERT_TRUE(iset1 == iset2);
   }
@@ -724,9 +1265,9 @@ TYPED_TEST(IntervalSetTest, insert) {
   {
     ISet iset1, iset2;
 
-    iset1.insert(3, 4);
-    iset1.insert(2, 2);
-    iset2.insert(2, 5);
+    iset1.union_insert(3, 4);
+    iset1.union_insert(2, 2);
+    iset2.union_insert(2, 5);
 
     ASSERT_TRUE(iset1 == iset2);
   }
@@ -735,9 +1276,9 @@ TYPED_TEST(IntervalSetTest, insert) {
   {
     ISet iset1, iset2;
 
-    iset1.insert(3, 4);
-    iset1.insert(2, 3);
-    iset2.insert(2, 5);
+    iset1.union_insert(3, 4);
+    iset1.union_insert(2, 3);
+    iset2.union_insert(2, 5);
 
     ASSERT_TRUE(iset1 == iset2);
   }
@@ -746,9 +1287,9 @@ TYPED_TEST(IntervalSetTest, insert) {
   {
     ISet iset1, iset2;
 
-    iset1.insert(3, 4);
-    iset1.insert(7, 2);
-    iset2.insert(3, 6);
+    iset1.union_insert(3, 4);
+    iset1.union_insert(7, 2);
+    iset2.union_insert(3, 6);
 
     ASSERT_TRUE(iset1 == iset2);
   }
@@ -757,9 +1298,9 @@ TYPED_TEST(IntervalSetTest, insert) {
   {
     ISet iset1, iset2;
 
-    iset1.insert(3, 4);
-    iset1.insert(6, 2);
-    iset2.insert(3, 5);
+    iset1.union_insert(3, 4);
+    iset1.union_insert(6, 2);
+    iset2.union_insert(3, 5);
 
     ASSERT_TRUE(iset1 == iset2);
   }
@@ -768,231 +1309,231 @@ TYPED_TEST(IntervalSetTest, insert) {
   {
     ISet iset1, iset2;
 
-    iset1.insert(3, 4);
-    iset1.insert(5, 3);
-    iset2.insert(3, 5);
+    iset1.union_insert(3, 4);
+    iset1.union_insert(5, 3);
+    iset2.union_insert(3, 5);
 
     ASSERT_TRUE(iset1 == iset2);
   }
 
-  // insert entirely contains existing.
+  // union_insert entirely contains existing.
   {
     ISet iset1, iset2;
 
-    iset1.insert(3, 4);
-    iset1.insert(2, 6);
-    iset2.insert(2, 6);
+    iset1.union_insert(3, 4);
+    iset1.union_insert(2, 6);
+    iset2.union_insert(2, 6);
 
     ASSERT_TRUE(iset1 == iset2);
   }
 
-  // insert entirely contained within existing
+  // union_insert entirely contained within existing
   {
     ISet iset1, iset2;
 
-    iset1.insert(3, 4);
-    iset1.insert(4, 2);
-    iset2.insert(3, 4);
+    iset1.union_insert(3, 4);
+    iset1.union_insert(4, 2);
+    iset2.union_insert(3, 4);
 
     ASSERT_TRUE(iset1 == iset2);
   }
 
-  // insert joins exactly
+  // union_insert joins exactly
   {
     ISet iset1, iset2;
 
-    iset1.insert(2, 4);
-    iset1.insert(10, 4);
-    iset1.insert(6, 4);
-    iset2.insert(2, 12);
+    iset1.union_insert(2, 4);
+    iset1.union_insert(10, 4);
+    iset1.union_insert(6, 4);
+    iset2.union_insert(2, 12);
 
     ASSERT_TRUE(iset1 == iset2);
   }
 
-  // insert join - overlaps before
+  // union_insert join - overlaps before
   {
     ISet iset1, iset2;
 
-    iset1.insert(2, 4);
-    iset1.insert(10, 4);
-    iset1.insert(5, 5);
-    iset2.insert(2, 12);
+    iset1.union_insert(2, 4);
+    iset1.union_insert(10, 4);
+    iset1.union_insert(5, 5);
+    iset2.union_insert(2, 12);
 
     ASSERT_TRUE(iset1 == iset2);
   }
 
-  // insert join - overlaps after
+  // union_insert join - overlaps after
   {
     ISet iset1, iset2;
 
-    iset1.insert(2, 4);
-    iset1.insert(10, 4);
-    iset1.insert(6, 5);
-    iset2.insert(2, 12);
+    iset1.union_insert(2, 4);
+    iset1.union_insert(10, 4);
+    iset1.union_insert(6, 5);
+    iset2.union_insert(2, 12);
 
     ASSERT_TRUE(iset1 == iset2);
   }
 
-  // insert join - overlaps before and after
+  // union_insert join - overlaps before and after
   {
     ISet iset1, iset2;
 
-    iset1.insert(2, 4);
-    iset1.insert(10, 4);
-    iset1.insert(5, 7);
-    iset2.insert(2, 12);
+    iset1.union_insert(2, 4);
+    iset1.union_insert(10, 4);
+    iset1.union_insert(5, 7);
+    iset2.union_insert(2, 12);
 
     ASSERT_TRUE(iset1 == iset2);
   }
 
-  // insert join multiple - start/start.
+  // union_insert join multiple - start/start.
   {
     ISet iset1, iset2;
 
-    iset1.insert(2, 4);
-    iset1.insert(8, 4);
-    iset1.insert(16, 4);
-    iset1.insert(24, 4);
-    iset1.insert(2, 22);
+    iset1.union_insert(2, 4);
+    iset1.union_insert(8, 4);
+    iset1.union_insert(16, 4);
+    iset1.union_insert(24, 4);
+    iset1.union_insert(2, 22);
 
-    iset2.insert(2, 26);
+    iset2.union_insert(2, 26);
 
     ASSERT_TRUE(iset1 == iset2);
   }
 
-  // insert join multiple - start/middle.
+  // union_insert join multiple - start/middle.
   {
     ISet iset1, iset2;
 
-    iset1.insert(2, 4);
-    iset1.insert(8, 4);
-    iset1.insert(16, 4);
-    iset1.insert(24, 4);
-    iset1.insert(2, 23);
+    iset1.union_insert(2, 4);
+    iset1.union_insert(8, 4);
+    iset1.union_insert(16, 4);
+    iset1.union_insert(24, 4);
+    iset1.union_insert(2, 23);
 
-    iset2.insert(2, 26);
+    iset2.union_insert(2, 26);
 
     ASSERT_TRUE(iset1 == iset2);
   }
-  // insert join multiple - start/end.
+  // union_insert join multiple - start/end.
   {
     ISet iset1, iset2;
 
-    iset1.insert(2, 4);
-    iset1.insert(8, 4);
-    iset1.insert(16, 4);
-    iset1.insert(24, 4);
-    iset1.insert(2, 26);
+    iset1.union_insert(2, 4);
+    iset1.union_insert(8, 4);
+    iset1.union_insert(16, 4);
+    iset1.union_insert(24, 4);
+    iset1.union_insert(2, 26);
 
-    iset2.insert(2, 26);
+    iset2.union_insert(2, 26);
 
     ASSERT_TRUE(iset1 == iset2);
   }
 
-  // insert join multiple - middle/start.
+  // union_insert join multiple - middle/start.
   {
     ISet iset1, iset2;
 
-    iset1.insert(2, 4);
-    iset1.insert(8, 4);
-    iset1.insert(16, 4);
-    iset1.insert(24, 4);
-    iset1.insert(3, 21);
+    iset1.union_insert(2, 4);
+    iset1.union_insert(8, 4);
+    iset1.union_insert(16, 4);
+    iset1.union_insert(24, 4);
+    iset1.union_insert(3, 21);
 
-    iset2.insert(2, 26);
+    iset2.union_insert(2, 26);
 
     ASSERT_TRUE(iset1 == iset2);
   }
 
-  // insert join multiple - middle/middle.
+  // union_insert join multiple - middle/middle.
   {
     ISet iset1, iset2;
 
-    iset1.insert(2, 4);
-    iset1.insert(8, 4);
-    iset1.insert(16, 4);
-    iset1.insert(24, 4);
-    iset1.insert(3, 22);
+    iset1.union_insert(2, 4);
+    iset1.union_insert(8, 4);
+    iset1.union_insert(16, 4);
+    iset1.union_insert(24, 4);
+    iset1.union_insert(3, 22);
 
-    iset2.insert(2, 26);
+    iset2.union_insert(2, 26);
 
     ASSERT_TRUE(iset1 == iset2);
   }
-  // insert join multiple - middle/end.
+  // union_insert join multiple - middle/end.
   {
     ISet iset1, iset2;
 
-    iset1.insert(2, 4);
-    iset1.insert(8, 4);
-    iset1.insert(16, 4);
-    iset1.insert(24, 4);
-    iset1.insert(3, 25);
+    iset1.union_insert(2, 4);
+    iset1.union_insert(8, 4);
+    iset1.union_insert(16, 4);
+    iset1.union_insert(24, 4);
+    iset1.union_insert(3, 25);
 
-    iset2.insert(2, 26);
+    iset2.union_insert(2, 26);
 
     ASSERT_TRUE(iset1 == iset2);
   }
 
-  // insert join multiple - end/start.
+  // union_insert join multiple - end/start.
   {
     ISet iset1, iset2;
 
-    iset1.insert(2, 4);
-    iset1.insert(8, 4);
-    iset1.insert(16, 4);
-    iset1.insert(24, 4);
-    iset1.insert(6, 18);
+    iset1.union_insert(2, 4);
+    iset1.union_insert(8, 4);
+    iset1.union_insert(16, 4);
+    iset1.union_insert(24, 4);
+    iset1.union_insert(6, 18);
 
-    iset2.insert(2, 26);
+    iset2.union_insert(2, 26);
 
     ASSERT_TRUE(iset1 == iset2);
   }
 
-  // insert join multiple - start/middle.
+  // union_insert join multiple - start/middle.
   {
     ISet iset1, iset2;
 
-    iset1.insert(2, 4);
-    iset1.insert(8, 4);
-    iset1.insert(16, 4);
-    iset1.insert(24, 4);
-    iset1.insert(6, 19);
+    iset1.union_insert(2, 4);
+    iset1.union_insert(8, 4);
+    iset1.union_insert(16, 4);
+    iset1.union_insert(24, 4);
+    iset1.union_insert(6, 19);
 
-    iset2.insert(2, 26);
+    iset2.union_insert(2, 26);
 
     ASSERT_TRUE(iset1 == iset2);
   }
-  // insert join multiple - start/end.
+  // union_insert join multiple - start/end.
   {
     ISet iset1, iset2;
 
-    iset1.insert(2, 4);
-    iset1.insert(8, 4);
-    iset1.insert(16, 4);
-    iset1.insert(24, 4);
-    iset1.insert(6, 22);
+    iset1.union_insert(2, 4);
+    iset1.union_insert(8, 4);
+    iset1.union_insert(16, 4);
+    iset1.union_insert(24, 4);
+    iset1.union_insert(6, 22);
 
-    iset2.insert(2, 26);
+    iset2.union_insert(2, 26);
 
     ASSERT_TRUE(iset1 == iset2);
   }
 
-  // insert entirely contained within existing
+  // union_insert entirely contained within existing
   {
     ISet iset1, iset2;
 
-    iset1.insert(0x3000,  0xd000);
-    iset1.insert(0x11000, 0xf000);
-    iset1.insert(0x20000, 0x9000);
-    iset1.insert(0x9000,  0x1000);
-    iset1.insert(0xa000,  0x1000);
-    iset1.insert(0xb000,  0x1000);
-    iset1.insert(0x18000, 0x1000);
-    iset1.insert(0x19000, 0x1000);
-    iset1.insert(0xc000,  0x4000);
-    iset1.insert(0x10000, 0x8000);
-    iset1.insert(0x10000, 0x1000);
-    iset2.insert(0x2c000, 0x10000);
+    iset1.union_insert(0x3000,  0xd000);
+    iset1.union_insert(0x11000, 0xf000);
+    iset1.union_insert(0x20000, 0x9000);
+    iset1.union_insert(0x9000,  0x1000);
+    iset1.union_insert(0xa000,  0x1000);
+    iset1.union_insert(0xb000,  0x1000);
+    iset1.union_insert(0x18000, 0x1000);
+    iset1.union_insert(0x19000, 0x1000);
+    iset1.union_insert(0xc000,  0x4000);
+    iset1.union_insert(0x10000, 0x8000);
+    iset1.union_insert(0x10000, 0x1000);
+    iset2.union_insert(0x2c000, 0x10000);
 
     iset2.intersection_of(iset1);
 
@@ -1006,9 +1547,9 @@ TYPED_TEST(IntervalSetTest, erase) {
   {
     ISet iset1, iset2;
 
-    iset1.insert(4, 4);
+    iset1.union_insert(4, 4);
     iset1.erase(1, 2);
-    iset2.insert(4, 4);
+    iset2.union_insert(4, 4);
 
     ASSERT_EQ(iset1, iset2);
   }
@@ -1017,9 +1558,9 @@ TYPED_TEST(IntervalSetTest, erase) {
   {
     ISet iset1, iset2;
 
-    iset1.insert(3, 4);
+    iset1.union_insert(3, 4);
     iset1.erase(1, 2);
-    iset2.insert(3, 4);
+    iset2.union_insert(3, 4);
 
     ASSERT_EQ(iset1, iset2);
   }
@@ -1028,9 +1569,9 @@ TYPED_TEST(IntervalSetTest, erase) {
   {
     ISet iset1, iset2;
 
-    iset1.insert(3, 4);
+    iset1.union_insert(3, 4);
     iset1.erase(1, 3);
-    iset2.insert(4, 3);
+    iset2.union_insert(4, 3);
 
     ASSERT_EQ(iset1, iset2);
   }
@@ -1039,9 +1580,9 @@ TYPED_TEST(IntervalSetTest, erase) {
   {
     ISet iset1, iset2;
 
-    iset1.insert(3, 4);
+    iset1.union_insert(3, 4);
     iset1.erase(1, 4);
-    iset2.insert(5, 2);
+    iset2.union_insert(5, 2);
 
     ASSERT_EQ(iset1, iset2);
   }
@@ -1050,7 +1591,7 @@ TYPED_TEST(IntervalSetTest, erase) {
   {
     ISet iset1, iset2;
 
-    iset1.insert(3, 4);
+    iset1.union_insert(3, 4);
     iset1.erase(1, 6);
 
     ASSERT_EQ(iset1, iset2);
@@ -1060,7 +1601,7 @@ TYPED_TEST(IntervalSetTest, erase) {
   {
     ISet iset1, iset2;
 
-    iset1.insert(3, 4);
+    iset1.union_insert(3, 4);
     iset1.erase(1, 7);
 
     ASSERT_EQ(iset1, iset2);
@@ -1070,10 +1611,10 @@ TYPED_TEST(IntervalSetTest, erase) {
   {
     ISet iset1, iset2;
 
-    iset1.insert(3, 4);
+    iset1.union_insert(3, 4);
     iset1.erase(4, 2);
-    iset2.insert(3, 1);
-    iset2.insert(6, 1);
+    iset2.union_insert(3, 1);
+    iset2.union_insert(6, 1);
 
     ASSERT_EQ(iset1, iset2);
   }
@@ -1082,9 +1623,9 @@ TYPED_TEST(IntervalSetTest, erase) {
   {
     ISet iset1, iset2;
 
-    iset1.insert(3, 4);
+    iset1.union_insert(3, 4);
     iset1.erase(4, 3);
-    iset2.insert(3, 1);
+    iset2.union_insert(3, 1);
 
     ASSERT_EQ(iset1, iset2);
   }
@@ -1093,9 +1634,9 @@ TYPED_TEST(IntervalSetTest, erase) {
   {
     ISet iset1, iset2;
 
-    iset1.insert(3, 4);
+    iset1.union_insert(3, 4);
     iset1.erase(4, 4);
-    iset2.insert(3, 1);
+    iset2.union_insert(3, 1);
 
     ASSERT_EQ(iset1, iset2);
   }
@@ -1104,9 +1645,9 @@ TYPED_TEST(IntervalSetTest, erase) {
   {
     ISet iset1, iset2;
 
-    iset1.insert(3, 4);
+    iset1.union_insert(3, 4);
     iset1.erase(7, 1);
-    iset2.insert(3, 4);
+    iset2.union_insert(3, 4);
 
     ASSERT_EQ(iset1, iset2);
   }
@@ -1115,9 +1656,9 @@ TYPED_TEST(IntervalSetTest, erase) {
   {
     ISet iset1, iset2;
 
-    iset1.insert(3, 4);
+    iset1.union_insert(3, 4);
     iset1.erase(8, 1);
-    iset2.insert(3, 4);
+    iset2.union_insert(3, 4);
 
     ASSERT_EQ(iset1, iset2);
   }
@@ -1126,11 +1667,11 @@ TYPED_TEST(IntervalSetTest, erase) {
   {
     ISet iset1, iset2;
 
-    iset1.insert(3, 4);
-    iset1.insert(10, 4);
+    iset1.union_insert(3, 4);
+    iset1.union_insert(10, 4);
     iset1.erase(8, 1);
-    iset2.insert(3, 4);
-    iset2.insert(10, 4);
+    iset2.union_insert(3, 4);
+    iset2.union_insert(10, 4);
 
     ASSERT_EQ(iset1, iset2);
   }
@@ -1139,8 +1680,8 @@ TYPED_TEST(IntervalSetTest, erase) {
   {
     ISet iset1, iset2;
 
-    iset1.insert(3, 4);
-    iset1.insert(10, 4);
+    iset1.union_insert(3, 4);
+    iset1.union_insert(10, 4);
     iset1.erase(3, 11);
 
     ASSERT_EQ(iset1, iset2);
@@ -1150,10 +1691,10 @@ TYPED_TEST(IntervalSetTest, erase) {
   {
     ISet iset1, iset2;
 
-    iset1.insert(3, 1);
-    iset1.insert(5, 1);
-    iset1.insert(7, 1);
-    iset1.insert(9, 1);
+    iset1.union_insert(3, 1);
+    iset1.union_insert(5, 1);
+    iset1.union_insert(7, 1);
+    iset1.union_insert(9, 1);
     iset1.erase(2, 9);
 
     ASSERT_EQ(iset1, iset2);
@@ -1163,14 +1704,14 @@ TYPED_TEST(IntervalSetTest, erase) {
   {
     ISet iset1, iset2;
 
-    iset1.insert(1, 1);
-    iset1.insert(3, 1);
-    iset1.insert(5, 1);
-    iset1.insert(7, 1);
-    iset1.insert(9, 1);
+    iset1.union_insert(1, 1);
+    iset1.union_insert(3, 1);
+    iset1.union_insert(5, 1);
+    iset1.union_insert(7, 1);
+    iset1.union_insert(9, 1);
     iset1.erase(2, 6);
-    iset2.insert(1, 1);
-    iset2.insert(9, 1);
+    iset2.union_insert(1, 1);
+    iset2.union_insert(9, 1);
 
     ASSERT_EQ(iset1, iset2);
   }
@@ -1179,15 +1720,15 @@ TYPED_TEST(IntervalSetTest, erase) {
   {
     ISet iset1, iset2;
 
-    iset1.insert(1, 1);
-    iset1.insert(3, 4);
-    iset1.insert(8, 1);
-    iset1.insert(10, 1);
-    iset1.insert(12, 4);
+    iset1.union_insert(1, 1);
+    iset1.union_insert(3, 4);
+    iset1.union_insert(8, 1);
+    iset1.union_insert(10, 1);
+    iset1.union_insert(12, 4);
     iset1.erase(4, 11);
-    iset2.insert(1, 1);
-    iset2.insert(3, 1);
-    iset2.insert(15, 1);
+    iset2.union_insert(1, 1);
+    iset2.union_insert(3, 1);
+    iset2.union_insert(15, 1);
 
     ASSERT_EQ(iset1, iset2);
   }
@@ -1200,7 +1741,7 @@ TYPED_TEST(IntervalSetTest, erase_after)
   {
     ISet iset1, iset2;
 
-    iset1.insert(4, 4);
+    iset1.union_insert(4, 4);
     iset1.erase_after(1);
 
     ASSERT_EQ(iset1, iset2);
@@ -1210,7 +1751,7 @@ TYPED_TEST(IntervalSetTest, erase_after)
   {
     ISet iset1, iset2;
 
-    iset1.insert(4, 4);
+    iset1.union_insert(4, 4);
     iset1.erase_after(4);
 
     ASSERT_EQ(iset1, iset2);
@@ -1220,9 +1761,9 @@ TYPED_TEST(IntervalSetTest, erase_after)
   {
     ISet iset1, iset2;
 
-    iset1.insert(3, 4);
+    iset1.union_insert(3, 4);
     iset1.erase_after(4);
-    iset2.insert(3, 1);
+    iset2.union_insert(3, 1);
 
     ASSERT_EQ(iset1, iset2);
   }
@@ -1231,9 +1772,9 @@ TYPED_TEST(IntervalSetTest, erase_after)
   {
     ISet iset1, iset2;
 
-    iset1.insert(3, 4);
+    iset1.union_insert(3, 4);
     iset1.erase_after(7);
-    iset2.insert(3, 4);
+    iset2.union_insert(3, 4);
 
     ASSERT_EQ(iset1, iset2);
   }
@@ -1242,10 +1783,10 @@ TYPED_TEST(IntervalSetTest, erase_after)
   {
     ISet iset1, iset2;
 
-    iset1.insert(3, 4);
-    iset1.insert(10, 4);
+    iset1.union_insert(3, 4);
+    iset1.union_insert(10, 4);
     iset1.erase_after(8);
-    iset2.insert(3, 4);
+    iset2.union_insert(3, 4);
 
     ASSERT_EQ(iset1, iset2);
   }
@@ -1254,8 +1795,8 @@ TYPED_TEST(IntervalSetTest, erase_after)
   {
     ISet iset1, iset2;
 
-    iset1.insert(3, 4);
-    iset1.insert(10, 4);
+    iset1.union_insert(3, 4);
+    iset1.union_insert(10, 4);
     iset1.erase_after(3);
 
     ASSERT_EQ(iset1, iset2);
@@ -1265,10 +1806,10 @@ TYPED_TEST(IntervalSetTest, erase_after)
   {
     ISet iset1, iset2;
 
-    iset1.insert(3, 1);
-    iset1.insert(5, 1);
-    iset1.insert(7, 1);
-    iset1.insert(9, 1);
+    iset1.union_insert(3, 1);
+    iset1.union_insert(5, 1);
+    iset1.union_insert(7, 1);
+    iset1.union_insert(9, 1);
     iset1.erase_after(2);
 
     ASSERT_EQ(iset1, iset2);
@@ -1278,13 +1819,13 @@ TYPED_TEST(IntervalSetTest, erase_after)
   {
     ISet iset1, iset2;
 
-    iset1.insert(1, 1);
-    iset1.insert(3, 1);
-    iset1.insert(5, 1);
-    iset1.insert(7, 1);
-    iset1.insert(9, 1);
+    iset1.union_insert(1, 1);
+    iset1.union_insert(3, 1);
+    iset1.union_insert(5, 1);
+    iset1.union_insert(7, 1);
+    iset1.union_insert(9, 1);
     iset1.erase_after(2);
-    iset2.insert(1, 1);
+    iset2.union_insert(1, 1);
 
     ASSERT_EQ(iset1, iset2);
   }
@@ -1306,10 +1847,10 @@ TYPED_TEST(IntervalSetTest, subtract) {
   // erase many with border
   {
     ISet iset1, iset2, iset3;
-    iset1.insert(1, 1);
+    iset1.union_insert(1, 1);
     iset1.subtract(iset2);
 
-    iset3.insert(1, 1);
+    iset3.union_insert(1, 1);
     ASSERT_EQ(iset1, iset3);
   }
 
@@ -1317,7 +1858,7 @@ TYPED_TEST(IntervalSetTest, subtract) {
   // erase many with border
   {
     ISet iset1, iset2, iset3;
-    iset2.insert(1, 1);
+    iset2.union_insert(1, 1);
     iset1.subtract(iset2);
 
     ASSERT_EQ(iset1, iset3);
@@ -1327,18 +1868,18 @@ TYPED_TEST(IntervalSetTest, subtract) {
   {
     ISet iset1, iset2, iset3;
 
-    iset1.insert(1, 1);
-    iset1.insert(3, 1);
-    iset1.insert(5, 1);
-    iset1.insert(7, 1);
-    iset1.insert(9, 1);
+    iset1.union_insert(1, 1);
+    iset1.union_insert(3, 1);
+    iset1.union_insert(5, 1);
+    iset1.union_insert(7, 1);
+    iset1.union_insert(9, 1);
 
-    iset2.insert(1, 4);
-    iset2.insert(7, 3);
+    iset2.union_insert(1, 4);
+    iset2.union_insert(7, 3);
 
     iset1.subtract(iset2);
 
-    iset3.insert(5, 1);
+    iset3.union_insert(5, 1);
     ASSERT_EQ(iset1, iset3);
   }
 
@@ -1346,17 +1887,17 @@ TYPED_TEST(IntervalSetTest, subtract) {
   {
     ISet iset1, iset2, iset3;
 
-    iset1.insert(0, 5);
-    iset1.insert(10, 5);
-    iset1.insert(20, 5);
-    iset1.insert(30, 5);
-    iset1.insert(40, 4);
+    iset1.union_insert(0, 5);
+    iset1.union_insert(10, 5);
+    iset1.union_insert(20, 5);
+    iset1.union_insert(30, 5);
+    iset1.union_insert(40, 4);
 
-    iset2.insert(20, 25);
+    iset2.union_insert(20, 25);
     iset1.subtract(iset2);
 
-    iset3.insert(0, 5);
-    iset3.insert(10, 5);
+    iset3.union_insert(0, 5);
+    iset3.union_insert(10, 5);
 
     ASSERT_EQ(iset1, iset3);
   }