[Boost-commit] svn:boost r67063 - in trunk: boost/icl/detail boost/icl/type_traits libs/icl/test libs/icl/test/test_casual_

Subject: [Boost-commit] svn:boost r67063 - in trunk: boost/icl/detail boost/icl/type_traits libs/icl/test libs/icl/test/test_casual_
From: afojgo_at_[hidden]
Date: 2010-12-06 06:51:28

Author: jofaber
Date: 2010-12-06 06:51:25 EST (Mon, 06 Dec 2010)
New Revision: 67063
URL: http://svn.boost.org/trac/boost/changeset/67063

Log:
Adjustments for compiler vacpp on platform IBM_Canada_Ltd and Sandia-pgi-10.1.
Addition of int-pointers as in and decrementable domain types in all tests.
Text files modified: 
   trunk/boost/icl/detail/element_iterator.hpp        |     2                                         
   trunk/boost/icl/type_traits/difference_type_of.hpp |    13 ++                                      
   trunk/libs/icl/test/test_casual_/test_casual.cpp   |    23 +++                                     
   trunk/libs/icl/test/test_icl_dynamic_interval.hpp  |     6                                         
   trunk/libs/icl/test/test_laws.hpp                  |   236 ++++++++++++++++++++--------------------
   trunk/libs/icl/test/test_type_lists.hpp            |    10 +                                       
   trunk/libs/icl/test/test_value_maker.hpp           |    52 +++++++-                                
   7 files changed, 207 insertions(+), 135 deletions(-)

