Boost-Commit :

Date view	Thread view	Subject view	Author view

Subject: [Boost-commit] svn:boost r66553 - in trunk: boost/icl libs/icl/example/party_ libs/icl/test
From: afojgo_at_[hidden]
Date: 2010-11-12 16:37:32

Author: jofaber
Date: 2010-11-12 16:37:09 EST (Fri, 12 Nov 2010)
New Revision: 66553
URL: http://svn.boost.org/trac/boost/changeset/66553

Log:
Adaptations for test matrix failures. Portability fixes for msvc-7.1 and clang-2.9. Used macros for some large test template parameters.
Text files modified:
   trunk/boost/icl/interval_base_map.hpp | 4
   trunk/boost/icl/map.hpp | 3
   trunk/libs/icl/example/party_/party.cpp | 10 -
   trunk/libs/icl/test/Jamfile.v2 | 3
   trunk/libs/icl/test/test_functions.hpp | 16 --
   trunk/libs/icl/test/test_icl_map.hpp | 39 +-----
   trunk/libs/icl/test/test_icl_quantifier_shared.hpp | 96 ++---------------
   trunk/libs/icl/test/test_interval_map_shared.hpp | 218 +++++----------------------------------
   trunk/libs/icl/test/test_interval_quantifier_shared.hpp | 110 ++------------------
   trunk/libs/icl/test/test_interval_set_laws_shared.hpp | 72 ++-----------
   trunk/libs/icl/test/test_interval_set_mixed.hpp | 6
   trunk/libs/icl/test/test_interval_set_shared.hpp | 136 ++++--------------------
   trunk/libs/icl/test/test_laws.hpp | 4
   trunk/libs/icl/test/test_quantifier_icl_map.hpp | 88 ++-------------
   trunk/libs/icl/test/test_quantifier_map_shared.hpp | 88 ++-------------
   trunk/libs/icl/test/test_set_icl_set.hpp | 49 +-------
   trunk/libs/icl/test/test_set_interval_set_shared.hpp | 8 -
   17 files changed, 143 insertions(+), 807 deletions(-)

