diff --git a/test/base_test.cpp b/test/base_test.cpp
index 97ae253..a5a5430 100644
--- a/test/base_test.cpp
+++ b/test/base_test.cpp
@@ -14,15 +14,15 @@
 
 void iterator_constructor_and_assign_test() {
 
-    circular_buffer<Integer> cb(4, 3);
-    circular_buffer<Integer>::iterator it = cb.begin();
-    circular_buffer<Integer>::iterator itCopy;
+    circular_buffer<MyInteger> cb(4, 3);
+    circular_buffer<MyInteger>::iterator it = cb.begin();
+    circular_buffer<MyInteger>::iterator itCopy;
     itCopy = it;
     it = it;
-    circular_buffer<Integer>::const_iterator cit;
+    circular_buffer<MyInteger>::const_iterator cit;
     cit = it;
-    circular_buffer<Integer>::const_iterator end1 = cb.end();
-    circular_buffer<Integer>::const_iterator end2 = end1;
+    circular_buffer<MyInteger>::const_iterator end1 = cb.end();
+    circular_buffer<MyInteger>::const_iterator end2 = end1;
 
     BOOST_CHECK(itCopy == it);
     BOOST_CHECK(cit == it);
@@ -49,12 +49,12 @@ void iterator_reference_test() {
 
 void iterator_difference_test() {
 
-    circular_buffer<Integer> cb(5, 1);
+    circular_buffer<MyInteger> cb(5, 1);
     cb.push_back(2);
-    circular_buffer<Integer>::iterator it1 = cb.begin() + 2;
-    circular_buffer<Integer>::iterator it2 = cb.begin() + 3;
-    circular_buffer<Integer>::const_iterator begin = cb.begin();
-    circular_buffer<Integer>::iterator end = cb.end();
+    circular_buffer<MyInteger>::iterator it1 = cb.begin() + 2;
+    circular_buffer<MyInteger>::iterator it2 = cb.begin() + 3;
+    circular_buffer<MyInteger>::const_iterator begin = cb.begin();
+    circular_buffer<MyInteger>::iterator end = cb.end();
 
     BOOST_CHECK(begin - begin == 0);
     BOOST_CHECK(end - cb.begin() == 5);
@@ -69,11 +69,11 @@ void iterator_difference_test() {
 
 void iterator_increment_test() {
 
-    circular_buffer<Integer> cb(10, 1);
+    circular_buffer<MyInteger> cb(10, 1);
     cb.push_back(2);
-    circular_buffer<Integer>::iterator it1 = cb.begin();
-    circular_buffer<Integer>::iterator it2 = cb.begin() + 5;
-    circular_buffer<Integer>::iterator it3 = cb.begin() + 9;
+    circular_buffer<MyInteger>::iterator it1 = cb.begin();
+    circular_buffer<MyInteger>::iterator it2 = cb.begin() + 5;
+    circular_buffer<MyInteger>::iterator it3 = cb.begin() + 9;
     it1++;
     it2++;
     ++it3;
@@ -85,11 +85,11 @@ void iterator_increment_test() {
 
 void iterator_decrement_test() {
 
-    circular_buffer<Integer> cb(10, 1);
+    circular_buffer<MyInteger> cb(10, 1);
     cb.push_back(2);
-    circular_buffer<Integer>::iterator it1= cb.end();
-    circular_buffer<Integer>::iterator it2= cb.end() - 5;
-    circular_buffer<Integer>::iterator it3= cb.end() - 9;
+    circular_buffer<MyInteger>::iterator it1= cb.end();
+    circular_buffer<MyInteger>::iterator it2= cb.end() - 5;
+    circular_buffer<MyInteger>::iterator it3= cb.end() - 9;
     --it1;
     it2--;
     --it3;
@@ -101,13 +101,13 @@ void iterator_decrement_test() {
 
 void iterator_addition_test() {
 
-    circular_buffer<Integer> cb(10, 1);
+    circular_buffer<MyInteger> cb(10, 1);
     cb.push_back(2);
     cb.push_back(2);
-    circular_buffer<Integer>::iterator it1 = cb.begin() + 2;
-    circular_buffer<Integer>::iterator it2 = cb.end();
-    circular_buffer<Integer>::iterator it3 = cb.begin() + 5;
-    circular_buffer<Integer>::iterator it4 = cb.begin() + 9;
+    circular_buffer<MyInteger>::iterator it1 = cb.begin() + 2;
+    circular_buffer<MyInteger>::iterator it2 = cb.end();
+    circular_buffer<MyInteger>::iterator it3 = cb.begin() + 5;
+    circular_buffer<MyInteger>::iterator it4 = cb.begin() + 9;
     it1 += 3;
     it2 += 0;
     it3 += 5;
@@ -123,14 +123,14 @@ void iterator_addition_test() {
 
 void iterator_subtraction_test() {
 
-    circular_buffer<Integer> cb(10, 1);
+    circular_buffer<MyInteger> cb(10, 1);
     cb.push_back(2);
     cb.push_back(2);
     cb.push_back(2);
-    circular_buffer<Integer>::iterator it1 = cb.begin();
-    circular_buffer<Integer>::iterator it2 = cb.end();
-    circular_buffer<Integer>::iterator it3 = cb.end() - 5;
-    circular_buffer<Integer>::iterator it4 = cb.begin() + 7;
+    circular_buffer<MyInteger>::iterator it1 = cb.begin();
+    circular_buffer<MyInteger>::iterator it2 = cb.end();
+    circular_buffer<MyInteger>::iterator it3 = cb.end() - 5;
+    circular_buffer<MyInteger>::iterator it4 = cb.begin() + 7;
     it1 -= -2;
     it2 -= 0;
     it3 -= 5;
@@ -145,14 +145,14 @@ void iterator_subtraction_test() {
 
 void iterator_element_access_test() {
 
-    circular_buffer<Integer> cb(10);
+    circular_buffer<MyInteger> cb(10);
     cb.push_back(1);
     cb.push_back(2);
     cb.push_back(3);
     cb.push_back(4);
     cb.push_back(5);
     cb.push_back(6);
-    circular_buffer<Integer>::iterator it = cb.begin() + 1;
+    circular_buffer<MyInteger>::iterator it = cb.begin() + 1;
 
     BOOST_CHECK(it[0] == 2);
     BOOST_CHECK(it[-1] == 1);
@@ -161,11 +161,11 @@ void iterator_element_access_test() {
 
 void iterator_comparison_test() {
 
-    circular_buffer<Integer> cb(5, 1);
+    circular_buffer<MyInteger> cb(5, 1);
     cb.push_back(2);
-    circular_buffer<Integer>::iterator it = cb.begin() + 2;
-    circular_buffer<Integer>::const_iterator begin = cb.begin();
-    circular_buffer<Integer>::iterator end = cb.end();
+    circular_buffer<MyInteger>::iterator it = cb.begin() + 2;
+    circular_buffer<MyInteger>::const_iterator begin = cb.begin();
+    circular_buffer<MyInteger>::iterator end = cb.end();
 
     BOOST_CHECK(begin == begin);
     BOOST_CHECK(end > cb.begin());
@@ -194,11 +194,11 @@ void iterator_invalidation_test() {
 
 #if BOOST_CB_ENABLE_DEBUG
 
-    circular_buffer<Integer>::iterator it1;
-    circular_buffer<Integer>::const_iterator it2;
-    circular_buffer<Integer>::iterator it3;
-    circular_buffer<Integer>::const_iterator it4;
-    circular_buffer<Integer>::const_iterator it5;
+    circular_buffer<MyInteger>::iterator it1;
+    circular_buffer<MyInteger>::const_iterator it2;
+    circular_buffer<MyInteger>::iterator it3;
+    circular_buffer<MyInteger>::const_iterator it4;
+    circular_buffer<MyInteger>::const_iterator it5;
 
     BOOST_CHECK(!it1.is_valid());
     BOOST_CHECK(!it2.is_valid());
@@ -207,8 +207,8 @@ void iterator_invalidation_test() {
     BOOST_CHECK(!it5.is_valid());
 
     {
-        circular_buffer<Integer> cb(5, 0);
-        const circular_buffer<Integer> ccb(5, 0);
+        circular_buffer<MyInteger> cb(5, 0);
+        const circular_buffer<MyInteger> ccb(5, 0);
 
         it1 = cb.begin();
         it2 = ccb.end();
@@ -229,8 +229,8 @@ void iterator_invalidation_test() {
     BOOST_CHECK(!it4.is_valid());
     BOOST_CHECK(!it5.is_valid());
 
-    circular_buffer<Integer> cb1(10, 0);
-    circular_buffer<Integer> cb2(20, 0);
+    circular_buffer<MyInteger> cb1(10, 0);
+    circular_buffer<MyInteger> cb2(20, 0);
     it1 = cb1.end();
     it2 = cb2.begin();
     BOOST_CHECK(it1.is_valid());
@@ -247,7 +247,7 @@ void iterator_invalidation_test() {
     BOOST_CHECK(!it2.is_valid());
     BOOST_CHECK(*it2.m_it == 1);
 
-    circular_buffer<Integer> cb3(5);
+    circular_buffer<MyInteger> cb3(5);
     cb3.push_back(1);
     cb3.push_back(2);
     cb3.push_back(3);
@@ -267,7 +267,7 @@ void iterator_invalidation_test() {
     BOOST_CHECK(!it2.is_valid());
     BOOST_CHECK(*it2.m_it == 7);
 
-    circular_buffer<Integer> cb4(5);
+    circular_buffer<MyInteger> cb4(5);
     cb4.push_back(1);
     cb4.push_back(2);
     cb4.push_back(3);
@@ -292,7 +292,7 @@ void iterator_invalidation_test() {
     BOOST_CHECK(it1.is_valid());
     BOOST_CHECK(!it2.is_valid());
 
-    circular_buffer<Integer> cb5(20, 0);
+    circular_buffer<MyInteger> cb5(20, 0);
     it1 = cb5.begin() + 5;
     it2 = it3 = cb5.begin() + 15;
     cb5.erase(cb5.begin() + 10);
@@ -307,7 +307,7 @@ void iterator_invalidation_test() {
     BOOST_CHECK(!it2.is_valid());
     BOOST_CHECK(!it3.is_valid());
 
-    circular_buffer<Integer> cb6(20, 0);
+    circular_buffer<MyInteger> cb6(20, 0);
     it4 = it1 = cb6.begin() + 5;
     it2 = cb6.begin() + 15;
     cb6.rerase(cb6.begin() + 10);
@@ -330,159 +330,159 @@ void exception_safety_test() {
 
 #if !defined(BOOST_NO_EXCEPTIONS)
 
-    circular_buffer<Integer> cb1(3, 5);
-    Integer::set_exception_trigger(3);
+    circular_buffer<MyInteger> cb1(3, 5);
+    MyInteger::set_exception_trigger(3);
     BOOST_CHECK_THROW(cb1.set_capacity(5), exception);
 
-    Integer::set_exception_trigger(3);
-    BOOST_CHECK_THROW(circular_buffer<Integer> cb2(5, 10), exception);
+    MyInteger::set_exception_trigger(3);
+    BOOST_CHECK_THROW(circular_buffer<MyInteger> cb2(5, 10), exception);
 
-    circular_buffer<Integer> cb3(5, 10);
-    Integer::set_exception_trigger(3);
-    BOOST_CHECK_THROW(circular_buffer<Integer> cb4(cb3), exception);
+    circular_buffer<MyInteger> cb3(5, 10);
+    MyInteger::set_exception_trigger(3);
+    BOOST_CHECK_THROW(circular_buffer<MyInteger> cb4(cb3), exception);
 
-    vector<Integer> v(5, 10);
-    Integer::set_exception_trigger(3);
-    BOOST_CHECK_THROW(circular_buffer<Integer> cb5(8, v.begin(), v.end()), exception);
+    vector<MyInteger> v(5, 10);
+    MyInteger::set_exception_trigger(3);
+    BOOST_CHECK_THROW(circular_buffer<MyInteger> cb5(8, v.begin(), v.end()), exception);
 
-    circular_buffer<Integer> cb6(5, 10);
-    circular_buffer<Integer> cb7(8, 3);
-    Integer::set_exception_trigger(3);
+    circular_buffer<MyInteger> cb6(5, 10);
+    circular_buffer<MyInteger> cb7(8, 3);
+    MyInteger::set_exception_trigger(3);
     BOOST_CHECK_THROW(cb7 = cb6, exception);
 
-    circular_buffer<Integer> cb8(5, 10);
-    Integer::set_exception_trigger(2);
+    circular_buffer<MyInteger> cb8(5, 10);
+    MyInteger::set_exception_trigger(2);
     BOOST_CHECK_THROW(cb8.push_front(1), exception);
 
-    circular_buffer<Integer> cb9(5);
+    circular_buffer<MyInteger> cb9(5);
     cb9.push_back(1);
     cb9.push_back(2);
     cb9.push_back(3);
-    Integer::set_exception_trigger(3);
+    MyInteger::set_exception_trigger(3);
     BOOST_CHECK_THROW(cb9.insert(cb9.begin() + 1, 4), exception);
 
-    circular_buffer<Integer> cb10(5);
+    circular_buffer<MyInteger> cb10(5);
     cb10.push_back(1);
     cb10.push_back(2);
     cb10.push_back(3);
-    Integer::set_exception_trigger(3);
+    MyInteger::set_exception_trigger(3);
     BOOST_CHECK_THROW(cb10.rinsert(cb10.begin() + 1, 4), exception);
 
-    circular_buffer<Integer> cb11(5);
+    circular_buffer<MyInteger> cb11(5);
     cb11.push_back(1);
     cb11.push_back(2);
-    Integer::set_exception_trigger(2);
+    MyInteger::set_exception_trigger(2);
     BOOST_CHECK_THROW(cb11.rinsert(cb11.begin(), 1), exception);
 
-    circular_buffer<Integer> cb12(5, 1);
-    Integer::set_exception_trigger(3);
+    circular_buffer<MyInteger> cb12(5, 1);
+    MyInteger::set_exception_trigger(3);
     BOOST_CHECK_THROW(cb12.assign(4, 2), exception);
 
-    circular_buffer<Integer> cb13(5, 1);
-    Integer::set_exception_trigger(3);
+    circular_buffer<MyInteger> cb13(5, 1);
+    MyInteger::set_exception_trigger(3);
     BOOST_CHECK_THROW(cb13.assign(6, 2), exception);
 
-    circular_buffer<Integer> cb14(5);
+    circular_buffer<MyInteger> cb14(5);
     cb14.push_back(1);
     cb14.push_back(2);
-    Integer::set_exception_trigger(3);
+    MyInteger::set_exception_trigger(3);
     BOOST_CHECK_THROW(cb14.insert(cb14.begin(), 10, 3), exception);
 
-    circular_buffer<Integer> cb15(5);
+    circular_buffer<MyInteger> cb15(5);
     cb15.push_back(1);
     cb15.push_back(2);
-    Integer::set_exception_trigger(3);
+    MyInteger::set_exception_trigger(3);
     BOOST_CHECK_THROW(cb15.insert(cb15.end(), 10, 3), exception);
 
-    circular_buffer<Integer> cb16(5);
+    circular_buffer<MyInteger> cb16(5);
     cb16.push_back(1);
     cb16.push_back(2);
-    Integer::set_exception_trigger(3);
+    MyInteger::set_exception_trigger(3);
     BOOST_CHECK_THROW(cb16.rinsert(cb16.begin(), 10, 3), exception);
 
-    circular_buffer<Integer> cb17(5);
+    circular_buffer<MyInteger> cb17(5);
     cb17.push_back(1);
     cb17.push_back(2);
-    Integer::set_exception_trigger(3);
+    MyInteger::set_exception_trigger(3);
     BOOST_CHECK_THROW(cb17.rinsert(cb17.end(), 10, 3), exception);
 
-    circular_buffer<Integer> cb18(5, 0);
+    circular_buffer<MyInteger> cb18(5, 0);
     cb18.push_back(1);
     cb18.push_back(2);
     cb18.pop_front();
-    Integer::set_exception_trigger(4);
+    MyInteger::set_exception_trigger(4);
     BOOST_CHECK_THROW(cb18.linearize(), exception);
 
-    circular_buffer<Integer> cb19(5, 0);
+    circular_buffer<MyInteger> cb19(5, 0);
     cb19.push_back(1);
     cb19.push_back(2);
-    Integer::set_exception_trigger(5);
+    MyInteger::set_exception_trigger(5);
     BOOST_CHECK_THROW(cb19.linearize(), exception);
 
-    circular_buffer<Integer> cb20(5, 0);
+    circular_buffer<MyInteger> cb20(5, 0);
     cb20.push_back(1);
     cb20.push_back(2);
-    Integer::set_exception_trigger(6);
+    MyInteger::set_exception_trigger(6);
     BOOST_CHECK_THROW(cb20.linearize(), exception);
 
-    circular_buffer<Integer> cb21(5);
+    circular_buffer<MyInteger> cb21(5);
     cb21.push_back(1);
     cb21.push_back(2);
     cb21.push_back(3);
-    Integer::set_exception_trigger(2);
+    MyInteger::set_exception_trigger(2);
     BOOST_CHECK_THROW(cb21.insert(cb21.begin() + 1, 4), exception);
 
-    circular_buffer<Integer> cb22(5);
+    circular_buffer<MyInteger> cb22(5);
     cb22.push_back(1);
     cb22.push_back(2);
     cb22.push_back(3);
-    Integer::set_exception_trigger(2);
+    MyInteger::set_exception_trigger(2);
     BOOST_CHECK_THROW(cb22.insert(cb22.end(), 4), exception);
 
-    circular_buffer<Integer> cb23(5, 0);
-    Integer::set_exception_trigger(2);
+    circular_buffer<MyInteger> cb23(5, 0);
+    MyInteger::set_exception_trigger(2);
     BOOST_CHECK_THROW(cb23.insert(cb23.begin() + 1, 4), exception);
 
-    circular_buffer<Integer> cb24(5);
+    circular_buffer<MyInteger> cb24(5);
     cb24.push_back(1);
     cb24.push_back(2);
     cb24.push_back(3);
-    Integer::set_exception_trigger(2);
+    MyInteger::set_exception_trigger(2);
     BOOST_CHECK_THROW(cb24.rinsert(cb24.begin() + 1, 4), exception);
 
-    circular_buffer<Integer> cb25(5, 0);
-    Integer::set_exception_trigger(2);
+    circular_buffer<MyInteger> cb25(5, 0);
+    MyInteger::set_exception_trigger(2);
     BOOST_CHECK_THROW(cb25.rinsert(cb25.begin() + 3, 4), exception);
 
-    circular_buffer<Integer> cb26(5);
+    circular_buffer<MyInteger> cb26(5);
     cb26.push_back(1);
     cb26.push_back(2);
-    Integer::set_exception_trigger(5);
+    MyInteger::set_exception_trigger(5);
     BOOST_CHECK_THROW(cb26.insert(cb26.begin(), 10, 3), exception);
 
-    circular_buffer<Integer> cb27(5);
+    circular_buffer<MyInteger> cb27(5);
     cb27.push_back(1);
     cb27.push_back(2);
-    Integer::set_exception_trigger(5);
+    MyInteger::set_exception_trigger(5);
     BOOST_CHECK_THROW(cb27.insert(cb27.end(), 10, 3), exception);
 
-    circular_buffer<Integer> cb28(5);
+    circular_buffer<MyInteger> cb28(5);
     cb28.push_back(1);
     cb28.push_back(2);
-    Integer::set_exception_trigger(5);
+    MyInteger::set_exception_trigger(5);
     BOOST_CHECK_THROW(cb28.rinsert(cb28.begin(), 10, 3), exception);
 
-    circular_buffer<Integer> cb29(5);
+    circular_buffer<MyInteger> cb29(5);
     cb29.push_back(1);
     cb29.push_back(2);
-    Integer::set_exception_trigger(5);
+    MyInteger::set_exception_trigger(5);
     BOOST_CHECK_THROW(cb29.rinsert(cb29.end(), 10, 3), exception);
 
-    circular_buffer<Integer> cb30(10);
+    circular_buffer<MyInteger> cb30(10);
     cb30.push_back(1);
     cb30.push_back(2);
     cb30.push_back(3);
-    Integer::set_exception_trigger(2);
+    MyInteger::set_exception_trigger(2);
     BOOST_CHECK_THROW(cb30.rinsert(cb30.begin(), 10, 3), exception);
 
 #endif // #if !defined(BOOST_NO_EXCEPTIONS)
@@ -490,11 +490,11 @@ void exception_safety_test() {
 
 void array_range_test() {
 
-    CB_CONTAINER<Integer> cb(7);
-    CB_CONTAINER<Integer>::array_range a1 = cb.array_one();
-    CB_CONTAINER<Integer>::array_range a2 = cb.array_two();
-    CB_CONTAINER<Integer>::const_array_range ca1 = cb.array_one();
-    CB_CONTAINER<Integer>::const_array_range ca2 = cb.array_two();
+    CB_CONTAINER<MyInteger> cb(7);
+    CB_CONTAINER<MyInteger>::array_range a1 = cb.array_one();
+    CB_CONTAINER<MyInteger>::array_range a2 = cb.array_two();
+    CB_CONTAINER<MyInteger>::const_array_range ca1 = cb.array_one();
+    CB_CONTAINER<MyInteger>::const_array_range ca2 = cb.array_two();
 
     BOOST_CHECK(a1.second == 0);
     BOOST_CHECK(a2.second == 0);
diff --git a/test/common.ipp b/test/common.ipp
index f5e44d9..08a70dc 100644
--- a/test/common.ipp
+++ b/test/common.ipp
@@ -6,7 +6,7 @@
 // License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 
-void generic_test(CB_CONTAINER<Integer>& cb) {
+void generic_test(CB_CONTAINER<MyInteger>& cb) {
 
     vector<int> v;
     v.push_back(11);
@@ -97,9 +97,9 @@ void basic_test() {
     v.push_back(5);
     v.push_back(6);
     v.push_back(7);
-    CB_CONTAINER<Integer> cb1(3, v.begin(), v.end());
-    CB_CONTAINER<Integer> cb2(10, v.begin(), v.end());
-    CB_CONTAINER<Integer> cb3(7, v.begin(), v.end());
+    CB_CONTAINER<MyInteger> cb1(3, v.begin(), v.end());
+    CB_CONTAINER<MyInteger> cb2(10, v.begin(), v.end());
+    CB_CONTAINER<MyInteger> cb3(7, v.begin(), v.end());
 
     BOOST_CHECK(cb1.full());
     BOOST_CHECK(cb1.capacity() == 3);
@@ -129,12 +129,12 @@ void constructor_and_element_access_test() {
 
 void size_test() {
 
-    CB_CONTAINER<Integer> cb1(3);
+    CB_CONTAINER<MyInteger> cb1(3);
     cb1.push_back(1);
     cb1.push_back(2);
     cb1.push_back(3);
     cb1.push_back(4);
-    CB_CONTAINER<Integer> cb2(5);
+    CB_CONTAINER<MyInteger> cb2(5);
 
     BOOST_CHECK(cb1.size() == 3);
     BOOST_CHECK(cb2.size() == 0);
@@ -146,7 +146,7 @@ void size_test() {
 
 void boundary_capacity_test() {
 
-    CB_CONTAINER<Integer> cb(0);
+    CB_CONTAINER<MyInteger> cb(0);
     cb.push_back(1);
 
     BOOST_CHECK(cb.size() == 0);
@@ -158,10 +158,10 @@ void boundary_capacity_test() {
 
 void allocator_test() {
 
-    CB_CONTAINER<Integer> cb1(10, 0);
-    const CB_CONTAINER<Integer> cb2(10, 0);
-    CB_CONTAINER<Integer>::allocator_type& alloc_ref = cb1.get_allocator();
-    CB_CONTAINER<Integer>::allocator_type alloc = cb2.get_allocator();
+    CB_CONTAINER<MyInteger> cb1(10, 0);
+    const CB_CONTAINER<MyInteger> cb2(10, 0);
+    CB_CONTAINER<MyInteger>::allocator_type& alloc_ref = cb1.get_allocator();
+    CB_CONTAINER<MyInteger>::allocator_type alloc = cb2.get_allocator();
 
     generic_test(cb1); 
 }
@@ -173,20 +173,20 @@ void begin_and_end_test() {
     v.push_back(12);
     v.push_back(13);
     
-    CB_CONTAINER<Integer> cb1(10, v.begin(), v.end());
-    const CB_CONTAINER<Integer> cb2(10, v.begin(), v.end());
+    CB_CONTAINER<MyInteger> cb1(10, v.begin(), v.end());
+    const CB_CONTAINER<MyInteger> cb2(10, v.begin(), v.end());
     
-    CB_CONTAINER<Integer> cb3(10);
+    CB_CONTAINER<MyInteger> cb3(10);
     cb3.push_back(1);
     cb3.push_back(2);
     cb3.insert(cb3.begin(), 3);
     int i = 0;
-    CB_CONTAINER<Integer>::const_iterator it = cb3.begin();
+    CB_CONTAINER<MyInteger>::const_iterator it = cb3.begin();
     for (; it != cb3.end(); it++) {
         i += *it;
     }
-    CB_CONTAINER<Integer> cb4(20);
-    const CB_CONTAINER<Integer> cb5(20);
+    CB_CONTAINER<MyInteger> cb4(20);
+    const CB_CONTAINER<MyInteger> cb5(20);
 
     BOOST_CHECK(*cb1.begin() == 11);
     BOOST_CHECK(*cb2.begin() == 11);
@@ -206,21 +206,21 @@ void rbegin_and_rend_test() {
     v.push_back(12);
     v.push_back(13);
     
-    CB_CONTAINER<Integer> cb1(10, v.begin(), v.end());
-    const CB_CONTAINER<Integer> cb2(10, v.begin(), v.end());
+    CB_CONTAINER<MyInteger> cb1(10, v.begin(), v.end());
+    const CB_CONTAINER<MyInteger> cb2(10, v.begin(), v.end());
     
-    CB_CONTAINER<Integer> cb3(3);
+    CB_CONTAINER<MyInteger> cb3(3);
     cb3.push_back(1);
     cb3.push_back(2);
     cb3.insert(cb3.begin(), 3);
     cb3.push_back(1);
     int i = 0;
-    CB_CONTAINER<Integer>::reverse_iterator it = cb3.rbegin();
+    CB_CONTAINER<MyInteger>::reverse_iterator it = cb3.rbegin();
     for (; it != cb3.rend(); it++) {
         i += *it;
     }
-    CB_CONTAINER<Integer> cb4(20);
-    const CB_CONTAINER<Integer> cb5(20);
+    CB_CONTAINER<MyInteger> cb4(20);
+    const CB_CONTAINER<MyInteger> cb5(20);
 
     BOOST_CHECK(*cb1.rbegin() == 13);
     BOOST_CHECK(*cb2.rbegin() == 13);
@@ -235,12 +235,12 @@ void rbegin_and_rend_test() {
 
 void element_access_and_insert_test() {
 
-    CB_CONTAINER<Integer> cb(3);
+    CB_CONTAINER<MyInteger> cb(3);
     cb.push_back(1);
     cb.push_back(2);
     cb.insert(cb.begin(), 3);
     cb.push_back(4);
-    const CB_CONTAINER<Integer> ccb(3, 2);
+    const CB_CONTAINER<MyInteger> ccb(3, 2);
 
     BOOST_CHECK(cb[0] == 1);
     BOOST_CHECK(cb[1] == 2);
@@ -254,7 +254,7 @@ void at_test() {
 
 #if !defined(BOOST_NO_EXCEPTIONS)
 
-    CB_CONTAINER<Integer> cb(3);
+    CB_CONTAINER<MyInteger> cb(3);
     cb.push_back(1);
 
     try {
@@ -273,7 +273,7 @@ void at_test() {
 
 void front_and_back_test() {
 
-    CB_CONTAINER<Integer> cb(1);
+    CB_CONTAINER<MyInteger> cb(1);
     cb.push_back(2);
     cb.push_back(3);
 
@@ -298,11 +298,11 @@ void linearize_test() {
     v.push_back(10);
     v.push_back(11);
     v.push_back(12);
-    CB_CONTAINER<Integer> cb1(10, v.begin(), v.begin() + 10);
+    CB_CONTAINER<MyInteger> cb1(10, v.begin(), v.begin() + 10);
     cb1.push_back(11);
     cb1.push_back(12);
     cb1.push_back(13);
-    CB_CONTAINER<Integer> cb2(10, v.begin(), v.begin() + 10);
+    CB_CONTAINER<MyInteger> cb2(10, v.begin(), v.begin() + 10);
     cb2.push_back(11);
     cb2.push_back(12);
     cb2.push_back(13);
@@ -310,14 +310,14 @@ void linearize_test() {
     cb2.push_back(15);
     cb2.push_back(16);
     cb2.push_back(17);
-    CB_CONTAINER<Integer> cb3(10, v.begin(), v.begin() + 10);
+    CB_CONTAINER<MyInteger> cb3(10, v.begin(), v.begin() + 10);
     cb3.push_back(11);
     cb3.push_back(12);
     cb3.push_back(13);
     cb3.pop_front();
     cb3.pop_front();
-    CB_CONTAINER<Integer> cb4(5);
-    CB_CONTAINER<Integer> cb5(12, v.begin(), v.end());
+    CB_CONTAINER<MyInteger> cb4(5);
+    CB_CONTAINER<MyInteger> cb5(12, v.begin(), v.end());
     cb5.push_back(13);
     cb5.push_back(14);
     cb5.push_back(15);
@@ -327,7 +327,7 @@ void linearize_test() {
     cb5.pop_front();
     cb5.pop_front();
     cb5.pop_front();
-    CB_CONTAINER<Integer> cb6(6);
+    CB_CONTAINER<MyInteger> cb6(6);
     cb6.push_back(-2);
     cb6.push_back(-1);
     cb6.push_back(0);
@@ -424,8 +424,8 @@ void linearize_test() {
 
 void capacity_test() {
 
-    CB_CONTAINER<Integer> cb1(0);
-    CB_CONTAINER<Integer> cb2(1);
+    CB_CONTAINER<MyInteger> cb1(0);
+    CB_CONTAINER<MyInteger> cb2(1);
 
     BOOST_CHECK(cb1.capacity() == 0);
     BOOST_CHECK(cb2.capacity() == 1);
@@ -436,10 +436,10 @@ void capacity_test() {
 
 void full_and_empty_test() {
 
-    CB_CONTAINER<Integer> cb1(10);
-    CB_CONTAINER<Integer> cb2(3);
-    CB_CONTAINER<Integer> cb3(2);
-    CB_CONTAINER<Integer> cb4(2);
+    CB_CONTAINER<MyInteger> cb1(10);
+    CB_CONTAINER<MyInteger> cb2(3);
+    CB_CONTAINER<MyInteger> cb3(2);
+    CB_CONTAINER<MyInteger> cb4(2);
     cb2.push_back(1);
     cb2.push_back(3);
     cb2.push_back(1);
@@ -463,17 +463,17 @@ void full_and_empty_test() {
 
 void set_capacity_test() {
 
-    CB_CONTAINER<Integer> cb1(10);
+    CB_CONTAINER<MyInteger> cb1(10);
     cb1.push_back(2);
     cb1.push_back(3);
     cb1.push_back(1);
     cb1.set_capacity(5);
-    CB_CONTAINER<Integer> cb2(3);
+    CB_CONTAINER<MyInteger> cb2(3);
     cb2.push_back(2);
     cb2.push_back(3);
     cb2.push_back(1);
     cb2.set_capacity(10);
-    CB_CONTAINER<Integer> cb3(5);
+    CB_CONTAINER<MyInteger> cb3(5);
     cb3.push_back(2);
     cb3.push_back(3);
     cb3.push_back(1);
@@ -512,17 +512,17 @@ void set_capacity_test() {
 
 void rset_capacity_test() {
 
-    CB_CONTAINER<Integer> cb1(10);
+    CB_CONTAINER<MyInteger> cb1(10);
     cb1.push_back(2);
     cb1.push_back(3);
     cb1.push_back(1);
     cb1.rset_capacity(5);
-    CB_CONTAINER<Integer> cb2(3);
+    CB_CONTAINER<MyInteger> cb2(3);
     cb2.push_back(2);
     cb2.push_back(3);
     cb2.push_back(1);
     cb2.rset_capacity(10);
-    CB_CONTAINER<Integer> cb3(5);
+    CB_CONTAINER<MyInteger> cb3(5);
     cb3.push_back(2);
     cb3.push_back(3);
     cb3.push_back(1);
@@ -560,21 +560,21 @@ void rset_capacity_test() {
 
 void resize_test() {
 
-    CB_CONTAINER<Integer> cb1(10);
+    CB_CONTAINER<MyInteger> cb1(10);
     cb1.push_back(1);
     cb1.push_back(2);
     cb1.push_back(3);
     cb1.push_back(4);
     cb1.resize(20, 5);
-    CB_CONTAINER<Integer> cb2(10);
+    CB_CONTAINER<MyInteger> cb2(10);
     cb2.push_back(1);
     cb2.push_back(2);
     cb2.push_back(3);
     cb2.push_back(4);
     cb2.resize(2);
-    CB_CONTAINER<Integer> cb3(10, 1);
+    CB_CONTAINER<MyInteger> cb3(10, 1);
     cb3.resize(0);
-    CB_CONTAINER<Integer> cb4(10, 1);
+    CB_CONTAINER<MyInteger> cb4(10, 1);
     cb4.resize(10);
 
     BOOST_CHECK(cb1.size() == 20);
@@ -602,21 +602,21 @@ void resize_test() {
 
 void rresize_test() {
 
-    CB_CONTAINER<Integer> cb1(10);
+    CB_CONTAINER<MyInteger> cb1(10);
     cb1.push_back(1);
     cb1.push_back(2);
     cb1.push_back(3);
     cb1.push_back(4);
     cb1.rresize(20, 5);
-    CB_CONTAINER<Integer> cb2(10);
+    CB_CONTAINER<MyInteger> cb2(10);
     cb2.push_back(1);
     cb2.push_back(2);
     cb2.push_back(3);
     cb2.push_back(4);
     cb2.rresize(2);
-    CB_CONTAINER<Integer> cb3(10, 1);
+    CB_CONTAINER<MyInteger> cb3(10, 1);
     cb3.rresize(0);
-    CB_CONTAINER<Integer> cb4(10, 1);
+    CB_CONTAINER<MyInteger> cb4(10, 1);
     cb4.rresize(10);
 
     BOOST_CHECK(cb1.size() == 20);
@@ -644,8 +644,8 @@ void rresize_test() {
 
 void constructor_test() {
 
-    CB_CONTAINER<Integer> cb1(3);
-    CB_CONTAINER<Integer> cb2(3, 2);
+    CB_CONTAINER<MyInteger> cb1(3);
+    CB_CONTAINER<MyInteger> cb2(3, 2);
 
     BOOST_CHECK(cb1.size() == 0);
     BOOST_CHECK(cb1.capacity() == 3);
@@ -661,7 +661,7 @@ void constructor_test() {
 
 void assign_test() {
 
-    CB_CONTAINER<Integer> cb1(4);
+    CB_CONTAINER<MyInteger> cb1(4);
     cb1.push_back(1);
     cb1.push_back(2);
     cb1.push_back(3);
@@ -683,7 +683,7 @@ void assign_test() {
     cb2.assign(3, 1.1f);
     BOOST_CHECK(cb2[0] == 1.1f);
 
-    CB_CONTAINER<Integer> cb3(5);
+    CB_CONTAINER<MyInteger> cb3(5);
     cb3.push_back(1);
     cb3.push_back(2);
     cb3.push_back(3);
@@ -699,19 +699,19 @@ void assign_test() {
 
 void copy_constructor_and_assign_test() {
 
-    CB_CONTAINER<Integer> cb1(4);
+    CB_CONTAINER<MyInteger> cb1(4);
     cb1.push_back(1);
     cb1.push_back(2);
     cb1.push_back(3);
     cb1.push_back(4);
     cb1.push_back(5);
-    CB_CONTAINER<Integer> cb2 = cb1;
+    CB_CONTAINER<MyInteger> cb2 = cb1;
 
     BOOST_CHECK(cb1 == cb2);
 
-    CB_CONTAINER<Integer> cb3(20);
+    CB_CONTAINER<MyInteger> cb3(20);
     cb1.pop_back();
-    CB_CONTAINER<Integer> cb4(3);
+    CB_CONTAINER<MyInteger> cb4(3);
     cb3 = cb2;
     cb3 = cb3;
     cb4 = cb1;
@@ -734,11 +734,11 @@ void copy_constructor_and_assign_test() {
 
 void swap_test() {
 
-    CB_CONTAINER<Integer> cb1(2);
+    CB_CONTAINER<MyInteger> cb1(2);
     cb1.push_back(1);
     cb1.push_back(2);
     cb1.push_back(3);
-    CB_CONTAINER<Integer> cb2(5);
+    CB_CONTAINER<MyInteger> cb2(5);
     cb2.push_back(8);
     cb2.swap(cb1);
     cb2.swap(cb2);
@@ -756,15 +756,15 @@ void swap_test() {
 
 void push_back_test() {
 
-    CB_CONTAINER<DefaultConstructible> cb1(5);
+    CB_CONTAINER<MyDefaultConstructible> cb1(5);
     cb1.push_back();
-    cb1.push_back(DefaultConstructible(2));
+    cb1.push_back(MyDefaultConstructible(2));
     BOOST_CHECK(cb1[0].m_n == 1);
     BOOST_CHECK(cb1[1].m_n == 2);
 
-    CB_CONTAINER<Integer> cb2(5);
+    CB_CONTAINER<MyInteger> cb2(5);
     cb2.push_back();
-    BOOST_CHECK(cb2.back() == CB_CONTAINER<Integer>::value_type());
+    BOOST_CHECK(cb2.back() == CB_CONTAINER<MyInteger>::value_type());
 
     cb2.push_back(1);
     BOOST_CHECK(cb2.back() == 1);
@@ -774,7 +774,7 @@ void push_back_test() {
 
 void pop_back_test() {
 
-    CB_CONTAINER<Integer> cb(4);
+    CB_CONTAINER<MyInteger> cb(4);
     cb.push_back(1);
     cb.push_back(2);
     cb.push_back(3);
@@ -791,19 +791,19 @@ void pop_back_test() {
 
 void insert_test() {
 
-    CB_CONTAINER<Integer> cb1(4);
+    CB_CONTAINER<MyInteger> cb1(4);
     cb1.push_back(1);
     cb1.push_back(2);
     cb1.push_back(3);
-    CB_CONTAINER<Integer>::iterator it1 = cb1.begin() + 1;
+    CB_CONTAINER<MyInteger>::iterator it1 = cb1.begin() + 1;
     it1 = cb1.insert(it1, 10);
-    CB_CONTAINER<Integer> cb2(4);
+    CB_CONTAINER<MyInteger> cb2(4);
     cb2.push_back(1);
     cb2.insert(cb2.begin());
     cb2.insert(cb2.begin(), -1);
-    CB_CONTAINER<Integer>::iterator it2 = cb2.begin() + 1;
+    CB_CONTAINER<MyInteger>::iterator it2 = cb2.begin() + 1;
     it2 = cb2.insert(it2, 5);
-    CB_CONTAINER<Integer> cb3(2);
+    CB_CONTAINER<MyInteger> cb3(2);
     cb3.insert(cb3.end(), 10);
     cb3.insert(cb3.end(), 20);
     cb3.insert(cb3.begin(), 30);
@@ -825,16 +825,16 @@ void insert_test() {
 
 void insert_n_test() {
 
-    CB_CONTAINER<Integer> cb1(4);
+    CB_CONTAINER<MyInteger> cb1(4);
     cb1.push_back(1);
     cb1.push_back(2);
     cb1.push_back(3);
     cb1.insert(cb1.begin() + 1, 2, 10);
-    CB_CONTAINER<Integer> cb2(2, 3);
+    CB_CONTAINER<MyInteger> cb2(2, 3);
     cb2.insert(cb2.begin(), 10, 5);
-    CB_CONTAINER<Integer> cb3(4);
+    CB_CONTAINER<MyInteger> cb3(4);
     cb3.insert(cb3.end(), 1, 6);
-    CB_CONTAINER<Integer> cb4(6);
+    CB_CONTAINER<MyInteger> cb4(6);
     cb4.push_back(1);
     cb4.push_back(2);
     cb4.push_back(3);
@@ -871,19 +871,19 @@ void insert_range_test() {
     v.push_back(11);
     v.push_back(12);
     v.push_back(13);
-    CB_CONTAINER<Integer> cb1(4);
+    CB_CONTAINER<MyInteger> cb1(4);
     cb1.push_back(1);
     cb1.push_back(2);
     cb1.push_back(3);
     cb1.insert(cb1.begin() + 1, v.begin(), v.end());
-    CB_CONTAINER<Integer> cb2(2, 2);
+    CB_CONTAINER<MyInteger> cb2(2, 2);
     cb2.insert(cb2.end(), v.begin(), v.end());
-    CB_CONTAINER<Integer> cb3(5);
+    CB_CONTAINER<MyInteger> cb3(5);
     cb3.insert(cb3.end(), v.end(), v.end());
-    CB_CONTAINER<Integer> cb4(5);
+    CB_CONTAINER<MyInteger> cb4(5);
     cb4.insert(cb4.end(), v.begin(), v.begin() + 1);
-    Integer array[] = { 5, 6, 7, 8, 9 };
-    CB_CONTAINER<Integer> cb5(6);
+    MyInteger array[] = { 5, 6, 7, 8, 9 };
+    CB_CONTAINER<MyInteger> cb5(6);
     cb5.push_back(1);
     cb5.push_back(2);
     cb5.push_back(3);
@@ -918,20 +918,20 @@ void insert_range_test() {
 
 void push_front_test() {
 
-    CB_CONTAINER<DefaultConstructible> cb1(5);
+    CB_CONTAINER<MyDefaultConstructible> cb1(5);
     cb1.push_front();
-    cb1.push_front(DefaultConstructible(2));
+    cb1.push_front(MyDefaultConstructible(2));
     BOOST_CHECK(cb1[0].m_n == 2);
     BOOST_CHECK(cb1[1].m_n == 1);
 
-    CB_CONTAINER<Integer> cb2(5);
+    CB_CONTAINER<MyInteger> cb2(5);
     cb2.push_front();
-    BOOST_CHECK(cb2.front() == CB_CONTAINER<Integer>::value_type());
+    BOOST_CHECK(cb2.front() == CB_CONTAINER<MyInteger>::value_type());
 
     cb2.push_front(1);
     BOOST_CHECK(cb2.front() == 1);
 
-    CB_CONTAINER<Integer> cb3(0);
+    CB_CONTAINER<MyInteger> cb3(0);
     cb3.push_front(10);
     BOOST_CHECK(cb3.empty());
 
@@ -941,7 +941,7 @@ void push_front_test() {
 
 void pop_front_test() {
 
-    CB_CONTAINER<Integer> cb(4);
+    CB_CONTAINER<MyInteger> cb(4);
     cb.push_front(1);
     cb.push_front(2);
     cb.push_front(3);
@@ -958,41 +958,41 @@ void pop_front_test() {
 
 void rinsert_test() {
 
-    CB_CONTAINER<Integer> cb1(4);
+    CB_CONTAINER<MyInteger> cb1(4);
     cb1.push_front(1);
     cb1.push_front(2);
     cb1.push_front(3);
-    CB_CONTAINER<Integer>::iterator it1 = cb1.begin() + 1;
+    CB_CONTAINER<MyInteger>::iterator it1 = cb1.begin() + 1;
     it1 = cb1.rinsert(it1, 10);
-    CB_CONTAINER<Integer> cb2(4);
+    CB_CONTAINER<MyInteger> cb2(4);
     cb2.push_front(1);
     cb2.rinsert(cb2.begin());
     cb2.rinsert(cb2.begin(), -1);
-    CB_CONTAINER<Integer>::iterator it2 = cb2.end() - 2;
+    CB_CONTAINER<MyInteger>::iterator it2 = cb2.end() - 2;
     it2 = cb2.rinsert(it2, 5);
-    CB_CONTAINER<Integer> cb3(2);
+    CB_CONTAINER<MyInteger> cb3(2);
     cb3.rinsert(cb3.begin(), 10);
     cb3.rinsert(cb3.begin(), 20);
     cb3.rinsert(cb3.end(), 30);
     cb3.rinsert(cb3.begin(), 40);
-    CB_CONTAINER<Integer> cb4(4);
+    CB_CONTAINER<MyInteger> cb4(4);
     cb4.push_back(1);
     cb4.push_back(2);
     cb4.push_back(3);
-    CB_CONTAINER<Integer>::iterator it3 = cb4.begin() + 1;
+    CB_CONTAINER<MyInteger>::iterator it3 = cb4.begin() + 1;
     it3 = cb4.rinsert(it3, 10);
-    CB_CONTAINER<Integer> cb5(4);
+    CB_CONTAINER<MyInteger> cb5(4);
     cb5.push_back(1);
     cb5.rinsert(cb5.begin(), 0);
     cb5.rinsert(cb5.begin(), -1);
-    CB_CONTAINER<Integer>::iterator it4 = cb5.begin() + 1;
+    CB_CONTAINER<MyInteger>::iterator it4 = cb5.begin() + 1;
     it4 = cb5.rinsert(it4, 5);
-    CB_CONTAINER<Integer> cb6(2);
+    CB_CONTAINER<MyInteger> cb6(2);
     cb6.rinsert(cb6.end(), 10);
     cb6.rinsert(cb6.end(), 20);
     cb6.rinsert(cb6.begin(), 30);
     cb6.rinsert(cb6.end(), 40);
-    CB_CONTAINER<Integer> cb7(6);
+    CB_CONTAINER<MyInteger> cb7(6);
     cb7.push_back(1);
     cb7.push_back(2);
     cb7.push_back(3);
@@ -1035,22 +1035,22 @@ void rinsert_test() {
 
 void rinsert_n_test() {
 
-    CB_CONTAINER<Integer> cb1(4);
+    CB_CONTAINER<MyInteger> cb1(4);
     cb1.push_front(1);
     cb1.push_front(2);
     cb1.push_front(3);
     cb1.rinsert(cb1.begin() + 1, 2, 10);
-    CB_CONTAINER<Integer> cb2(2, 3);
+    CB_CONTAINER<MyInteger> cb2(2, 3);
     cb2.rinsert(cb2.begin(), 10, 5);
-    CB_CONTAINER<Integer> cb3(4);
+    CB_CONTAINER<MyInteger> cb3(4);
     cb3.rinsert(cb3.end(), 1, 6);
-    CB_CONTAINER<Integer> cb4(4);
+    CB_CONTAINER<MyInteger> cb4(4);
     cb4.push_back(1);
     cb4.push_back(2);
     cb4.push_back(3);
     cb4.rinsert(cb4.begin() + 1, 2, 10);
-    Integer array[] = { 5, 6, 7, 8, 9 };
-    CB_CONTAINER<Integer> cb5(6);
+    MyInteger array[] = { 5, 6, 7, 8, 9 };
+    CB_CONTAINER<MyInteger> cb5(6);
     cb5.push_back(1);
     cb5.push_back(2);
     cb5.push_back(3);
@@ -1094,16 +1094,16 @@ void rinsert_range_test() {
     v.push_back(12);
     v.push_back(13);
     v.push_back(14);
-    CB_CONTAINER<Integer> cb1(4);
+    CB_CONTAINER<MyInteger> cb1(4);
     cb1.push_back(1);
     cb1.push_back(2);
     cb1.push_back(3);
     cb1.rinsert(cb1.begin() + 1, v.begin(), v.end());
-    CB_CONTAINER<Integer> cb2(2, 2);
+    CB_CONTAINER<MyInteger> cb2(2, 2);
     cb2.rinsert(cb2.begin(), v.begin(), v.end());
-    CB_CONTAINER<Integer> cb3(5);
+    CB_CONTAINER<MyInteger> cb3(5);
     cb3.rinsert(cb3.begin(), v.end(), v.end());
-    CB_CONTAINER<Integer> cb4(5);
+    CB_CONTAINER<MyInteger> cb4(5);
     cb4.rinsert(cb4.begin(), v.begin(), v.begin() + 1);
 
     BOOST_CHECK(cb1.full());
@@ -1125,20 +1125,20 @@ void rinsert_range_test() {
 
 void erase_test() {
 
-    CB_CONTAINER<Integer> cb1(4);
+    CB_CONTAINER<MyInteger> cb1(4);
     cb1.push_back(1);
     cb1.push_back(2);
     cb1.push_back(3);
-    CB_CONTAINER<Integer>::iterator it1 = cb1.erase(cb1.begin() + 1);
+    CB_CONTAINER<MyInteger>::iterator it1 = cb1.erase(cb1.begin() + 1);
 
-    CB_CONTAINER<Integer> cb2(1, 1);
-    CB_CONTAINER<Integer>::iterator it2 = cb2.erase(cb2.begin());
+    CB_CONTAINER<MyInteger> cb2(1, 1);
+    CB_CONTAINER<MyInteger>::iterator it2 = cb2.erase(cb2.begin());
 
-    CB_CONTAINER<Integer> cb3(4);
+    CB_CONTAINER<MyInteger> cb3(4);
     cb3.push_back(1);
     cb3.push_back(2);
     cb3.push_back(3);
-    CB_CONTAINER<Integer>::iterator it3 = cb3.erase(cb3.begin() + 2);
+    CB_CONTAINER<MyInteger>::iterator it3 = cb3.erase(cb3.begin() + 2);
 
     BOOST_CHECK(cb1.size() == 2);
     BOOST_CHECK(cb1.capacity() == 4);
@@ -1161,29 +1161,29 @@ void erase_test() {
 
 void erase_range_test() {
 
-    CB_CONTAINER<Integer> cb1(4);
+    CB_CONTAINER<MyInteger> cb1(4);
     cb1.push_back(1);
     cb1.push_back(2);
     cb1.push_back(3);
     cb1.push_back(4);
-    CB_CONTAINER<Integer>::iterator it1 = cb1.erase(cb1.begin() + 1, cb1.begin() + 3);
+    CB_CONTAINER<MyInteger>::iterator it1 = cb1.erase(cb1.begin() + 1, cb1.begin() + 3);
 
-    CB_CONTAINER<Integer> cb2(4);
+    CB_CONTAINER<MyInteger> cb2(4);
     cb2.push_back(1);
     cb2.push_back(2);
     cb2.push_back(3);
     cb2.push_back(4);
-    CB_CONTAINER<Integer>::iterator it2 = cb2.erase(cb2.begin(), cb2.begin());
+    CB_CONTAINER<MyInteger>::iterator it2 = cb2.erase(cb2.begin(), cb2.begin());
 
-    CB_CONTAINER<Integer> cb3(4);
+    CB_CONTAINER<MyInteger> cb3(4);
     cb3.push_back(1);
     cb3.push_back(2);
     cb3.push_back(3);
     cb3.push_back(4);
-    CB_CONTAINER<Integer>::iterator it3 = cb3.erase(cb3.begin() + 2, cb3.end());
+    CB_CONTAINER<MyInteger>::iterator it3 = cb3.erase(cb3.begin() + 2, cb3.end());
 
-    CB_CONTAINER<Integer> cb4(10, 1);
-    CB_CONTAINER<Integer>::iterator it4 = cb4.erase(cb4.begin(), cb4.end());
+    CB_CONTAINER<MyInteger> cb4(10, 1);
+    CB_CONTAINER<MyInteger>::iterator it4 = cb4.erase(cb4.begin(), cb4.end());
 
     BOOST_CHECK(cb1.size() == 2);
     BOOST_CHECK(cb1.capacity() == 4);
@@ -1211,20 +1211,20 @@ void erase_range_test() {
 
 void rerase_test() {
 
-    CB_CONTAINER<Integer> cb1(4);
+    CB_CONTAINER<MyInteger> cb1(4);
     cb1.push_back(1);
     cb1.push_back(2);
     cb1.push_back(3);
-    CB_CONTAINER<Integer>::iterator it1 = cb1.rerase(cb1.begin() + 1);
+    CB_CONTAINER<MyInteger>::iterator it1 = cb1.rerase(cb1.begin() + 1);
 
-    CB_CONTAINER<Integer> cb2(1, 1);
-    CB_CONTAINER<Integer>::iterator it2 = cb2.rerase(cb2.begin());
+    CB_CONTAINER<MyInteger> cb2(1, 1);
+    CB_CONTAINER<MyInteger>::iterator it2 = cb2.rerase(cb2.begin());
 
-    CB_CONTAINER<Integer> cb3(4);
+    CB_CONTAINER<MyInteger> cb3(4);
     cb3.push_back(1);
     cb3.push_back(2);
     cb3.push_back(3);
-    CB_CONTAINER<Integer>::iterator it3 = cb3.rerase(cb3.begin());
+    CB_CONTAINER<MyInteger>::iterator it3 = cb3.rerase(cb3.begin());
 
     BOOST_CHECK(cb1.size() == 2);
     BOOST_CHECK(cb1.capacity() == 4);
@@ -1248,29 +1248,29 @@ void rerase_test() {
 
 void rerase_range_test() {
 
-    CB_CONTAINER<Integer> cb1(4);
+    CB_CONTAINER<MyInteger> cb1(4);
     cb1.push_back(1);
     cb1.push_back(2);
     cb1.push_back(3);
     cb1.push_back(4);
-    CB_CONTAINER<Integer>::iterator it1 = cb1.rerase(cb1.begin() + 1, cb1.begin() + 3);
+    CB_CONTAINER<MyInteger>::iterator it1 = cb1.rerase(cb1.begin() + 1, cb1.begin() + 3);
 
-    CB_CONTAINER<Integer> cb2(4);
+    CB_CONTAINER<MyInteger> cb2(4);
     cb2.push_back(1);
     cb2.push_back(2);
     cb2.push_back(3);
     cb2.push_back(4);
-    CB_CONTAINER<Integer>::iterator it2 = cb2.rerase(cb2.begin(), cb2.begin());
+    CB_CONTAINER<MyInteger>::iterator it2 = cb2.rerase(cb2.begin(), cb2.begin());
 
-    CB_CONTAINER<Integer> cb3(4);
+    CB_CONTAINER<MyInteger> cb3(4);
     cb3.push_back(1);
     cb3.push_back(2);
     cb3.push_back(3);
     cb3.push_back(4);
-    CB_CONTAINER<Integer>::iterator it3 = cb3.rerase(cb3.begin(), cb3.begin() + 2);
+    CB_CONTAINER<MyInteger>::iterator it3 = cb3.rerase(cb3.begin(), cb3.begin() + 2);
 
-    CB_CONTAINER<Integer> cb4(10, 1);
-    CB_CONTAINER<Integer>::iterator it4 = cb4.rerase(cb4.begin(), cb4.end());
+    CB_CONTAINER<MyInteger> cb4(10, 1);
+    CB_CONTAINER<MyInteger>::iterator it4 = cb4.rerase(cb4.begin(), cb4.end());
 
     BOOST_CHECK(cb1.size() == 2);
     BOOST_CHECK(cb1.capacity() == 4);
@@ -1298,7 +1298,7 @@ void rerase_range_test() {
 
 void clear_test() {
 
-    CB_CONTAINER<Integer> cb(4);
+    CB_CONTAINER<MyInteger> cb(4);
     cb.push_back(1);
     cb.push_back(2);
     cb.push_back(3);
@@ -1312,12 +1312,12 @@ void clear_test() {
 
 void equality_test() {
 
-    CB_CONTAINER<Integer> cb1(4);
+    CB_CONTAINER<MyInteger> cb1(4);
     cb1.push_back(1);
     cb1.push_back(2);
     cb1.push_back(3);
     cb1.push_back(4);
-    CB_CONTAINER<Integer> cb2(10);
+    CB_CONTAINER<MyInteger> cb2(10);
     cb2.push_back(1);
     cb2.push_back(2);
     cb2.push_back(3);
@@ -1353,12 +1353,12 @@ void assign_range_test() {
     v.push_back(11);
     v.push_back(12);
     v.push_back(13);
-    CB_CONTAINER<Integer> cb1(4);
+    CB_CONTAINER<MyInteger> cb1(4);
     cb1.push_back(1);
     cb1.push_back(2);
     cb1.push_back(3);
     cb1.assign(v.begin() + 1, v.end());
-    CB_CONTAINER<Integer> cb2(2);
+    CB_CONTAINER<MyInteger> cb2(2);
     cb2.push_back(1);
     cb2.push_back(2);
     cb2.assign(v.begin(), v.end());
@@ -1470,7 +1470,7 @@ void const_methods_test() {
     v.push_back(3);
     v.push_back(4);
     v.push_back(5);
-    const CB_CONTAINER<Integer> cb(5, v.begin(), v.end());
+    const CB_CONTAINER<MyInteger> cb(5, v.begin(), v.end());
 
     BOOST_CHECK(*cb.begin() == 1);
     BOOST_CHECK(*(cb.end() - 1) == 5);
@@ -1502,27 +1502,27 @@ void input_range_test() {
     v.push_back(4);
     v.push_back(5);
 
-    CB_CONTAINER<int> cb1(InputIteratorSimulator(v.begin()), InputIteratorSimulator(v.end()));
+    CB_CONTAINER<int> cb1(MyInputIterator(v.begin()), MyInputIterator(v.end()));
 
-    CB_CONTAINER<int> cb2(3, InputIteratorSimulator(v.begin()), InputIteratorSimulator(v.end()));
+    CB_CONTAINER<int> cb2(3, MyInputIterator(v.begin()), MyInputIterator(v.end()));
 
     CB_CONTAINER<int> cb3(3);
-    cb3.assign(InputIteratorSimulator(v.begin()), InputIteratorSimulator(v.end()));
+    cb3.assign(MyInputIterator(v.begin()), MyInputIterator(v.end()));
 
     CB_CONTAINER<int> cb4(3);
-    cb4.assign(4, InputIteratorSimulator(v.begin()), InputIteratorSimulator(v.end()));
+    cb4.assign(4, MyInputIterator(v.begin()), MyInputIterator(v.end()));
 
     CB_CONTAINER<int> cb5(4);
     cb5.push_back(0);
     cb5.push_back(-1);
     cb5.push_back(-2);
-    cb5.insert(cb5.begin() + 1, InputIteratorSimulator(v.begin()), InputIteratorSimulator(v.end()));
+    cb5.insert(cb5.begin() + 1, MyInputIterator(v.begin()), MyInputIterator(v.end()));
 
     CB_CONTAINER<int> cb6(4);
     cb6.push_back(0);
     cb6.push_back(-1);
     cb6.push_back(-2);
-    cb6.rinsert(cb6.begin() + 1, InputIteratorSimulator(v.begin()), InputIteratorSimulator(v.end()));
+    cb6.rinsert(cb6.begin() + 1, MyInputIterator(v.begin()), MyInputIterator(v.end()));
 
     BOOST_CHECK(cb1.capacity() == 5);
     BOOST_CHECK(cb2.capacity() == 3);
@@ -1540,13 +1540,13 @@ void input_range_test() {
     cb11.push_back(1);
     cb11.push_back(2);
     cb11.push_back(3);
-    cb11.rinsert(cb11.begin() + 1, InputIteratorSimulator(v.begin()), InputIteratorSimulator(v.end()));
+    cb11.rinsert(cb11.begin() + 1, MyInputIterator(v.begin()), MyInputIterator(v.end()));
     CB_CONTAINER<int> cb12(2, 2);
-    cb12.rinsert(cb12.begin(), InputIteratorSimulator(v.begin()), InputIteratorSimulator(v.end()));
+    cb12.rinsert(cb12.begin(), MyInputIterator(v.begin()), MyInputIterator(v.end()));
     CB_CONTAINER<int> cb13(5);
-    cb13.rinsert(cb13.begin(), InputIteratorSimulator(v.end()), InputIteratorSimulator(v.end()));
+    cb13.rinsert(cb13.begin(), MyInputIterator(v.end()), MyInputIterator(v.end()));
     CB_CONTAINER<int> cb14(5);
-    cb14.rinsert(cb14.begin(), InputIteratorSimulator(v.begin()), InputIteratorSimulator(v.begin() + 1));
+    cb14.rinsert(cb14.begin(), MyInputIterator(v.begin()), MyInputIterator(v.begin() + 1));
 
     BOOST_CHECK(cb11.full());
     BOOST_CHECK(cb11[0] == 1);
@@ -1567,13 +1567,13 @@ void input_range_test() {
     cb21.push_back(1);
     cb21.push_back(2);
     cb21.push_back(3);
-    cb21.insert(cb21.begin() + 1, InputIteratorSimulator(v.begin()), InputIteratorSimulator(v.end()));
+    cb21.insert(cb21.begin() + 1, MyInputIterator(v.begin()), MyInputIterator(v.end()));
     CB_CONTAINER<int> cb22(2, 2);
-    cb22.insert(cb22.end(), InputIteratorSimulator(v.begin()), InputIteratorSimulator(v.end()));
+    cb22.insert(cb22.end(), MyInputIterator(v.begin()), MyInputIterator(v.end()));
     CB_CONTAINER<int> cb23(5);
-    cb23.insert(cb23.end(), InputIteratorSimulator(v.end()), InputIteratorSimulator(v.end()));
+    cb23.insert(cb23.end(), MyInputIterator(v.end()), MyInputIterator(v.end()));
     CB_CONTAINER<int> cb24(5);
-    cb24.insert(cb24.end(), InputIteratorSimulator(v.begin()), InputIteratorSimulator(v.begin() + 1));
+    cb24.insert(cb24.end(), MyInputIterator(v.begin()), MyInputIterator(v.begin() + 1));
     v.clear();
     v.push_back(5);
     v.push_back(6);
@@ -1585,8 +1585,8 @@ void input_range_test() {
     cb25.push_back(2);
     cb25.push_back(3);
     cb25.push_back(4);
-    cb25.insert(cb25.begin() + 2, InputIteratorSimulator(v.begin()), InputIteratorSimulator(v.begin() + 5));
-    cb25.insert(cb25.begin(), InputIteratorSimulator(v.begin()), InputIteratorSimulator(v.begin() + 5));
+    cb25.insert(cb25.begin() + 2, MyInputIterator(v.begin()), MyInputIterator(v.begin() + 5));
+    cb25.insert(cb25.begin(), MyInputIterator(v.begin()), MyInputIterator(v.begin() + 5));
 
     BOOST_CHECK(cb21.full());
     BOOST_CHECK(cb21[0] == 12);
@@ -1609,7 +1609,7 @@ void input_range_test() {
 #endif // #if !defined(BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS)
 }
 
-int Integer::ms_exception_trigger = 0;
+int MyInteger::ms_exception_trigger = 0;
 int InstanceCounter::ms_count = 0;
 
 // add common tests into a test suite
diff --git a/test/soft_iterator_invalidation.cpp b/test/soft_iterator_invalidation.cpp
index 407c7ce..71fd040 100644
--- a/test/soft_iterator_invalidation.cpp
+++ b/test/soft_iterator_invalidation.cpp
@@ -187,7 +187,7 @@ void validity_insert_range_test() {
     circular_buffer<int>::iterator it22 = cb2.begin() + 1;
     circular_buffer<int>::iterator it23 = cb2.begin() + 2;
 
-    cb2.insert(cb2.begin() + 1, InputIteratorSimulator(v1.begin()), InputIteratorSimulator(v1.end()));
+    cb2.insert(cb2.begin() + 1, MyInputIterator(v1.begin()), MyInputIterator(v1.end()));
 
     // memory placement: { 1, 4, 5, 2, 3 }
     // circular buffer:  { 1, 4, 5, 2, 3 }
@@ -204,7 +204,7 @@ void validity_insert_range_test() {
     circular_buffer<int>::iterator it24 = it21 + 3;
     circular_buffer<int>::iterator it25 = it21 + 4;
 
-    cb2.insert(cb2.begin() + 1, InputIteratorSimulator(v2.begin()), InputIteratorSimulator(v2.end()));
+    cb2.insert(cb2.begin() + 1, MyInputIterator(v2.begin()), MyInputIterator(v2.end()));
 
     // memory placement: { 2, 3, 7, 4, 5 } - using input iterator inserts all items even if they are later replaced
     // circular buffer:  { 7, 4, 5, 2, 3 }
@@ -376,7 +376,7 @@ void validity_rinsert_range_test() {
     circular_buffer<int>::iterator it22 = cb2.begin() + 1;
     circular_buffer<int>::iterator it23 = cb2.begin() + 2;
 
-    cb2.rinsert(cb2.begin() + 2, InputIteratorSimulator(v1.begin()), InputIteratorSimulator(v1.end()));
+    cb2.rinsert(cb2.begin() + 2, MyInputIterator(v1.begin()), MyInputIterator(v1.end()));
 
     // memory placement: { 4, 5, 3, 1, 2 }
     // circular buffer:  { 1, 2, 4, 5, 3 }
@@ -393,7 +393,7 @@ void validity_rinsert_range_test() {
     circular_buffer<int>::iterator it24 = it21 - 2;
     circular_buffer<int>::iterator it25 = it21 - 1;
 
-    cb2.rinsert(cb2.begin() + 4, InputIteratorSimulator(v2.begin()), InputIteratorSimulator(v2.end()));
+    cb2.rinsert(cb2.begin() + 4, MyInputIterator(v2.begin()), MyInputIterator(v2.end()));
 
     // memory placement: { 5, 6, 1, 2, 4 }
     // circular buffer:  { 1, 2, 4, 5, 6 }
diff --git a/test/space_optimized_test.cpp b/test/space_optimized_test.cpp
index 1162b99..9540ab1 100644
--- a/test/space_optimized_test.cpp
+++ b/test/space_optimized_test.cpp
@@ -14,7 +14,7 @@
 
 #include "common.ipp"
 
-typedef circular_buffer_space_optimized<Integer> cb_space_optimized;
+typedef circular_buffer_space_optimized<MyInteger> cb_space_optimized;
 typedef cb_space_optimized::capacity_control capacity_ctrl;
 
 // min_capacity test (it is useful to use a debug tool)
diff --git a/test/test.hpp b/test/test.hpp
index 5ce8a1f..beabb3c 100644
--- a/test/test.hpp
+++ b/test/test.hpp
@@ -24,7 +24,7 @@
 #endif
 
 // Integer (substitute for int) - more appropriate for testing
-class Integer {
+class MyInteger {
 private:
     int* m_pValue;
     static int ms_exception_trigger;
@@ -40,11 +40,11 @@ private:
         }
     }
 public:
-    Integer() : m_pValue(new int(0)) { check_exception(); }
-    Integer(int i) : m_pValue(new int(i)) { check_exception(); }
-    Integer(const Integer& src) : m_pValue(new int(src)) { check_exception(); }
-    ~Integer() { delete m_pValue; }
-    Integer& operator = (const Integer& src) {
+    MyInteger() : m_pValue(new int(0)) { check_exception(); }
+    MyInteger(int i) : m_pValue(new int(i)) { check_exception(); }
+    MyInteger(const MyInteger& src) : m_pValue(new int(src)) { check_exception(); }
+    ~MyInteger() { delete m_pValue; }
+    MyInteger& operator = (const MyInteger& src) {
         if (this == &src)
             return *this;
         check_exception();
@@ -57,11 +57,11 @@ public:
 };
 
 // default constructible class
-class DefaultConstructible
+class MyDefaultConstructible
 {
 public:
-    DefaultConstructible() : m_n(1) {}
-    DefaultConstructible(int n) : m_n(n) {}
+    MyDefaultConstructible() : m_n(1) {}
+    MyDefaultConstructible(int n) : m_n(n) {}
     int m_n;
 };
 
@@ -95,7 +95,7 @@ public:
 };
 
 // simulator of an input iterator
-struct InputIteratorSimulator
+struct MyInputIterator
 : boost::iterator<std::input_iterator_tag, int, ptrdiff_t, int*, int&> {
     typedef std::vector<int>::iterator vector_iterator;
     typedef int value_type;
@@ -103,8 +103,8 @@ struct InputIteratorSimulator
     typedef int& reference;
     typedef size_t size_type;
     typedef ptrdiff_t difference_type;
-    explicit InputIteratorSimulator(const vector_iterator& it) : m_it(it) {}
-    InputIteratorSimulator& operator = (const InputIteratorSimulator& it) {
+    explicit MyInputIterator(const vector_iterator& it) : m_it(it) {}
+    MyInputIterator& operator = (const MyInputIterator& it) {
         if (this == &it)
             return *this;
         m_it = it.m_it;
@@ -112,28 +112,28 @@ struct InputIteratorSimulator
     }
     reference operator * () const { return *m_it; }
     pointer operator -> () const { return &(operator*()); }
-    InputIteratorSimulator& operator ++ () {
+    MyInputIterator& operator ++ () {
         ++m_it;
         return *this;
     }
-    InputIteratorSimulator operator ++ (int) {
-        InputIteratorSimulator tmp = *this;
+    MyInputIterator operator ++ (int) {
+        MyInputIterator tmp = *this;
         ++*this;
         return tmp;
     }
-    bool operator == (const InputIteratorSimulator& it) const { return m_it == it.m_it; }
-    bool operator != (const InputIteratorSimulator& it) const { return m_it != it.m_it; }
+    bool operator == (const MyInputIterator& it) const { return m_it == it.m_it; }
+    bool operator != (const MyInputIterator& it) const { return m_it != it.m_it; }
 private:
     vector_iterator m_it;
 };
 
 #if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !defined(BOOST_MSVC_STD_ITERATOR)
 
-inline std::input_iterator_tag iterator_category(const InputIteratorSimulator&) {
+inline std::input_iterator_tag iterator_category(const MyInputIterator&) {
     return std::input_iterator_tag();
 }
-inline int* value_type(const InputIteratorSimulator&) { return 0; }
-inline ptrdiff_t* distance_type(const InputIteratorSimulator&) { return 0; }
+inline int* value_type(const MyInputIterator&) { return 0; }
+inline ptrdiff_t* distance_type(const MyInputIterator&) { return 0; }
 
 #endif // #if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !defined(BOOST_MSVC_STD_ITERATOR)