Modified: trunk/boost/icl/detail/element_iterator.hpp
==============================================================================
--- trunk/boost/icl/detail/element_iterator.hpp	(original)
+++ trunk/boost/icl/detail/element_iterator.hpp	2010-12-06 06:51:25 EST (Mon, 06 Dec 2010)
@@ -294,7 +294,7 @@
 
     void increment()
     { 
-		if(_reptator < icl::pred(adapt::length(_saltator)))
+        if(_reptator < icl::pred(adapt::length(_saltator)))
             ++_reptator; 
         else
         {

Modified: trunk/boost/icl/type_traits/difference_type_of.hpp
==============================================================================
--- trunk/boost/icl/type_traits/difference_type_of.hpp	(original)
+++ trunk/boost/icl/type_traits/difference_type_of.hpp	2010-12-06 06:51:25 EST (Mon, 06 Dec 2010)
@@ -9,6 +9,8 @@
 #define BOOST_ICL_TYPE_TRAITS_DIFFERENCE_TYPE_OF_HPP_JOFA_080911
 
 #include <boost/config.hpp> // For macro BOOST_STATIC_CONSTANT
+#include <boost/type_traits/is_pointer.hpp>
+#include <boost/mpl/or.hpp>
 #include <boost/icl/type_traits/no_type.hpp>
 #include <boost/icl/type_traits/is_numeric.hpp>
 
@@ -19,7 +21,10 @@
     struct has_difference
     {
         typedef has_difference type;
-        BOOST_STATIC_CONSTANT(bool, value = is_numeric<Type>::value);
+        BOOST_STATIC_CONSTANT(bool, 
+            value = (mpl::or_< is_numeric<Type>
+                             , is_pointer<Type> >::value) 
+            );
     };
 
     //--------------------------------------------------------------------------
@@ -33,6 +38,12 @@
     };
 
     template <class Type>
+    struct get_difference_type<Type*, true>
+    {
+        typedef std::ptrdiff_t type;
+    };
+
+    template <class Type>
     struct get_difference_type<Type, true>
     {
         typedef Type type;

Modified: trunk/libs/icl/test/test_casual_/test_casual.cpp
==============================================================================
--- trunk/libs/icl/test/test_casual_/test_casual.cpp	(original)
+++ trunk/libs/icl/test/test_casual_/test_casual.cpp	2010-12-06 06:51:25 EST (Mon, 06 Dec 2010)
@@ -27,12 +27,33 @@
 
 BOOST_AUTO_TEST_CASE(casual)
 {
-    typedef int T;
+    typedef int* T;
     typedef int U;
     typedef interval_map<T,U, total_absorber> IntervalMapT;
     typedef interval_set<T>                   IntervalSetT;
     typedef IntervalMapT::interval_type       IntervalT;
 
+    int values[100];
+    for(int idx=0; idx < 100; idx++)
+        values[idx] = idx;
+    
+    IntervalSetT ptr_set;
+
+    cout << IntervalT::right_open(values,   values+3) << endl;
+
+    ptr_set += IntervalT::right_open(values,   values+3);
+    ptr_set += IntervalT::right_open(values+4, values+7);
+    IntervalSetT::difference_type count = ptr_set.size();
+
+    ICL_const_FORALL(IntervalSetT, it_, ptr_set)
+    {
+        for(T ptr = first(*it_); ptr <= last(*it_); ++ptr)
+            cout << *ptr << " ";
+    }
+    cout << endl;
+
+    cout << ptr_set << endl;
+
     BOOST_CHECK_EQUAL(true, true);
 }
 

Modified: trunk/libs/icl/test/test_icl_dynamic_interval.hpp
==============================================================================
--- trunk/libs/icl/test/test_icl_dynamic_interval.hpp	(original)
+++ trunk/libs/icl/test/test_icl_dynamic_interval.hpp	2010-12-06 06:51:25 EST (Mon, 06 Dec 2010)
@@ -28,9 +28,9 @@
 {
     typedef typename icl::interval<T>::type IntervalT;
 
-    BOOST_CHECK_EQUAL( T(), pred(succ(T())));
-    BOOST_CHECK_EQUAL( icl::identity_element<T>::value(), pred(succ(icl::identity_element<T>::value())) );
-    BOOST_CHECK_EQUAL( icl::unit_element<T>::value(),     succ(icl::identity_element<T>::value())        );
+    BOOST_CHECK_EQUAL( T(), icl::pred(icl::succ(T())));
+    BOOST_CHECK_EQUAL( icl::identity_element<T>::value(), icl::pred(icl::succ(icl::identity_element<T>::value())) );
+    BOOST_CHECK_EQUAL( icl::unit_element<T>::value(),     icl::succ(icl::identity_element<T>::value())        );
     BOOST_CHECK_EQUAL( length(IntervalT()), icl::identity_element<typename difference_type_of<T>::type>::value() );
 
     //LAW: I x: borders(x)==closed => contains(x, lower(x)) && contains(x, upper(x))

Modified: trunk/libs/icl/test/test_laws.hpp
==============================================================================
--- trunk/libs/icl/test/test_laws.hpp	(original)
+++ trunk/libs/icl/test/test_laws.hpp	2010-12-06 06:51:25 EST (Mon, 06 Dec 2010)
@@ -58,14 +58,14 @@
 
 // Here we actually generate function templates by calling the defining
 // macros.
-DEFINE_ASSOCIATIVITY_CHECK_WRT      (plus,  + );
-DEFINE_ASSOCIATIVITY_CHECK_WRT_EQUAL(plus,  + );
-DEFINE_ASSOCIATIVITY_CHECK_WRT      (pipe,  | );
-DEFINE_ASSOCIATIVITY_CHECK_WRT_EQUAL(pipe,  | );
-DEFINE_ASSOCIATIVITY_CHECK_WRT      (et,    & );
-DEFINE_ASSOCIATIVITY_CHECK_WRT_EQUAL(et,    & );
-DEFINE_ASSOCIATIVITY_CHECK_WRT      (caret, ^ );
-DEFINE_ASSOCIATIVITY_CHECK_WRT_EQUAL(caret, ^ );
+DEFINE_ASSOCIATIVITY_CHECK_WRT      (plus,  + )
+DEFINE_ASSOCIATIVITY_CHECK_WRT_EQUAL(plus,  + )
+DEFINE_ASSOCIATIVITY_CHECK_WRT      (pipe,  | )
+DEFINE_ASSOCIATIVITY_CHECK_WRT_EQUAL(pipe,  | )
+DEFINE_ASSOCIATIVITY_CHECK_WRT      (et,    & )
+DEFINE_ASSOCIATIVITY_CHECK_WRT_EQUAL(et,    & )
+DEFINE_ASSOCIATIVITY_CHECK_WRT      (caret, ^ )
+DEFINE_ASSOCIATIVITY_CHECK_WRT_EQUAL(caret, ^ )
 
 
 //------------------------------------------------------------------------------
@@ -115,16 +115,16 @@
 #define CHECK_NEUTRALITY_WRT(op_tag) check_neutrality_wrt_##op_tag
 #define CHECK_NEUTRALITY_WRT_EQUAL(op_tag) check_neutrality_wrt_equal_##op_tag
 
-DEFINE_NEUTRALITY_CHECK_WRT      (plus,  + );
-DEFINE_NEUTRALITY_CHECK_WRT_EQUAL(plus,  + );
-DEFINE_NEUTRALITY_CHECK_WRT      (pipe,  | );
-DEFINE_NEUTRALITY_CHECK_WRT_EQUAL(pipe,  | );
-DEFINE_NEUTRALITY_CHECK_WRT      (minus, - );
-DEFINE_NEUTRALITY_CHECK_WRT_EQUAL(minus, - );
-DEFINE_NEUTRALITY_CHECK_WRT      (et,    & );
-DEFINE_NEUTRALITY_CHECK_WRT_EQUAL(et,    & );
-DEFINE_NEUTRALITY_CHECK_WRT      (caret, ^ );
-DEFINE_NEUTRALITY_CHECK_WRT_EQUAL(caret, ^ );
+DEFINE_NEUTRALITY_CHECK_WRT      (plus,  + )
+DEFINE_NEUTRALITY_CHECK_WRT_EQUAL(plus,  + )
+DEFINE_NEUTRALITY_CHECK_WRT      (pipe,  | )
+DEFINE_NEUTRALITY_CHECK_WRT_EQUAL(pipe,  | )
+DEFINE_NEUTRALITY_CHECK_WRT      (minus, - )
+DEFINE_NEUTRALITY_CHECK_WRT_EQUAL(minus, - )
+DEFINE_NEUTRALITY_CHECK_WRT      (et,    & )
+DEFINE_NEUTRALITY_CHECK_WRT_EQUAL(et,    & )
+DEFINE_NEUTRALITY_CHECK_WRT      (caret, ^ )
+DEFINE_NEUTRALITY_CHECK_WRT_EQUAL(caret, ^ )
 
 //------------------------------------------------------------------------------
 // Commutativity
@@ -152,14 +152,14 @@
 #define CHECK_COMMUTATIVITY_WRT_EQUAL(op_tag) check_commutativity_wrt_equal_##op_tag
 #define CHECK_COMMUTATIVITY_WRT(op_tag) check_commutativity_wrt_##op_tag
 
-DEFINE_COMMUTATIVITY_CHECK_WRT      (plus,  + );
-DEFINE_COMMUTATIVITY_CHECK_WRT_EQUAL(plus,  + );
-DEFINE_COMMUTATIVITY_CHECK_WRT      (pipe,  | );
-DEFINE_COMMUTATIVITY_CHECK_WRT_EQUAL(pipe,  | );
-DEFINE_COMMUTATIVITY_CHECK_WRT      (et,    & );
-DEFINE_COMMUTATIVITY_CHECK_WRT_EQUAL(et,    & );
-DEFINE_COMMUTATIVITY_CHECK_WRT      (caret, ^ );
-DEFINE_COMMUTATIVITY_CHECK_WRT_EQUAL(caret, ^ );
+DEFINE_COMMUTATIVITY_CHECK_WRT      (plus,  + )
+DEFINE_COMMUTATIVITY_CHECK_WRT_EQUAL(plus,  + )
+DEFINE_COMMUTATIVITY_CHECK_WRT      (pipe,  | )
+DEFINE_COMMUTATIVITY_CHECK_WRT_EQUAL(pipe,  | )
+DEFINE_COMMUTATIVITY_CHECK_WRT      (et,    & )
+DEFINE_COMMUTATIVITY_CHECK_WRT_EQUAL(et,    & )
+DEFINE_COMMUTATIVITY_CHECK_WRT      (caret, ^ )
+DEFINE_COMMUTATIVITY_CHECK_WRT_EQUAL(caret, ^ )
 
 //------------------------------------------------------------------------------
 // Natural inversion
@@ -186,10 +186,10 @@
 #define CHECK_PARTIAL_INVERSION_WRT_EQUAL(plus_tag) check_partial_inversion_wrt_equal_##plus_tag
 #define CHECK_PARTIAL_INVERSION_WRT(plus_tag) check_partial_inversion_wrt_##plus_tag
 
-DEFINE_PARTIAL_INVERSION_CHECK_WRT      (plus,  + );
-DEFINE_PARTIAL_INVERSION_CHECK_WRT_EQUAL(plus,  + );
-DEFINE_PARTIAL_INVERSION_CHECK_WRT      (pipe,  | );
-DEFINE_PARTIAL_INVERSION_CHECK_WRT_EQUAL(pipe,  | );
+DEFINE_PARTIAL_INVERSION_CHECK_WRT      (plus,  + )
+DEFINE_PARTIAL_INVERSION_CHECK_WRT_EQUAL(plus,  + )
+DEFINE_PARTIAL_INVERSION_CHECK_WRT      (pipe,  | )
+DEFINE_PARTIAL_INVERSION_CHECK_WRT_EQUAL(pipe,  | )
 
 //------------------------------------------------------------------------------
 // Inverse
@@ -220,10 +220,10 @@
 #define CHECK_INVERSE_WRT_EQUAL(plus_tag) check_inverse_wrt_equal_##plus_tag
 #define CHECK_INVERSE_WRT(plus_tag) check_inverse_wrt_##plus_tag
 
-DEFINE_INVERSE_CHECK_WRT      (plus,  + );
-DEFINE_INVERSE_CHECK_WRT_EQUAL(plus,  + );
-DEFINE_INVERSE_CHECK_WRT      (pipe,  | );
-DEFINE_INVERSE_CHECK_WRT_EQUAL(pipe,  | );
+DEFINE_INVERSE_CHECK_WRT      (plus,  + )
+DEFINE_INVERSE_CHECK_WRT_EQUAL(plus,  + )
+DEFINE_INVERSE_CHECK_WRT      (pipe,  | )
+DEFINE_INVERSE_CHECK_WRT_EQUAL(pipe,  | )
 
 //------------------------------------------------------------------------------
 // Containedness laws (Valid for sets, NOT for maps)
@@ -360,14 +360,14 @@
     CHECK_NEUTRALITY_WRT(op_tag)(a,identity_element); \
 }
 
-DEFINE_MONOID_CHECK_WRT(plus);
-DEFINE_MONOID_CHECK_WRT_EQUAL(plus);
-DEFINE_MONOID_CHECK_WRT(pipe);
-DEFINE_MONOID_CHECK_WRT_EQUAL(pipe);
-DEFINE_MONOID_CHECK_WRT(et);
-DEFINE_MONOID_CHECK_WRT_EQUAL(et);
-DEFINE_MONOID_CHECK_WRT(caret);
-DEFINE_MONOID_CHECK_WRT_EQUAL(caret);
+DEFINE_MONOID_CHECK_WRT      (plus)
+DEFINE_MONOID_CHECK_WRT_EQUAL(plus)
+DEFINE_MONOID_CHECK_WRT      (pipe)
+DEFINE_MONOID_CHECK_WRT_EQUAL(pipe)
+DEFINE_MONOID_CHECK_WRT      (et)
+DEFINE_MONOID_CHECK_WRT_EQUAL(et)
+DEFINE_MONOID_CHECK_WRT      (caret)
+DEFINE_MONOID_CHECK_WRT_EQUAL(caret)
 
 #define CHECK_MONOID_WRT(op_tag) check_monoid_wrt_##op_tag
 #define CHECK_MONOID_WRT_EQUAL(op_tag) check_monoid_wrt_equal_##op_tag
@@ -399,14 +399,14 @@
     CHECK_COMMUTATIVITY_WRT(op_tag)(a,c); \
 }
 
-DEFINE_ABELIAN_MONOID_CHECK_WRT(plus);
-DEFINE_ABELIAN_MONOID_CHECK_WRT_EQUAL(plus);
-DEFINE_ABELIAN_MONOID_CHECK_WRT(pipe);
-DEFINE_ABELIAN_MONOID_CHECK_WRT_EQUAL(pipe);
-DEFINE_ABELIAN_MONOID_CHECK_WRT(et);
-DEFINE_ABELIAN_MONOID_CHECK_WRT_EQUAL(et);
-DEFINE_ABELIAN_MONOID_CHECK_WRT(caret);
-DEFINE_ABELIAN_MONOID_CHECK_WRT_EQUAL(caret);
+DEFINE_ABELIAN_MONOID_CHECK_WRT      (plus)
+DEFINE_ABELIAN_MONOID_CHECK_WRT_EQUAL(plus)
+DEFINE_ABELIAN_MONOID_CHECK_WRT      (pipe)
+DEFINE_ABELIAN_MONOID_CHECK_WRT_EQUAL(pipe)
+DEFINE_ABELIAN_MONOID_CHECK_WRT      (et)
+DEFINE_ABELIAN_MONOID_CHECK_WRT_EQUAL(et)
+DEFINE_ABELIAN_MONOID_CHECK_WRT      (caret)
+DEFINE_ABELIAN_MONOID_CHECK_WRT_EQUAL(caret)
 
 #define CHECK_ABELIAN_MONOID_WRT(op_tag) check_abelian_monoid_wrt_##op_tag
 #define CHECK_ABELIAN_MONOID_WRT_EQUAL(op_tag) check_abelian_monoid_wrt_equal_##op_tag
@@ -434,14 +434,14 @@
     CHECK_PARTIAL_INVERSION_WRT(op_tag)(identity_element,a); \
 }
 
-DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_WRT(plus);
-DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_WRT_EQUAL(plus);
-DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_WRT(pipe);
-DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_WRT_EQUAL(pipe);
-DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_WRT(et);
-DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_WRT_EQUAL(et);
-DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_WRT(caret);
-DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_WRT_EQUAL(caret);
+DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_WRT      (plus)
+DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_WRT_EQUAL(plus)
+DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_WRT      (pipe)
+DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_WRT_EQUAL(pipe)
+DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_WRT      (et)
+DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_WRT_EQUAL(et)
+DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_WRT      (caret)
+DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_WRT_EQUAL(caret)
 
 #define CHECK_PARTIAL_INVERTIVE_MONOID_WRT(op_tag) check_partial_invertive_monoid_wrt_##op_tag
 #define CHECK_PARTIAL_INVERTIVE_MONOID_WRT_EQUAL(op_tag) check_partial_invertive_monoid_wrt_equal_##op_tag
@@ -471,10 +471,10 @@
 }
 
 
-DEFINE_ABELIAN_GROUP_CHECK_WRT(plus);
-DEFINE_ABELIAN_GROUP_CHECK_WRT_EQUAL(plus);
-DEFINE_ABELIAN_GROUP_CHECK_WRT(pipe);
-DEFINE_ABELIAN_GROUP_CHECK_WRT_EQUAL(pipe);
+DEFINE_ABELIAN_GROUP_CHECK_WRT      (plus)
+DEFINE_ABELIAN_GROUP_CHECK_WRT_EQUAL(plus)
+DEFINE_ABELIAN_GROUP_CHECK_WRT      (pipe)
+DEFINE_ABELIAN_GROUP_CHECK_WRT_EQUAL(pipe)
 
 #define CHECK_ABELIAN_GROUP_WRT(op_tag) check_abelian_group_wrt_##op_tag
 #define CHECK_ABELIAN_GROUP_WRT_EQUAL(op_tag) check_abelian_group_wrt_equal_##op_tag