Modified: trunk/boost/icl/interval_base_map.hpp
==============================================================================
--- trunk/boost/icl/interval_base_map.hpp (original)
+++ trunk/boost/icl/interval_base_map.hpp 2010-11-12 16:37:09 EST (Fri, 12 Nov 2010)
@@ -6,8 +6,8 @@
(See accompanying file LICENCE.txt or copy at
http://www.boost.org/LICENSE_1_0.txt)
+-----------------------------------------------------------------------------*/
-#ifndef __interval_base_map_h_JOFA_990223__
-#define __interval_base_map_h_JOFA_990223__
+#ifndef BOOST_ICL_INTERVAL_BASE_MAP_HPP_JOFA_990223
+#define BOOST_ICL_INTERVAL_BASE_MAP_HPP_JOFA_990223

#include <limits>
#include <boost/type_traits/ice.hpp>

Modified: trunk/boost/icl/map.hpp
==============================================================================
--- trunk/boost/icl/map.hpp (original)
+++ trunk/boost/icl/map.hpp 2010-11-12 16:37:09 EST (Fri, 12 Nov 2010)
@@ -175,7 +175,8 @@
         : base_type(first,past,comp)
     {}

- map(const map& src): base_type::map(src)
+ map(const map& src)
+ : base_type(src)
     {
         BOOST_CONCEPT_ASSERT((DefaultConstructibleConcept<DomainT>));
         BOOST_CONCEPT_ASSERT((LessThanComparableConcept<DomainT>));

Modified: trunk/libs/icl/example/party_/party.cpp
==============================================================================
--- trunk/libs/icl/example/party_/party.cpp (original)
+++ trunk/libs/icl/example/party_/party.cpp 2010-11-12 16:37:09 EST (Fri, 12 Nov 2010)
@@ -1,7 +1,7 @@
/*-----------------------------------------------------------------------------+
Interval Container Library
Author: Joachim Faulhaber
-Copyright (c) 2007-2009: Joachim Faulhaber
+Copyright (c) 2007-2010: Joachim Faulhaber
Copyright (c) 1999-2006: Cortex Software GmbH, Kantstrasse 57, Berlin
+------------------------------------------------------------------------------+
    Distributed under the Boost Software License, Version 1.0.
@@ -16,7 +16,6 @@
using namespace boost::icl;

/**
-
     Party.cpp demonstrates the possibilities of an interval map (interval_map or
     split_interval_map). An interval_map maps intervals to a given content. In
     this case the content is a set of party guests represented by their name
@@ -49,7 +48,6 @@

     The accumulative behavior accumulates associated values on every overlap of
     an insertion for the associated values.
-
*/

// Type set<string> collects the names of party guests. Since std::set is
@@ -57,7 +55,7 @@
// that performs a set union on overlap of intervals.
typedef std::set<string> GuestSetT;

-// Time is the domain type the split_interval_map. It's key values are therefore
+// 'Time' is the domain type the interval_map. It's key values are therefore
// time intervals. The content is the set of names: GuestSetT.

@@ -76,10 +74,6 @@

     interval_map<Time, GuestSetT> party;

- //party += make_pair( discrete_interval<Time>::right_open(Time(19,30), Time(23,00)), mary_harry);
- //party += make_pair( discrete_interval<Time>::right_open(Time(20,10), Time(monday,0,0)), diana_susan);
- //party += make_pair( discrete_interval<Time>::right_open(Time(22,15), Time(monday,0,30)), peter);
-
     party += make_pair( interval<Time>::right_open(Time(19,30), Time(23,00)), mary_harry);
     party += make_pair( interval<Time>::right_open(Time(20,10), Time(monday,0,0)), diana_susan);
     party += make_pair( interval<Time>::right_open(Time(22,15), Time(monday,0,30)), peter);

Modified: trunk/libs/icl/test/Jamfile.v2
==============================================================================
--- trunk/libs/icl/test/Jamfile.v2 (original)
+++ trunk/libs/icl/test/Jamfile.v2 2010-11-12 16:37:09 EST (Fri, 12 Nov 2010)
@@ -56,6 +56,7 @@
       [ run test_misc_/test_misc.cpp ]
       [ run test_doc_code_/test_doc_code.cpp ]
       [ run test_type_traits_/test_type_traits.cpp ]
- [ run test_combinable_/test_combinable.cpp ]
+ # test_combinable is too slow or too large for some compilers
+ #[ run test_combinable_/test_combinable.cpp ]
       [ run test_changing_interval_defaults_/test_changing_interval_defaults.cpp ]
     ;

Modified: trunk/libs/icl/test/test_functions.hpp
==============================================================================
--- trunk/libs/icl/test/test_functions.hpp (original)
+++ trunk/libs/icl/test/test_functions.hpp 2010-11-12 16:37:09 EST (Fri, 12 Nov 2010)
@@ -26,14 +26,6 @@

template <class T, class U, class Trt,
           ICL_IntervalMap_TEMPLATE(_T,_U,Traits,Trt) IntervalMap,
- //CL template<class _T, class _U,
- // class Traits = Trt,
- // ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, _T),
- // ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, _U),
- // ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, _U),
- // ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, _T, Compare),
- // ICL_ALLOC Alloc = std::allocator
- // >class IntervalMap,
           class SequenceT
>
void itl_map_copy(const SequenceT& segments,
@@ -46,14 +38,6 @@

template <class T, class U, class Trt,
           ICL_IntervalMap_TEMPLATE(_T,_U,Traits,Trt) IntervalMap,
- //template<class T, class U,
- // class Traits = Trt,
- // ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- // ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, U),
- // ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, U),
- // ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- // ICL_ALLOC Alloc = std::allocator
- // >class IntervalMap,
           class SequenceT
>
void test_interval_map_copy_via_inserter(const SequenceT& segments,

Modified: trunk/libs/icl/test/test_icl_map.hpp
==============================================================================
--- trunk/libs/icl/test/test_icl_map.hpp (original)
+++ trunk/libs/icl/test/test_icl_map.hpp 2010-11-12 16:37:09 EST (Fri, 12 Nov 2010)
@@ -1,24 +1,17 @@
/*-----------------------------------------------------------------------------+
-Copyright (c) 2008-2009: Joachim Faulhaber
+Copyright (c) 2008-2010: Joachim Faulhaber
+------------------------------------------------------------------------------+
    Distributed under the Boost Software License, Version 1.0.
       (See accompanying file LICENCE.txt or copy at
            http://www.boost.org/LICENSE_1_0.txt)
+-----------------------------------------------------------------------------*/
-#ifndef LIBS_ICL_TEST_TEST_ICL_itl_map_h_JOFA_090119__
-#define LIBS_ICL_TEST_TEST_ICL_itl_map_h_JOFA_090119__
+#ifndef LIBS_ICL_TEST_TEST_ICL_MAP_HPP_JOFA_090119
+#define LIBS_ICL_TEST_TEST_ICL_MAP_HPP_JOFA_090119

+#include "portability.hpp"

template <class T, class U, class Trt,
- template<class T, class U,
- class Traits = Trt,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, U),
- ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalMap
- >
+ ICL_IntervalMap_TEMPLATE(_T,_U,Traits,Trt) IntervalMap>
void itl_map_contains_4_bicremental_types()
{
     typedef IntervalMap<T,U,Trt> IntervalMapT;
@@ -47,15 +40,7 @@

template <class T, class U, class Trt,
- template<class T, class U,
- class Traits = Trt,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, U),
- ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalMap
- >
+ ICL_IntervalMap_TEMPLATE(_T,_U,Traits,Trt) IntervalMap>
void itl_map_find_4_bicremental_types()
{
     typedef IntervalMap<T,U,Trt> IntervalMapT;
@@ -80,15 +65,7 @@

template <class T, class U, class Trt,
- template<class T, class U,
- class Traits = Trt,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, U),
- ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalMap
- >
+ ICL_IntervalMap_TEMPLATE(_T,_U,Traits,Trt) IntervalMap>
void itl_map_inclusion_compare_4_bicremental_types()
{
     typedef IntervalMap<T,U,Trt> IntervalMapT;
@@ -155,5 +132,5 @@
}

-#endif // LIBS_ICL_TEST_TEST_ICL_itl_map_h_JOFA_090119__
+#endif // LIBS_ICL_TEST_TEST_ICL_MAP_HPP_JOFA_090119

Modified: trunk/libs/icl/test/test_icl_quantifier_shared.hpp
==============================================================================
--- trunk/libs/icl/test/test_icl_quantifier_shared.hpp (original)
+++ trunk/libs/icl/test/test_icl_quantifier_shared.hpp 2010-11-12 16:37:09 EST (Fri, 12 Nov 2010)
@@ -5,21 +5,13 @@
       (See accompanying file LICENCE.txt or copy at
            http://www.boost.org/LICENSE_1_0.txt)
+-----------------------------------------------------------------------------*/
-#ifndef __TEST_ICL_QUANTIFIER_SHARED_H_JOFA_100819__
-#define __TEST_ICL_QUANTIFIER_SHARED_H_JOFA_100819__
+#ifndef LIBS_ICL_TEST_TEST_ICL_QUANTIFIER_SHARED_HPP_JOFA_100819
+#define LIBS_ICL_TEST_TEST_ICL_QUANTIFIER_SHARED_HPP_JOFA_100819

#include "portability.hpp"

template <class T, class U, class Trt,
- template<class T, class U,
- class Traits = Trt,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, U),
- ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalMap
- >
+ ICL_IntervalMap_TEMPLATE(_T,_U,Traits,Trt) IntervalMap>
void make_3_icl_maps_and_derivatives_1
                    (icl::map<T,U,Trt>& map_a,
                     icl::map<T,U,Trt>& map_b,
@@ -68,15 +60,7 @@
// Monoid EAN
//------------------------------------------------------------------------------
template <class T, class U, class Trt,
- template<class T, class U,
- class Traits = Trt,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, U),
- ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalMap
- >
+ ICL_IntervalMap_TEMPLATE(_T,_U,Traits,Trt) IntervalMap>
void icl_quantifier_check_monoid_plus_4_bicremental_types()
{
     typedef IntervalMap<T,U,Trt> IntervalMapT;
@@ -92,15 +76,7 @@

template <class T, class U, class Trt,
- template<class T, class U,
- class Traits = Trt,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, U),
- ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalMap
- >
+ ICL_IntervalMap_TEMPLATE(_T,_U,Traits,Trt) IntervalMap>
void icl_quantifier_check_monoid_et_4_bicremental_types()
{
     typedef IntervalMap<T,U,Trt> IntervalMapT;
@@ -143,15 +119,7 @@

template <class T, class U, class Trt,
- template<class T, class U,
- class Traits = Trt,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, U),
- ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalMap
- >
+ ICL_IntervalMap_TEMPLATE(_T,_U,Traits,Trt) IntervalMap>
void icl_quantifier_check_abelian_monoid_et_4_bicremental_types()
{
     typedef IntervalMap<T,U,Trt> IntervalMapT;
@@ -170,15 +138,7 @@
// Abelian partial invertive monoid
//------------------------------------------------------------------------------
template <class T, class U, class Trt,
- template<class T, class U,
- class Traits = Trt,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, U),
- ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalMap
- >
+ ICL_IntervalMap_TEMPLATE(_T,_U,Traits,Trt) IntervalMap>
void icl_quantifier_check_partial_invertive_monoid_plus_4_bicremental_types()
{
     typedef IntervalMap<T,U,Trt> IntervalMapT;
@@ -196,15 +156,7 @@
// Abelian partial invertive monoid with protonic equality for inversion
//------------------------------------------------------------------------------
template <class T, class U, class Trt,
- template<class T, class U,
- class Traits = Trt,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, U),
- ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalMap
- >
+ ICL_IntervalMap_TEMPLATE(_T,_U,Traits,Trt) IntervalMap>
void icl_quantifier_check_partial_invertive_monoid_plus_prot_inv_4_bicremental_types()
{
     typedef IntervalMap<T,U,Trt> IntervalMapT;
@@ -226,15 +178,7 @@
// Abelian group EANIC
//------------------------------------------------------------------------------
template <class T, class U, class Trt,
- template<class T, class U,
- class Traits = Trt,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, U),
- ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalMap
- >
+ ICL_IntervalMap_TEMPLATE(_T,_U,Traits,Trt) IntervalMap>
void icl_quantifier_check_abelian_group_plus_4_bicremental_types()
{
     typedef IntervalMap<T,U,Trt> IntervalMapT;
@@ -252,15 +196,7 @@
// (0 - x) + x =p= 0
//------------------------------------------------------------------------------
template <class T, class U, class Trt,
- template<class T, class U,
- class Traits = Trt,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, U),
- ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalMap
- >
+ ICL_IntervalMap_TEMPLATE(_T,_U,Traits,Trt) IntervalMap>
void icl_quantifier_check_abelian_group_plus_prot_inv_4_bicremental_types()
{
     // check abelian group wrt. + and inverability wrt. protonic equality =p= :
@@ -284,15 +220,7 @@
// Containedness
//------------------------------------------------------------------------------
template <class T, class U, class Trt,
- template<class T, class U,
- class Traits = Trt,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, U),
- ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalMap
- >
+ ICL_IntervalMap_TEMPLATE(_T,_U,Traits,Trt) IntervalMap>
void icl_quantifier_check_containedness_4_bicremental_types()
{
     typedef IntervalMap<T,U,Trt> IntervalMapT;
@@ -312,5 +240,5 @@
}

-#endif // __TEST_ICL_QUANTIFIER_SHARED_H_JOFA_100819__
+#endif // LIBS_ICL_TEST_TEST_ICL_QUANTIFIER_SHARED_HPP_JOFA_100819

Modified: trunk/libs/icl/test/test_interval_map_shared.hpp
==============================================================================
--- trunk/libs/icl/test/test_interval_map_shared.hpp (original)
+++ trunk/libs/icl/test/test_interval_map_shared.hpp 2010-11-12 16:37:09 EST (Fri, 12 Nov 2010)
@@ -5,17 +5,12 @@
       (See accompanying file LICENCE.txt or copy at
            http://www.boost.org/LICENSE_1_0.txt)
+-----------------------------------------------------------------------------*/
-#ifndef LIBS_ICL_TEST_TEST_ICL_interval_map_shared_h_JOFA_081005__
-#define LIBS_ICL_TEST_TEST_ICL_interval_map_shared_h_JOFA_081005__
+#ifndef LIBS_ICL_TEST_TEST_INTERVAL_MAP_SHARED_HPP_JOFA_081005
+#define LIBS_ICL_TEST_TEST_INTERVAL_MAP_SHARED_HPP_JOFA_081005

-template <template<class T, class U,
- class Traits = partial_absorber,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, U),
- ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalMap,
+#include "portability.hpp"
+
+template <ICL_IntervalMap_TEMPLATE(_T,_U,Traits,partial_absorber) IntervalMap,
           class T, class U>
void interval_map_fundamentals_4_ordered_types()
{
@@ -162,14 +157,7 @@

}

-template <template<class T, class U,
- class Traits = partial_absorber,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, U),
- ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalMap,
+template <ICL_IntervalMap_TEMPLATE(_T,_U,Traits,partial_absorber) IntervalMap,
           class T, class U>
void interval_map_ctor_4_bicremental_types()
{
@@ -227,14 +215,7 @@
}

-template <template<class T, class U,
- class Traits = partial_absorber,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, U),
- ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalMap,
+template <ICL_IntervalMap_TEMPLATE(_T,_U,Traits,partial_absorber) IntervalMap,
           class T, class U>
void interval_map_add_sub_4_bicremental_types()
{
@@ -281,14 +262,7 @@
     BOOST_CHECK_EQUAL( map_A2, map_B2 );
}

-template <template<class T, class U,
- class Traits = partial_absorber,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, U),
- ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalMap,
+template <ICL_IntervalMap_TEMPLATE(_T,_U,Traits,partial_absorber) IntervalMap,
           class T, class U>