@@ -506,14 +506,14 @@
 }
 
 
-DEFINE_MONOID_CHECK_PERMUTED_WRT(plus);
-DEFINE_MONOID_CHECK_PERMUTED_WRT_EQUAL(plus);
-DEFINE_MONOID_CHECK_PERMUTED_WRT(pipe);
-DEFINE_MONOID_CHECK_PERMUTED_WRT_EQUAL(pipe);
-DEFINE_MONOID_CHECK_PERMUTED_WRT(et);
-DEFINE_MONOID_CHECK_PERMUTED_WRT_EQUAL(et);
-DEFINE_MONOID_CHECK_PERMUTED_WRT(caret);
-DEFINE_MONOID_CHECK_PERMUTED_WRT_EQUAL(caret);
+DEFINE_MONOID_CHECK_PERMUTED_WRT      (plus)
+DEFINE_MONOID_CHECK_PERMUTED_WRT_EQUAL(plus)
+DEFINE_MONOID_CHECK_PERMUTED_WRT      (pipe)
+DEFINE_MONOID_CHECK_PERMUTED_WRT_EQUAL(pipe)
+DEFINE_MONOID_CHECK_PERMUTED_WRT      (et)
+DEFINE_MONOID_CHECK_PERMUTED_WRT_EQUAL(et)
+DEFINE_MONOID_CHECK_PERMUTED_WRT      (caret)
+DEFINE_MONOID_CHECK_PERMUTED_WRT_EQUAL(caret)
 
 #define CHECK_MONOID_PERMUTED_WRT(op_tag)       check_monoid_permuted_wrt_##op_tag
 #define CHECK_MONOID_PERMUTED_WRT_EQUAL(op_tag) check_monoid_permuted_wrt_equal_##op_tag