void interval_map_distinct_4_bicremental_types()
{
@@ -316,14 +290,7 @@
     BOOST_CHECK_EQUAL( iterative_size(is_1_3_5), 3 );
}

-template <template<class T, class U,
- class Traits = partial_absorber,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, U),
- ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalMap,
+template <ICL_IntervalMap_TEMPLATE(_T,_U,Traits,partial_absorber) IntervalMap,
           class T, class U>
void interval_map_distinct_4_bicremental_continuous_types()
{
@@ -370,14 +337,7 @@

}

-template <template<class T, class U,
- class Traits = partial_absorber,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, U),
- ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalMap,
+template <ICL_IntervalMap_TEMPLATE(_T,_U,Traits,partial_absorber) IntervalMap,
           class T, class U>
void interval_map_isolate_4_bicremental_continuous_types()
{
@@ -426,14 +386,7 @@
}

-template <template<class T, class U,
- class Traits = partial_absorber,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, U),
- ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalMap,
+template <ICL_IntervalMap_TEMPLATE(_T,_U,Traits,partial_absorber) IntervalMap,
           class T, class U>
void interval_map_contains_4_bicremental_types()
{
@@ -469,14 +422,7 @@
     BOOST_CHECK_EQUAL( icl::contains(itv_map, itv_set2), true );
}

-template <template<class T, class U,
- class Traits = partial_absorber,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, U),
- ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalMap,
+template <ICL_IntervalMap_TEMPLATE(_T,_U,Traits,partial_absorber) IntervalMap,
           class T, class U>
void interval_map_contains_key_objects_4_bicremental_types()
{
@@ -511,14 +457,7 @@
}

-template <template<class T, class U,
- class Traits = partial_absorber,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, U),
- ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalMap,
+template <ICL_IntervalMap_TEMPLATE(_T,_U,Traits,partial_absorber) IntervalMap,
           class T, class U>
void interval_map_operators_4_bicremental_types()
{
@@ -554,14 +493,7 @@

// Test for nontrivial intersection of interval maps with intervals and values
-template <template<class T, class U,
- class Traits = partial_absorber,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, U),
- ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalMap,
+template <ICL_IntervalMap_TEMPLATE(_T,_U,Traits,partial_absorber) IntervalMap,
           class T, class U>
void interval_map_base_intersect_4_bicremental_types()
{
@@ -661,14 +593,7 @@

// Test for nontrivial erasure of interval maps with intervals and interval sets
-template <template<class T, class U,
- class Traits = partial_absorber,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, U),
- ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalMap,
+template <ICL_IntervalMap_TEMPLATE(_T,_U,Traits,partial_absorber) IntervalMap,
           class T, class U>
void interval_map_base_erase_4_bicremental_types()
{
@@ -779,14 +704,7 @@

// Test first_collision
-template <template<class T, class U,
- class Traits = partial_absorber,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, U),
- ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalMap,
+template <ICL_IntervalMap_TEMPLATE(_T,_U,Traits,partial_absorber) IntervalMap,
           class T, class U>
void interval_map_base_is_disjoint_4_bicremental_types()
{
@@ -864,14 +782,7 @@
     BOOST_CHECK_EQUAL( intersects(map_B, set_A), true );
}

-template <template<class T, class U,
- class Traits = partial_absorber,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, U),
- ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalMap,
+template <ICL_IntervalMap_TEMPLATE(_T,_U,Traits,partial_absorber) IntervalMap,
           class T, class U>
void interval_map_flip_4_bicremental_types()
{
@@ -892,14 +803,7 @@
     BOOST_CHECK_EQUAL(set_a ^= IDv(1,3,1), IMap(IDv(0,1,1)) + IDv(2,3,1));
}

-template <template<class T, class U,
- class Traits = partial_absorber,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, U),
- ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalMap,
+template <ICL_IntervalMap_TEMPLATE(_T,_U,Traits,partial_absorber) IntervalMap,
           class T, class U>
void interval_map_infix_plus_overload_4_bicremental_types()
{
@@ -920,14 +824,7 @@
     BOOST_CHECK_EQUAL(map_b + map_pair, map_pair + map_b);
}

-template <template<class T, class U,
- class Traits = partial_absorber,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, U),
- ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalMap,
+template <ICL_IntervalMap_TEMPLATE(_T,_U,Traits,partial_absorber) IntervalMap,
           class T, class U>
void interval_map_infix_pipe_overload_4_bicremental_types()
{
@@ -950,14 +847,7 @@

-template <template<class T, class U,
- class Traits = partial_absorber,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, U),
- ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalMap,
+template <ICL_IntervalMap_TEMPLATE(_T,_U,Traits,partial_absorber) IntervalMap,
           class T, class U>
void interval_map_infix_minus_overload_4_bicremental_types()
{
@@ -1003,14 +893,7 @@
}

-template <template<class T, class U,
- class Traits = partial_absorber,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, U),
- ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalMap,
+template <ICL_IntervalMap_TEMPLATE(_T,_U,Traits,partial_absorber) IntervalMap,
           class T, class U>
void interval_map_infix_et_overload_4_bicremental_types()
{
@@ -1053,14 +936,7 @@
}

-template <template<class T, class U,
- class Traits = partial_absorber,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, U),
- ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalMap,
+template <ICL_IntervalMap_TEMPLATE(_T,_U,Traits,partial_absorber) IntervalMap,
           class T, class U>
void interval_map_infix_caret_overload_4_bicremental_types()
{
@@ -1093,14 +969,7 @@
     BOOST_CHECK_EQUAL(map_b ^ map_pair, map_pair ^ map_b);
}

-template <template<class T, class U,
- class Traits = partial_absorber,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, U),
- ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalMap,
+template <ICL_IntervalMap_TEMPLATE(_T,_U,Traits,partial_absorber) IntervalMap,
           class T, class U>
void interval_map_find_4_bicremental_types()
{
@@ -1126,14 +995,7 @@
}

-template <template<class T, class U,
- class Traits = partial_absorber,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, U),
- ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalMap,
+template <ICL_IntervalMap_TEMPLATE(_T,_U,Traits,partial_absorber) IntervalMap,
           class T, class U>
void interval_map_set_4_bicremental_types()
{
@@ -1154,15 +1016,7 @@

template <class T, class U, class Trt,
- template<class T, class U,
- class Traits = Trt,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, U),
- ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalMap
- >
+ ICL_IntervalMap_TEMPLATE(_T,_U,Traits,Trt) IntervalMap>
void interval_map_inclusion_compare_4_bicremental_types()
{
     typedef IntervalMap<T,U,Trt> IntervalMapT;
@@ -1226,15 +1080,7 @@
}

template <class T, class U, class Trt,
- template<class T, class U,
- class Traits = Trt,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, U),
- ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalMap
- >
+ ICL_IntervalMap_TEMPLATE(_T,_U,Traits,Trt) IntervalMap>
void interval_map_std_copy_via_inserter_4_bicremental_types()
{
     typedef IntervalMap<T,U,Trt> IntervalMapT; //Nedded for the test value generator
@@ -1268,15 +1114,7 @@

template <class T, class U, class Trt,
- template<class T, class U,
- class Traits = Trt,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, U),
- ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalMap
- >
+ ICL_IntervalMap_TEMPLATE(_T,_U,Traits,Trt) IntervalMap>
void interval_map_element_iter_4_discrete_types()
{
     typedef IntervalMap<T,U,Trt> IntervalMapT;
@@ -1312,5 +1150,5 @@

}

-#endif // LIBS_ICL_TEST_TEST_ICL_interval_map_shared_h_JOFA_080920__
+#endif // LIBS_ICL_TEST_TEST_INTERVAL_MAP_SHARED_HPP_JOFA_081005

Modified: trunk/libs/icl/test/test_interval_quantifier_shared.hpp
==============================================================================
--- trunk/libs/icl/test/test_interval_quantifier_shared.hpp (original)
+++ trunk/libs/icl/test/test_interval_quantifier_shared.hpp 2010-11-12 16:37:09 EST (Fri, 12 Nov 2010)
@@ -11,15 +11,7 @@
#include "portability.hpp"

template <class T, class U, class Trt,
- template<class T, class U,
- class Traits = Trt,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, U),
- ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalMap
- >
+ ICL_IntervalMap_TEMPLATE(_T,_U,Traits,Trt) IntervalMap>
void make_3_itv_maps_and_derivatives_1
                    (ICL_PORT_msvc_7_1_IntervalMap(T,U,Trt)& itv_map_a,
                     ICL_PORT_msvc_7_1_IntervalMap(T,U,Trt)& itv_map_b,
@@ -42,15 +34,7 @@
// Monoid EAN
//------------------------------------------------------------------------------
template <class T, class U, class Trt,
- template<class T, class U,
- class Traits = Trt,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, U),
- ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalMap
- >
+ ICL_IntervalMap_TEMPLATE(_T,_U,Traits,Trt) IntervalMap>
void itv_quantifier_check_monoid_plus_4_bicremental_types()
{
     typedef IntervalMap<T,U,Trt> IntervalMapT;
@@ -65,15 +49,7 @@

template <class T, class U, class Trt,
- template<class T, class U,
- class Traits = Trt,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, U),
- ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalMap
- >
+ ICL_IntervalMap_TEMPLATE(_T,_U,Traits,Trt) IntervalMap>
void itv_quantifier_check_monoid_et_4_bicremental_types()
{
     typedef IntervalMap<T,U,Trt> IntervalMapT;
@@ -91,15 +67,7 @@
//------------------------------------------------------------------------------

template <class T, class U, class Trt,
- template<class T, class U,
- class Traits = Trt,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, U),
- ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalMap
- >
+ ICL_IntervalMap_TEMPLATE(_T,_U,Traits,Trt) IntervalMap>
void itv_quantifier_check_abelian_monoid_plus_4_bicremental_types()
{
     typedef IntervalMap<T,U,Trt> IntervalMapT;
@@ -114,15 +82,7 @@

template <class T, class U, class Trt,
- template<class T, class U,
- class Traits = Trt,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, U),
- ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalMap
- >
+ ICL_IntervalMap_TEMPLATE(_T,_U,Traits,Trt) IntervalMap>
void itv_quantifier_check_abelian_monoid_et_4_bicremental_types()
{
     typedef IntervalMap<T,U,Trt> IntervalMapT;
@@ -140,15 +100,7 @@
// Abelian partial invertive monoid
//------------------------------------------------------------------------------
template <class T, class U, class Trt,
- template<class T, class U,
- class Traits = Trt,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, U),
- ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalMap
- >
+ ICL_IntervalMap_TEMPLATE(_T,_U,Traits,Trt) IntervalMap>
void itv_quantifier_check_partial_invertive_monoid_plus_4_bicremental_types()
{
     typedef IntervalMap<T,U,Trt> IntervalMapT;
@@ -165,15 +117,7 @@
// Abelian partial invertive monoid with protonic equality for inversion
//------------------------------------------------------------------------------
template <class T, class U, class Trt,
- template<class T, class U,
- class Traits = Trt,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, U),
- ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalMap
- >
+ ICL_IntervalMap_TEMPLATE(_T,_U,Traits,Trt) IntervalMap>
void itv_quantifier_check_partial_invertive_monoid_plus_prot_inv_4_bicremental_types()
{
     typedef IntervalMap<T,U,Trt> IntervalMapT;
@@ -194,15 +138,7 @@
// Abelian group EANIC
//------------------------------------------------------------------------------
template <class T, class U, class Trt,
- template<class T, class U,
- class Traits = Trt,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, U),
- ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalMap
- >
+ ICL_IntervalMap_TEMPLATE(_T,_U,Traits,Trt) IntervalMap>
void itv_quantifier_check_abelian_group_plus_4_bicremental_types()
{
     typedef IntervalMap<T,U,Trt> IntervalMapT;
@@ -219,15 +155,7 @@
// (0 - x) + x =p= 0
//------------------------------------------------------------------------------
template <class T, class U, class Trt,
- template<class T, class U,
- class Traits = Trt,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, U),
- ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalMap
- >
+ ICL_IntervalMap_TEMPLATE(_T,_U,Traits,Trt) IntervalMap>
void itv_quantifier_check_abelian_group_plus_prot_inv_4_bicremental_types()
{
     // check abelian group wrt. + and inverability wrt. protonic equality =p= :
@@ -251,15 +179,7 @@
// Inner complement
//------------------------------------------------------------------------------
template <class T, class U, class Trt,
- template<class T, class U,
- class Traits = Trt,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, U),
- ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalMap
- >
+ ICL_IntervalMap_TEMPLATE(_T,_U,Traits,Trt) IntervalMap>
void itv_quantifier_check_inner_complementarity_4_bicremental_types()
{
     typedef IntervalMap<T,U,Trt> IntervalMapT;
@@ -275,15 +195,7 @@
}