@@ -546,14 +546,14 @@
 }
 
 
-DEFINE_ABELIAN_MONOID_CHECK_PERMUTED_WRT(plus);
-DEFINE_ABELIAN_MONOID_CHECK_PERMUTED_WRT_EQUAL(plus);
-DEFINE_ABELIAN_MONOID_CHECK_PERMUTED_WRT(pipe);
-DEFINE_ABELIAN_MONOID_CHECK_PERMUTED_WRT_EQUAL(pipe);
-DEFINE_ABELIAN_MONOID_CHECK_PERMUTED_WRT(et);
-DEFINE_ABELIAN_MONOID_CHECK_PERMUTED_WRT_EQUAL(et);
-DEFINE_ABELIAN_MONOID_CHECK_PERMUTED_WRT(caret);
-DEFINE_ABELIAN_MONOID_CHECK_PERMUTED_WRT_EQUAL(caret);
+DEFINE_ABELIAN_MONOID_CHECK_PERMUTED_WRT      (plus)
+DEFINE_ABELIAN_MONOID_CHECK_PERMUTED_WRT_EQUAL(plus)
+DEFINE_ABELIAN_MONOID_CHECK_PERMUTED_WRT      (pipe)
+DEFINE_ABELIAN_MONOID_CHECK_PERMUTED_WRT_EQUAL(pipe)
+DEFINE_ABELIAN_MONOID_CHECK_PERMUTED_WRT      (et)
+DEFINE_ABELIAN_MONOID_CHECK_PERMUTED_WRT_EQUAL(et)
+DEFINE_ABELIAN_MONOID_CHECK_PERMUTED_WRT      (caret)
+DEFINE_ABELIAN_MONOID_CHECK_PERMUTED_WRT_EQUAL(caret)
 
 #define CHECK_ABELIAN_MONOID_PERMUTED_WRT(op_tag)       check_abelian_monoid_permuted_wrt_##op_tag
 #define CHECK_ABELIAN_MONOID_PERMUTED_WRT_EQUAL(op_tag) check_abelian_monoid_permuted_wrt_equal_##op_tag