template <class T, class U, class Trt,
- template<class T, class U,
- class Traits = Trt,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, U),
- ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalMap
- >
+ ICL_IntervalMap_TEMPLATE(_T,_U,Traits,Trt) IntervalMap>
void itv_quantifier_check_length_complementarity_4_bicremental_types()
{
     typedef IntervalMap<T,U,Trt> IntervalMapT;

Modified: trunk/libs/icl/test/test_interval_set_laws_shared.hpp
==============================================================================
--- trunk/libs/icl/test/test_interval_set_laws_shared.hpp (original)
+++ trunk/libs/icl/test/test_interval_set_laws_shared.hpp 2010-11-12 16:37:09 EST (Fri, 12 Nov 2010)
@@ -1,24 +1,18 @@
/*-----------------------------------------------------------------------------+
-Copyright (c) 2008-2009: Joachim Faulhaber
+Copyright (c) 2008-2010: Joachim Faulhaber
+------------------------------------------------------------------------------+
    Distributed under the Boost Software License, Version 1.0.
       (See accompanying file LICENCE.txt or copy at
            http://www.boost.org/LICENSE_1_0.txt)
+-----------------------------------------------------------------------------*/
-#ifndef LIBS_ICL_TEST_TEST_ICL_interval_set_laws_shared_h_JOFA_090201__
-#define LIBS_ICL_TEST_TEST_ICL_interval_set_laws_shared_h_JOFA_090201__
+#ifndef LIBS_ICL_TEST_TEST_INTERVAL_SET_LAWS_SHARED_HPP_JOFA_090201
+#define LIBS_ICL_TEST_TEST_INTERVAL_SET_LAWS_SHARED_HPP_JOFA_090201

//------------------------------------------------------------------------------
// Monoid EAN
//------------------------------------------------------------------------------
-template <class T,
- template<class T,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalSet
- >
+template <class T, ICL_IntervalSet_TEMPLATE(_T) IntervalSet>
void interval_set_check_monoid_plus_4_bicremental_types()
{
     typedef IntervalSet<T> IntervalSetT;
@@ -36,13 +30,7 @@
}

-template <class T,
- template<class T,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalSet
- >
+template <class T, ICL_IntervalSet_TEMPLATE(_T) IntervalSet>
void interval_set_check_monoid_et_4_bicremental_types()
{
     typedef IntervalSet<T> IntervalSetT;
@@ -63,13 +51,7 @@
// Abelian monoid EANC
//------------------------------------------------------------------------------

-template <class T,
- template<class T,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalSet
- >
+template <class T, ICL_IntervalSet_TEMPLATE(_T) IntervalSet>
void interval_set_check_abelian_monoid_plus_4_bicremental_types()
{
     typedef IntervalSet<T> IntervalSetT;
@@ -87,13 +69,7 @@
}

-template <class T,
- template<class T,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalSet
- >
+template <class T, ICL_IntervalSet_TEMPLATE(_T) IntervalSet>
void interval_set_check_abelian_monoid_et_4_bicremental_types()
{
     typedef IntervalSet<T> IntervalSetT;
@@ -114,13 +90,7 @@
//------------------------------------------------------------------------------
// Abelian partial invertive monoid
//------------------------------------------------------------------------------
-template <class T,
- template<class T,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalSet
- >
+template <class T, ICL_IntervalSet_TEMPLATE(_T) IntervalSet>
void interval_set_check_partial_invertive_monoid_plus_4_bicremental_types()
{
     typedef IntervalSet<T> IntervalSetT;
@@ -140,13 +110,7 @@
//------------------------------------------------------------------------------
// Abelian partial invertive monoid with protonic equality for inversion
//------------------------------------------------------------------------------
-template <class T,
- template<class T,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalSet
- >
+template <class T, ICL_IntervalSet_TEMPLATE(_T) IntervalSet>
void interval_set_check_partial_invertive_monoid_plus_prot_inv_4_bicremental_types()
{
     typedef IntervalSet<T> IntervalSetT;
@@ -170,13 +134,7 @@
//------------------------------------------------------------------------------
// Abelian group EANIC
//------------------------------------------------------------------------------
-template <class T,
- template<class T,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalSet
- >
+template <class T, ICL_IntervalSet_TEMPLATE(_T) IntervalSet>
void interval_set_check_abelian_group_plus_4_bicremental_types()
{
     typedef IntervalSet<T> IntervalSetT;
@@ -196,13 +154,7 @@
//------------------------------------------------------------------------------
// (0 - x) + x =p= 0 |
//------------------------------------------------------------------------------
-template <class T,
- template<class T,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalSet
- >
+template <class T, ICL_IntervalSet_TEMPLATE(_T) IntervalSet>
void interval_set_check_abelian_group_plus_prot_inv_4_bicremental_types()
{
     typedef IntervalSet<T> IntervalSetT;
@@ -222,5 +174,5 @@
     CHECK_ABELIAN_GROUP_INSTANCE_WRT_EQUAL(pipe) (is_distinct_equal, set_a, set_b, set_c, segm, elem);
}

-#endif // LIBS_ICL_TEST_TEST_ICL_interval_set_laws_shared_h_JOFA_090201__
+#endif // LIBS_ICL_TEST_TEST_INTERVAL_SET_LAWS_SHARED_HPP_JOFA_090201

Modified: trunk/libs/icl/test/test_interval_set_mixed.hpp
==============================================================================
--- trunk/libs/icl/test/test_interval_set_mixed.hpp (original)
+++ trunk/libs/icl/test/test_interval_set_mixed.hpp 2010-11-12 16:37:09 EST (Fri, 12 Nov 2010)
@@ -5,8 +5,8 @@
       (See accompanying file LICENCE.txt or copy at
            http://www.boost.org/LICENSE_1_0.txt)
+-----------------------------------------------------------------------------*/
-#ifndef __fastest_icl_interval_set_mixed_h_JOFA_090702__
-#define __fastest_icl_interval_set_mixed_h_JOFA_090702__
+#ifndef LIBS_ICL_TEST_TEST_INTERVAL_SET_MIXED_HPP_JOFA_090702
+#define LIBS_ICL_TEST_TEST_INTERVAL_SET_MIXED_HPP_JOFA_090702

template <class T>
void interval_set_mixed_ctor_4_ordered_types()
@@ -874,4 +874,4 @@
     BOOST_CHECK_EQUAL(sep_a ^ join_a, join_a ^ sep_a );
}

-#endif // __fastest_icl_interval_set_mixed_h_JOFA_090702__
+#endif // LIBS_ICL_TEST_TEST_INTERVAL_SET_MIXED_HPP_JOFA_090702

Modified: trunk/libs/icl/test/test_interval_set_shared.hpp
==============================================================================
--- trunk/libs/icl/test/test_interval_set_shared.hpp (original)
+++ trunk/libs/icl/test/test_interval_set_shared.hpp 2010-11-12 16:37:09 EST (Fri, 12 Nov 2010)
@@ -1,20 +1,16 @@
/*-----------------------------------------------------------------------------+
-Copyright (c) 2008-2009: Joachim Faulhaber
+Copyright (c) 2008-2010: Joachim Faulhaber
+------------------------------------------------------------------------------+
    Distributed under the Boost Software License, Version 1.0.
       (See accompanying file LICENCE.txt or copy at
            http://www.boost.org/LICENSE_1_0.txt)
+-----------------------------------------------------------------------------*/
-#ifndef LIBS_ICL_TEST_TEST_ICL_interval_set_shared_h_JOFA_080920__
-#define LIBS_ICL_TEST_TEST_ICL_interval_set_shared_h_JOFA_080920__
+#ifndef LIBS_ICL_TEST_TEST_INTERVAL_SET_SHARED_HPP_JOFA_080920
+#define LIBS_ICL_TEST_TEST_INTERVAL_SET_SHARED_HPP_JOFA_080920

+#include "portability.hpp"

-template <template< class T,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, T),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalSet,
- class T>
+template <ICL_IntervalSet_TEMPLATE(_T) IntervalSet, class T>
void interval_set_fundamentals_4_ordered_types()
{
     typedef IntervalSet<T> IntervalSetT;
@@ -146,12 +142,7 @@

-template <template< class T,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, T),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalSet,
- class T>
+template <ICL_IntervalSet_TEMPLATE(_T) IntervalSet, class T>
void interval_set_ctor_4_bicremental_types()
{
     typedef IntervalSet<T> IntervalSetT;
@@ -201,12 +192,7 @@

}

-template <template< class T,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, T),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalSet,
- class T>
+template <ICL_IntervalSet_TEMPLATE(_T) IntervalSet, class T>
void interval_set_add_sub_4_bicremental_types()
{
     typedef IntervalSet<T> IntervalSetT;
@@ -245,12 +231,7 @@
}

-template <template< class T,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, T),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalSet,
- class T>
+template <ICL_IntervalSet_TEMPLATE(_T) IntervalSet, class T>
void interval_set_distinct_4_bicremental_types()
{
     typedef IntervalSet<T> IntervalSetT;
@@ -275,12 +256,7 @@
}

-template <template< class T,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, T),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalSet,
- class T>
+template <ICL_IntervalSet_TEMPLATE(_T) IntervalSet, class T>
void interval_set_distinct_4_bicremental_continuous_types()
{
     typedef IntervalSet<T> IntervalSetT;
@@ -317,12 +293,7 @@
}

-template <template< class T,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, T),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalSet,
- class T>
+template <ICL_IntervalSet_TEMPLATE(_T) IntervalSet, class T>
void interval_set_isolate_4_bicremental_continuous_types()
{
     typedef IntervalSet<T> IntervalSetT;
@@ -365,12 +336,8 @@
     BOOST_CHECK_EQUAL( iso_set, iso_set4 );
}

-template <template< class T,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, T),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalSet,
- class T>
+
+template <ICL_IntervalSet_TEMPLATE(_T) IntervalSet, class T>
void interval_set_element_compare_4_bicremental_types()
{
     typedef IntervalSet<T> IntervalSetT;
@@ -411,12 +378,7 @@
     BOOST_CHECK_EQUAL( is_element_equal( I_D(0,1)+ISet(I_D(1,4))+I_D(3,4), I_D(0,2)+ISet(I_D(2,4)) ), true );
}