@@ -586,14 +586,14 @@
 }
 
 
-DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_PERMUTED_WRT(plus);
-DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_PERMUTED_WRT_EQUAL(plus);
-DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_PERMUTED_WRT(pipe);
-DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_PERMUTED_WRT_EQUAL(pipe);
-DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_PERMUTED_WRT(et);
-DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_PERMUTED_WRT_EQUAL(et);
-DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_PERMUTED_WRT(caret);
-DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_PERMUTED_WRT_EQUAL(caret);
+DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_PERMUTED_WRT      (plus)
+DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_PERMUTED_WRT_EQUAL(plus)
+DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_PERMUTED_WRT      (pipe)
+DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_PERMUTED_WRT_EQUAL(pipe)
+DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_PERMUTED_WRT      (et)
+DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_PERMUTED_WRT_EQUAL(et)
+DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_PERMUTED_WRT      (caret)
+DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_PERMUTED_WRT_EQUAL(caret)
 
 #define CHECK_PARTIAL_INVERTIVE_MONOID_PERMUTED_WRT(op_tag)       check_partial_invertive_monoid_permuted_wrt_##op_tag
 #define CHECK_PARTIAL_INVERTIVE_MONOID_PERMUTED_WRT_EQUAL(op_tag) check_partial_invertive_monoid_permuted_wrt_equal_##op_tag
@@ -626,10 +626,10 @@
 }
 
 
-DEFINE_ABELIAN_GROUP_CHECK_PERMUTED_WRT(plus);
-DEFINE_ABELIAN_GROUP_CHECK_PERMUTED_WRT_EQUAL(plus);
-DEFINE_ABELIAN_GROUP_CHECK_PERMUTED_WRT(pipe);
-DEFINE_ABELIAN_GROUP_CHECK_PERMUTED_WRT_EQUAL(pipe);
+DEFINE_ABELIAN_GROUP_CHECK_PERMUTED_WRT      (plus)
+DEFINE_ABELIAN_GROUP_CHECK_PERMUTED_WRT_EQUAL(plus)
+DEFINE_ABELIAN_GROUP_CHECK_PERMUTED_WRT      (pipe)
+DEFINE_ABELIAN_GROUP_CHECK_PERMUTED_WRT_EQUAL(pipe)
 
 #define CHECK_ABELIAN_GROUP_PERMUTED_WRT(op_tag)       check_abelian_group_permuted_wrt_##op_tag
 #define CHECK_ABELIAN_GROUP_PERMUTED_WRT_EQUAL(op_tag) check_abelian_group_permuted_wrt_equal_##op_tag
@@ -661,14 +661,14 @@
     CHECK_MONOID_PERMUTED_WRT(op_tag)(var_a, var_b, ass_b);\
 }
 
-DEFINE_MONOID_CHECK_INSTANCE_WRT(plus);
-DEFINE_MONOID_CHECK_INSTANCE_WRT_EQUAL(plus);
-DEFINE_MONOID_CHECK_INSTANCE_WRT(pipe);
-DEFINE_MONOID_CHECK_INSTANCE_WRT_EQUAL(pipe);
-DEFINE_MONOID_CHECK_INSTANCE_WRT(et);
-DEFINE_MONOID_CHECK_INSTANCE_WRT_EQUAL(et);
-DEFINE_MONOID_CHECK_INSTANCE_WRT(caret);
-DEFINE_MONOID_CHECK_INSTANCE_WRT_EQUAL(caret);
+DEFINE_MONOID_CHECK_INSTANCE_WRT      (plus)
+DEFINE_MONOID_CHECK_INSTANCE_WRT_EQUAL(plus)
+DEFINE_MONOID_CHECK_INSTANCE_WRT      (pipe)
+DEFINE_MONOID_CHECK_INSTANCE_WRT_EQUAL(pipe)
+DEFINE_MONOID_CHECK_INSTANCE_WRT      (et)
+DEFINE_MONOID_CHECK_INSTANCE_WRT_EQUAL(et)
+DEFINE_MONOID_CHECK_INSTANCE_WRT      (caret)
+DEFINE_MONOID_CHECK_INSTANCE_WRT_EQUAL(caret)
 
 #define CHECK_MONOID_INSTANCE_WRT(op_tag)       check_monoid_instance_wrt_##op_tag
 #define CHECK_MONOID_INSTANCE_WRT_EQUAL(op_tag) check_monoid_instance_wrt_equal_##op_tag