-template <template< class T,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, T),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalSet,
- class T>
+template <ICL_IntervalSet_TEMPLATE(_T) IntervalSet, class T>
void interval_set_contains_4_bicremental_types()
{
     typedef IntervalSet<T> IntervalSetT;
@@ -452,12 +414,7 @@
}

-template <template< class T,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, T),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalSet,
- class T>
+template <ICL_IntervalSet_TEMPLATE(_T) IntervalSet, class T>
void interval_set_operators_4_bicremental_types()
{
     typedef IntervalSet<T> IntervalSetT;
@@ -498,12 +455,7 @@

// Test for nontrivial intersection of interval sets with intervals and values
-template <template< class T,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, T),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalSet,
- class T>
+template <ICL_IntervalSet_TEMPLATE(_T) IntervalSet, class T>
void interval_set_base_intersect_4_bicremental_types()
{
     typedef IntervalSet<T> IntervalSetT;
@@ -573,12 +525,7 @@
}

-template <template< class T,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, T),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalSet,
- class T>
+template <ICL_IntervalSet_TEMPLATE(_T) IntervalSet, class T>
void interval_set_flip_4_bicremental_types()
{
     typedef IntervalSet<T> IntervalSetT;
@@ -613,12 +560,7 @@
}

-template <template< class T,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, T),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalSet,
- class T>
+template <ICL_IntervalSet_TEMPLATE(_T) IntervalSet, class T>
void interval_set_infix_plus_overload_4_bicremental_types()
{
     typedef IntervalSet<T> IntervalSetT;
@@ -636,12 +578,7 @@
}

-template <template< class T,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, T),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalSet,
- class T>
+template <ICL_IntervalSet_TEMPLATE(_T) IntervalSet, class T>
void interval_set_infix_pipe_overload_4_bicremental_types()
{
     typedef IntervalSet<T> IntervalSetT;
@@ -661,12 +598,7 @@

-template <template< class T,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, T),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalSet,
- class T>
+template <ICL_IntervalSet_TEMPLATE(_T) IntervalSet, class T>
void interval_set_infix_minus_overload_4_bicremental_types()
{
     typedef IntervalSet<T> IntervalSetT;
@@ -685,12 +617,7 @@
}

-template <template< class T,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, T),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalSet,
- class T>
+template <ICL_IntervalSet_TEMPLATE(_T) IntervalSet, class T>
void interval_set_infix_et_overload_4_bicremental_types()
{
     typedef IntervalSet<T> IntervalSetT;
@@ -710,12 +637,7 @@

-template <template< class T,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, T),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalSet,
- class T>
+template <ICL_IntervalSet_TEMPLATE(_T) IntervalSet, class T>
void interval_set_infix_caret_overload_4_bicremental_types()
{
     typedef IntervalSet<T> IntervalSetT;
@@ -735,12 +657,7 @@

-template <template< class T,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, T),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalSet,
- class T>
+template <ICL_IntervalSet_TEMPLATE(_T) IntervalSet, class T>
void interval_set_find_4_bicremental_types()
{
     typedef IntervalSet<T> IntervalSetT;
@@ -760,12 +677,7 @@
     BOOST_CHECK_EQUAL( found == set_a.end(), true );
}

-template <template< class T,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, T),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalSet,
- class T>
+template <ICL_IntervalSet_TEMPLATE(_T) IntervalSet, class T>
void interval_set_element_iter_4_discrete_types()
{
     typedef IntervalSet<T> IntervalSetT;
@@ -796,5 +708,5 @@
     BOOST_CHECK_EQUAL( vec == dest, true );
}

-#endif // LIBS_ICL_TEST_TEST_ICL_interval_set_shared_h_JOFA_080920__
+#endif // LIBS_ICL_TEST_TEST_INTERVAL_SET_SHARED_HPP_JOFA_080920

Modified: trunk/libs/icl/test/test_laws.hpp
==============================================================================
--- trunk/libs/icl/test/test_laws.hpp (original)
+++ trunk/libs/icl/test/test_laws.hpp 2010-11-12 16:37:09 EST (Fri, 12 Nov 2010)
@@ -1,5 +1,5 @@
/*-----------------------------------------------------------------------------+
-Copyright (c) 2008-2009: Joachim Faulhaber
+Copyright (c) 2008-2010: Joachim Faulhaber
+------------------------------------------------------------------------------+
Distributed under the Boost Software License, Version 1.0.
(See accompanying file LICENCE.txt or copy at
@@ -789,5 +789,5 @@

}} // namespace icl boost

-#endif // LIBS_ICL_TEST_TEST_ICL_laws_h_JOFA_080920__
+#endif // BOOST_LIBS_ICL_TEST_ICL_LAWS_HPP_JOFA_090119

Modified: trunk/libs/icl/test/test_quantifier_icl_map.hpp
==============================================================================
--- trunk/libs/icl/test/test_quantifier_icl_map.hpp (original)
+++ trunk/libs/icl/test/test_quantifier_icl_map.hpp 2010-11-12 16:37:09 EST (Fri, 12 Nov 2010)
@@ -1,27 +1,19 @@
/*-----------------------------------------------------------------------------+
-Copyright (c) 2008-2009: Joachim Faulhaber
+Copyright (c) 2008-2010: Joachim Faulhaber
+------------------------------------------------------------------------------+
    Distributed under the Boost Software License, Version 1.0.
       (See accompanying file LICENCE.txt or copy at
            http://www.boost.org/LICENSE_1_0.txt)
+-----------------------------------------------------------------------------*/
-#ifndef LIBS_ICL_TEST_TEST_ICL_quantifier_itl_map_h_JOFA_090119__
-#define LIBS_ICL_TEST_TEST_ICL_quantifier_itl_map_h_JOFA_090119__
+#ifndef LIBS_ICL_TEST_TEST_QUANTIFIER_ICL_MAP_HPP_JOFA_090119
+#define LIBS_ICL_TEST_TEST_QUANTIFIER_ICL_MAP_HPP_JOFA_090119