@@ -701,14 +701,14 @@
     CHECK_ABELIAN_MONOID_PERMUTED_WRT(op_tag)(var_a, var_b, ass_b);\
 }
 
-DEFINE_ABELIAN_MONOID_CHECK_INSTANCE_WRT(plus);
-DEFINE_ABELIAN_MONOID_CHECK_INSTANCE_WRT_EQUAL(plus);
-DEFINE_ABELIAN_MONOID_CHECK_INSTANCE_WRT(pipe);
-DEFINE_ABELIAN_MONOID_CHECK_INSTANCE_WRT_EQUAL(pipe);
-DEFINE_ABELIAN_MONOID_CHECK_INSTANCE_WRT(et);
-DEFINE_ABELIAN_MONOID_CHECK_INSTANCE_WRT_EQUAL(et);
-DEFINE_ABELIAN_MONOID_CHECK_INSTANCE_WRT(caret);
-DEFINE_ABELIAN_MONOID_CHECK_INSTANCE_WRT_EQUAL(caret);
+DEFINE_ABELIAN_MONOID_CHECK_INSTANCE_WRT      (plus)
+DEFINE_ABELIAN_MONOID_CHECK_INSTANCE_WRT_EQUAL(plus)
+DEFINE_ABELIAN_MONOID_CHECK_INSTANCE_WRT      (pipe)
+DEFINE_ABELIAN_MONOID_CHECK_INSTANCE_WRT_EQUAL(pipe)
+DEFINE_ABELIAN_MONOID_CHECK_INSTANCE_WRT      (et)
+DEFINE_ABELIAN_MONOID_CHECK_INSTANCE_WRT_EQUAL(et)
+DEFINE_ABELIAN_MONOID_CHECK_INSTANCE_WRT      (caret)
+DEFINE_ABELIAN_MONOID_CHECK_INSTANCE_WRT_EQUAL(caret)
 
 #define CHECK_ABELIAN_MONOID_INSTANCE_WRT(op_tag)       check_abelian_monoid_instance_wrt_##op_tag
 #define CHECK_ABELIAN_MONOID_INSTANCE_WRT_EQUAL(op_tag) check_abelian_monoid_instance_wrt_equal_##op_tag
@@ -740,14 +740,14 @@
     CHECK_PARTIAL_INVERTIVE_MONOID_PERMUTED_WRT(op_tag)(var_a, var_b, ass_b);\
 }
 
-DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_INSTANCE_WRT(plus);
-DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_INSTANCE_WRT_EQUAL(plus);
-DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_INSTANCE_WRT(pipe);
-DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_INSTANCE_WRT_EQUAL(pipe);
-DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_INSTANCE_WRT(et);
-DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_INSTANCE_WRT_EQUAL(et);
-DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_INSTANCE_WRT(caret);
-DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_INSTANCE_WRT_EQUAL(caret);
+DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_INSTANCE_WRT      (plus)
+DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_INSTANCE_WRT_EQUAL(plus)
+DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_INSTANCE_WRT      (pipe)
+DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_INSTANCE_WRT_EQUAL(pipe)
+DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_INSTANCE_WRT      (et)
+DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_INSTANCE_WRT_EQUAL(et)
+DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_INSTANCE_WRT      (caret)
+DEFINE_PARTIAL_INVERTIVE_MONOID_CHECK_INSTANCE_WRT_EQUAL(caret)
 
 #define CHECK_PARTIAL_INVERTIVE_MONOID_INSTANCE_WRT(op_tag)       check_partial_invertive_monoid_instance_wrt_##op_tag
 #define CHECK_PARTIAL_INVERTIVE_MONOID_INSTANCE_WRT_EQUAL(op_tag) check_partial_invertive_monoid_instance_wrt_equal_##op_tag
@@ -779,10 +779,10 @@
     CHECK_ABELIAN_GROUP_PERMUTED_WRT(op_tag)(var_a, var_b, ass_b);\
 }
 