//------------------------------------------------------------------------------
// Monoid EAN
//------------------------------------------------------------------------------
template <class T, class U, class Trt,
- template<class T, class U,
- class Traits = Trt,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, U),
- ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalMap
- >
+ ICL_IntervalMap_TEMPLATE(_T,_U,Traits,Trt) IntervalMap>
void itv_quantifier_check_monoid_plus_4_bicremental_types()
{
     typedef IntervalMap<T,U,Trt> IntervalMapT;
@@ -46,15 +38,7 @@

template <class T, class U, class Trt,
- template<class T, class U,
- class Traits = Trt,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, U),
- ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalMap
- >
+ ICL_IntervalMap_TEMPLATE(_T,_U,Traits,Trt) IntervalMap>
void itv_quantifier_check_monoid_et_4_bicremental_types()
{
     typedef IntervalMap<T,U,Trt> IntervalMapT;
@@ -82,15 +66,7 @@
//------------------------------------------------------------------------------

template <class T, class U, class Trt,
- template<class T, class U,
- class Traits = Trt,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, U),
- ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalMap
- >
+ ICL_IntervalMap_TEMPLATE(_T,_U,Traits,Trt) IntervalMap>
void itv_quantifier_check_abelian_monoid_plus_4_bicremental_types()
{
     typedef IntervalMap<T,U,Trt> IntervalMapT;
@@ -115,15 +91,7 @@

template <class T, class U, class Trt,
- template<class T, class U,
- class Traits = Trt,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, U),
- ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalMap
- >
+ ICL_IntervalMap_TEMPLATE(_T,_U,Traits,Trt) IntervalMap>
void itv_quantifier_check_abelian_monoid_et_4_bicremental_types()
{
     typedef IntervalMap<T,U,Trt> IntervalMapT;
@@ -151,15 +119,7 @@
// Abelian partial invertive monoid
//------------------------------------------------------------------------------
template <class T, class U, class Trt,
- template<class T, class U,
- class Traits = Trt,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, U),
- ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalMap
- >
+ ICL_IntervalMap_TEMPLATE(_T,_U,Traits,Trt) IntervalMap>
void itv_quantifier_check_partial_invertive_monoid_plus_4_bicremental_types()
{
     typedef IntervalMap<T,U,Trt> IntervalMapT;
@@ -186,15 +146,7 @@
// Abelian partial invertive monoid with protonic equality for inversion
//------------------------------------------------------------------------------
template <class T, class U, class Trt,
- template<class T, class U,
- class Traits = Trt,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, U),
- ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalMap
- >
+ ICL_IntervalMap_TEMPLATE(_T,_U,Traits,Trt) IntervalMap>
void itv_quantifier_check_partial_invertive_monoid_plus_prot_inv_4_bicremental_types()
{
     typedef IntervalMap<T,U,Trt> IntervalMapT;
@@ -225,15 +177,7 @@
// Abelian group EANIC
//------------------------------------------------------------------------------
template <class T, class U, class Trt,
- template<class T, class U,
- class Traits = Trt,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, U),
- ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalMap
- >
+ ICL_IntervalMap_TEMPLATE(_T,_U,Traits,Trt) IntervalMap>
void itv_quantifier_check_abelian_group_plus_4_bicremental_types()
{
     typedef IntervalMap<T,U,Trt> IntervalMapT;
@@ -260,15 +204,7 @@
// (0 - x) + x =p= 0 |
//------------------------------------------------------------------------------
template <class T, class U, class Trt,
- template<class T, class U,
- class Traits = Trt,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, U),
- ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalMap
- >
+ ICL_IntervalMap_TEMPLATE(_T,_U,Traits,Trt) IntervalMap>
void itv_quantifier_check_abelian_group_plus_prot_inv_4_bicremental_types()
{
     typedef IntervalMap<T,U,Trt> IntervalMapT;
@@ -294,5 +230,5 @@
     CHECK_ABELIAN_GROUP_INSTANCE_WRT_EQUAL(pipe) (is_distinct_equal, map_a, map_b, map_c, map_pair1, map_pair2);
}

-#endif // LIBS_ICL_TEST_TEST_ICL_quantifier_itl_map_h_JOFA_090119__
+#endif // LIBS_ICL_TEST_TEST_QUANTIFIER_ICL_MAP_HPP_JOFA_090119

Modified: trunk/libs/icl/test/test_quantifier_map_shared.hpp
==============================================================================
--- trunk/libs/icl/test/test_quantifier_map_shared.hpp (original)
+++ trunk/libs/icl/test/test_quantifier_map_shared.hpp 2010-11-12 16:37:09 EST (Fri, 12 Nov 2010)
@@ -1,27 +1,19 @@
/*-----------------------------------------------------------------------------+
-Copyright (c) 2008-2009: Joachim Faulhaber
+Copyright (c) 2008-2010: Joachim Faulhaber
+------------------------------------------------------------------------------+
    Distributed under the Boost Software License, Version 1.0.
       (See accompanying file LICENCE.txt or copy at
            http://www.boost.org/LICENSE_1_0.txt)
+-----------------------------------------------------------------------------*/
-#ifndef LIBS_ICL_TEST_TEST_ICL_itv_quantifier_shared_h_JOFA_090119__
-#define LIBS_ICL_TEST_TEST_ICL_itv_quantifier_shared_h_JOFA_090119__
+#ifndef LIBS_ICL_TEST_TEST_QUANTIFIER_MAP_SHARED_HPP_JOFA_090119
+#define LIBS_ICL_TEST_TEST_QUANTIFIER_MAP_SHARED_HPP_JOFA_090119

//------------------------------------------------------------------------------
// Monoid EAN
//------------------------------------------------------------------------------
template <class T, class U, class Trt,
- template<class T, class U,
- class Traits = Trt,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, U),
- ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalMap
- >
+ ICL_IntervalMap_TEMPLATE(_T,_U,Traits,Trt) IntervalMap>
void itv_quantifier_check_monoid_plus_4_bicremental_types()
{
     typedef IntervalMap<T,U,Trt> IntervalMapT;
@@ -40,15 +32,7 @@

template <class T, class U, class Trt,
- template<class T, class U,
- class Traits = Trt,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, U),
- ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalMap
- >
+ ICL_IntervalMap_TEMPLATE(_T,_U,Traits,Trt) IntervalMap>
void itv_quantifier_check_monoid_et_4_bicremental_types()
{
     typedef IntervalMap<T,U,Trt> IntervalMapT;
@@ -70,15 +54,7 @@
//------------------------------------------------------------------------------

template <class T, class U, class Trt,
- template<class T, class U,
- class Traits = Trt,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, U),
- ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalMap
- >
+ ICL_IntervalMap_TEMPLATE(_T,_U,Traits,Trt) IntervalMap>
void itv_quantifier_check_abelian_monoid_plus_4_bicremental_types()
{
     typedef IntervalMap<T,U,Trt> IntervalMapT;
@@ -97,15 +73,7 @@

template <class T, class U, class Trt,
- template<class T, class U,
- class Traits = Trt,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, U),
- ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalMap
- >
+ ICL_IntervalMap_TEMPLATE(_T,_U,Traits,Trt) IntervalMap>
void itv_quantifier_check_abelian_monoid_et_4_bicremental_types()
{
     typedef IntervalMap<T,U,Trt> IntervalMapT;
@@ -127,15 +95,7 @@
// Abelian partial invertive monoid
//------------------------------------------------------------------------------
template <class T, class U, class Trt,
- template<class T, class U,
- class Traits = Trt,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, U),
- ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalMap
- >
+ ICL_IntervalMap_TEMPLATE(_T,_U,Traits,Trt) IntervalMap>
void itv_quantifier_check_partial_invertive_monoid_plus_4_bicremental_types()
{
     typedef IntervalMap<T,U,Trt> IntervalMapT;
@@ -156,15 +116,7 @@
// Abelian partial invertive monoid with protonic equality for inversion
//------------------------------------------------------------------------------
template <class T, class U, class Trt,
- template<class T, class U,
- class Traits = Trt,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, U),
- ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalMap
- >
+ ICL_IntervalMap_TEMPLATE(_T,_U,Traits,Trt) IntervalMap>
void itv_quantifier_check_partial_invertive_monoid_plus_prot_inv_4_bicremental_types()
{
     typedef IntervalMap<T,U,Trt> IntervalMapT;
@@ -189,15 +141,7 @@
// Abelian group EANIC
//------------------------------------------------------------------------------
template <class T, class U, class Trt,
- template<class T, class U,
- class Traits = Trt,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, U),
- ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalMap
- >
+ ICL_IntervalMap_TEMPLATE(_T,_U,Traits,Trt) IntervalMap>
void itv_quantifier_check_abelian_group_plus_4_bicremental_types()
{
     typedef IntervalMap<T,U,Trt> IntervalMapT;
@@ -218,15 +162,7 @@
// (0 - x) + x =p= 0 |
//------------------------------------------------------------------------------
template <class T, class U, class Trt,
- template<class T, class U,
- class Traits = Trt,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_COMBINE Combine = ICL_COMBINE_INSTANCE(icl::inplace_plus, U),
- ICL_SECTION Section = ICL_SECTION_INSTANCE(icl::inter_section, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalMap
- >
+ ICL_IntervalMap_TEMPLATE(_T,_U,Traits,Trt) IntervalMap>
void itv_quantifier_check_abelian_group_plus_prot_inv_4_bicremental_types()
{
     typedef IntervalMap<T,U,Trt> IntervalMapT;
@@ -246,5 +182,5 @@
     CHECK_ABELIAN_GROUP_INSTANCE_WRT_EQUAL(pipe) (is_distinct_equal, map_a, map_b, map_c, val_pair, map_pair);
}

-#endif // LIBS_ICL_TEST_TEST_ICL_itv_quantifier_shared_h_JOFA_090119__
+#endif // LIBS_ICL_TEST_TEST_QUANTIFIER_MAP_SHARED_HPP_JOFA_090119

Modified: trunk/libs/icl/test/test_set_icl_set.hpp
==============================================================================
--- trunk/libs/icl/test/test_set_icl_set.hpp (original)
+++ trunk/libs/icl/test/test_set_icl_set.hpp 2010-11-12 16:37:09 EST (Fri, 12 Nov 2010)
@@ -1,24 +1,19 @@
/*-----------------------------------------------------------------------------+
-Copyright (c) 2008-2009: Joachim Faulhaber
+Copyright (c) 2008-2010: Joachim Faulhaber
+------------------------------------------------------------------------------+
    Distributed under the Boost Software License, Version 1.0.
       (See accompanying file LICENCE.txt or copy at
            http://www.boost.org/LICENSE_1_0.txt)
+-----------------------------------------------------------------------------*/
-#ifndef LIBS_ICL_TEST_TEST_ICL_set_itl_set_h_JOFA_090119__
-#define LIBS_ICL_TEST_TEST_ICL_set_itl_set_h_JOFA_090119__
+#ifndef LIBS_ICL_TEST_TEST_SET_ICL_SET_HPP_JOFA_090119
+#define LIBS_ICL_TEST_TEST_SET_ICL_SET_HPP_JOFA_090119

+#include "portability.hpp"

//------------------------------------------------------------------------------
// Monoid EAN
//------------------------------------------------------------------------------
-template <class T,
- template<class T,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalSet
- >
+template <class T, ICL_IntervalSet_TEMPLATE(_T) IntervalSet>
void itl_set_check_monoid_plus_4_bicremental_types()
{
     typedef IntervalSet<T> IntervalSetT;
@@ -42,13 +37,7 @@
     CHECK_MONOID_INSTANCE_WRT(pipe) (set_a, set_b, set_c, val1, val2);
}

-template <class T,
- template<class T,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalSet
- >
+template <class T, ICL_IntervalSet_TEMPLATE(_T) IntervalSet>
void itl_set_check_monoid_et_4_bicremental_types()
{
     typedef IntervalSet<T> IntervalSetT;
@@ -76,13 +65,7 @@
// Abelian monoid EANC
//------------------------------------------------------------------------------

-template <class T,
- template<class T,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalSet
- >
+template <class T, ICL_IntervalSet_TEMPLATE(_T) IntervalSet>
void itl_set_check_abelian_monoid_plus_4_bicremental_types()
{
     typedef IntervalSet<T> IntervalSetT;
@@ -106,13 +89,7 @@
     CHECK_ABELIAN_MONOID_INSTANCE_WRT(pipe) (set_a, set_b, set_c, val1, val2);
}

-template <class T,
- template<class T,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalSet
- >
+template <class T, ICL_IntervalSet_TEMPLATE(_T) IntervalSet>
void itl_set_check_abelian_monoid_et_4_bicremental_types()
{
     typedef IntervalSet<T> IntervalSetT;
@@ -140,13 +117,7 @@
//------------------------------------------------------------------------------
// Abelian partial invertive monoid
//------------------------------------------------------------------------------
-template <class T,
- template<class T,
- ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- ICL_ALLOC Alloc = std::allocator
- >class IntervalSet
- >
+template <class T, ICL_IntervalSet_TEMPLATE(_T) IntervalSet>
void itl_set_check_partial_invertive_monoid_plus_4_bicremental_types()
{
     typedef IntervalSet<T> IntervalSetT;
@@ -170,5 +141,5 @@
     CHECK_PARTIAL_INVERTIVE_MONOID_INSTANCE_WRT(pipe) (set_a, set_b, set_c, val1, val2);
}

-#endif // LIBS_ICL_TEST_TEST_ICL_set_itl_set_h_JOFA_090119__
+#endif // LIBS_ICL_TEST_TEST_SET_ICL_SET_HPP_JOFA_090119

Modified: trunk/libs/icl/test/test_set_interval_set_shared.hpp
==============================================================================
--- trunk/libs/icl/test/test_set_interval_set_shared.hpp (original)
+++ trunk/libs/icl/test/test_set_interval_set_shared.hpp 2010-11-12 16:37:09 EST (Fri, 12 Nov 2010)
@@ -1,5 +1,5 @@
/*-----------------------------------------------------------------------------+
-Copyright (c) 2008-2009: Joachim Faulhaber
+Copyright (c) 2008-2010: Joachim Faulhaber
+------------------------------------------------------------------------------+
    Distributed under the Boost Software License, Version 1.0.
       (See accompanying file LICENCE.txt or copy at
@@ -11,12 +11,6 @@
#include "portability.hpp"

template <class T, ICL_IntervalSet_TEMPLATE(_T) IntervalSet>
- //CL template<class T,
- // ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, U),
- // ICL_INTERVAL(ICL_COMPARE) Interval = ICL_INTERVAL_INSTANCE(ICL_INTERVAL_DEFAULT, T, Compare),
- // ICL_ALLOC Alloc = std::allocator
- // >class IntervalSet
- //>
void make_3_interval_sets_and_derivatives_1
                    (ICL_PORT_msvc_7_1_IntervalSet(T)& set_a,
                     ICL_PORT_msvc_7_1_IntervalSet(T)& set_b,

Date view	Thread view	Subject view	Author view

Boost-Commit list run by bdawes at acm.org, david.abrahams at rcn.com, gregod at cs.rpi.edu, cpdaniel at pacbell.net, john at johnmaddock.co.uk