-DEFINE_ABELIAN_GROUP_CHECK_INSTANCE_WRT(plus);
-DEFINE_ABELIAN_GROUP_CHECK_INSTANCE_WRT_EQUAL(plus);
-DEFINE_ABELIAN_GROUP_CHECK_INSTANCE_WRT(pipe);
-DEFINE_ABELIAN_GROUP_CHECK_INSTANCE_WRT_EQUAL(pipe);
+DEFINE_ABELIAN_GROUP_CHECK_INSTANCE_WRT      (plus)
+DEFINE_ABELIAN_GROUP_CHECK_INSTANCE_WRT_EQUAL(plus)
+DEFINE_ABELIAN_GROUP_CHECK_INSTANCE_WRT      (pipe)
+DEFINE_ABELIAN_GROUP_CHECK_INSTANCE_WRT_EQUAL(pipe)
 
 #define CHECK_ABELIAN_GROUP_INSTANCE_WRT(op_tag)       check_abelian_group_instance_wrt_##op_tag
 #define CHECK_ABELIAN_GROUP_INSTANCE_WRT_EQUAL(op_tag) check_abelian_group_instance_wrt_equal_##op_tag

Modified: trunk/libs/icl/test/test_type_lists.hpp
==============================================================================
--- trunk/libs/icl/test/test_type_lists.hpp	(original)
+++ trunk/libs/icl/test/test_type_lists.hpp	2010-12-06 06:51:25 EST (Mon, 06 Dec 2010)
@@ -22,12 +22,13 @@
 #endif
 
 typedef ::boost::mpl::list<
-    unsigned short, unsigned int, unsigned long  
+     unsigned short, unsigned int, unsigned long  
     ,short, int, long, long long
     ,float, double, long double
     ,boost::rational<int>
     ,boost_posix_time_ptime
 //    ,boost::gregorian::date
+    ,int*
 > bicremental_types;
 
 typedef unsigned int             bicremental_type_1;
@@ -35,9 +36,10 @@
 typedef          double          bicremental_type_3;
 typedef boost::rational<int>     bicremental_type_4;
 typedef boost_posix_time_ptime   bicremental_type_5;
-typedef unsigned short           bicremental_type_6;
-typedef          short           bicremental_type_7;
-typedef          float           bicremental_type_8;
+typedef          short           bicremental_type_6;
+typedef          float           bicremental_type_7;
+typedef          int*            bicremental_type_8;
+
 
 typedef ::boost::mpl::list<
      short, int, long, long long

Modified: trunk/libs/icl/test/test_value_maker.hpp
==============================================================================
--- trunk/libs/icl/test/test_value_maker.hpp	(original)
+++ trunk/libs/icl/test/test_value_maker.hpp	2010-12-06 06:51:25 EST (Mon, 06 Dec 2010)
@@ -76,6 +76,44 @@
     }
 };
 
+
+template <class Type>
+struct test_value<Type*>
+{
+
+    static bool map_integers(int values[], int size)
+    {
+        static const int offset = size/2;
+        for(int idx = 0; idx < size; idx++)
+            values[idx] = idx - offset;
+    
+        return true;
+    }
+
+    static Type* make(int n)
+    {
+        static bool initialized;
+        static const int size   = 100;
+        static const int offset = size/2;
+        static int values[size];
+
+        if(!initialized)
+            initialized = map_integers(values, size);
+
+        Type* value = values + offset;
+        if(n>=0)
+            for(int i=0; i<n; i++)
+                ++value;
+        else
+            for(int i=0; i>n; i--)
+                --value;
+
+        return value;
+    }
+};
+
+
+
 template <class Type>
 struct test_value
 { 
@@ -135,18 +173,18 @@
 // Very short value denotation for intervals
 // Assumption typename T and IntervalT exists in scope
 //I_I : [a,b]
-#define I_I(low,up) icl::interval<T>::closed    (make<T>(low), make<T>(up))
+#define I_I(low,up) icl::interval<T>::closed    (test_value<T>::make(low), test_value<T>::make(up))
 //I_D : [a,b)
-#define I_D(low,up) icl::interval<T>::right_open(make<T>(low), make<T>(up))
+#define I_D(low,up) icl::interval<T>::right_open(test_value<T>::make(low), test_value<T>::make(up))
 //C_I : (a,b]
-#define C_I(low,up) icl::interval<T>::left_open (make<T>(low), make<T>(up))
+#define C_I(low,up) icl::interval<T>::left_open (test_value<T>::make(low), test_value<T>::make(up))
 //C_D : (a,b)
-#define C_D(low,up) icl::interval<T>::open      (make<T>(low), make<T>(up))
+#define C_D(low,up) icl::interval<T>::open      (test_value<T>::make(low), test_value<T>::make(up))
 
-#define MK_I(ItvT,low,up) ItvT(make<T>(low), make<T>(up))
+#define MK_I(ItvT,low,up) ItvT(test_value<T>::make(low), test_value<T>::make(up))
 
-#define MK_v(key)  make<T>(key)
-#define MK_u(key)  make<U>(key)
+#define MK_v(key)  test_value<T>::make(key)
+#define MK_u(key)  test_value<U>::make(key)
 
 // Very short value denotation for interval value pairs
 // Assumption typename IntervalMapT existes in scope