Boost logo

Boost-Commit :

Subject: [Boost-commit] svn:boost r72993 - in sandbox/type_traits: boost/type_traits boost/type_traits/detail libs/type_traits/doc libs/type_traits/test
From: frederic.bron_at_[hidden]
Date: 2011-07-09 16:29:58


Author: bronf
Date: 2011-07-09 16:29:47 EDT (Sat, 09 Jul 2011)
New Revision: 72993
URL: http://svn.boost.org/trac/boost/changeset/72993

Log:
operator traits:
- exhaustive testing of all cv qualifiers, pointer and references for operator
  arguments and return types
- works find with g++ 4.5.2 but intel has some troubles with const volatile
  references

Added:
   sandbox/type_traits/libs/type_traits/test/can_call_binary_classes.hpp (contents, props changed)
   sandbox/type_traits/libs/type_traits/test/can_call_binary_classes0_test.cpp (contents, props changed)
   sandbox/type_traits/libs/type_traits/test/can_call_binary_classes1_test.cpp (contents, props changed)
   sandbox/type_traits/libs/type_traits/test/can_call_binary_classes2_test.cpp (contents, props changed)
   sandbox/type_traits/libs/type_traits/test/can_call_binary_classes3_test.cpp (contents, props changed)
   sandbox/type_traits/libs/type_traits/test/can_call_binary_classes4_test.cpp (contents, props changed)
   sandbox/type_traits/libs/type_traits/test/can_call_binary_classes5_test.cpp (contents, props changed)
   sandbox/type_traits/libs/type_traits/test/can_call_binary_classes6_test.cpp (contents, props changed)
   sandbox/type_traits/libs/type_traits/test/can_call_binary_classes7_test.cpp (contents, props changed)
   sandbox/type_traits/libs/type_traits/test/can_call_binary_classes8_test.cpp (contents, props changed)
   sandbox/type_traits/libs/type_traits/test/can_call_binary_classes9_test.cpp (contents, props changed)
   sandbox/type_traits/libs/type_traits/test/can_call_postfix_classes.hpp (contents, props changed)
   sandbox/type_traits/libs/type_traits/test/can_call_postfix_classes0_test.cpp (contents, props changed)
   sandbox/type_traits/libs/type_traits/test/can_call_postfix_classes1_test.cpp (contents, props changed)
   sandbox/type_traits/libs/type_traits/test/can_call_postfix_classes2_test.cpp (contents, props changed)
   sandbox/type_traits/libs/type_traits/test/can_call_postfix_classes3_test.cpp (contents, props changed)
   sandbox/type_traits/libs/type_traits/test/can_call_prefix_classes.hpp (contents, props changed)
   sandbox/type_traits/libs/type_traits/test/can_call_prefix_classes0_test.cpp (contents, props changed)
   sandbox/type_traits/libs/type_traits/test/can_call_prefix_classes1_test.cpp (contents, props changed)
   sandbox/type_traits/libs/type_traits/test/can_call_prefix_classes2_test.cpp (contents, props changed)
   sandbox/type_traits/libs/type_traits/test/can_call_prefix_classes3_test.cpp (contents, props changed)
Removed:
   sandbox/type_traits/libs/type_traits/test/can_call_addition_assignment_test.hpp
   sandbox/type_traits/libs/type_traits/test/can_call_addition_test.hpp
   sandbox/type_traits/libs/type_traits/test/can_call_binary_logical_test.hpp
   sandbox/type_traits/libs/type_traits/test/can_call_comparison_test.hpp
   sandbox/type_traits/libs/type_traits/test/can_call_complement_test.hpp
   sandbox/type_traits/libs/type_traits/test/can_call_dereference_test.hpp
   sandbox/type_traits/libs/type_traits/test/can_call_integral_no_constlhs_test.hpp
   sandbox/type_traits/libs/type_traits/test/can_call_integral_test.hpp
   sandbox/type_traits/libs/type_traits/test/can_call_no_pointer_no_constlhs_test.hpp
   sandbox/type_traits/libs/type_traits/test/can_call_no_pointer_test.hpp
   sandbox/type_traits/libs/type_traits/test/can_call_post_decrement_test.hpp
   sandbox/type_traits/libs/type_traits/test/can_call_post_increment_test.hpp
   sandbox/type_traits/libs/type_traits/test/can_call_pre_decrement_test.hpp
   sandbox/type_traits/libs/type_traits/test/can_call_pre_increment_test.hpp
   sandbox/type_traits/libs/type_traits/test/can_call_subtraction_assignment_test.hpp
   sandbox/type_traits/libs/type_traits/test/can_call_subtraction_test.hpp
   sandbox/type_traits/libs/type_traits/test/can_call_unary_minus_test.hpp
   sandbox/type_traits/libs/type_traits/test/can_call_unary_plus_not_test.hpp
Text files modified:
   sandbox/type_traits/boost/type_traits/can_call_addition.hpp | 24 +-
   sandbox/type_traits/boost/type_traits/can_call_addition_assignment.hpp | 31 ++-
   sandbox/type_traits/boost/type_traits/can_call_bitwise_and.hpp | 23 +-
   sandbox/type_traits/boost/type_traits/can_call_bitwise_and_assignment.hpp | 32 ++-
   sandbox/type_traits/boost/type_traits/can_call_bitwise_or.hpp | 23 +-
   sandbox/type_traits/boost/type_traits/can_call_bitwise_or_assignment.hpp | 32 ++-
   sandbox/type_traits/boost/type_traits/can_call_bitwise_xor.hpp | 23 +-
   sandbox/type_traits/boost/type_traits/can_call_bitwise_xor_assignment.hpp | 32 ++-
   sandbox/type_traits/boost/type_traits/can_call_division_assignment.hpp | 5
   sandbox/type_traits/boost/type_traits/can_call_equal.hpp | 5
   sandbox/type_traits/boost/type_traits/can_call_greater.hpp | 5
   sandbox/type_traits/boost/type_traits/can_call_greater_equal.hpp | 5
   sandbox/type_traits/boost/type_traits/can_call_left_shift.hpp | 23 +-
   sandbox/type_traits/boost/type_traits/can_call_left_shift_assignment.hpp | 32 ++-
   sandbox/type_traits/boost/type_traits/can_call_less.hpp | 5
   sandbox/type_traits/boost/type_traits/can_call_less_equal.hpp | 5
   sandbox/type_traits/boost/type_traits/can_call_modulus.hpp | 23 +-
   sandbox/type_traits/boost/type_traits/can_call_modulus_assignment.hpp | 32 ++-
   sandbox/type_traits/boost/type_traits/can_call_multiplication_assignment.hpp | 5
   sandbox/type_traits/boost/type_traits/can_call_not_equal.hpp | 5
   sandbox/type_traits/boost/type_traits/can_call_post_decrement.hpp | 11 +
   sandbox/type_traits/boost/type_traits/can_call_post_increment.hpp | 10
   sandbox/type_traits/boost/type_traits/can_call_pre_decrement.hpp | 11 +
   sandbox/type_traits/boost/type_traits/can_call_pre_increment.hpp | 10
   sandbox/type_traits/boost/type_traits/can_call_right_shift.hpp | 23 +-
   sandbox/type_traits/boost/type_traits/can_call_right_shift_assignment.hpp | 32 ++-
   sandbox/type_traits/boost/type_traits/can_call_subtraction.hpp | 18 +-
   sandbox/type_traits/boost/type_traits/can_call_subtraction_assignment.hpp | 43 +++-
   sandbox/type_traits/boost/type_traits/detail/can_call_binary_operator.hpp | 23 +-
   sandbox/type_traits/boost/type_traits/detail/can_call_postfix_operator.hpp | 23 +-
   sandbox/type_traits/boost/type_traits/detail/can_call_prefix_operator.hpp | 23 +-
   sandbox/type_traits/libs/type_traits/doc/operators.qbk | 6
   sandbox/type_traits/libs/type_traits/test/can_call_addition_assignment_test.cpp | 261 +++++++++++++++++++++++++++++++++-
   sandbox/type_traits/libs/type_traits/test/can_call_addition_test.cpp | 261 +++++++++++++++++++++++++++++++++-
   sandbox/type_traits/libs/type_traits/test/can_call_and_test.cpp | 261 +++++++++++++++++++++++++++++++++-
   sandbox/type_traits/libs/type_traits/test/can_call_binary_operators.hpp | 10
   sandbox/type_traits/libs/type_traits/test/can_call_bitwise_and_assignment_test.cpp | 261 +++++++++++++++++++++++++++++++++-
   sandbox/type_traits/libs/type_traits/test/can_call_bitwise_and_test.cpp | 261 +++++++++++++++++++++++++++++++++-
   sandbox/type_traits/libs/type_traits/test/can_call_bitwise_or_assignment_test.cpp | 261 +++++++++++++++++++++++++++++++++-
   sandbox/type_traits/libs/type_traits/test/can_call_bitwise_or_test.cpp | 261 +++++++++++++++++++++++++++++++++-
   sandbox/type_traits/libs/type_traits/test/can_call_bitwise_xor_assignment_test.cpp | 261 +++++++++++++++++++++++++++++++++-
   sandbox/type_traits/libs/type_traits/test/can_call_bitwise_xor_test.cpp | 261 +++++++++++++++++++++++++++++++++-
   sandbox/type_traits/libs/type_traits/test/can_call_complement_test.cpp | 261 +++++++++++++++++++++++++++++++++-
   sandbox/type_traits/libs/type_traits/test/can_call_dereference_test.cpp | 261 +++++++++++++++++++++++++++++++++-
   sandbox/type_traits/libs/type_traits/test/can_call_division_assignment_test.cpp | 261 +++++++++++++++++++++++++++++++++-
   sandbox/type_traits/libs/type_traits/test/can_call_division_test.cpp | 261 +++++++++++++++++++++++++++++++++-
   sandbox/type_traits/libs/type_traits/test/can_call_equal_test.cpp | 261 +++++++++++++++++++++++++++++++++-
   sandbox/type_traits/libs/type_traits/test/can_call_greater_equal_test.cpp | 261 +++++++++++++++++++++++++++++++++-
   sandbox/type_traits/libs/type_traits/test/can_call_greater_test.cpp | 261 +++++++++++++++++++++++++++++++++-
   sandbox/type_traits/libs/type_traits/test/can_call_left_shift_assignment_test.cpp | 261 +++++++++++++++++++++++++++++++++-
   sandbox/type_traits/libs/type_traits/test/can_call_left_shift_test.cpp | 302 ++++++++++++++++++++++++++++++++++++---
   sandbox/type_traits/libs/type_traits/test/can_call_less_equal_test.cpp | 261 +++++++++++++++++++++++++++++++++-
   sandbox/type_traits/libs/type_traits/test/can_call_less_test.cpp | 261 +++++++++++++++++++++++++++++++++-
   sandbox/type_traits/libs/type_traits/test/can_call_modulus_assignment_test.cpp | 261 +++++++++++++++++++++++++++++++++-
   sandbox/type_traits/libs/type_traits/test/can_call_modulus_test.cpp | 261 +++++++++++++++++++++++++++++++++-
   sandbox/type_traits/libs/type_traits/test/can_call_multiplication_assignment_test.cpp | 261 +++++++++++++++++++++++++++++++++-
   sandbox/type_traits/libs/type_traits/test/can_call_multiplication_test.cpp | 261 +++++++++++++++++++++++++++++++++-
   sandbox/type_traits/libs/type_traits/test/can_call_not_equal_test.cpp | 261 +++++++++++++++++++++++++++++++++-
   sandbox/type_traits/libs/type_traits/test/can_call_not_test.cpp | 266 +++++++++++++++++++++++++++++++++-
   sandbox/type_traits/libs/type_traits/test/can_call_or_test.cpp | 261 +++++++++++++++++++++++++++++++++-
   sandbox/type_traits/libs/type_traits/test/can_call_post_decrement_test.cpp | 261 +++++++++++++++++++++++++++++++++-
   sandbox/type_traits/libs/type_traits/test/can_call_post_increment_test.cpp | 261 +++++++++++++++++++++++++++++++++-
   sandbox/type_traits/libs/type_traits/test/can_call_postfix_operators.hpp | 6
   sandbox/type_traits/libs/type_traits/test/can_call_pre_decrement_test.cpp | 261 +++++++++++++++++++++++++++++++++-
   sandbox/type_traits/libs/type_traits/test/can_call_pre_increment_test.cpp | 261 +++++++++++++++++++++++++++++++++-
   sandbox/type_traits/libs/type_traits/test/can_call_prefix_operators.hpp | 6
   sandbox/type_traits/libs/type_traits/test/can_call_right_shift_assignment_test.cpp | 261 +++++++++++++++++++++++++++++++++-
   sandbox/type_traits/libs/type_traits/test/can_call_right_shift_test.cpp | 296 +++++++++++++++++++++++++++++++++++---
   sandbox/type_traits/libs/type_traits/test/can_call_subtraction_assignment_test.cpp | 261 +++++++++++++++++++++++++++++++++-
   sandbox/type_traits/libs/type_traits/test/can_call_subtraction_test.cpp | 261 +++++++++++++++++++++++++++++++++-
   sandbox/type_traits/libs/type_traits/test/can_call_unary_minus_test.cpp | 261 +++++++++++++++++++++++++++++++++-
   sandbox/type_traits/libs/type_traits/test/can_call_unary_plus_test.cpp | 261 +++++++++++++++++++++++++++++++++-
   72 files changed, 9750 insertions(+), 613 deletions(-)

Modified: sandbox/type_traits/boost/type_traits/can_call_addition.hpp
==============================================================================
--- sandbox/type_traits/boost/type_traits/can_call_addition.hpp (original)
+++ sandbox/type_traits/boost/type_traits/can_call_addition.hpp 2011-07-09 16:29:47 EDT (Sat, 09 Jul 2011)
@@ -13,32 +13,34 @@
 #define BOOST_TT_TRAIT_OP +
 #define BOOST_TT_FORBIDDEN_IF\
    ::boost::type_traits::ice_or<\
- /* pointer with pointer */\
+ /* Lhs==pointer and Rhs==pointer */\
       ::boost::type_traits::ice_and<\
          ::boost::is_pointer< Lhs_noref >::value,\
          ::boost::is_pointer< Rhs_noref >::value\
>::value,\
- /* pointer with fundamental non integral */\
+ /* Lhs==void* and Rhs==fundamental */\
       ::boost::type_traits::ice_and<\
          ::boost::is_pointer< Lhs_noref >::value,\
- ::boost::is_fundamental< Rhs_nocv >::value,\
- ::boost::type_traits::ice_not< ::boost::is_integral< Rhs_noref >::value >::value\
+ ::boost::is_void< Lhs_noptr >::value,\
+ ::boost::is_fundamental< Rhs_nocv >::value\
>::value,\
+ /* Rhs==void* and Lhs==fundamental */\
       ::boost::type_traits::ice_and<\
          ::boost::is_pointer< Rhs_noref >::value,\
- ::boost::is_fundamental< Lhs_nocv >::value,\
- ::boost::type_traits::ice_not< ::boost::is_integral< Lhs_noref >::value >::value\
+ ::boost::is_void< Rhs_noptr >::value,\
+ ::boost::is_fundamental< Lhs_nocv >::value\
>::value,\
- /* void* with fundamental */\
+ /* Lhs==pointer and Rhs==fundamental and Rhs!=integral */\
       ::boost::type_traits::ice_and<\
          ::boost::is_pointer< Lhs_noref >::value,\
- ::boost::is_void< Lhs_noptr >::value,\
- ::boost::is_fundamental< Rhs_nocv >::value\
+ ::boost::is_fundamental< Rhs_nocv >::value,\
+ ::boost::type_traits::ice_not< ::boost::is_integral< Rhs_noref >::value >::value\
>::value,\
+ /* Rhs==pointer and Lhs==fundamental and Lhs!=integral */\
       ::boost::type_traits::ice_and<\
          ::boost::is_pointer< Rhs_noref >::value,\
- ::boost::is_void< Rhs_noptr >::value,\
- ::boost::is_fundamental< Lhs_nocv >::value\
+ ::boost::is_fundamental< Lhs_nocv >::value,\
+ ::boost::type_traits::ice_not< ::boost::is_integral< Lhs_noref >::value >::value\
>::value\
>::value
 

Modified: sandbox/type_traits/boost/type_traits/can_call_addition_assignment.hpp
==============================================================================
--- sandbox/type_traits/boost/type_traits/can_call_addition_assignment.hpp (original)
+++ sandbox/type_traits/boost/type_traits/can_call_addition_assignment.hpp 2011-07-09 16:29:47 EDT (Sat, 09 Jul 2011)
@@ -13,39 +13,46 @@
 #define BOOST_TT_TRAIT_OP +=
 #define BOOST_TT_FORBIDDEN_IF\
    ::boost::type_traits::ice_or<\
- /* LHS is fundamental and const, RHS is fundamental */\
- ::boost::type_traits::ice_and<\
- ::boost::is_fundamental< Lhs_nocv >::value,\
- ::boost::is_const< Lhs_noref >::value,\
- ::boost::is_fundamental< Rhs_nocv >::value\
- >::value,\
- /* two pointers */\
+ /* Lhs==pointer and Rhs==pointer */\
       ::boost::type_traits::ice_and<\
          ::boost::is_pointer< Lhs_noref >::value,\
          ::boost::is_pointer< Rhs_noref >::value\
>::value,\
- /* void* with fundamental */\
+ /* Lhs==void* and Rhs==fundamental */\
       ::boost::type_traits::ice_and<\
          ::boost::is_pointer< Lhs_noref >::value,\
          ::boost::is_void< Lhs_noptr >::value,\
          ::boost::is_fundamental< Rhs_nocv >::value\
>::value,\
+ /* Rhs==void* and Lhs==fundamental */\
       ::boost::type_traits::ice_and<\
          ::boost::is_pointer< Rhs_noref >::value,\
          ::boost::is_void< Rhs_noptr >::value,\
          ::boost::is_fundamental< Lhs_nocv >::value\
>::value,\
- /* LHS==pointer and RHS==fundamental non integral */\
+ /* Lhs==pointer and Rhs==fundamental and Rhs!=integral */\
       ::boost::type_traits::ice_and<\
          ::boost::is_pointer< Lhs_noref >::value,\
          ::boost::is_fundamental< Rhs_nocv >::value,\
          ::boost::type_traits::ice_not< ::boost::is_integral< Rhs_noref >::value >::value\
>::value,\
- /* LHS==non bool fundamental and RHS==pointer */\
+ /* Rhs==pointer and Lhs==fundamental and Lhs!=bool */\
       ::boost::type_traits::ice_and<\
+ ::boost::is_pointer< Rhs_noref >::value,\
          ::boost::is_fundamental< Lhs_nocv >::value,\
- ::boost::type_traits::ice_not< ::boost::is_same< bool, Lhs_nocv >::value >::value,\
- ::boost::is_pointer< Rhs_noref >::value\
+ ::boost::type_traits::ice_not< ::boost::is_same< Lhs_nocv, bool >::value >::value\
+ >::value,\
+ /* (Lhs==fundamental or Lhs==pointer) and (Rhs==fundamental or Rhs==pointer) and (Lhs==const) */\
+ ::boost::type_traits::ice_and<\
+ ::boost::type_traits::ice_or<\
+ ::boost::is_fundamental< Lhs_nocv >::value,\
+ ::boost::is_pointer< Lhs_noref >::value\
+ >::value,\
+ ::boost::type_traits::ice_or<\
+ ::boost::is_fundamental< Rhs_nocv >::value,\
+ ::boost::is_pointer< Rhs_noref >::value\
+ >::value,\
+ ::boost::is_const< Lhs_noref >::value\
>::value\
>::value
 

Modified: sandbox/type_traits/boost/type_traits/can_call_bitwise_and.hpp
==============================================================================
--- sandbox/type_traits/boost/type_traits/can_call_bitwise_and.hpp (original)
+++ sandbox/type_traits/boost/type_traits/can_call_bitwise_and.hpp 2011-07-09 16:29:47 EDT (Sat, 09 Jul 2011)
@@ -13,7 +13,7 @@
 #define BOOST_TT_TRAIT_OP &
 #define BOOST_TT_FORBIDDEN_IF\
    ::boost::type_traits::ice_or<\
- /* two fundamental, one non integral */\
+ /* Lhs==fundamental and Rhs==fundamental and (Lhs!=integral or Rhs!=integral) */\
       ::boost::type_traits::ice_and<\
          ::boost::is_fundamental< Lhs_nocv >::value,\
          ::boost::is_fundamental< Rhs_nocv >::value,\
@@ -22,18 +22,17 @@
             ::boost::type_traits::ice_not< ::boost::is_integral< Rhs_noref >::value >::value\
>::value\
>::value,\
- /* one fundamental, one pointer */\
- ::boost::type_traits::ice_or<\
- ::boost::type_traits::ice_and<\
- ::boost::is_fundamental< Lhs_nocv >::value,\
- ::boost::is_pointer< Rhs_noref >::value\
- >::value,\
- ::boost::type_traits::ice_and<\
- ::boost::is_fundamental< Rhs_nocv >::value,\
- ::boost::is_pointer< Lhs_noref >::value\
- >::value\
+ /* Lhs==fundamental and Rhs==pointer */\
+ ::boost::type_traits::ice_and<\
+ ::boost::is_fundamental< Lhs_nocv >::value,\
+ ::boost::is_pointer< Rhs_noref >::value\
+ >::value,\
+ /* Rhs==fundamental and Lhs==pointer */\
+ ::boost::type_traits::ice_and<\
+ ::boost::is_fundamental< Rhs_nocv >::value,\
+ ::boost::is_pointer< Lhs_noref >::value\
>::value,\
- /* two pointers */\
+ /* Lhs==pointer and Rhs==pointer */\
       ::boost::type_traits::ice_and<\
          ::boost::is_pointer< Lhs_noref >::value,\
          ::boost::is_pointer< Rhs_noref >::value\

Modified: sandbox/type_traits/boost/type_traits/can_call_bitwise_and_assignment.hpp
==============================================================================
--- sandbox/type_traits/boost/type_traits/can_call_bitwise_and_assignment.hpp (original)
+++ sandbox/type_traits/boost/type_traits/can_call_bitwise_and_assignment.hpp 2011-07-09 16:29:47 EDT (Sat, 09 Jul 2011)
@@ -13,31 +13,35 @@
 #define BOOST_TT_TRAIT_OP &=
 #define BOOST_TT_FORBIDDEN_IF\
    ::boost::type_traits::ice_or<\
- /* two fundamental, one non integral or lhs is const*/\
+ /* Lhs==fundamental and Rhs==fundamental and (Lhs!=integral or Rhs!=integral) */\
       ::boost::type_traits::ice_and<\
          ::boost::is_fundamental< Lhs_nocv >::value,\
          ::boost::is_fundamental< Rhs_nocv >::value,\
          ::boost::type_traits::ice_or<\
             ::boost::type_traits::ice_not< ::boost::is_integral< Lhs_noref >::value >::value,\
- ::boost::type_traits::ice_not< ::boost::is_integral< Rhs_noref >::value >::value,\
- ::boost::is_const< Lhs_noref >::value\
+ ::boost::type_traits::ice_not< ::boost::is_integral< Rhs_noref >::value >::value\
>::value\
>::value,\
- /* one fundamental, one pointer */\
- ::boost::type_traits::ice_or<\
- ::boost::type_traits::ice_and<\
- ::boost::is_fundamental< Lhs_nocv >::value,\
- ::boost::is_pointer< Rhs_noref >::value\
- >::value,\
- ::boost::type_traits::ice_and<\
- ::boost::is_fundamental< Rhs_nocv >::value,\
- ::boost::is_pointer< Lhs_noref >::value\
- >::value\
+ /* Lhs==fundamental and Rhs==pointer */\
+ ::boost::type_traits::ice_and<\
+ ::boost::is_fundamental< Lhs_nocv >::value,\
+ ::boost::is_pointer< Rhs_noref >::value\
>::value,\
- /* two pointers */\
+ /* Rhs==fundamental and Lhs==pointer */\
+ ::boost::type_traits::ice_and<\
+ ::boost::is_fundamental< Rhs_nocv >::value,\
+ ::boost::is_pointer< Lhs_noref >::value\
+ >::value,\
+ /* Lhs==pointer and Rhs==pointer */\
       ::boost::type_traits::ice_and<\
          ::boost::is_pointer< Lhs_noref >::value,\
          ::boost::is_pointer< Rhs_noref >::value\
+ >::value,\
+ /* Lhs==fundamental and Rhs==fundamental and Lhs==const */\
+ ::boost::type_traits::ice_and<\
+ ::boost::is_fundamental< Lhs_nocv >::value,\
+ ::boost::is_fundamental< Rhs_nocv >::value,\
+ ::boost::is_const< Lhs_noref >::value\
>::value\
>::value
 

Modified: sandbox/type_traits/boost/type_traits/can_call_bitwise_or.hpp
==============================================================================
--- sandbox/type_traits/boost/type_traits/can_call_bitwise_or.hpp (original)
+++ sandbox/type_traits/boost/type_traits/can_call_bitwise_or.hpp 2011-07-09 16:29:47 EDT (Sat, 09 Jul 2011)
@@ -13,7 +13,7 @@
 #define BOOST_TT_TRAIT_OP |
 #define BOOST_TT_FORBIDDEN_IF\
    ::boost::type_traits::ice_or<\
- /* two fundamental, one non integral */\
+ /* Lhs==fundamental and Rhs==fundamental and (Lhs!=integral or Rhs!=integral) */\
       ::boost::type_traits::ice_and<\
          ::boost::is_fundamental< Lhs_nocv >::value,\
          ::boost::is_fundamental< Rhs_nocv >::value,\
@@ -22,18 +22,17 @@
             ::boost::type_traits::ice_not< ::boost::is_integral< Rhs_noref >::value >::value\
>::value\
>::value,\
- /* one fundamental, one pointer */\
- ::boost::type_traits::ice_or<\
- ::boost::type_traits::ice_and<\
- ::boost::is_fundamental< Lhs_nocv >::value,\
- ::boost::is_pointer< Rhs_noref >::value\
- >::value,\
- ::boost::type_traits::ice_and<\
- ::boost::is_fundamental< Rhs_nocv >::value,\
- ::boost::is_pointer< Lhs_noref >::value\
- >::value\
+ /* Lhs==fundamental and Rhs==pointer */\
+ ::boost::type_traits::ice_and<\
+ ::boost::is_fundamental< Lhs_nocv >::value,\
+ ::boost::is_pointer< Rhs_noref >::value\
+ >::value,\
+ /* Rhs==fundamental and Lhs==pointer */\
+ ::boost::type_traits::ice_and<\
+ ::boost::is_fundamental< Rhs_nocv >::value,\
+ ::boost::is_pointer< Lhs_noref >::value\
>::value,\
- /* two pointers */\
+ /* Lhs==pointer and Rhs==pointer */\
       ::boost::type_traits::ice_and<\
          ::boost::is_pointer< Lhs_noref >::value,\
          ::boost::is_pointer< Rhs_noref >::value\

Modified: sandbox/type_traits/boost/type_traits/can_call_bitwise_or_assignment.hpp
==============================================================================
--- sandbox/type_traits/boost/type_traits/can_call_bitwise_or_assignment.hpp (original)
+++ sandbox/type_traits/boost/type_traits/can_call_bitwise_or_assignment.hpp 2011-07-09 16:29:47 EDT (Sat, 09 Jul 2011)
@@ -13,31 +13,35 @@
 #define BOOST_TT_TRAIT_OP |=
 #define BOOST_TT_FORBIDDEN_IF\
    ::boost::type_traits::ice_or<\
- /* two fundamental, one non integral or lhs is const*/\
+ /* Lhs==fundamental and Rhs==fundamental and (Lhs!=integral or Rhs!=integral) */\
       ::boost::type_traits::ice_and<\
          ::boost::is_fundamental< Lhs_nocv >::value,\
          ::boost::is_fundamental< Rhs_nocv >::value,\
          ::boost::type_traits::ice_or<\
             ::boost::type_traits::ice_not< ::boost::is_integral< Lhs_noref >::value >::value,\
- ::boost::type_traits::ice_not< ::boost::is_integral< Rhs_noref >::value >::value,\
- ::boost::is_const< Lhs_noref >::value\
+ ::boost::type_traits::ice_not< ::boost::is_integral< Rhs_noref >::value >::value\
>::value\
>::value,\
- /* one fundamental, one pointer */\
- ::boost::type_traits::ice_or<\
- ::boost::type_traits::ice_and<\
- ::boost::is_fundamental< Lhs_nocv >::value,\
- ::boost::is_pointer< Rhs_noref >::value\
- >::value,\
- ::boost::type_traits::ice_and<\
- ::boost::is_fundamental< Rhs_nocv >::value,\
- ::boost::is_pointer< Lhs_noref >::value\
- >::value\
+ /* Lhs==fundamental and Rhs==pointer */\
+ ::boost::type_traits::ice_and<\
+ ::boost::is_fundamental< Lhs_nocv >::value,\
+ ::boost::is_pointer< Rhs_noref >::value\
>::value,\
- /* two pointers */\
+ /* Rhs==fundamental and Lhs==pointer */\
+ ::boost::type_traits::ice_and<\
+ ::boost::is_fundamental< Rhs_nocv >::value,\
+ ::boost::is_pointer< Lhs_noref >::value\
+ >::value,\
+ /* Lhs==pointer and Rhs==pointer */\
       ::boost::type_traits::ice_and<\
          ::boost::is_pointer< Lhs_noref >::value,\
          ::boost::is_pointer< Rhs_noref >::value\
+ >::value,\
+ /* Lhs==fundamental and Rhs==fundamental and Lhs==const */\
+ ::boost::type_traits::ice_and<\
+ ::boost::is_fundamental< Lhs_nocv >::value,\
+ ::boost::is_fundamental< Rhs_nocv >::value,\
+ ::boost::is_const< Lhs_noref >::value\
>::value\
>::value
 

Modified: sandbox/type_traits/boost/type_traits/can_call_bitwise_xor.hpp
==============================================================================
--- sandbox/type_traits/boost/type_traits/can_call_bitwise_xor.hpp (original)
+++ sandbox/type_traits/boost/type_traits/can_call_bitwise_xor.hpp 2011-07-09 16:29:47 EDT (Sat, 09 Jul 2011)
@@ -13,7 +13,7 @@
 #define BOOST_TT_TRAIT_OP ^
 #define BOOST_TT_FORBIDDEN_IF\
    ::boost::type_traits::ice_or<\
- /* two fundamental, one non integral */\
+ /* Lhs==fundamental and Rhs==fundamental and (Lhs!=integral or Rhs!=integral) */\
       ::boost::type_traits::ice_and<\
          ::boost::is_fundamental< Lhs_nocv >::value,\
          ::boost::is_fundamental< Rhs_nocv >::value,\
@@ -22,18 +22,17 @@
             ::boost::type_traits::ice_not< ::boost::is_integral< Rhs_noref >::value >::value\
>::value\
>::value,\
- /* one fundamental, one pointer */\
- ::boost::type_traits::ice_or<\
- ::boost::type_traits::ice_and<\
- ::boost::is_fundamental< Lhs_nocv >::value,\
- ::boost::is_pointer< Rhs_noref >::value\
- >::value,\
- ::boost::type_traits::ice_and<\
- ::boost::is_fundamental< Rhs_nocv >::value,\
- ::boost::is_pointer< Lhs_noref >::value\
- >::value\
+ /* Lhs==fundamental and Rhs==pointer */\
+ ::boost::type_traits::ice_and<\
+ ::boost::is_fundamental< Lhs_nocv >::value,\
+ ::boost::is_pointer< Rhs_noref >::value\
+ >::value,\
+ /* Rhs==fundamental and Lhs==pointer */\
+ ::boost::type_traits::ice_and<\
+ ::boost::is_fundamental< Rhs_nocv >::value,\
+ ::boost::is_pointer< Lhs_noref >::value\
>::value,\
- /* two pointers */\
+ /* Lhs==pointer and Rhs==pointer */\
       ::boost::type_traits::ice_and<\
          ::boost::is_pointer< Lhs_noref >::value,\
          ::boost::is_pointer< Rhs_noref >::value\

Modified: sandbox/type_traits/boost/type_traits/can_call_bitwise_xor_assignment.hpp
==============================================================================
--- sandbox/type_traits/boost/type_traits/can_call_bitwise_xor_assignment.hpp (original)
+++ sandbox/type_traits/boost/type_traits/can_call_bitwise_xor_assignment.hpp 2011-07-09 16:29:47 EDT (Sat, 09 Jul 2011)
@@ -13,31 +13,35 @@
 #define BOOST_TT_TRAIT_OP ^=
 #define BOOST_TT_FORBIDDEN_IF\
    ::boost::type_traits::ice_or<\
- /* two fundamental, one non integral or lhs is const*/\
+ /* Lhs==fundamental and Rhs==fundamental and (Lhs!=integral or Rhs!=integral) */\
       ::boost::type_traits::ice_and<\
          ::boost::is_fundamental< Lhs_nocv >::value,\
          ::boost::is_fundamental< Rhs_nocv >::value,\
          ::boost::type_traits::ice_or<\
             ::boost::type_traits::ice_not< ::boost::is_integral< Lhs_noref >::value >::value,\
- ::boost::type_traits::ice_not< ::boost::is_integral< Rhs_noref >::value >::value,\
- ::boost::is_const< Lhs_noref >::value\
+ ::boost::type_traits::ice_not< ::boost::is_integral< Rhs_noref >::value >::value\
>::value\
>::value,\
- /* one fundamental, one pointer */\
- ::boost::type_traits::ice_or<\
- ::boost::type_traits::ice_and<\
- ::boost::is_fundamental< Lhs_nocv >::value,\
- ::boost::is_pointer< Rhs_noref >::value\
- >::value,\
- ::boost::type_traits::ice_and<\
- ::boost::is_fundamental< Rhs_nocv >::value,\
- ::boost::is_pointer< Lhs_noref >::value\
- >::value\
+ /* Lhs==fundamental and Rhs==pointer */\
+ ::boost::type_traits::ice_and<\
+ ::boost::is_fundamental< Lhs_nocv >::value,\
+ ::boost::is_pointer< Rhs_noref >::value\
>::value,\
- /* two pointers */\
+ /* Rhs==fundamental and Lhs==pointer */\
+ ::boost::type_traits::ice_and<\
+ ::boost::is_fundamental< Rhs_nocv >::value,\
+ ::boost::is_pointer< Lhs_noref >::value\
+ >::value,\
+ /* Lhs==pointer and Rhs==pointer */\
       ::boost::type_traits::ice_and<\
          ::boost::is_pointer< Lhs_noref >::value,\
          ::boost::is_pointer< Rhs_noref >::value\
+ >::value,\
+ /* Lhs==fundamental and Rhs==fundamental and Lhs==const */\
+ ::boost::type_traits::ice_and<\
+ ::boost::is_fundamental< Lhs_nocv >::value,\
+ ::boost::is_fundamental< Rhs_nocv >::value,\
+ ::boost::is_const< Lhs_noref >::value\
>::value\
>::value
 

Modified: sandbox/type_traits/boost/type_traits/can_call_division_assignment.hpp
==============================================================================
--- sandbox/type_traits/boost/type_traits/can_call_division_assignment.hpp (original)
+++ sandbox/type_traits/boost/type_traits/can_call_division_assignment.hpp 2011-07-09 16:29:47 EDT (Sat, 09 Jul 2011)
@@ -13,13 +13,13 @@
 #define BOOST_TT_TRAIT_OP /=
 #define BOOST_TT_FORBIDDEN_IF\
    ::boost::type_traits::ice_or<\
- /* LHS is fundamental and const, RHS is fundamental */\
+ /* Lhs==fundamental and Lhs==const and Rhs==fundamental */\
       ::boost::type_traits::ice_and<\
          ::boost::is_fundamental< Lhs_nocv >::value,\
          ::boost::is_const< Lhs_noref >::value,\
          ::boost::is_fundamental< Rhs_nocv >::value\
>::value,\
- /* pointer with pointer or fundamental */\
+ /* Lhs==pointer and (Rhs==fundamental or Rhs==pointer) */\
       ::boost::type_traits::ice_and<\
          ::boost::is_pointer< Lhs_noref >::value,\
          ::boost::type_traits::ice_or<\
@@ -27,6 +27,7 @@
             ::boost::is_pointer< Rhs_noref >::value\
>::value\
>::value,\
+ /* Rhs==pointer and (Lhs==fundamental or Lhs==pointer) */\
       ::boost::type_traits::ice_and<\
          ::boost::is_pointer< Rhs_noref >::value,\
          ::boost::type_traits::ice_or<\

Modified: sandbox/type_traits/boost/type_traits/can_call_equal.hpp
==============================================================================
--- sandbox/type_traits/boost/type_traits/can_call_equal.hpp (original)
+++ sandbox/type_traits/boost/type_traits/can_call_equal.hpp 2011-07-09 16:29:47 EDT (Sat, 09 Jul 2011)
@@ -13,16 +13,17 @@
 #define BOOST_TT_TRAIT_OP ==
 #define BOOST_TT_FORBIDDEN_IF\
    ::boost::type_traits::ice_or<\
- /* pointer and fundamental */\
+ /* Lhs==pointer and Rhs==fundamental */\
       ::boost::type_traits::ice_and<\
          ::boost::is_pointer< Lhs_noref >::value,\
          ::boost::is_fundamental< Rhs_nocv >::value\
>::value,\
+ /* Rhs==pointer and Lhs==fundamental */\
       ::boost::type_traits::ice_and<\
          ::boost::is_pointer< Rhs_noref >::value,\
          ::boost::is_fundamental< Lhs_nocv >::value\
>::value,\
- /* two pointers but no inheritance or no void* */\
+ /* Lhs==pointer and Rhs==pointer and Lhs!=base(Rhs) and Rhs!=base(Lhs) and Lhs!=void* and Rhs!=void* */\
       ::boost::type_traits::ice_and<\
          ::boost::is_pointer< Lhs_noref >::value,\
          ::boost::is_pointer< Rhs_noref >::value,\

Modified: sandbox/type_traits/boost/type_traits/can_call_greater.hpp
==============================================================================
--- sandbox/type_traits/boost/type_traits/can_call_greater.hpp (original)
+++ sandbox/type_traits/boost/type_traits/can_call_greater.hpp 2011-07-09 16:29:47 EDT (Sat, 09 Jul 2011)
@@ -13,16 +13,17 @@
 #define BOOST_TT_TRAIT_OP >
 #define BOOST_TT_FORBIDDEN_IF\
    ::boost::type_traits::ice_or<\
- /* pointer and fundamental */\
+ /* Lhs==pointer and Rhs==fundamental */\
       ::boost::type_traits::ice_and<\
          ::boost::is_pointer< Lhs_noref >::value,\
          ::boost::is_fundamental< Rhs_nocv >::value\
>::value,\
+ /* Rhs==pointer and Lhs==fundamental */\
       ::boost::type_traits::ice_and<\
          ::boost::is_pointer< Rhs_noref >::value,\
          ::boost::is_fundamental< Lhs_nocv >::value\
>::value,\
- /* two pointers but no inheritance or no void* */\
+ /* Lhs==pointer and Rhs==pointer and Lhs!=base(Rhs) and Rhs!=base(Lhs) and Lhs!=void* and Rhs!=void* */\
       ::boost::type_traits::ice_and<\
          ::boost::is_pointer< Lhs_noref >::value,\
          ::boost::is_pointer< Rhs_noref >::value,\

Modified: sandbox/type_traits/boost/type_traits/can_call_greater_equal.hpp
==============================================================================
--- sandbox/type_traits/boost/type_traits/can_call_greater_equal.hpp (original)
+++ sandbox/type_traits/boost/type_traits/can_call_greater_equal.hpp 2011-07-09 16:29:47 EDT (Sat, 09 Jul 2011)
@@ -13,16 +13,17 @@
 #define BOOST_TT_TRAIT_OP >=
 #define BOOST_TT_FORBIDDEN_IF\
    ::boost::type_traits::ice_or<\
- /* pointer and fundamental */\
+ /* Lhs==pointer and Rhs==fundamental */\
       ::boost::type_traits::ice_and<\
          ::boost::is_pointer< Lhs_noref >::value,\
          ::boost::is_fundamental< Rhs_nocv >::value\
>::value,\
+ /* Rhs==pointer and Lhs==fundamental */\
       ::boost::type_traits::ice_and<\
          ::boost::is_pointer< Rhs_noref >::value,\
          ::boost::is_fundamental< Lhs_nocv >::value\
>::value,\
- /* two pointers but no inheritance or no void* */\
+ /* Lhs==pointer and Rhs==pointer and Lhs!=base(Rhs) and Rhs!=base(Lhs) and Lhs!=void* and Rhs!=void* */\
       ::boost::type_traits::ice_and<\
          ::boost::is_pointer< Lhs_noref >::value,\
          ::boost::is_pointer< Rhs_noref >::value,\

Modified: sandbox/type_traits/boost/type_traits/can_call_left_shift.hpp
==============================================================================
--- sandbox/type_traits/boost/type_traits/can_call_left_shift.hpp (original)
+++ sandbox/type_traits/boost/type_traits/can_call_left_shift.hpp 2011-07-09 16:29:47 EDT (Sat, 09 Jul 2011)
@@ -13,7 +13,7 @@
 #define BOOST_TT_TRAIT_OP <<
 #define BOOST_TT_FORBIDDEN_IF\
    ::boost::type_traits::ice_or<\
- /* two fundamental, one non integral */\
+ /* Lhs==fundamental and Rhs==fundamental and (Lhs!=integral or Rhs!=integral) */\
       ::boost::type_traits::ice_and<\
          ::boost::is_fundamental< Lhs_nocv >::value,\
          ::boost::is_fundamental< Rhs_nocv >::value,\
@@ -22,18 +22,17 @@
             ::boost::type_traits::ice_not< ::boost::is_integral< Rhs_noref >::value >::value\
>::value\
>::value,\
- /* one fundamental, one pointer */\
- ::boost::type_traits::ice_or<\
- ::boost::type_traits::ice_and<\
- ::boost::is_fundamental< Lhs_nocv >::value,\
- ::boost::is_pointer< Rhs_noref >::value\
- >::value,\
- ::boost::type_traits::ice_and<\
- ::boost::is_fundamental< Rhs_nocv >::value,\
- ::boost::is_pointer< Lhs_noref >::value\
- >::value\
+ /* Lhs==fundamental and Rhs==pointer */\
+ ::boost::type_traits::ice_and<\
+ ::boost::is_fundamental< Lhs_nocv >::value,\
+ ::boost::is_pointer< Rhs_noref >::value\
+ >::value,\
+ /* Rhs==fundamental and Lhs==pointer */\
+ ::boost::type_traits::ice_and<\
+ ::boost::is_fundamental< Rhs_nocv >::value,\
+ ::boost::is_pointer< Lhs_noref >::value\
>::value,\
- /* two pointers */\
+ /* Lhs==pointer and Rhs==pointer */\
       ::boost::type_traits::ice_and<\
          ::boost::is_pointer< Lhs_noref >::value,\
          ::boost::is_pointer< Rhs_noref >::value\

Modified: sandbox/type_traits/boost/type_traits/can_call_left_shift_assignment.hpp
==============================================================================
--- sandbox/type_traits/boost/type_traits/can_call_left_shift_assignment.hpp (original)
+++ sandbox/type_traits/boost/type_traits/can_call_left_shift_assignment.hpp 2011-07-09 16:29:47 EDT (Sat, 09 Jul 2011)
@@ -13,31 +13,35 @@
 #define BOOST_TT_TRAIT_OP <<=
 #define BOOST_TT_FORBIDDEN_IF\
    ::boost::type_traits::ice_or<\
- /* two fundamental, one non integral or lhs is const*/\
+ /* Lhs==fundamental and Rhs==fundamental and (Lhs!=integral or Rhs!=integral) */\
       ::boost::type_traits::ice_and<\
          ::boost::is_fundamental< Lhs_nocv >::value,\
          ::boost::is_fundamental< Rhs_nocv >::value,\
          ::boost::type_traits::ice_or<\
             ::boost::type_traits::ice_not< ::boost::is_integral< Lhs_noref >::value >::value,\
- ::boost::type_traits::ice_not< ::boost::is_integral< Rhs_noref >::value >::value,\
- ::boost::is_const< Lhs_noref >::value\
+ ::boost::type_traits::ice_not< ::boost::is_integral< Rhs_noref >::value >::value\
>::value\
>::value,\
- /* one fundamental, one pointer */\
- ::boost::type_traits::ice_or<\
- ::boost::type_traits::ice_and<\
- ::boost::is_fundamental< Lhs_nocv >::value,\
- ::boost::is_pointer< Rhs_noref >::value\
- >::value,\
- ::boost::type_traits::ice_and<\
- ::boost::is_fundamental< Rhs_nocv >::value,\
- ::boost::is_pointer< Lhs_noref >::value\
- >::value\
+ /* Lhs==fundamental and Rhs==pointer */\
+ ::boost::type_traits::ice_and<\
+ ::boost::is_fundamental< Lhs_nocv >::value,\
+ ::boost::is_pointer< Rhs_noref >::value\
>::value,\
- /* two pointers */\
+ /* Rhs==fundamental and Lhs==pointer */\
+ ::boost::type_traits::ice_and<\
+ ::boost::is_fundamental< Rhs_nocv >::value,\
+ ::boost::is_pointer< Lhs_noref >::value\
+ >::value,\
+ /* Lhs==pointer and Rhs==pointer */\
       ::boost::type_traits::ice_and<\
          ::boost::is_pointer< Lhs_noref >::value,\
          ::boost::is_pointer< Rhs_noref >::value\
+ >::value,\
+ /* Lhs==fundamental and Rhs==fundamental and Lhs==const */\
+ ::boost::type_traits::ice_and<\
+ ::boost::is_fundamental< Lhs_nocv >::value,\
+ ::boost::is_fundamental< Rhs_nocv >::value,\
+ ::boost::is_const< Lhs_noref >::value\
>::value\
>::value
 

Modified: sandbox/type_traits/boost/type_traits/can_call_less.hpp
==============================================================================
--- sandbox/type_traits/boost/type_traits/can_call_less.hpp (original)
+++ sandbox/type_traits/boost/type_traits/can_call_less.hpp 2011-07-09 16:29:47 EDT (Sat, 09 Jul 2011)
@@ -13,16 +13,17 @@
 #define BOOST_TT_TRAIT_OP <
 #define BOOST_TT_FORBIDDEN_IF\
    ::boost::type_traits::ice_or<\
- /* pointer and fundamental */\
+ /* Lhs==pointer and Rhs==fundamental */\
       ::boost::type_traits::ice_and<\
          ::boost::is_pointer< Lhs_noref >::value,\
          ::boost::is_fundamental< Rhs_nocv >::value\
>::value,\
+ /* Rhs==pointer and Lhs==fundamental */\
       ::boost::type_traits::ice_and<\
          ::boost::is_pointer< Rhs_noref >::value,\
          ::boost::is_fundamental< Lhs_nocv >::value\
>::value,\
- /* two pointers but no inheritance or no void* */\
+ /* Lhs==pointer and Rhs==pointer and Lhs!=base(Rhs) and Rhs!=base(Lhs) and Lhs!=void* and Rhs!=void* */\
       ::boost::type_traits::ice_and<\
          ::boost::is_pointer< Lhs_noref >::value,\
          ::boost::is_pointer< Rhs_noref >::value,\

Modified: sandbox/type_traits/boost/type_traits/can_call_less_equal.hpp
==============================================================================
--- sandbox/type_traits/boost/type_traits/can_call_less_equal.hpp (original)
+++ sandbox/type_traits/boost/type_traits/can_call_less_equal.hpp 2011-07-09 16:29:47 EDT (Sat, 09 Jul 2011)
@@ -13,16 +13,17 @@
 #define BOOST_TT_TRAIT_OP <=
 #define BOOST_TT_FORBIDDEN_IF\
    ::boost::type_traits::ice_or<\
- /* pointer and fundamental */\
+ /* Lhs==pointer and Rhs==fundamental */\
       ::boost::type_traits::ice_and<\
          ::boost::is_pointer< Lhs_noref >::value,\
          ::boost::is_fundamental< Rhs_nocv >::value\
>::value,\
+ /* Rhs==pointer and Lhs==fundamental */\
       ::boost::type_traits::ice_and<\
          ::boost::is_pointer< Rhs_noref >::value,\
          ::boost::is_fundamental< Lhs_nocv >::value\
>::value,\
- /* two pointers but no inheritance or no void* */\
+ /* Lhs==pointer and Rhs==pointer and Lhs!=base(Rhs) and Rhs!=base(Lhs) and Lhs!=void* and Rhs!=void* */\
       ::boost::type_traits::ice_and<\
          ::boost::is_pointer< Lhs_noref >::value,\
          ::boost::is_pointer< Rhs_noref >::value,\

Modified: sandbox/type_traits/boost/type_traits/can_call_modulus.hpp
==============================================================================
--- sandbox/type_traits/boost/type_traits/can_call_modulus.hpp (original)
+++ sandbox/type_traits/boost/type_traits/can_call_modulus.hpp 2011-07-09 16:29:47 EDT (Sat, 09 Jul 2011)
@@ -13,7 +13,7 @@
 #define BOOST_TT_TRAIT_OP %
 #define BOOST_TT_FORBIDDEN_IF\
    ::boost::type_traits::ice_or<\
- /* two fundamental, one non integral */\
+ /* Lhs==fundamental and Rhs==fundamental and (Lhs!=integral or Rhs!=integral) */\
       ::boost::type_traits::ice_and<\
          ::boost::is_fundamental< Lhs_nocv >::value,\
          ::boost::is_fundamental< Rhs_nocv >::value,\
@@ -22,18 +22,17 @@
             ::boost::type_traits::ice_not< ::boost::is_integral< Rhs_noref >::value >::value\
>::value\
>::value,\
- /* one fundamental, one pointer */\
- ::boost::type_traits::ice_or<\
- ::boost::type_traits::ice_and<\
- ::boost::is_fundamental< Lhs_nocv >::value,\
- ::boost::is_pointer< Rhs_noref >::value\
- >::value,\
- ::boost::type_traits::ice_and<\
- ::boost::is_fundamental< Rhs_nocv >::value,\
- ::boost::is_pointer< Lhs_noref >::value\
- >::value\
+ /* Lhs==fundamental and Rhs==pointer */\
+ ::boost::type_traits::ice_and<\
+ ::boost::is_fundamental< Lhs_nocv >::value,\
+ ::boost::is_pointer< Rhs_noref >::value\
+ >::value,\
+ /* Rhs==fundamental and Lhs==pointer */\
+ ::boost::type_traits::ice_and<\
+ ::boost::is_fundamental< Rhs_nocv >::value,\
+ ::boost::is_pointer< Lhs_noref >::value\
>::value,\
- /* two pointers */\
+ /* Lhs==pointer and Rhs==pointer */\
       ::boost::type_traits::ice_and<\
          ::boost::is_pointer< Lhs_noref >::value,\
          ::boost::is_pointer< Rhs_noref >::value\

Modified: sandbox/type_traits/boost/type_traits/can_call_modulus_assignment.hpp
==============================================================================
--- sandbox/type_traits/boost/type_traits/can_call_modulus_assignment.hpp (original)
+++ sandbox/type_traits/boost/type_traits/can_call_modulus_assignment.hpp 2011-07-09 16:29:47 EDT (Sat, 09 Jul 2011)
@@ -13,31 +13,35 @@
 #define BOOST_TT_TRAIT_OP %=
 #define BOOST_TT_FORBIDDEN_IF\
    ::boost::type_traits::ice_or<\
- /* two fundamental, one non integral or lhs is const*/\
+ /* Lhs==fundamental and Rhs==fundamental and (Lhs!=integral or Rhs!=integral) */\
       ::boost::type_traits::ice_and<\
          ::boost::is_fundamental< Lhs_nocv >::value,\
          ::boost::is_fundamental< Rhs_nocv >::value,\
          ::boost::type_traits::ice_or<\
             ::boost::type_traits::ice_not< ::boost::is_integral< Lhs_noref >::value >::value,\
- ::boost::type_traits::ice_not< ::boost::is_integral< Rhs_noref >::value >::value,\
- ::boost::is_const< Lhs_noref >::value\
+ ::boost::type_traits::ice_not< ::boost::is_integral< Rhs_noref >::value >::value\
>::value\
>::value,\
- /* one fundamental, one pointer */\
- ::boost::type_traits::ice_or<\
- ::boost::type_traits::ice_and<\
- ::boost::is_fundamental< Lhs_nocv >::value,\
- ::boost::is_pointer< Rhs_noref >::value\
- >::value,\
- ::boost::type_traits::ice_and<\
- ::boost::is_fundamental< Rhs_nocv >::value,\
- ::boost::is_pointer< Lhs_noref >::value\
- >::value\
+ /* Lhs==fundamental and Rhs==pointer */\
+ ::boost::type_traits::ice_and<\
+ ::boost::is_fundamental< Lhs_nocv >::value,\
+ ::boost::is_pointer< Rhs_noref >::value\
>::value,\
- /* two pointers */\
+ /* Rhs==fundamental and Lhs==pointer */\
+ ::boost::type_traits::ice_and<\
+ ::boost::is_fundamental< Rhs_nocv >::value,\
+ ::boost::is_pointer< Lhs_noref >::value\
+ >::value,\
+ /* Lhs==pointer and Rhs==pointer */\
       ::boost::type_traits::ice_and<\
          ::boost::is_pointer< Lhs_noref >::value,\
          ::boost::is_pointer< Rhs_noref >::value\
+ >::value,\
+ /* Lhs==fundamental and Rhs==fundamental and Lhs==const */\
+ ::boost::type_traits::ice_and<\
+ ::boost::is_fundamental< Lhs_nocv >::value,\
+ ::boost::is_fundamental< Rhs_nocv >::value,\
+ ::boost::is_const< Lhs_noref >::value\
>::value\
>::value
 

Modified: sandbox/type_traits/boost/type_traits/can_call_multiplication_assignment.hpp
==============================================================================
--- sandbox/type_traits/boost/type_traits/can_call_multiplication_assignment.hpp (original)
+++ sandbox/type_traits/boost/type_traits/can_call_multiplication_assignment.hpp 2011-07-09 16:29:47 EDT (Sat, 09 Jul 2011)
@@ -13,13 +13,13 @@
 #define BOOST_TT_TRAIT_OP *=
 #define BOOST_TT_FORBIDDEN_IF\
    ::boost::type_traits::ice_or<\
- /* LHS is fundamental and const, RHS is fundamental */\
+ /* Lhs==fundamental and Lhs==const and Rhs==fundamental */\
       ::boost::type_traits::ice_and<\
          ::boost::is_fundamental< Lhs_nocv >::value,\
          ::boost::is_const< Lhs_noref >::value,\
          ::boost::is_fundamental< Rhs_nocv >::value\
>::value,\
- /* pointer with pointer or fundamental */\
+ /* Lhs==pointer and (Rhs==fundamental or Rhs==pointer) */\
       ::boost::type_traits::ice_and<\
          ::boost::is_pointer< Lhs_noref >::value,\
          ::boost::type_traits::ice_or<\
@@ -27,6 +27,7 @@
             ::boost::is_pointer< Rhs_noref >::value\
>::value\
>::value,\
+ /* Rhs==pointer and (Lhs==fundamental or Lhs==pointer) */\
       ::boost::type_traits::ice_and<\
          ::boost::is_pointer< Rhs_noref >::value,\
          ::boost::type_traits::ice_or<\

Modified: sandbox/type_traits/boost/type_traits/can_call_not_equal.hpp
==============================================================================
--- sandbox/type_traits/boost/type_traits/can_call_not_equal.hpp (original)
+++ sandbox/type_traits/boost/type_traits/can_call_not_equal.hpp 2011-07-09 16:29:47 EDT (Sat, 09 Jul 2011)
@@ -13,16 +13,17 @@
 #define BOOST_TT_TRAIT_OP !=
 #define BOOST_TT_FORBIDDEN_IF\
    ::boost::type_traits::ice_or<\
- /* pointer and fundamental */\
+ /* Lhs==pointer and Rhs==fundamental */\
       ::boost::type_traits::ice_and<\
          ::boost::is_pointer< Lhs_noref >::value,\
          ::boost::is_fundamental< Rhs_nocv >::value\
>::value,\
+ /* Rhs==pointer and Lhs==fundamental */\
       ::boost::type_traits::ice_and<\
          ::boost::is_pointer< Rhs_noref >::value,\
          ::boost::is_fundamental< Lhs_nocv >::value\
>::value,\
- /* two pointers but no inheritance or no void* */\
+ /* Lhs==pointer and Rhs==pointer and Lhs!=base(Rhs) and Rhs!=base(Lhs) and Lhs!=void* and Rhs!=void* */\
       ::boost::type_traits::ice_and<\
          ::boost::is_pointer< Lhs_noref >::value,\
          ::boost::is_pointer< Rhs_noref >::value,\

Modified: sandbox/type_traits/boost/type_traits/can_call_post_decrement.hpp
==============================================================================
--- sandbox/type_traits/boost/type_traits/can_call_post_decrement.hpp (original)
+++ sandbox/type_traits/boost/type_traits/can_call_post_decrement.hpp 2011-07-09 16:29:47 EDT (Sat, 09 Jul 2011)
@@ -12,17 +12,22 @@
 #define BOOST_TT_TRAIT_NAME can_call_post_decrement
 #define BOOST_TT_TRAIT_OP --
 #define BOOST_TT_FORBIDDEN_IF\
- /* bool or void* or const fundamental */\
    ::boost::type_traits::ice_or<\
+ /* bool */\
       ::boost::is_same< bool, Lhs_nocv >::value,\
+ /* void* */\
       ::boost::type_traits::ice_and<\
          ::boost::is_pointer< Lhs_noref >::value,\
          ::boost::is_void< Lhs_noptr >::value\
>::value,\
+ /* (fundamental or pointer) and const */\
       ::boost::type_traits::ice_and<\
- ::boost::is_fundamental< Lhs_nocv >::value,\
+ ::boost::type_traits::ice_or<\
+ ::boost::is_fundamental< Lhs_nocv >::value,\
+ ::boost::is_pointer< Lhs_noref >::value\
+ >::value,\
          ::boost::is_const< Lhs_noref >::value\
- >::value\
+ >::value\
>::value
 
 

Modified: sandbox/type_traits/boost/type_traits/can_call_post_increment.hpp
==============================================================================
--- sandbox/type_traits/boost/type_traits/can_call_post_increment.hpp (original)
+++ sandbox/type_traits/boost/type_traits/can_call_post_increment.hpp 2011-07-09 16:29:47 EDT (Sat, 09 Jul 2011)
@@ -12,16 +12,20 @@
 #define BOOST_TT_TRAIT_NAME can_call_post_increment
 #define BOOST_TT_TRAIT_OP ++
 #define BOOST_TT_FORBIDDEN_IF\
- /* void* or const fundamental */\
    ::boost::type_traits::ice_or<\
+ /* void* */\
       ::boost::type_traits::ice_and<\
          ::boost::is_pointer< Lhs_noref >::value,\
          ::boost::is_void< Lhs_noptr >::value\
>::value,\
+ /* (fundamental or pointer) and const */\
       ::boost::type_traits::ice_and<\
- ::boost::is_fundamental< Lhs_nocv >::value,\
+ ::boost::type_traits::ice_or<\
+ ::boost::is_fundamental< Lhs_nocv >::value,\
+ ::boost::is_pointer< Lhs_noref >::value\
+ >::value,\
          ::boost::is_const< Lhs_noref >::value\
- >::value\
+ >::value\
>::value
 
 

Modified: sandbox/type_traits/boost/type_traits/can_call_pre_decrement.hpp
==============================================================================
--- sandbox/type_traits/boost/type_traits/can_call_pre_decrement.hpp (original)
+++ sandbox/type_traits/boost/type_traits/can_call_pre_decrement.hpp 2011-07-09 16:29:47 EDT (Sat, 09 Jul 2011)
@@ -12,17 +12,22 @@
 #define BOOST_TT_TRAIT_NAME can_call_pre_decrement
 #define BOOST_TT_TRAIT_OP --
 #define BOOST_TT_FORBIDDEN_IF\
- /* bool or void* or const fundamental */\
    ::boost::type_traits::ice_or<\
+ /* bool */\
       ::boost::is_same< bool, Rhs_nocv >::value,\
+ /* void* */\
       ::boost::type_traits::ice_and<\
          ::boost::is_pointer< Rhs_noref >::value,\
          ::boost::is_void< Rhs_noptr >::value\
>::value,\
+ /* (fundamental or pointer) and const */\
       ::boost::type_traits::ice_and<\
- ::boost::is_fundamental< Rhs_nocv >::value,\
+ ::boost::type_traits::ice_or<\
+ ::boost::is_fundamental< Rhs_nocv >::value,\
+ ::boost::is_pointer< Rhs_noref >::value\
+ >::value,\
          ::boost::is_const< Rhs_noref >::value\
- >::value\
+ >::value\
>::value
 
 

Modified: sandbox/type_traits/boost/type_traits/can_call_pre_increment.hpp
==============================================================================
--- sandbox/type_traits/boost/type_traits/can_call_pre_increment.hpp (original)
+++ sandbox/type_traits/boost/type_traits/can_call_pre_increment.hpp 2011-07-09 16:29:47 EDT (Sat, 09 Jul 2011)
@@ -12,16 +12,20 @@
 #define BOOST_TT_TRAIT_NAME can_call_pre_increment
 #define BOOST_TT_TRAIT_OP ++
 #define BOOST_TT_FORBIDDEN_IF\
- /* void* or const fundamental */\
    ::boost::type_traits::ice_or<\
+ /* void* */\
       ::boost::type_traits::ice_and<\
          ::boost::is_pointer< Rhs_noref >::value,\
          ::boost::is_void< Rhs_noptr >::value\
>::value,\
+ /* (fundamental or pointer) and const */\
       ::boost::type_traits::ice_and<\
- ::boost::is_fundamental< Rhs_nocv >::value,\
+ ::boost::type_traits::ice_or<\
+ ::boost::is_fundamental< Rhs_nocv >::value,\
+ ::boost::is_pointer< Rhs_noref >::value\
+ >::value,\
          ::boost::is_const< Rhs_noref >::value\
- >::value\
+ >::value\
>::value
 
 

Modified: sandbox/type_traits/boost/type_traits/can_call_right_shift.hpp
==============================================================================
--- sandbox/type_traits/boost/type_traits/can_call_right_shift.hpp (original)
+++ sandbox/type_traits/boost/type_traits/can_call_right_shift.hpp 2011-07-09 16:29:47 EDT (Sat, 09 Jul 2011)
@@ -13,7 +13,7 @@
 #define BOOST_TT_TRAIT_OP >>
 #define BOOST_TT_FORBIDDEN_IF\
    ::boost::type_traits::ice_or<\
- /* two fundamental, one non integral */\
+ /* Lhs==fundamental and Rhs==fundamental and (Lhs!=integral or Rhs!=integral) */\
       ::boost::type_traits::ice_and<\
          ::boost::is_fundamental< Lhs_nocv >::value,\
          ::boost::is_fundamental< Rhs_nocv >::value,\
@@ -22,18 +22,17 @@
             ::boost::type_traits::ice_not< ::boost::is_integral< Rhs_noref >::value >::value\
>::value\
>::value,\
- /* one fundamental, one pointer */\
- ::boost::type_traits::ice_or<\
- ::boost::type_traits::ice_and<\
- ::boost::is_fundamental< Lhs_nocv >::value,\
- ::boost::is_pointer< Rhs_noref >::value\
- >::value,\
- ::boost::type_traits::ice_and<\
- ::boost::is_fundamental< Rhs_nocv >::value,\
- ::boost::is_pointer< Lhs_noref >::value\
- >::value\
+ /* Lhs==fundamental and Rhs==pointer */\
+ ::boost::type_traits::ice_and<\
+ ::boost::is_fundamental< Lhs_nocv >::value,\
+ ::boost::is_pointer< Rhs_noref >::value\
+ >::value,\
+ /* Rhs==fundamental and Lhs==pointer */\
+ ::boost::type_traits::ice_and<\
+ ::boost::is_fundamental< Rhs_nocv >::value,\
+ ::boost::is_pointer< Lhs_noref >::value\
>::value,\
- /* two pointers */\
+ /* Lhs==pointer and Rhs==pointer */\
       ::boost::type_traits::ice_and<\
          ::boost::is_pointer< Lhs_noref >::value,\
          ::boost::is_pointer< Rhs_noref >::value\

Modified: sandbox/type_traits/boost/type_traits/can_call_right_shift_assignment.hpp
==============================================================================
--- sandbox/type_traits/boost/type_traits/can_call_right_shift_assignment.hpp (original)
+++ sandbox/type_traits/boost/type_traits/can_call_right_shift_assignment.hpp 2011-07-09 16:29:47 EDT (Sat, 09 Jul 2011)
@@ -13,31 +13,35 @@
 #define BOOST_TT_TRAIT_OP >>=
 #define BOOST_TT_FORBIDDEN_IF\
    ::boost::type_traits::ice_or<\
- /* two fundamental, one non integral or lhs is const*/\
+ /* Lhs==fundamental and Rhs==fundamental and (Lhs!=integral or Rhs!=integral) */\
       ::boost::type_traits::ice_and<\
          ::boost::is_fundamental< Lhs_nocv >::value,\
          ::boost::is_fundamental< Rhs_nocv >::value,\
          ::boost::type_traits::ice_or<\
             ::boost::type_traits::ice_not< ::boost::is_integral< Lhs_noref >::value >::value,\
- ::boost::type_traits::ice_not< ::boost::is_integral< Rhs_noref >::value >::value,\
- ::boost::is_const< Lhs_noref >::value\
+ ::boost::type_traits::ice_not< ::boost::is_integral< Rhs_noref >::value >::value\
>::value\
>::value,\
- /* one fundamental, one pointer */\
- ::boost::type_traits::ice_or<\
- ::boost::type_traits::ice_and<\
- ::boost::is_fundamental< Lhs_nocv >::value,\
- ::boost::is_pointer< Rhs_noref >::value\
- >::value,\
- ::boost::type_traits::ice_and<\
- ::boost::is_fundamental< Rhs_nocv >::value,\
- ::boost::is_pointer< Lhs_noref >::value\
- >::value\
+ /* Lhs==fundamental and Rhs==pointer */\
+ ::boost::type_traits::ice_and<\
+ ::boost::is_fundamental< Lhs_nocv >::value,\
+ ::boost::is_pointer< Rhs_noref >::value\
>::value,\
- /* two pointers */\
+ /* Rhs==fundamental and Lhs==pointer */\
+ ::boost::type_traits::ice_and<\
+ ::boost::is_fundamental< Rhs_nocv >::value,\
+ ::boost::is_pointer< Lhs_noref >::value\
+ >::value,\
+ /* Lhs==pointer and Rhs==pointer */\
       ::boost::type_traits::ice_and<\
          ::boost::is_pointer< Lhs_noref >::value,\
          ::boost::is_pointer< Rhs_noref >::value\
+ >::value,\
+ /* Lhs==fundamental and Rhs==fundamental and Lhs==const */\
+ ::boost::type_traits::ice_and<\
+ ::boost::is_fundamental< Lhs_nocv >::value,\
+ ::boost::is_fundamental< Rhs_nocv >::value,\
+ ::boost::is_const< Lhs_noref >::value\
>::value\
>::value
 

Modified: sandbox/type_traits/boost/type_traits/can_call_subtraction.hpp
==============================================================================
--- sandbox/type_traits/boost/type_traits/can_call_subtraction.hpp (original)
+++ sandbox/type_traits/boost/type_traits/can_call_subtraction.hpp 2011-07-09 16:29:47 EDT (Sat, 09 Jul 2011)
@@ -13,7 +13,13 @@
 #define BOOST_TT_TRAIT_OP -
 #define BOOST_TT_FORBIDDEN_IF\
    ::boost::type_traits::ice_or<\
- /* void* with fundamental or pointer */\
+ /* Lhs==pointer and Rhs==fundamental and Rhs!=integral */\
+ ::boost::type_traits::ice_and<\
+ ::boost::is_pointer< Lhs_noref >::value,\
+ ::boost::is_fundamental< Rhs_nocv >::value,\
+ ::boost::type_traits::ice_not< ::boost::is_integral< Rhs_noref >::value >::value\
+ >::value,\
+ /* Lhs==void* and (Rhs==fundamental or Rhs==pointer) */\
       ::boost::type_traits::ice_and<\
          ::boost::is_pointer< Lhs_noref >::value,\
          ::boost::is_void< Lhs_noptr >::value,\
@@ -22,6 +28,7 @@
             ::boost::is_pointer< Rhs_noref >::value\
>::value\
>::value,\
+ /* Rhs==void* and (Lhs==fundamental or Lhs==pointer) */\
       ::boost::type_traits::ice_and<\
          ::boost::is_pointer< Rhs_noref >::value,\
          ::boost::is_void< Rhs_noptr >::value,\
@@ -30,14 +37,7 @@
             ::boost::is_pointer< Lhs_noref >::value\
>::value\
>::value,\
- /* LHS==pointer!=void* and RHS==fundamental non integral */\
- ::boost::type_traits::ice_and<\
- ::boost::is_pointer< Lhs_noref >::value,\
- ::boost::type_traits::ice_not< ::boost::is_void< Lhs_noptr >::value >::value,\
- ::boost::is_fundamental< Rhs_nocv >::value,\
- ::boost::type_traits::ice_not< ::boost::is_integral< Rhs_noref >::value >::value\
- >::value,\
- /* LHS=fundamental and RHS=pointer */\
+ /* Lhs=fundamental and Rhs=pointer */\
       ::boost::type_traits::ice_and<\
          ::boost::is_fundamental< Lhs_nocv >::value,\
          ::boost::is_pointer< Rhs_noref >::value\

Modified: sandbox/type_traits/boost/type_traits/can_call_subtraction_assignment.hpp
==============================================================================
--- sandbox/type_traits/boost/type_traits/can_call_subtraction_assignment.hpp (original)
+++ sandbox/type_traits/boost/type_traits/can_call_subtraction_assignment.hpp 2011-07-09 16:29:47 EDT (Sat, 09 Jul 2011)
@@ -13,28 +13,45 @@
 #define BOOST_TT_TRAIT_OP -=
 #define BOOST_TT_FORBIDDEN_IF\
    ::boost::type_traits::ice_or<\
- /* LHS is fundamental and const, RHS is fundamental */\
+ /* Lhs==pointer and Rhs==fundamental and Rhs!=integral */\
       ::boost::type_traits::ice_and<\
- ::boost::is_fundamental< Lhs_nocv >::value,\
- ::boost::is_const< Lhs_noref >::value,\
+ ::boost::is_pointer< Lhs_noref >::value,\
+ ::boost::is_fundamental< Rhs_nocv >::value,\
+ ::boost::type_traits::ice_not< ::boost::is_integral< Rhs_noref >::value >::value\
+ >::value,\
+ /* Lhs==void* and Rhs==fundamental */\
+ ::boost::type_traits::ice_and<\
+ ::boost::is_pointer< Lhs_noref >::value,\
+ ::boost::is_void< Lhs_noptr >::value,\
          ::boost::is_fundamental< Rhs_nocv >::value\
>::value,\
- /* RHS==pointer */\
+ /* Rhs==void* and Lhs==fundamental */\
       ::boost::type_traits::ice_and<\
          ::boost::is_pointer< Rhs_noref >::value,\
- ::boost::type_traits::ice_or<\
- ::boost::is_fundamental< Lhs_nocv >::value,\
- ::boost::is_pointer< Lhs_noref >::value\
- >::value\
+ ::boost::is_void< Rhs_noptr >::value,\
+ ::boost::is_fundamental< Lhs_nocv >::value\
>::value,\
- /* LHS==pointer and RHS==fundamental and (LHS==void* or RHS!=integral) */\
+ /* Lhs=fundamental and Rhs=pointer */\
+ ::boost::type_traits::ice_and<\
+ ::boost::is_fundamental< Lhs_nocv >::value,\
+ ::boost::is_pointer< Rhs_noref >::value\
+ >::value,\
+ /* Lhs==pointer and Rhs==pointer */\
       ::boost::type_traits::ice_and<\
          ::boost::is_pointer< Lhs_noref >::value,\
- ::boost::is_fundamental< Rhs_nocv >::value,\
+ ::boost::is_pointer< Rhs_noref >::value\
+ >::value,\
+ /* (Lhs==fundamental or Lhs==pointer) and (Rhs==fundamental or Rhs==pointer) and (Lhs==const) */\
+ ::boost::type_traits::ice_and<\
+ ::boost::type_traits::ice_or<\
+ ::boost::is_fundamental< Lhs_nocv >::value,\
+ ::boost::is_pointer< Lhs_noref >::value\
+ >::value,\
          ::boost::type_traits::ice_or<\
- ::boost::is_void< Lhs_noptr >::value,\
- ::boost::type_traits::ice_not< ::boost::is_integral< Rhs_noref >::value >::value\
- >::value\
+ ::boost::is_fundamental< Rhs_nocv >::value,\
+ ::boost::is_pointer< Rhs_noref >::value\
+ >::value,\
+ ::boost::is_const< Lhs_noref >::value\
>::value\
>::value
 

Modified: sandbox/type_traits/boost/type_traits/detail/can_call_binary_operator.hpp
==============================================================================
--- sandbox/type_traits/boost/type_traits/detail/can_call_binary_operator.hpp (original)
+++ sandbox/type_traits/boost/type_traits/detail/can_call_binary_operator.hpp 2011-07-09 16:29:47 EDT (Sat, 09 Jul 2011)
@@ -54,7 +54,7 @@
 template <typename T> T &make();
 
 
-// 2. checks if operator BOOST_TT_TRAIT_OP returns void or not
+// 2. checks if the operator returns void or not
 // conditions: Lhs!=void and Rhs!=void
 
 // we first redefine "operator," so that we have no compilation error if
@@ -64,7 +64,7 @@
 // - operator BOOST_TT_TRAIT_OP returns void -> (lhs BOOST_TT_TRAIT_OP rhs, returns_void_t()) returns returns_void_t
 // - operator BOOST_TT_TRAIT_OP returns !=void -> (lhs BOOST_TT_TRAIT_OP rhs, returns_void_t()) returns int
 struct returns_void_t {};
-template <typename T> int operator,(T const &, returns_void_t);
+template <typename T> int operator,(T, returns_void_t);
 
 // this intermediate trait has member value of type bool:
 // - value==true -> operator BOOST_TT_TRAIT_OP returns void
@@ -79,7 +79,7 @@
 };
 
 
-// 3. check for return type if Ret!=dont_care
+// 3. checks if the return type is Ret or Ret==dont_care
 // conditions: Lhs!=void and Rhs!=void
 
 struct dont_care { };
@@ -112,8 +112,9 @@
    BOOST_STATIC_CONSTANT(bool, value = false);
 };
 
-// when Ret!=void, checks if it is convertible to Ret using the sizeof trick
+// otherwise checks if it is convertible to Ret using the sizeof trick
 // based on overload resolution
+// condition: Ret!=void and Ret!=dont_care and the operator does not return void
 template < typename Lhs, typename Rhs, typename Ret >
 struct operator_returns_Ret < Lhs, Rhs, Ret, false > {
    static ::boost::type_traits::yes_type is_convertible_to_Ret(Ret); // this version is preferred for types convertible to Ret
@@ -126,8 +127,8 @@
 // 4. we provide our operator definition for types that do not have one already
 
 // a type returned from operator BOOST_TT_TRAIT_OP when no such operator is
-// found in the type's own namespace so that we have a means to know that our
-// operator was used
+// found in the type's own namespace (our own operator is used) so that we have
+// a means to know that our operator was used
 struct tag { };
 
 // this class allows implicit conversions and makes the following operator
@@ -139,10 +140,10 @@
 tag operator BOOST_TT_TRAIT_OP (const any&, const any&);
 
 
-// 5. check for operator existence
+// 5. checks for operator existence
 // condition: Lhs!=void and Rhs!=void
 
-// check if our definition of operator BOOST_TT_TRAIT_OP is used or an other
+// checks if our definition of operator BOOST_TT_TRAIT_OP is used or an other
 // existing one;
 // this is done with redefinition of "operator," that returns tag or tag2
 struct tag2 { };
@@ -157,9 +158,9 @@
 };
 
 
-// 5. main trait: to avoid any compilation error, this struct behaves
-// differently when:
-// - operator BOOST_TT_TRAIT_OP(Lhs, Rhs) is forbidden by the standard
+// 5. main trait: to avoid any compilation error, this class behaves
+// differently when operator BOOST_TT_TRAIT_OP(Lhs, Rhs) is forbidden by the
+// standard.
 // Forbidden_if is a bool that is:
 // - true when the operator BOOST_TT_TRAIT_OP(Lhs, Rhs) is forbidden by the standard
 // (would yield compilation error if used)

Modified: sandbox/type_traits/boost/type_traits/detail/can_call_postfix_operator.hpp
==============================================================================
--- sandbox/type_traits/boost/type_traits/detail/can_call_postfix_operator.hpp (original)
+++ sandbox/type_traits/boost/type_traits/detail/can_call_postfix_operator.hpp 2011-07-09 16:29:47 EDT (Sat, 09 Jul 2011)
@@ -32,7 +32,7 @@
 template <typename T> T &make();
 
 
-// 2. checks if operator BOOST_TT_TRAIT_OP returns void or not
+// 2. checks if the operator returns void or not
 // conditions: Lhs!=void
 
 // we first redefine "operator," so that we have no compilation error if
@@ -42,7 +42,7 @@
 // - operator BOOST_TT_TRAIT_OP returns void -> (lhs BOOST_TT_TRAIT_OP, returns_void_t()) returns returns_void_t
 // - operator BOOST_TT_TRAIT_OP returns !=void -> (lhs BOOST_TT_TRAIT_OP, returns_void_t()) returns int
 struct returns_void_t {};
-template <typename T> int operator,(T const &, returns_void_t);
+template <typename T> int operator,(T, returns_void_t);
 
 // this intermediate trait has member value of type bool:
 // - value==true -> operator BOOST_TT_TRAIT_OP returns void
@@ -57,7 +57,7 @@
 };
 
 
-// 3. check for return type if Ret!=dont_care
+// 3. checks if the return type is Ret or Ret==dont_care
 // conditions: Lhs!=void
 
 struct dont_care { };
@@ -90,8 +90,9 @@
    BOOST_STATIC_CONSTANT(bool, value = false);
 };
 
-// when Ret!=void, checks if it is convertible to Ret using the sizeof trick
+// otherwise checks if it is convertible to Ret using the sizeof trick
 // based on overload resolution
+// condition: Ret!=void and Ret!=dont_care and the operator does not return void
 template < typename Lhs, typename Ret >
 struct operator_returns_Ret < Lhs, Ret, false > {
    static ::boost::type_traits::yes_type is_convertible_to_Ret(Ret); // this version is preferred for types convertible to Ret
@@ -104,8 +105,8 @@
 // 4. we provide our operator definition for types that do not have one already
 
 // a type returned from operator BOOST_TT_TRAIT_OP when no such operator is
-// found in the type's own namespace so that we have a means to know that our
-// operator was used
+// found in the type's own namespace (our own operator is used) so that we have
+// a means to know that our operator was used
 struct tag { };
 
 // this class allows implicit conversions and makes the following operator
@@ -117,10 +118,10 @@
 tag operator BOOST_TT_TRAIT_OP (const any&, int);
 
 
-// 5. check for operator existence
+// 5. checks for operator existence
 // condition: Lhs!=void
 
-// check if our definition of operator BOOST_TT_TRAIT_OP is used or an other
+// checks if our definition of operator BOOST_TT_TRAIT_OP is used or an other
 // existing one;
 // this is done with redefinition of "operator," that returns tag or tag2
 struct tag2 { };
@@ -135,9 +136,9 @@
 };
 
 
-// 5. main trait: to avoid any compilation error, this struct behaves
-// differently when:
-// - operator BOOST_TT_TRAIT_OP(Lhs) is forbidden by the standard
+// 5. main trait: to avoid any compilation error, this class behaves
+// differently when operator BOOST_TT_TRAIT_OP(Lhs) is forbidden by the
+// standard.
 // Forbidden_if is a bool that is:
 // - true when the operator BOOST_TT_TRAIT_OP(Lhs) is forbidden by the standard
 // (would yield compilation error if used)

Modified: sandbox/type_traits/boost/type_traits/detail/can_call_prefix_operator.hpp
==============================================================================
--- sandbox/type_traits/boost/type_traits/detail/can_call_prefix_operator.hpp (original)
+++ sandbox/type_traits/boost/type_traits/detail/can_call_prefix_operator.hpp 2011-07-09 16:29:47 EDT (Sat, 09 Jul 2011)
@@ -48,7 +48,7 @@
 template <typename T> T &make();
 
 
-// 2. checks if operator BOOST_TT_TRAIT_OP returns void or not
+// 2. checks if the operator returns void or not
 // conditions: Rhs!=void
 
 // we first redefine "operator," so that we have no compilation error if
@@ -58,7 +58,7 @@
 // - operator BOOST_TT_TRAIT_OP returns void -> (BOOST_TT_TRAIT_OP rhs, returns_void_t()) returns returns_void_t
 // - operator BOOST_TT_TRAIT_OP returns !=void -> (BOOST_TT_TRAIT_OP rhs, returns_void_t()) returns int
 struct returns_void_t {};
-template <typename T> int operator,(T const &, returns_void_t);
+template <typename T> int operator,(T, returns_void_t);
 
 // this intermediate trait has member value of type bool:
 // - value==true -> operator BOOST_TT_TRAIT_OP returns void
@@ -73,7 +73,7 @@
 };
 
 
-// 3. check for return type if Ret!=dont_care
+// 3. checks if the return type is Ret or Ret==dont_care
 // conditions: Rhs!=void
 
 struct dont_care { };
@@ -106,8 +106,9 @@
    BOOST_STATIC_CONSTANT(bool, value = false);
 };
 
-// when Ret!=void, checks if it is convertible to Ret using the sizeof trick
+// otherwise checks if it is convertible to Ret using the sizeof trick
 // based on overload resolution
+// condition: Ret!=void and Ret!=dont_care and the operator does not return void
 template < typename Rhs, typename Ret >
 struct operator_returns_Ret < Rhs, Ret, false > {
    static ::boost::type_traits::yes_type is_convertible_to_Ret(Ret); // this version is preferred for types convertible to Ret
@@ -120,8 +121,8 @@
 // 4. we provide our operator definition for types that do not have one already
 
 // a type returned from operator BOOST_TT_TRAIT_OP when no such operator is
-// found in the type's own namespace so that we have a means to know that our
-// operator was used
+// found in the type's own namespace (our own operator is used) so that we have
+// a means to know that our operator was used
 struct tag { };
 
 // this class allows implicit conversions and makes the following operator
@@ -133,10 +134,10 @@
 tag operator BOOST_TT_TRAIT_OP (const any&);
 
 
-// 5. check for operator existence
+// 5. checks for operator existence
 // condition: Rhs!=void
 
-// check if our definition of operator BOOST_TT_TRAIT_OP is used or an other
+// checks if our definition of operator BOOST_TT_TRAIT_OP is used or an other
 // existing one;
 // this is done with redefinition of "operator," that returns tag or tag2
 struct tag2 { };
@@ -151,9 +152,9 @@
 };
 
 
-// 5. main trait: to avoid any compilation error, this struct behaves
-// differently when:
-// - operator BOOST_TT_TRAIT_OP(Rhs) is forbidden by the standard
+// 5. main trait: to avoid any compilation error, this class behaves
+// differently when operator BOOST_TT_TRAIT_OP(Rhs) is forbidden by the
+// standard.
 // Forbidden_if is a bool that is:
 // - true when the operator BOOST_TT_TRAIT_OP(Rhs) is forbidden by the standard
 // (would yield compilation error if used)

Modified: sandbox/type_traits/libs/type_traits/doc/operators.qbk
==============================================================================
--- sandbox/type_traits/libs/type_traits/doc/operators.qbk (original)
+++ sandbox/type_traits/libs/type_traits/doc/operators.qbk 2011-07-09 16:29:47 EDT (Sat, 09 Jul 2011)
@@ -309,7 +309,7 @@
 ``
 
 * There is an issue if the operator exists only for type `A` and `B` is
-convertible to `A`. In this case, the compiler will report an ambigous overload
+convertible to `A`. In this case, the compiler will report an ambiguous overload
 because both the existing operator and the one we provide (with argument of type
 `any`) need type conversion, so that none is preferred.
 
@@ -318,7 +318,7 @@
 void operator-(const A&);
 struct B { operator A(); };
 boost::can_call_unary_minus<A>::value; // this is fine
-boost::can_call_unary_minus<B>::value; // error: ambigous overload between
+boost::can_call_unary_minus<B>::value; // error: ambiguous overload between
                                            // operator-(const any&) and
                                            // operator-(const A&)
                                            // both need type conversion
@@ -328,7 +328,7 @@
 struct A { A(const B&) { } };
 void operator-(const A&);
 boost::can_call_unary_minus<A>::value; // this is fine
-boost::can_call_unary_minus<B>::value; // error: ambigous overload between
+boost::can_call_unary_minus<B>::value; // error: ambiguous overload between
                                            // operator-(const any&) and
                                            // operator-(const A&)
                                            // both need type conversion

Modified: sandbox/type_traits/libs/type_traits/test/can_call_addition_assignment_test.cpp
==============================================================================
--- sandbox/type_traits/libs/type_traits/test/can_call_addition_assignment_test.cpp (original)
+++ sandbox/type_traits/libs/type_traits/test/can_call_addition_assignment_test.cpp 2011-07-09 16:29:47 EDT (Sat, 09 Jul 2011)
@@ -15,19 +15,264 @@
 #define BOOST_TT_TRAIT_NAME can_call_addition_assignment
 #define BOOST_TT_TRAIT_OP +=
 
+
 #include "can_call_binary_operators.hpp"
-#include "can_call_addition_assignment_test.hpp"
 
-namespace {
 void specific() {
- /* nothing specific */
-}
-}
-
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, bool const, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, void* const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, bool const volatile, int const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, double, int & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, double volatile &, int const & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, void* volatile, bool const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, void* const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int* const, int volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int* const volatile &, int volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, bool const, bool volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, void*, int const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, void*, int volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, void* const &, int const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int* const, bool const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int* const volatile, int & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool volatile, bool const &, bool const volatile & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool volatile, int volatile & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool volatile, double, int volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool volatile, double &, int >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool volatile, double const &, int const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool volatile, double const volatile &, int volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool volatile, int* &, bool const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool volatile, int* const &, bool volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const volatile, bool const volatile &, int const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const volatile, int const volatile, bool const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const volatile, double, int const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const volatile, double volatile, bool const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const volatile, void* &, int >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, bool const, int const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, double &, bool volatile & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, double volatile &, bool const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int* const volatile, int const & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, bool const volatile, bool const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, bool const &, bool const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, int, int const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, int const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, void* volatile, bool volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool volatile &, void* const volatile, bool >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool volatile &, void* const &, bool volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool volatile &, int* const, bool const volatile & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const volatile &, bool, bool >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const volatile &, bool &, int volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const volatile &, double const, bool const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const volatile &, void* const volatile, int const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const volatile &, int*, int >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const volatile &, int* volatile &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool const, int volatile & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, int const volatile, int & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, int &, int const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, int*, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, int* const, bool volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, int* &, bool volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, int* const &, bool const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, int* const volatile &, bool volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, int* const volatile &, int const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, bool, int volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, bool volatile &, int >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, void* &, bool const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int* const &, int const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int volatile, bool const &, bool volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int volatile, bool const volatile &, int const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int volatile, int const volatile &, int const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int volatile, double, bool volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int volatile, void* const volatile, int const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const volatile, int const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const volatile, int const &, int const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const volatile, int volatile &, bool >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const volatile, int const volatile &, int const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const volatile, double &, int const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const volatile, void* const volatile, bool const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const volatile, void* &, bool >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, bool volatile &, int & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, bool const volatile & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, double &, bool >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, int*, int const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, double volatile &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, double const volatile &, bool const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, void*, int const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int* volatile &, int const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int volatile &, bool, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int volatile &, bool &, int const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int volatile &, int &, int const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int volatile &, double, int const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int volatile &, double volatile, bool const & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int volatile &, void*, bool const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int volatile &, int* const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const volatile &, bool const volatile, bool >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const volatile &, int volatile &, bool const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const volatile &, double &, bool const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const volatile &, double const &, bool & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const volatile &, void* const volatile, bool >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const volatile &, int* const volatile, bool & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const volatile &, int* const volatile &, bool volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, int &, bool const & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, int const &, int volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, double, bool const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, double volatile, bool >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, void* const volatile, bool const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, void* &, int const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, void* &, int const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, int* volatile, int >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, int* const volatile, bool volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, int* const &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, int* volatile &, bool >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, int* volatile &, int volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, bool const volatile &, bool >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, double &, int & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, double volatile &, bool >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double volatile, bool const volatile, bool const & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double volatile, void*, int volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double volatile, void* const volatile, int const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double volatile, void* const volatile &, bool const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double volatile, int*, bool const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double volatile, int* const, bool volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double volatile, int* volatile, bool const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double volatile, int* &, int volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const volatile, double volatile, bool const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const volatile, double const volatile, int volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const volatile, double volatile &, int const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const volatile, void* volatile &, bool >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const volatile, int* volatile &, bool & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, int const volatile, bool >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, double const volatile, int const & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, double &, int const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, void* const &, bool & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, int* const, bool const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, int* volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, int* const &, bool volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, double const volatile, bool volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, void* &, bool const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double volatile &, int &, bool & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double volatile &, double volatile, int volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double volatile &, int* const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double volatile &, int* const &, bool const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const volatile &, bool, bool & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const volatile &, bool const, bool & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const volatile &, bool const &, bool const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const volatile &, bool volatile &, bool const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, bool const, int volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, bool volatile &, int const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int const, int const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, double >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, double const volatile, bool const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, double volatile &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, bool const volatile, int const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, bool &, int volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, int volatile, bool volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, int volatile, int const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, int const volatile, bool volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, int const volatile, int const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, int const volatile &, bool const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, double const volatile &, bool const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, void* const volatile &, bool const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* volatile, int volatile, bool volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* volatile, void* const volatile, int const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* volatile, int*, int >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const volatile, double volatile &, bool const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const volatile, void*, int const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const volatile, void* &, bool >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const volatile, int*, bool & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const volatile, int* const volatile, bool volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, bool const &, int const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int* volatile, int const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int* const volatile &, int const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, bool const &, int volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int const, int const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int volatile, bool const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, double volatile, bool const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, double volatile, bool const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, double const volatile, int const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, double const volatile &, int volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, void* const volatile &, bool const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, void* const volatile &, int volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* volatile &, bool volatile &, bool volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* volatile &, double &, int volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* volatile &, void* const &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* volatile &, void* const &, bool & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const volatile &, bool, bool const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const volatile &, bool, bool volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const volatile &, bool volatile, bool const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const volatile &, bool volatile, bool const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const volatile &, bool const &, bool const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const volatile &, int const volatile &, int const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const volatile &, double const volatile &, int volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const volatile &, void* const volatile, bool const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const volatile &, void* const &, bool volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const volatile &, int* volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const volatile &, int* volatile, bool >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const volatile &, int* const &, int >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const volatile &, int* volatile &, int const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, bool, bool const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, bool const &, int & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, bool const volatile &, int >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int volatile &, bool volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, double const volatile &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, double const volatile &, bool const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, bool, int const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, bool const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, double &, bool volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, double volatile &, int const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, int* const, bool const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* volatile, bool const & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* volatile, void* &, bool const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* volatile, void* const volatile &, int const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const volatile, bool, bool >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const volatile, bool const &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const volatile, int const, bool const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const volatile, int const, int const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const volatile, double const volatile, bool const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const volatile, double &, bool volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const volatile, void* volatile, int volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const volatile, void* const &, int const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const volatile, int*, int volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const volatile, int* const volatile &, int const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, int, int const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, int volatile, bool volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, int const & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, void* const, bool volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, void* volatile, int const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, void* volatile &, int & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, void* const volatile &, int >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, bool const &, bool & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, bool volatile &, bool const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, bool volatile &, bool & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int, int volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int const &, int const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, double volatile, bool volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, double &, int volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, double volatile &, int & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, void*, bool const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, void* volatile, bool const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, void* const volatile, bool >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int*, bool const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int*, bool const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int* const volatile &, bool volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* volatile &, bool &, int volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* volatile &, int const volatile, bool volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* volatile &, double const volatile, int const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* volatile &, void*, bool const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* volatile &, void*, bool volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* volatile &, void* const volatile, bool const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* volatile &, void* &, int const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* volatile &, void* const volatile &, bool const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* volatile &, int* volatile &, int const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* volatile &, int* const volatile &, int const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const volatile &, bool, int const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const volatile &, int const volatile, int const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const volatile &, int const &, int volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const volatile &, double const volatile &, int const volatile & >::value), 0);
 
+}
 
 TT_TEST_BEGIN(BOOST_TT_TRAIT_NAME)
- run1();
- run2();
+ common();
    specific();
 TT_TEST_END

Deleted: sandbox/type_traits/libs/type_traits/test/can_call_addition_assignment_test.hpp
==============================================================================
--- sandbox/type_traits/libs/type_traits/test/can_call_addition_assignment_test.hpp 2011-07-09 16:29:47 EDT (Sat, 09 Jul 2011)
+++ (empty file)
@@ -1,1250 +0,0 @@
-// (C) Copyright Frederic Bron 2009-2011.
-// Use, modification and distribution are subject to the
-// Boost Software License, Version 1.0. (See accompanying file
-// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-namespace {
-
-void run2() {
- // test with only one template parameter
- TEST_T(void, false);
- TEST_T(bool, true);
- TEST_T(char, true);
- TEST_T(signed char, true);
- TEST_T(short int, true);
- TEST_T(int, true);
- TEST_T(long int, true);
- TEST_T(unsigned char, true);
- TEST_T(unsigned short int, true);
- TEST_T(unsigned int, true);
- TEST_T(unsigned long int, true);
- TEST_T(wchar_t, true);
- TEST_T(float, true);
- TEST_T(double, true);
- TEST_T(long double, true);
- TEST_T(void, false);
-# undef CV
-# define CV(T) const T
- TEST_T(CV(bool), false);
- TEST_T(CV(int), false);
- TEST_T(CV(double), false);
-# undef CV
-# define CV(T) volatile T
- TEST_T(CV(bool), true);
- TEST_T(CV(int), true);
- TEST_T(CV(double), true);
-# undef CV
-# define CV(T) const volatile T
- TEST_T(CV(bool), false);
- TEST_T(CV(int), false);
- TEST_T(CV(double), false);
-# undef CV
-# define CV(T) const T&
- TEST_T(CV(bool), false);
- TEST_T(CV(int), false);
- TEST_T(CV(double), false);
-# undef CV
-# define CV(T) volatile T&
- TEST_T(CV(bool), true);
- TEST_T(CV(int), true);
- TEST_T(CV(double), true);
-# undef CV
-# define CV(T) const volatile T&
- TEST_T(CV(bool), false);
- TEST_T(CV(int), false);
- TEST_T(CV(double), false);
-
- // test with only two template parameters
- TEST_TT(void, int, false);
- TEST_TT(int, void, false);
- TEST_TT(void, void, false);
- TEST_TT(bool, bool, true);
- TEST_TT(bool, char, true);
- TEST_TT(bool, signed char, true);
- TEST_TT(bool, short int, true);
- TEST_TT(bool, int, true);
- TEST_TT(bool, long int, true);
- TEST_TT(bool, unsigned char, true);
- TEST_TT(bool, unsigned short int, true);
- TEST_TT(bool, unsigned int, true);
- TEST_TT(bool, unsigned long int, true);
- TEST_TT(bool, wchar_t, true);
- TEST_TT(bool, float, true);
- TEST_TT(bool, double, true);
- TEST_TT(bool, long double, true);
- TEST_TT(char, bool, true);
- TEST_TT(char, char, true);
- TEST_TT(char, signed char, true);
- TEST_TT(char, short int, true);
- TEST_TT(char, int, true);
- TEST_TT(char, long int, true);
- TEST_TT(char, unsigned char, true);
- TEST_TT(char, unsigned short int, true);
- TEST_TT(char, unsigned int, true);
- TEST_TT(char, unsigned long int, true);
- TEST_TT(char, wchar_t, true);
- TEST_TT(char, float, true);
- TEST_TT(char, double, true);
- TEST_TT(char, long double, true);
- TEST_TT(signed char, bool, true);
- TEST_TT(signed char, char, true);
- TEST_TT(signed char, signed char, true);
- TEST_TT(signed char, short int, true);
- TEST_TT(signed char, int, true);
- TEST_TT(signed char, long int, true);
- TEST_TT(signed char, unsigned char, true);
- TEST_TT(signed char, unsigned short int, true);
- TEST_TT(signed char, unsigned int, true);
- TEST_TT(signed char, unsigned long int, true);
- TEST_TT(signed char, wchar_t, true);
- TEST_TT(signed char, float, true);
- TEST_TT(signed char, double, true);
- TEST_TT(signed char, long double, true);
- TEST_TT(short int, bool, true);
- TEST_TT(short int, char, true);
- TEST_TT(short int, signed char, true);
- TEST_TT(short int, short int, true);
- TEST_TT(short int, int, true);
- TEST_TT(short int, long int, true);
- TEST_TT(short int, unsigned char, true);
- TEST_TT(short int, unsigned short int, true);
- TEST_TT(short int, unsigned int, true);
- TEST_TT(short int, unsigned long int, true);
- TEST_TT(short int, wchar_t, true);
- TEST_TT(short int, float, true);
- TEST_TT(short int, double, true);
- TEST_TT(short int, long double, true);
- TEST_TT(int, bool, true);
- TEST_TT(int, char, true);
- TEST_TT(int, signed char, true);
- TEST_TT(int, short int, true);
- TEST_TT(int, int, true);
- TEST_TT(int, long int, true);
- TEST_TT(int, unsigned char, true);
- TEST_TT(int, unsigned short int, true);
- TEST_TT(int, unsigned int, true);
- TEST_TT(int, unsigned long int, true);
- TEST_TT(int, wchar_t, true);
- TEST_TT(int, float, true);
- TEST_TT(int, double, true);
- TEST_TT(int, long double, true);
- TEST_TT(long int, bool, true);
- TEST_TT(long int, char, true);
- TEST_TT(long int, signed char, true);
- TEST_TT(long int, short int, true);
- TEST_TT(long int, int, true);
- TEST_TT(long int, long int, true);
- TEST_TT(long int, unsigned char, true);
- TEST_TT(long int, unsigned short int, true);
- TEST_TT(long int, unsigned int, true);
- TEST_TT(long int, unsigned long int, true);
- TEST_TT(long int, wchar_t, true);
- TEST_TT(long int, float, true);
- TEST_TT(long int, double, true);
- TEST_TT(long int, long double, true);
- TEST_TT(unsigned char, bool, true);
- TEST_TT(unsigned char, char, true);
- TEST_TT(unsigned char, signed char, true);
- TEST_TT(unsigned char, short int, true);
- TEST_TT(unsigned char, int, true);
- TEST_TT(unsigned char, long int, true);
- TEST_TT(unsigned char, unsigned char, true);
- TEST_TT(unsigned char, unsigned short int, true);
- TEST_TT(unsigned char, unsigned int, true);
- TEST_TT(unsigned char, unsigned long int, true);
- TEST_TT(unsigned char, wchar_t, true);
- TEST_TT(unsigned char, float, true);
- TEST_TT(unsigned char, double, true);
- TEST_TT(unsigned char, long double, true);
- TEST_TT(unsigned short int, bool, true);
- TEST_TT(unsigned short int, char, true);
- TEST_TT(unsigned short int, signed char, true);
- TEST_TT(unsigned short int, short int, true);
- TEST_TT(unsigned short int, int, true);
- TEST_TT(unsigned short int, long int, true);
- TEST_TT(unsigned short int, unsigned char, true);
- TEST_TT(unsigned short int, unsigned short int, true);
- TEST_TT(unsigned short int, unsigned int, true);
- TEST_TT(unsigned short int, unsigned long int, true);
- TEST_TT(unsigned short int, wchar_t, true);
- TEST_TT(unsigned short int, float, true);
- TEST_TT(unsigned short int, double, true);
- TEST_TT(unsigned short int, long double, true);
- TEST_TT(unsigned int, bool, true);
- TEST_TT(unsigned int, char, true);
- TEST_TT(unsigned int, signed char, true);
- TEST_TT(unsigned int, short int, true);
- TEST_TT(unsigned int, int, true);
- TEST_TT(unsigned int, long int, true);
- TEST_TT(unsigned int, unsigned char, true);
- TEST_TT(unsigned int, unsigned short int, true);
- TEST_TT(unsigned int, unsigned int, true);
- TEST_TT(unsigned int, unsigned long int, true);
- TEST_TT(unsigned int, wchar_t, true);
- TEST_TT(unsigned int, float, true);
- TEST_TT(unsigned int, double, true);
- TEST_TT(unsigned int, long double, true);
- TEST_TT(unsigned long int, bool, true);
- TEST_TT(unsigned long int, char, true);
- TEST_TT(unsigned long int, signed char, true);
- TEST_TT(unsigned long int, short int, true);
- TEST_TT(unsigned long int, int, true);
- TEST_TT(unsigned long int, long int, true);
- TEST_TT(unsigned long int, unsigned char, true);
- TEST_TT(unsigned long int, unsigned short int, true);
- TEST_TT(unsigned long int, unsigned int, true);
- TEST_TT(unsigned long int, unsigned long int, true);
- TEST_TT(unsigned long int, wchar_t, true);
- TEST_TT(unsigned long int, float, true);
- TEST_TT(unsigned long int, double, true);
- TEST_TT(unsigned long int, long double, true);
- TEST_TT(wchar_t, bool, true);
- TEST_TT(wchar_t, char, true);
- TEST_TT(wchar_t, signed char, true);
- TEST_TT(wchar_t, short int, true);
- TEST_TT(wchar_t, int, true);
- TEST_TT(wchar_t, long int, true);
- TEST_TT(wchar_t, unsigned char, true);
- TEST_TT(wchar_t, unsigned short int, true);
- TEST_TT(wchar_t, unsigned int, true);
- TEST_TT(wchar_t, unsigned long int, true);
- TEST_TT(wchar_t, wchar_t, true);
- TEST_TT(wchar_t, float, true);
- TEST_TT(wchar_t, double, true);
- TEST_TT(wchar_t, long double, true);
- TEST_TT(float, bool, true);
- TEST_TT(float, char, true);
- TEST_TT(float, signed char, true);
- TEST_TT(float, short int, true);
- TEST_TT(float, int, true);
- TEST_TT(float, long int, true);
- TEST_TT(float, unsigned char, true);
- TEST_TT(float, unsigned short int, true);
- TEST_TT(float, unsigned int, true);
- TEST_TT(float, unsigned long int, true);
- TEST_TT(float, wchar_t, true);
- TEST_TT(float, float, true);
- TEST_TT(float, double, true);
- TEST_TT(float, long double, true);
- TEST_TT(double, bool, true);
- TEST_TT(double, char, true);
- TEST_TT(double, signed char, true);
- TEST_TT(double, short int, true);
- TEST_TT(double, int, true);
- TEST_TT(double, long int, true);
- TEST_TT(double, unsigned char, true);
- TEST_TT(double, unsigned short int, true);
- TEST_TT(double, unsigned int, true);
- TEST_TT(double, unsigned long int, true);
- TEST_TT(double, wchar_t, true);
- TEST_TT(double, float, true);
- TEST_TT(double, double, true);
- TEST_TT(double, long double, true);
- TEST_TT(long double, bool, true);
- TEST_TT(long double, char, true);
- TEST_TT(long double, signed char, true);
- TEST_TT(long double, short int, true);
- TEST_TT(long double, int, true);
- TEST_TT(long double, long int, true);
- TEST_TT(long double, unsigned char, true);
- TEST_TT(long double, unsigned short int, true);
- TEST_TT(long double, unsigned int, true);
- TEST_TT(long double, unsigned long int, true);
- TEST_TT(long double, wchar_t, true);
- TEST_TT(long double, float, true);
- TEST_TT(long double, double, true);
- TEST_TT(long double, long double, true);
- TEST_TT(bool, void, false);
- TEST_TT(void, bool, false);
- TEST_TT(char, void, false);
- TEST_TT(void, char, false);
- TEST_TT(signed char, void, false);
- TEST_TT(void, signed char, false);
- TEST_TT(short int, void, false);
- TEST_TT(void, short int, false);
- TEST_TT(int, void, false);
- TEST_TT(void, int, false);
- TEST_TT(long int, void, false);
- TEST_TT(void, long int, false);
- TEST_TT(unsigned char, void, false);
- TEST_TT(void, unsigned char, false);
- TEST_TT(unsigned short int, void, false);
- TEST_TT(void, unsigned short int, false);
- TEST_TT(unsigned int, void, false);
- TEST_TT(void, unsigned int, false);
- TEST_TT(unsigned long int, void, false);
- TEST_TT(void, unsigned long int, false);
- TEST_TT(wchar_t, void, false);
- TEST_TT(void, wchar_t, false);
- TEST_TT(float, void, false);
- TEST_TT(void, float, false);
- TEST_TT(double, void, false);
- TEST_TT(void, double, false);
- TEST_TT(long double, void, false);
- TEST_TT(void, long double, false);
-
-// test with three template parameters
- TEST_TTR(bool, bool, bool, true);
- TEST_TTR(bool, char, bool, true);
- TEST_TTR(bool, signed char, bool, true);
- TEST_TTR(bool, short int, bool, true);
- TEST_TTR(bool, int, bool, true);
- TEST_TTR(bool, long int, bool, true);
- TEST_TTR(bool, unsigned char, bool, true);
- TEST_TTR(bool, unsigned short int, bool, true);
- TEST_TTR(bool, unsigned int, bool, true);
- TEST_TTR(bool, unsigned long int, bool, true);
- TEST_TTR(bool, wchar_t, bool, true);
- TEST_TTR(bool, float, bool, true);
- TEST_TTR(bool, double, bool, true);
- TEST_TTR(bool, long double, bool, true);
- TEST_TTR(char, bool, bool, true);
- TEST_TTR(char, char, bool, true);
- TEST_TTR(char, signed char, bool, true);
- TEST_TTR(char, short int, bool, true);
- TEST_TTR(char, int, bool, true);
- TEST_TTR(char, long int, bool, true);
- TEST_TTR(char, unsigned char, bool, true);
- TEST_TTR(char, unsigned short int, bool, true);
- TEST_TTR(char, unsigned int, bool, true);
- TEST_TTR(char, unsigned long int, bool, true);
- TEST_TTR(char, wchar_t, bool, true);
- TEST_TTR(char, float, bool, true);
- TEST_TTR(char, double, bool, true);
- TEST_TTR(char, long double, bool, true);
- TEST_TTR(signed char, bool, bool, true);
- TEST_TTR(signed char, char, bool, true);
- TEST_TTR(signed char, signed char, bool, true);
- TEST_TTR(signed char, short int, bool, true);
- TEST_TTR(signed char, int, bool, true);
- TEST_TTR(signed char, long int, bool, true);
- TEST_TTR(signed char, unsigned char, bool, true);
- TEST_TTR(signed char, unsigned short int, bool, true);
- TEST_TTR(signed char, unsigned int, bool, true);
- TEST_TTR(signed char, unsigned long int, bool, true);
- TEST_TTR(signed char, wchar_t, bool, true);
- TEST_TTR(signed char, float, bool, true);
- TEST_TTR(signed char, double, bool, true);
- TEST_TTR(signed char, long double, bool, true);
- TEST_TTR(short int, bool, bool, true);
- TEST_TTR(short int, char, bool, true);
- TEST_TTR(short int, signed char, bool, true);
- TEST_TTR(short int, short int, bool, true);
- TEST_TTR(short int, int, bool, true);
- TEST_TTR(short int, long int, bool, true);
- TEST_TTR(short int, unsigned char, bool, true);
- TEST_TTR(short int, unsigned short int, bool, true);
- TEST_TTR(short int, unsigned int, bool, true);
- TEST_TTR(short int, unsigned long int, bool, true);
- TEST_TTR(short int, wchar_t, bool, true);
- TEST_TTR(short int, float, bool, true);
- TEST_TTR(short int, double, bool, true);
- TEST_TTR(short int, long double, bool, true);
- TEST_TTR(int, bool, bool, true);
- TEST_TTR(int, char, bool, true);
- TEST_TTR(int, signed char, bool, true);
- TEST_TTR(int, short int, bool, true);
- TEST_TTR(int, int, bool, true);
- TEST_TTR(int, long int, bool, true);
- TEST_TTR(int, unsigned char, bool, true);
- TEST_TTR(int, unsigned short int, bool, true);
- TEST_TTR(int, unsigned int, bool, true);
- TEST_TTR(int, unsigned long int, bool, true);
- TEST_TTR(int, wchar_t, bool, true);
- TEST_TTR(int, float, bool, true);
- TEST_TTR(int, double, bool, true);
- TEST_TTR(int, long double, bool, true);
- TEST_TTR(long int, bool, bool, true);
- TEST_TTR(long int, char, bool, true);
- TEST_TTR(long int, signed char, bool, true);
- TEST_TTR(long int, short int, bool, true);
- TEST_TTR(long int, int, bool, true);
- TEST_TTR(long int, long int, bool, true);
- TEST_TTR(long int, unsigned char, bool, true);
- TEST_TTR(long int, unsigned short int, bool, true);
- TEST_TTR(long int, unsigned int, bool, true);
- TEST_TTR(long int, unsigned long int, bool, true);
- TEST_TTR(long int, wchar_t, bool, true);
- TEST_TTR(long int, float, bool, true);
- TEST_TTR(long int, double, bool, true);
- TEST_TTR(long int, long double, bool, true);
- TEST_TTR(unsigned char, bool, bool, true);
- TEST_TTR(unsigned char, char, bool, true);
- TEST_TTR(unsigned char, signed char, bool, true);
- TEST_TTR(unsigned char, short int, bool, true);
- TEST_TTR(unsigned char, int, bool, true);
- TEST_TTR(unsigned char, long int, bool, true);
- TEST_TTR(unsigned char, unsigned char, bool, true);
- TEST_TTR(unsigned char, unsigned short int, bool, true);
- TEST_TTR(unsigned char, unsigned int, bool, true);
- TEST_TTR(unsigned char, unsigned long int, bool, true);
- TEST_TTR(unsigned char, wchar_t, bool, true);
- TEST_TTR(unsigned char, float, bool, true);
- TEST_TTR(unsigned char, double, bool, true);
- TEST_TTR(unsigned char, long double, bool, true);
- TEST_TTR(unsigned short int, bool, bool, true);
- TEST_TTR(unsigned short int, char, bool, true);
- TEST_TTR(unsigned short int, signed char, bool, true);
- TEST_TTR(unsigned short int, short int, bool, true);
- TEST_TTR(unsigned short int, int, bool, true);
- TEST_TTR(unsigned short int, long int, bool, true);
- TEST_TTR(unsigned short int, unsigned char, bool, true);
- TEST_TTR(unsigned short int, unsigned short int, bool, true);
- TEST_TTR(unsigned short int, unsigned int, bool, true);
- TEST_TTR(unsigned short int, unsigned long int, bool, true);
- TEST_TTR(unsigned short int, wchar_t, bool, true);
- TEST_TTR(unsigned short int, float, bool, true);
- TEST_TTR(unsigned short int, double, bool, true);
- TEST_TTR(unsigned short int, long double, bool, true);
- TEST_TTR(unsigned int, bool, bool, true);
- TEST_TTR(unsigned int, char, bool, true);
- TEST_TTR(unsigned int, signed char, bool, true);
- TEST_TTR(unsigned int, short int, bool, true);
- TEST_TTR(unsigned int, int, bool, true);
- TEST_TTR(unsigned int, long int, bool, true);
- TEST_TTR(unsigned int, unsigned char, bool, true);
- TEST_TTR(unsigned int, unsigned short int, bool, true);
- TEST_TTR(unsigned int, unsigned int, bool, true);
- TEST_TTR(unsigned int, unsigned long int, bool, true);
- TEST_TTR(unsigned int, wchar_t, bool, true);
- TEST_TTR(unsigned int, float, bool, true);
- TEST_TTR(unsigned int, double, bool, true);
- TEST_TTR(unsigned int, long double, bool, true);
- TEST_TTR(unsigned long int, bool, bool, true);
- TEST_TTR(unsigned long int, char, bool, true);
- TEST_TTR(unsigned long int, signed char, bool, true);
- TEST_TTR(unsigned long int, short int, bool, true);
- TEST_TTR(unsigned long int, int, bool, true);
- TEST_TTR(unsigned long int, long int, bool, true);
- TEST_TTR(unsigned long int, unsigned char, bool, true);
- TEST_TTR(unsigned long int, unsigned short int, bool, true);
- TEST_TTR(unsigned long int, unsigned int, bool, true);
- TEST_TTR(unsigned long int, unsigned long int, bool, true);
- TEST_TTR(unsigned long int, wchar_t, bool, true);
- TEST_TTR(unsigned long int, float, bool, true);
- TEST_TTR(unsigned long int, double, bool, true);
- TEST_TTR(unsigned long int, long double, bool, true);
- TEST_TTR(wchar_t, bool, bool, true);
- TEST_TTR(wchar_t, char, bool, true);
- TEST_TTR(wchar_t, signed char, bool, true);
- TEST_TTR(wchar_t, short int, bool, true);
- TEST_TTR(wchar_t, int, bool, true);
- TEST_TTR(wchar_t, long int, bool, true);
- TEST_TTR(wchar_t, unsigned char, bool, true);
- TEST_TTR(wchar_t, unsigned short int, bool, true);
- TEST_TTR(wchar_t, unsigned int, bool, true);
- TEST_TTR(wchar_t, unsigned long int, bool, true);
- TEST_TTR(wchar_t, wchar_t, bool, true);
- TEST_TTR(wchar_t, float, bool, true);
- TEST_TTR(wchar_t, double, bool, true);
- TEST_TTR(wchar_t, long double, bool, true);
- TEST_TTR(float, bool, bool, true);
- TEST_TTR(float, char, bool, true);
- TEST_TTR(float, signed char, bool, true);
- TEST_TTR(float, short int, bool, true);
- TEST_TTR(float, int, bool, true);
- TEST_TTR(float, long int, bool, true);
- TEST_TTR(float, unsigned char, bool, true);
- TEST_TTR(float, unsigned short int, bool, true);
- TEST_TTR(float, unsigned int, bool, true);
- TEST_TTR(float, unsigned long int, bool, true);
- TEST_TTR(float, wchar_t, bool, true);
- TEST_TTR(float, float, bool, true);
- TEST_TTR(float, double, bool, true);
- TEST_TTR(float, long double, bool, true);
- TEST_TTR(double, bool, bool, true);
- TEST_TTR(double, char, bool, true);
- TEST_TTR(double, signed char, bool, true);
- TEST_TTR(double, short int, bool, true);
- TEST_TTR(double, int, bool, true);
- TEST_TTR(double, long int, bool, true);
- TEST_TTR(double, unsigned char, bool, true);
- TEST_TTR(double, unsigned short int, bool, true);
- TEST_TTR(double, unsigned int, bool, true);
- TEST_TTR(double, unsigned long int, bool, true);
- TEST_TTR(double, wchar_t, bool, true);
- TEST_TTR(double, float, bool, true);
- TEST_TTR(double, double, bool, true);
- TEST_TTR(double, long double, bool, true);
- TEST_TTR(long double, bool, bool, true);
- TEST_TTR(long double, char, bool, true);
- TEST_TTR(long double, signed char, bool, true);
- TEST_TTR(long double, short int, bool, true);
- TEST_TTR(long double, int, bool, true);
- TEST_TTR(long double, long int, bool, true);
- TEST_TTR(long double, unsigned char, bool, true);
- TEST_TTR(long double, unsigned short int, bool, true);
- TEST_TTR(long double, unsigned int, bool, true);
- TEST_TTR(long double, unsigned long int, bool, true);
- TEST_TTR(long double, wchar_t, bool, true);
- TEST_TTR(long double, float, bool, true);
- TEST_TTR(long double, double, bool, true);
- TEST_TTR(long double, long double, bool, true);
- TEST_TTR(bool, bool, tag, false);
- TEST_TTR(bool, char, tag, false);
- TEST_TTR(bool, signed char, tag, false);
- TEST_TTR(bool, short int, tag, false);
- TEST_TTR(bool, int, tag, false);
- TEST_TTR(bool, long int, tag, false);
- TEST_TTR(bool, unsigned char, tag, false);
- TEST_TTR(bool, unsigned short int, tag, false);
- TEST_TTR(bool, unsigned int, tag, false);
- TEST_TTR(bool, unsigned long int, tag, false);
- TEST_TTR(bool, wchar_t, tag, false);
- TEST_TTR(bool, float, tag, false);
- TEST_TTR(bool, double, tag, false);
- TEST_TTR(bool, long double, tag, false);
- TEST_TTR(char, bool, tag, false);
- TEST_TTR(char, char, tag, false);
- TEST_TTR(char, signed char, tag, false);
- TEST_TTR(char, short int, tag, false);
- TEST_TTR(char, int, tag, false);
- TEST_TTR(char, long int, tag, false);
- TEST_TTR(char, unsigned char, tag, false);
- TEST_TTR(char, unsigned short int, tag, false);
- TEST_TTR(char, unsigned int, tag, false);
- TEST_TTR(char, unsigned long int, tag, false);
- TEST_TTR(char, wchar_t, tag, false);
- TEST_TTR(char, float, tag, false);
- TEST_TTR(char, double, tag, false);
- TEST_TTR(char, long double, tag, false);
- TEST_TTR(signed char, bool, tag, false);
- TEST_TTR(signed char, char, tag, false);
- TEST_TTR(signed char, signed char, tag, false);
- TEST_TTR(signed char, short int, tag, false);
- TEST_TTR(signed char, int, tag, false);
- TEST_TTR(signed char, long int, tag, false);
- TEST_TTR(signed char, unsigned char, tag, false);
- TEST_TTR(signed char, unsigned short int, tag, false);
- TEST_TTR(signed char, unsigned int, tag, false);
- TEST_TTR(signed char, unsigned long int, tag, false);
- TEST_TTR(signed char, wchar_t, tag, false);
- TEST_TTR(signed char, float, tag, false);
- TEST_TTR(signed char, double, tag, false);
- TEST_TTR(signed char, long double, tag, false);
- TEST_TTR(short int, bool, tag, false);
- TEST_TTR(short int, char, tag, false);
- TEST_TTR(short int, signed char, tag, false);
- TEST_TTR(short int, short int, tag, false);
- TEST_TTR(short int, int, tag, false);
- TEST_TTR(short int, long int, tag, false);
- TEST_TTR(short int, unsigned char, tag, false);
- TEST_TTR(short int, unsigned short int, tag, false);
- TEST_TTR(short int, unsigned int, tag, false);
- TEST_TTR(short int, unsigned long int, tag, false);
- TEST_TTR(short int, wchar_t, tag, false);
- TEST_TTR(short int, float, tag, false);
- TEST_TTR(short int, double, tag, false);
- TEST_TTR(short int, long double, tag, false);
- TEST_TTR(int, bool, tag, false);
- TEST_TTR(int, char, tag, false);
- TEST_TTR(int, signed char, tag, false);
- TEST_TTR(int, short int, tag, false);
- TEST_TTR(int, int, tag, false);
- TEST_TTR(int, long int, tag, false);
- TEST_TTR(int, unsigned char, tag, false);
- TEST_TTR(int, unsigned short int, tag, false);
- TEST_TTR(int, unsigned int, tag, false);
- TEST_TTR(int, unsigned long int, tag, false);
- TEST_TTR(int, wchar_t, tag, false);
- TEST_TTR(int, float, tag, false);
- TEST_TTR(int, double, tag, false);
- TEST_TTR(int, long double, tag, false);
- TEST_TTR(long int, bool, tag, false);
- TEST_TTR(long int, char, tag, false);
- TEST_TTR(long int, signed char, tag, false);
- TEST_TTR(long int, short int, tag, false);
- TEST_TTR(long int, int, tag, false);
- TEST_TTR(long int, long int, tag, false);
- TEST_TTR(long int, unsigned char, tag, false);
- TEST_TTR(long int, unsigned short int, tag, false);
- TEST_TTR(long int, unsigned int, tag, false);
- TEST_TTR(long int, unsigned long int, tag, false);
- TEST_TTR(long int, wchar_t, tag, false);
- TEST_TTR(long int, float, tag, false);
- TEST_TTR(long int, double, tag, false);
- TEST_TTR(long int, long double, tag, false);
- TEST_TTR(unsigned char, bool, tag, false);
- TEST_TTR(unsigned char, char, tag, false);
- TEST_TTR(unsigned char, signed char, tag, false);
- TEST_TTR(unsigned char, short int, tag, false);
- TEST_TTR(unsigned char, int, tag, false);
- TEST_TTR(unsigned char, long int, tag, false);
- TEST_TTR(unsigned char, unsigned char, tag, false);
- TEST_TTR(unsigned char, unsigned short int, tag, false);
- TEST_TTR(unsigned char, unsigned int, tag, false);
- TEST_TTR(unsigned char, unsigned long int, tag, false);
- TEST_TTR(unsigned char, wchar_t, tag, false);
- TEST_TTR(unsigned char, float, tag, false);
- TEST_TTR(unsigned char, double, tag, false);
- TEST_TTR(unsigned char, long double, tag, false);
- TEST_TTR(unsigned short int, bool, tag, false);
- TEST_TTR(unsigned short int, char, tag, false);
- TEST_TTR(unsigned short int, signed char, tag, false);
- TEST_TTR(unsigned short int, short int, tag, false);
- TEST_TTR(unsigned short int, int, tag, false);
- TEST_TTR(unsigned short int, long int, tag, false);
- TEST_TTR(unsigned short int, unsigned char, tag, false);
- TEST_TTR(unsigned short int, unsigned short int, tag, false);
- TEST_TTR(unsigned short int, unsigned int, tag, false);
- TEST_TTR(unsigned short int, unsigned long int, tag, false);
- TEST_TTR(unsigned short int, wchar_t, tag, false);
- TEST_TTR(unsigned short int, float, tag, false);
- TEST_TTR(unsigned short int, double, tag, false);
- TEST_TTR(unsigned short int, long double, tag, false);
- TEST_TTR(unsigned int, bool, tag, false);
- TEST_TTR(unsigned int, char, tag, false);
- TEST_TTR(unsigned int, signed char, tag, false);
- TEST_TTR(unsigned int, short int, tag, false);
- TEST_TTR(unsigned int, int, tag, false);
- TEST_TTR(unsigned int, long int, tag, false);
- TEST_TTR(unsigned int, unsigned char, tag, false);
- TEST_TTR(unsigned int, unsigned short int, tag, false);
- TEST_TTR(unsigned int, unsigned int, tag, false);
- TEST_TTR(unsigned int, unsigned long int, tag, false);
- TEST_TTR(unsigned int, wchar_t, tag, false);
- TEST_TTR(unsigned int, float, tag, false);
- TEST_TTR(unsigned int, double, tag, false);
- TEST_TTR(unsigned int, long double, tag, false);
- TEST_TTR(unsigned long int, bool, tag, false);
- TEST_TTR(unsigned long int, char, tag, false);
- TEST_TTR(unsigned long int, signed char, tag, false);
- TEST_TTR(unsigned long int, short int, tag, false);
- TEST_TTR(unsigned long int, int, tag, false);
- TEST_TTR(unsigned long int, long int, tag, false);
- TEST_TTR(unsigned long int, unsigned char, tag, false);
- TEST_TTR(unsigned long int, unsigned short int, tag, false);
- TEST_TTR(unsigned long int, unsigned int, tag, false);
- TEST_TTR(unsigned long int, unsigned long int, tag, false);
- TEST_TTR(unsigned long int, wchar_t, tag, false);
- TEST_TTR(unsigned long int, float, tag, false);
- TEST_TTR(unsigned long int, double, tag, false);
- TEST_TTR(unsigned long int, long double, tag, false);
- TEST_TTR(wchar_t, bool, tag, false);
- TEST_TTR(wchar_t, char, tag, false);
- TEST_TTR(wchar_t, signed char, tag, false);
- TEST_TTR(wchar_t, short int, tag, false);
- TEST_TTR(wchar_t, int, tag, false);
- TEST_TTR(wchar_t, long int, tag, false);
- TEST_TTR(wchar_t, unsigned char, tag, false);
- TEST_TTR(wchar_t, unsigned short int, tag, false);
- TEST_TTR(wchar_t, unsigned int, tag, false);
- TEST_TTR(wchar_t, unsigned long int, tag, false);
- TEST_TTR(wchar_t, wchar_t, tag, false);
- TEST_TTR(wchar_t, float, tag, false);
- TEST_TTR(wchar_t, double, tag, false);
- TEST_TTR(wchar_t, long double, tag, false);
- TEST_TTR(float, bool, tag, false);
- TEST_TTR(float, char, tag, false);
- TEST_TTR(float, signed char, tag, false);
- TEST_TTR(float, short int, tag, false);
- TEST_TTR(float, int, tag, false);
- TEST_TTR(float, long int, tag, false);
- TEST_TTR(float, unsigned char, tag, false);
- TEST_TTR(float, unsigned short int, tag, false);
- TEST_TTR(float, unsigned int, tag, false);
- TEST_TTR(float, unsigned long int, tag, false);
- TEST_TTR(float, wchar_t, tag, false);
- TEST_TTR(float, float, tag, false);
- TEST_TTR(float, double, tag, false);
- TEST_TTR(float, long double, tag, false);
- TEST_TTR(double, bool, tag, false);
- TEST_TTR(double, char, tag, false);
- TEST_TTR(double, signed char, tag, false);
- TEST_TTR(double, short int, tag, false);
- TEST_TTR(double, int, tag, false);
- TEST_TTR(double, long int, tag, false);
- TEST_TTR(double, unsigned char, tag, false);
- TEST_TTR(double, unsigned short int, tag, false);
- TEST_TTR(double, unsigned int, tag, false);
- TEST_TTR(double, unsigned long int, tag, false);
- TEST_TTR(double, wchar_t, tag, false);
- TEST_TTR(double, float, tag, false);
- TEST_TTR(double, double, tag, false);
- TEST_TTR(double, long double, tag, false);
- TEST_TTR(long double, bool, tag, false);
- TEST_TTR(long double, char, tag, false);
- TEST_TTR(long double, signed char, tag, false);
- TEST_TTR(long double, short int, tag, false);
- TEST_TTR(long double, int, tag, false);
- TEST_TTR(long double, long int, tag, false);
- TEST_TTR(long double, unsigned char, tag, false);
- TEST_TTR(long double, unsigned short int, tag, false);
- TEST_TTR(long double, unsigned int, tag, false);
- TEST_TTR(long double, unsigned long int, tag, false);
- TEST_TTR(long double, wchar_t, tag, false);
- TEST_TTR(long double, float, tag, false);
- TEST_TTR(long double, double, tag, false);
- TEST_TTR(long double, long double, tag, false);
-# undef CV1
-# define CV1(T) const T
-# undef CV2
-# define CV2(T) T
- // test with only two template parameters
- TEST_TT(CV1(bool), CV2(int), false);
- TEST_TT(CV1(bool), CV2(double), false);
- TEST_TT(CV1(int), CV2(bool), false);
- TEST_TT(CV1(int), CV2(double), false);
- TEST_TT(CV1(double), CV2(bool), false);
- TEST_TT(CV1(double), CV2(int), false);
-
- // test with three template parameters
- TEST_TTR(CV1(bool), CV2(int), bool, false);
- TEST_TTR(CV1(bool), CV2(double), bool, false);
- TEST_TTR(CV1(int), CV2(bool), bool, false);
- TEST_TTR(CV1(int), CV2(double), bool, false);
- TEST_TTR(CV1(double), CV2(bool), bool, false);
- TEST_TTR(CV1(double), CV2(int), bool, false);
- TEST_TTR(CV1(bool), CV2(int), tag, false);
- TEST_TTR(CV1(bool), CV2(double), tag, false);
- TEST_TTR(CV1(int), CV2(bool), tag, false);
- TEST_TTR(CV1(int), CV2(double), tag, false);
- TEST_TTR(CV1(double), CV2(bool), tag, false);
- TEST_TTR(CV1(double), CV2(int), tag, false);
-
-# undef CV1
-# define CV1(T) volatile T
-# undef CV2
-# define CV2(T) T
- // test with only two template parameters
- TEST_TT(CV1(bool), CV2(int), true);
- TEST_TT(CV1(bool), CV2(double), true);
- TEST_TT(CV1(int), CV2(bool), true);
- TEST_TT(CV1(int), CV2(double), true);
- TEST_TT(CV1(double), CV2(bool), true);
- TEST_TT(CV1(double), CV2(int), true);
-
- // test with three template parameters
- TEST_TTR(CV1(bool), CV2(int), bool, true);
- TEST_TTR(CV1(bool), CV2(double), bool, true);
- TEST_TTR(CV1(int), CV2(bool), bool, true);
- TEST_TTR(CV1(int), CV2(double), bool, true);
- TEST_TTR(CV1(double), CV2(bool), bool, true);
- TEST_TTR(CV1(double), CV2(int), bool, true);
- TEST_TTR(CV1(bool), CV2(int), tag, false);
- TEST_TTR(CV1(bool), CV2(double), tag, false);
- TEST_TTR(CV1(int), CV2(bool), tag, false);
- TEST_TTR(CV1(int), CV2(double), tag, false);
- TEST_TTR(CV1(double), CV2(bool), tag, false);
- TEST_TTR(CV1(double), CV2(int), tag, false);
-
-# undef CV1
-# define CV1(T) const volatile T
-# undef CV2
-# define CV2(T) T
- // test with only two template parameters
- TEST_TT(CV1(bool), CV2(int), false);
- TEST_TT(CV1(bool), CV2(double), false);
- TEST_TT(CV1(int), CV2(bool), false);
- TEST_TT(CV1(int), CV2(double), false);
- TEST_TT(CV1(double), CV2(bool), false);
- TEST_TT(CV1(double), CV2(int), false);
-
- // test with three template parameters
- TEST_TTR(CV1(bool), CV2(int), bool, false);
- TEST_TTR(CV1(bool), CV2(double), bool, false);
- TEST_TTR(CV1(int), CV2(bool), bool, false);
- TEST_TTR(CV1(int), CV2(double), bool, false);
- TEST_TTR(CV1(double), CV2(bool), bool, false);
- TEST_TTR(CV1(double), CV2(int), bool, false);
- TEST_TTR(CV1(bool), CV2(int), tag, false);
- TEST_TTR(CV1(bool), CV2(double), tag, false);
- TEST_TTR(CV1(int), CV2(bool), tag, false);
- TEST_TTR(CV1(int), CV2(double), tag, false);
- TEST_TTR(CV1(double), CV2(bool), tag, false);
- TEST_TTR(CV1(double), CV2(int), tag, false);
-
-# undef CV1
-# define CV1(T) const T&
-# undef CV2
-# define CV2(T) T
- // test with only two template parameters
- TEST_TT(CV1(bool), CV2(int), false);
- TEST_TT(CV1(bool), CV2(double), false);
- TEST_TT(CV1(int), CV2(bool), false);
- TEST_TT(CV1(int), CV2(double), false);
- TEST_TT(CV1(double), CV2(bool), false);
- TEST_TT(CV1(double), CV2(int), false);
-
- // test with three template parameters
- TEST_TTR(CV1(bool), CV2(int), bool, false);
- TEST_TTR(CV1(bool), CV2(double), bool, false);
- TEST_TTR(CV1(int), CV2(bool), bool, false);
- TEST_TTR(CV1(int), CV2(double), bool, false);
- TEST_TTR(CV1(double), CV2(bool), bool, false);
- TEST_TTR(CV1(double), CV2(int), bool, false);
- TEST_TTR(CV1(bool), CV2(int), tag, false);
- TEST_TTR(CV1(bool), CV2(double), tag, false);
- TEST_TTR(CV1(int), CV2(bool), tag, false);
- TEST_TTR(CV1(int), CV2(double), tag, false);
- TEST_TTR(CV1(double), CV2(bool), tag, false);
- TEST_TTR(CV1(double), CV2(int), tag, false);
-
-# undef CV1
-# define CV1(T) volatile T&
-# undef CV2
-# define CV2(T) T
- // test with only two template parameters
- TEST_TT(CV1(bool), CV2(int), true);
- TEST_TT(CV1(bool), CV2(double), true);
- TEST_TT(CV1(int), CV2(bool), true);
- TEST_TT(CV1(int), CV2(double), true);
- TEST_TT(CV1(double), CV2(bool), true);
- TEST_TT(CV1(double), CV2(int), true);
-
- // test with three template parameters
- TEST_TTR(CV1(bool), CV2(int), bool, true);
- TEST_TTR(CV1(bool), CV2(double), bool, true);
- TEST_TTR(CV1(int), CV2(bool), bool, true);
- TEST_TTR(CV1(int), CV2(double), bool, true);
- TEST_TTR(CV1(double), CV2(bool), bool, true);
- TEST_TTR(CV1(double), CV2(int), bool, true);
- TEST_TTR(CV1(bool), CV2(int), tag, false);
- TEST_TTR(CV1(bool), CV2(double), tag, false);
- TEST_TTR(CV1(int), CV2(bool), tag, false);
- TEST_TTR(CV1(int), CV2(double), tag, false);
- TEST_TTR(CV1(double), CV2(bool), tag, false);
- TEST_TTR(CV1(double), CV2(int), tag, false);
-
-# undef CV1
-# define CV1(T) const volatile T&
-# undef CV2
-# define CV2(T) T
- // test with only two template parameters
- TEST_TT(CV1(bool), CV2(int), false);
- TEST_TT(CV1(bool), CV2(double), false);
- TEST_TT(CV1(int), CV2(bool), false);
- TEST_TT(CV1(int), CV2(double), false);
- TEST_TT(CV1(double), CV2(bool), false);
- TEST_TT(CV1(double), CV2(int), false);
-
- // test with three template parameters
- TEST_TTR(CV1(bool), CV2(int), bool, false);
- TEST_TTR(CV1(bool), CV2(double), bool, false);
- TEST_TTR(CV1(int), CV2(bool), bool, false);
- TEST_TTR(CV1(int), CV2(double), bool, false);
- TEST_TTR(CV1(double), CV2(bool), bool, false);
- TEST_TTR(CV1(double), CV2(int), bool, false);
- TEST_TTR(CV1(bool), CV2(int), tag, false);
- TEST_TTR(CV1(bool), CV2(double), tag, false);
- TEST_TTR(CV1(int), CV2(bool), tag, false);
- TEST_TTR(CV1(int), CV2(double), tag, false);
- TEST_TTR(CV1(double), CV2(bool), tag, false);
- TEST_TTR(CV1(double), CV2(int), tag, false);
-
-# undef CV1
-# define CV1(T) T
-# undef CV2
-# define CV2(T) const T
- // test with only two template parameters
- TEST_TT(CV1(bool), CV2(int), true);
- TEST_TT(CV1(bool), CV2(double), true);
- TEST_TT(CV1(int), CV2(bool), true);
- TEST_TT(CV1(int), CV2(double), true);
- TEST_TT(CV1(double), CV2(bool), true);
- TEST_TT(CV1(double), CV2(int), true);
-
- // test with three template parameters
- TEST_TTR(CV1(bool), CV2(int), bool, true);
- TEST_TTR(CV1(bool), CV2(double), bool, true);
- TEST_TTR(CV1(int), CV2(bool), bool, true);
- TEST_TTR(CV1(int), CV2(double), bool, true);
- TEST_TTR(CV1(double), CV2(bool), bool, true);
- TEST_TTR(CV1(double), CV2(int), bool, true);
- TEST_TTR(CV1(bool), CV2(int), tag, false);
- TEST_TTR(CV1(bool), CV2(double), tag, false);
- TEST_TTR(CV1(int), CV2(bool), tag, false);
- TEST_TTR(CV1(int), CV2(double), tag, false);
- TEST_TTR(CV1(double), CV2(bool), tag, false);
- TEST_TTR(CV1(double), CV2(int), tag, false);
-
-# undef CV1
-# define CV1(T) T
-# undef CV2
-# define CV2(T) volatile T
- // test with only two template parameters
- TEST_TT(CV1(bool), CV2(int), true);
- TEST_TT(CV1(bool), CV2(double), true);
- TEST_TT(CV1(int), CV2(bool), true);
- TEST_TT(CV1(int), CV2(double), true);
- TEST_TT(CV1(double), CV2(bool), true);
- TEST_TT(CV1(double), CV2(int), true);
-
- // test with three template parameters
- TEST_TTR(CV1(bool), CV2(int), bool, true);
- TEST_TTR(CV1(bool), CV2(double), bool, true);
- TEST_TTR(CV1(int), CV2(bool), bool, true);
- TEST_TTR(CV1(int), CV2(double), bool, true);
- TEST_TTR(CV1(double), CV2(bool), bool, true);
- TEST_TTR(CV1(double), CV2(int), bool, true);
- TEST_TTR(CV1(bool), CV2(int), tag, false);
- TEST_TTR(CV1(bool), CV2(double), tag, false);
- TEST_TTR(CV1(int), CV2(bool), tag, false);
- TEST_TTR(CV1(int), CV2(double), tag, false);
- TEST_TTR(CV1(double), CV2(bool), tag, false);
- TEST_TTR(CV1(double), CV2(int), tag, false);
-
-# undef CV1
-# define CV1(T) T
-# undef CV2
-# define CV2(T) const volatile T
- // test with only two template parameters
- TEST_TT(CV1(bool), CV2(int), true);
- TEST_TT(CV1(bool), CV2(double), true);
- TEST_TT(CV1(int), CV2(bool), true);
- TEST_TT(CV1(int), CV2(double), true);
- TEST_TT(CV1(double), CV2(bool), true);
- TEST_TT(CV1(double), CV2(int), true);
-
- // test with three template parameters
- TEST_TTR(CV1(bool), CV2(int), bool, true);
- TEST_TTR(CV1(bool), CV2(double), bool, true);
- TEST_TTR(CV1(int), CV2(bool), bool, true);
- TEST_TTR(CV1(int), CV2(double), bool, true);
- TEST_TTR(CV1(double), CV2(bool), bool, true);
- TEST_TTR(CV1(double), CV2(int), bool, true);
- TEST_TTR(CV1(bool), CV2(int), tag, false);
- TEST_TTR(CV1(bool), CV2(double), tag, false);
- TEST_TTR(CV1(int), CV2(bool), tag, false);
- TEST_TTR(CV1(int), CV2(double), tag, false);
- TEST_TTR(CV1(double), CV2(bool), tag, false);
- TEST_TTR(CV1(double), CV2(int), tag, false);
-
-# undef CV1
-# define CV1(T) T
-# undef CV2
-# define CV2(T) const T&
- // test with only two template parameters
- TEST_TT(CV1(bool), CV2(int), true);
- TEST_TT(CV1(bool), CV2(double), true);
- TEST_TT(CV1(int), CV2(bool), true);
- TEST_TT(CV1(int), CV2(double), true);
- TEST_TT(CV1(double), CV2(bool), true);
- TEST_TT(CV1(double), CV2(int), true);
-
- // test with three template parameters
- TEST_TTR(CV1(bool), CV2(int), bool, true);
- TEST_TTR(CV1(bool), CV2(double), bool, true);
- TEST_TTR(CV1(int), CV2(bool), bool, true);
- TEST_TTR(CV1(int), CV2(double), bool, true);
- TEST_TTR(CV1(double), CV2(bool), bool, true);
- TEST_TTR(CV1(double), CV2(int), bool, true);
- TEST_TTR(CV1(bool), CV2(int), tag, false);
- TEST_TTR(CV1(bool), CV2(double), tag, false);
- TEST_TTR(CV1(int), CV2(bool), tag, false);
- TEST_TTR(CV1(int), CV2(double), tag, false);
- TEST_TTR(CV1(double), CV2(bool), tag, false);
- TEST_TTR(CV1(double), CV2(int), tag, false);
-
-# undef CV1
-# define CV1(T) T
-# undef CV2
-# define CV2(T) volatile T&
- // test with only two template parameters
- TEST_TT(CV1(bool), CV2(int), true);
- TEST_TT(CV1(bool), CV2(double), true);
- TEST_TT(CV1(int), CV2(bool), true);
- TEST_TT(CV1(int), CV2(double), true);
- TEST_TT(CV1(double), CV2(bool), true);
- TEST_TT(CV1(double), CV2(int), true);
-
- // test with three template parameters
- TEST_TTR(CV1(bool), CV2(int), bool, true);
- TEST_TTR(CV1(bool), CV2(double), bool, true);
- TEST_TTR(CV1(int), CV2(bool), bool, true);
- TEST_TTR(CV1(int), CV2(double), bool, true);
- TEST_TTR(CV1(double), CV2(bool), bool, true);
- TEST_TTR(CV1(double), CV2(int), bool, true);
- TEST_TTR(CV1(bool), CV2(int), tag, false);
- TEST_TTR(CV1(bool), CV2(double), tag, false);
- TEST_TTR(CV1(int), CV2(bool), tag, false);
- TEST_TTR(CV1(int), CV2(double), tag, false);
- TEST_TTR(CV1(double), CV2(bool), tag, false);
- TEST_TTR(CV1(double), CV2(int), tag, false);
-
-# undef CV1
-# define CV1(T) T
-# undef CV2
-# define CV2(T) const volatile T&
- // test with only two template parameters
- TEST_TT(CV1(bool), CV2(int), true);
- TEST_TT(CV1(bool), CV2(double), true);
- TEST_TT(CV1(int), CV2(bool), true);
- TEST_TT(CV1(int), CV2(double), true);
- TEST_TT(CV1(double), CV2(bool), true);
- TEST_TT(CV1(double), CV2(int), true);
-
- // test with three template parameters
- TEST_TTR(CV1(bool), CV2(int), bool, true);
- TEST_TTR(CV1(bool), CV2(double), bool, true);
- TEST_TTR(CV1(int), CV2(bool), bool, true);
- TEST_TTR(CV1(int), CV2(double), bool, true);
- TEST_TTR(CV1(double), CV2(bool), bool, true);
- TEST_TTR(CV1(double), CV2(int), bool, true);
- TEST_TTR(CV1(bool), CV2(int), tag, false);
- TEST_TTR(CV1(bool), CV2(double), tag, false);
- TEST_TTR(CV1(int), CV2(bool), tag, false);
- TEST_TTR(CV1(int), CV2(double), tag, false);
- TEST_TTR(CV1(double), CV2(bool), tag, false);
- TEST_TTR(CV1(double), CV2(int), tag, false);
-
-# undef CV1
-# define CV1(T) const T
-# undef CV2
-# define CV2(T) const T
- // test with only two template parameters
- TEST_TT(CV1(bool), CV2(int), false);
- TEST_TT(CV1(bool), CV2(double), false);
- TEST_TT(CV1(int), CV2(bool), false);
- TEST_TT(CV1(int), CV2(double), false);
- TEST_TT(CV1(double), CV2(bool), false);
- TEST_TT(CV1(double), CV2(int), false);
-
- // test with three template parameters
- TEST_TTR(CV1(bool), CV2(int), bool, false);
- TEST_TTR(CV1(bool), CV2(double), bool, false);
- TEST_TTR(CV1(int), CV2(bool), bool, false);
- TEST_TTR(CV1(int), CV2(double), bool, false);
- TEST_TTR(CV1(double), CV2(bool), bool, false);
- TEST_TTR(CV1(double), CV2(int), bool, false);
- TEST_TTR(CV1(bool), CV2(int), tag, false);
- TEST_TTR(CV1(bool), CV2(double), tag, false);
- TEST_TTR(CV1(int), CV2(bool), tag, false);
- TEST_TTR(CV1(int), CV2(double), tag, false);
- TEST_TTR(CV1(double), CV2(bool), tag, false);
- TEST_TTR(CV1(double), CV2(int), tag, false);
-
-# undef CV1
-# define CV1(T) const T&
-# undef CV2
-# define CV2(T) const T&
- // test with only two template parameters
- TEST_TT(CV1(bool), CV2(int), false);
- TEST_TT(CV1(bool), CV2(double), false);
- TEST_TT(CV1(int), CV2(bool), false);
- TEST_TT(CV1(int), CV2(double), false);
- TEST_TT(CV1(double), CV2(bool), false);
- TEST_TT(CV1(double), CV2(int), false);
-
- // test with three template parameters
- TEST_TTR(CV1(bool), CV2(int), bool, false);
- TEST_TTR(CV1(bool), CV2(double), bool, false);
- TEST_TTR(CV1(int), CV2(bool), bool, false);
- TEST_TTR(CV1(int), CV2(double), bool, false);
- TEST_TTR(CV1(double), CV2(bool), bool, false);
- TEST_TTR(CV1(double), CV2(int), bool, false);
- TEST_TTR(CV1(bool), CV2(int), tag, false);
- TEST_TTR(CV1(bool), CV2(double), tag, false);
- TEST_TTR(CV1(int), CV2(bool), tag, false);
- TEST_TTR(CV1(int), CV2(double), tag, false);
- TEST_TTR(CV1(double), CV2(bool), tag, false);
- TEST_TTR(CV1(double), CV2(int), tag, false);
-
-# undef CV1
-# define CV1(T) volatile T
-# undef CV2
-# define CV2(T) volatile T
- // test with only two template parameters
- TEST_TT(CV1(bool), CV2(int), true);
- TEST_TT(CV1(bool), CV2(double), true);
- TEST_TT(CV1(int), CV2(bool), true);
- TEST_TT(CV1(int), CV2(double), true);
- TEST_TT(CV1(double), CV2(bool), true);
- TEST_TT(CV1(double), CV2(int), true);
-
- // test with three template parameters
- TEST_TTR(CV1(bool), CV2(int), bool, true);
- TEST_TTR(CV1(bool), CV2(double), bool, true);
- TEST_TTR(CV1(int), CV2(bool), bool, true);
- TEST_TTR(CV1(int), CV2(double), bool, true);
- TEST_TTR(CV1(double), CV2(bool), bool, true);
- TEST_TTR(CV1(double), CV2(int), bool, true);
- TEST_TTR(CV1(bool), CV2(int), tag, false);
- TEST_TTR(CV1(bool), CV2(double), tag, false);
- TEST_TTR(CV1(int), CV2(bool), tag, false);
- TEST_TTR(CV1(int), CV2(double), tag, false);
- TEST_TTR(CV1(double), CV2(bool), tag, false);
- TEST_TTR(CV1(double), CV2(int), tag, false);
-
-# undef CV1
-# define CV1(T) volatile T&
-# undef CV2
-# define CV2(T) volatile T&
- // test with only two template parameters
- TEST_TT(CV1(bool), CV2(int), true);
- TEST_TT(CV1(bool), CV2(double), true);
- TEST_TT(CV1(int), CV2(bool), true);
- TEST_TT(CV1(int), CV2(double), true);
- TEST_TT(CV1(double), CV2(bool), true);
- TEST_TT(CV1(double), CV2(int), true);
-
- // test with three template parameters
- TEST_TTR(CV1(bool), CV2(int), bool, true);
- TEST_TTR(CV1(bool), CV2(double), bool, true);
- TEST_TTR(CV1(int), CV2(bool), bool, true);
- TEST_TTR(CV1(int), CV2(double), bool, true);
- TEST_TTR(CV1(double), CV2(bool), bool, true);
- TEST_TTR(CV1(double), CV2(int), bool, true);
- TEST_TTR(CV1(bool), CV2(int), tag, false);
- TEST_TTR(CV1(bool), CV2(double), tag, false);
- TEST_TTR(CV1(int), CV2(bool), tag, false);
- TEST_TTR(CV1(int), CV2(double), tag, false);
- TEST_TTR(CV1(double), CV2(bool), tag, false);
- TEST_TTR(CV1(double), CV2(int), tag, false);
-
-# undef CV1
-# define CV1(T) const volatile T
-# undef CV2
-# define CV2(T) const volatile T
- // test with only two template parameters
- TEST_TT(CV1(bool), CV2(int), false);
- TEST_TT(CV1(bool), CV2(double), false);
- TEST_TT(CV1(int), CV2(bool), false);
- TEST_TT(CV1(int), CV2(double), false);
- TEST_TT(CV1(double), CV2(bool), false);
- TEST_TT(CV1(double), CV2(int), false);
-
- // test with three template parameters
- TEST_TTR(CV1(bool), CV2(int), bool, false);
- TEST_TTR(CV1(bool), CV2(double), bool, false);
- TEST_TTR(CV1(int), CV2(bool), bool, false);
- TEST_TTR(CV1(int), CV2(double), bool, false);
- TEST_TTR(CV1(double), CV2(bool), bool, false);
- TEST_TTR(CV1(double), CV2(int), bool, false);
- TEST_TTR(CV1(bool), CV2(int), tag, false);
- TEST_TTR(CV1(bool), CV2(double), tag, false);
- TEST_TTR(CV1(int), CV2(bool), tag, false);
- TEST_TTR(CV1(int), CV2(double), tag, false);
- TEST_TTR(CV1(double), CV2(bool), tag, false);
- TEST_TTR(CV1(double), CV2(int), tag, false);
-
-# undef CV1
-# define CV1(T) const volatile T&
-# undef CV2
-# define CV2(T) const volatile T&
- // test with only two template parameters
- TEST_TT(CV1(bool), CV2(int), false);
- TEST_TT(CV1(bool), CV2(double), false);
- TEST_TT(CV1(int), CV2(bool), false);
- TEST_TT(CV1(int), CV2(double), false);
- TEST_TT(CV1(double), CV2(bool), false);
- TEST_TT(CV1(double), CV2(int), false);
-
- // test with three template parameters
- TEST_TTR(CV1(bool), CV2(int), bool, false);
- TEST_TTR(CV1(bool), CV2(double), bool, false);
- TEST_TTR(CV1(int), CV2(bool), bool, false);
- TEST_TTR(CV1(int), CV2(double), bool, false);
- TEST_TTR(CV1(double), CV2(bool), bool, false);
- TEST_TTR(CV1(double), CV2(int), bool, false);
- TEST_TTR(CV1(bool), CV2(int), tag, false);
- TEST_TTR(CV1(bool), CV2(double), tag, false);
- TEST_TTR(CV1(int), CV2(bool), tag, false);
- TEST_TTR(CV1(int), CV2(double), tag, false);
- TEST_TTR(CV1(double), CV2(bool), tag, false);
- TEST_TTR(CV1(double), CV2(int), tag, false);
-
- // pointers
- TEST_TT(void*, bool, false);
- TEST_TT(void*, int, false);
- TEST_TT(void*, double, false);
- TEST_TT(void*, A, false);
- TEST_TT(void*, B, false);
- TEST_TT(bool*, bool, true);
- TEST_TT(bool*, int, true);
- TEST_TT(bool*, double, false);
- TEST_TT(bool*, A, false);
- TEST_TT(bool*, B, false);
- TEST_TT(int*, bool, true);
- TEST_TT(int*, int, true);
- TEST_TT(int*, double, false);
- TEST_TT(int*, A, false);
- TEST_TT(int*, B, false);
- TEST_TT(double*, bool, true);
- TEST_TT(double*, int, true);
- TEST_TT(double*, double, false);
- TEST_TT(double*, A, false);
- TEST_TT(double*, B, false);
- TEST_TT(A*, bool, true);
- TEST_TT(A*, int, true);
- TEST_TT(A*, double, false);
- TEST_TT(A*, A, false);
- TEST_TT(A*, B, false);
- TEST_TT(B*, bool, true);
- TEST_TT(B*, int, true);
- TEST_TT(B*, double, false);
- TEST_TT(B*, A, false);
- TEST_TT(B*, B, false);
- TEST_TT(bool, void*, false);
- TEST_TT(bool, bool*, true);
- TEST_TT(bool, int*, true);
- TEST_TT(bool, double*, true);
- TEST_TT(bool, A*, true);
- TEST_TT(bool, B*, true);
- TEST_TT(int, void*, false);
- TEST_TT(int, bool*, false);
- TEST_TT(int, int*, false);
- TEST_TT(int, double*, false);
- TEST_TT(int, A*, false);
- TEST_TT(int, B*, false);
- TEST_TT(double, void*, false);
- TEST_TT(double, bool*, false);
- TEST_TT(double, int*, false);
- TEST_TT(double, double*, false);
- TEST_TT(double, A*, false);
- TEST_TT(double, B*, false);
- TEST_TT(A, void*, false);
- TEST_TT(A, bool*, false);
- TEST_TT(A, int*, false);
- TEST_TT(A, double*, false);
- TEST_TT(A, A*, false);
- TEST_TT(A, B*, false);
- TEST_TT(B, void*, false);
- TEST_TT(B, bool*, false);
- TEST_TT(B, int*, false);
- TEST_TT(B, double*, false);
- TEST_TT(B, A*, false);
- TEST_TT(B, B*, false);
- TEST_TT(void*, void*, false);
- TEST_TT(void*, bool*, false);
- TEST_TT(void*, int*, false);
- TEST_TT(void*, double*, false);
- TEST_TT(void*, A*, false);
- TEST_TT(void*, B*, false);
- TEST_TT(bool*, void*, false);
- TEST_TT(bool*, bool*, false);
- TEST_TT(bool*, int*, false);
- TEST_TT(bool*, double*, false);
- TEST_TT(bool*, A*, false);
- TEST_TT(bool*, B*, false);
- TEST_TT(int*, void*, false);
- TEST_TT(int*, bool*, false);
- TEST_TT(int*, int*, false);
- TEST_TT(int*, double*, false);
- TEST_TT(int*, A*, false);
- TEST_TT(int*, B*, false);
- TEST_TT(double*, void*, false);
- TEST_TT(double*, bool*, false);
- TEST_TT(double*, int*, false);
- TEST_TT(double*, double*, false);
- TEST_TT(double*, A*, false);
- TEST_TT(double*, B*, false);
- TEST_TT(A*, void*, false);
- TEST_TT(A*, bool*, false);
- TEST_TT(A*, int*, false);
- TEST_TT(A*, double*, false);
- TEST_TT(A*, A*, false);
- TEST_TT(A*, B*, false);
- TEST_TT(B*, void*, false);
- TEST_TT(B*, bool*, false);
- TEST_TT(B*, int*, false);
- TEST_TT(B*, double*, false);
- TEST_TT(B*, A*, false);
- TEST_TT(B*, B*, false);
- TEST_TT(C, void*, true);
- TEST_TT(D, void*, false);
- TEST_TT(void*, C, false);
- TEST_TT(void*, D, true);
- TEST_TT(C, D, true);
-}
-}

Modified: sandbox/type_traits/libs/type_traits/test/can_call_addition_test.cpp
==============================================================================
--- sandbox/type_traits/libs/type_traits/test/can_call_addition_test.cpp (original)
+++ sandbox/type_traits/libs/type_traits/test/can_call_addition_test.cpp 2011-07-09 16:29:47 EDT (Sat, 09 Jul 2011)
@@ -15,19 +15,264 @@
 #define BOOST_TT_TRAIT_NAME can_call_addition
 #define BOOST_TT_TRAIT_OP +
 
+
 #include "can_call_binary_operators.hpp"
-#include "can_call_addition_test.hpp"
 
-namespace {
 void specific() {
- /* nothing specific */
-}
-}
-
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, bool const, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, void* const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, bool const volatile, int const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, double, int & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, double volatile &, int const & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, void* volatile, bool const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, void* const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int* const, int volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int* const volatile &, int volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, bool const, bool volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, void*, int const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, void*, int volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, void* const &, int const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int* const, bool const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int* const volatile, int & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool volatile, bool const &, bool const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool volatile, int volatile & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool volatile, double, int volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool volatile, double &, int >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool volatile, double const &, int const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool volatile, double const volatile &, int volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool volatile, int* &, bool const & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool volatile, int* const &, bool volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const volatile, bool const volatile &, int const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const volatile, int const volatile, bool const & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const volatile, double, int const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const volatile, double volatile, bool const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const volatile, void* &, int >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, bool const, int const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, double &, bool volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, double volatile &, bool const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int* const volatile, int const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, bool const volatile, bool const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, bool const &, bool const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, int, int const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, int const volatile & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, void* volatile, bool volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool volatile &, void* const volatile, bool >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool volatile &, void* const &, bool volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool volatile &, int* const, bool const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const volatile &, bool, bool >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const volatile &, bool &, int volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const volatile &, double const, bool const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const volatile &, void* const volatile, int const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const volatile &, int*, int >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const volatile &, int* volatile &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool const, int volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, int const volatile, int & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, int &, int const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, int*, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, int* const, bool volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, int* &, bool volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, int* const &, bool const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, int* const volatile &, bool volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, int* const volatile &, int const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, bool, int volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, bool volatile &, int >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, void* &, bool const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int* const &, int const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int volatile, bool const &, bool volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int volatile, bool const volatile &, int const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int volatile, int const volatile &, int const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int volatile, double, bool volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int volatile, void* const volatile, int const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const volatile, int const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const volatile, int const &, int const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const volatile, int volatile &, bool >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const volatile, int const volatile &, int const & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const volatile, double &, int const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const volatile, void* const volatile, bool const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const volatile, void* &, bool >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, bool volatile &, int & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, bool const volatile & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, double &, bool >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, int*, int const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, double volatile &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, double const volatile &, bool const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, void*, int const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int* volatile &, int const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int volatile &, bool, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int volatile &, bool &, int const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int volatile &, int &, int const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int volatile &, double, int const & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int volatile &, double volatile, bool const & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int volatile &, void*, bool const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int volatile &, int* const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const volatile &, bool const volatile, bool >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const volatile &, int volatile &, bool const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const volatile &, double &, bool const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const volatile &, double const &, bool & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const volatile &, void* const volatile, bool >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const volatile &, int* const volatile, bool & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const volatile &, int* const volatile &, bool volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, int &, bool const & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, int const &, int volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, double, bool const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, double volatile, bool >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, void* const volatile, bool const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, void* &, int const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, void* &, int const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, int* volatile, int >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, int* const volatile, bool volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, int* const &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, int* volatile &, bool >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, int* volatile &, int volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, bool const volatile &, bool >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, double &, int & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, double volatile &, bool >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double volatile, bool const volatile, bool const & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double volatile, void*, int volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double volatile, void* const volatile, int const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double volatile, void* const volatile &, bool const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double volatile, int*, bool const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double volatile, int* const, bool volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double volatile, int* volatile, bool const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double volatile, int* &, int volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const volatile, double volatile, bool const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const volatile, double const volatile, int volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const volatile, double volatile &, int const & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const volatile, void* volatile &, bool >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const volatile, int* volatile &, bool & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, int const volatile, bool >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, double const volatile, int const & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, double &, int const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, void* const &, bool & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, int* const, bool const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, int* volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, int* const &, bool volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, double const volatile, bool volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, void* &, bool const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double volatile &, int &, bool & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double volatile &, double volatile, int volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double volatile &, int* const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double volatile &, int* const &, bool const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const volatile &, bool, bool & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const volatile &, bool const, bool & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const volatile &, bool const &, bool const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const volatile &, bool volatile &, bool const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, bool const, int volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, bool volatile &, int const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int const, int const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, double >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, double const volatile, bool const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, double volatile &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, bool const volatile, int const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, bool &, int volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, int volatile, bool volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, int volatile, int const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, int const volatile, bool volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, int const volatile, int const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, int const volatile &, bool const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, double const volatile &, bool const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, void* const volatile &, bool const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* volatile, int volatile, bool volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* volatile, void* const volatile, int const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* volatile, int*, int >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const volatile, double volatile &, bool const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const volatile, void*, int const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const volatile, void* &, bool >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const volatile, int*, bool & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const volatile, int* const volatile, bool volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, bool const &, int const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int* volatile, int const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int* const volatile &, int const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, bool const &, int volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int const, int const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int volatile, bool const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, double volatile, bool const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, double volatile, bool const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, double const volatile, int const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, double const volatile &, int volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, void* const volatile &, bool const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, void* const volatile &, int volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* volatile &, bool volatile &, bool volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* volatile &, double &, int volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* volatile &, void* const &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* volatile &, void* const &, bool & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const volatile &, bool, bool const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const volatile &, bool, bool volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const volatile &, bool volatile, bool const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const volatile &, bool volatile, bool const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const volatile &, bool const &, bool const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const volatile &, int const volatile &, int const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const volatile &, double const volatile &, int volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const volatile &, void* const volatile, bool const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const volatile &, void* const &, bool volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const volatile &, int* volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const volatile &, int* volatile, bool >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const volatile &, int* const &, int >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const volatile &, int* volatile &, int const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, bool, bool const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, bool const &, int & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, bool const volatile &, int >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int volatile &, bool volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, double const volatile &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, double const volatile &, bool const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, bool, int const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, bool const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, double &, bool volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, double volatile &, int const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, int* const, bool const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* volatile, bool const & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* volatile, void* &, bool const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* volatile, void* const volatile &, int const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const volatile, bool, bool >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const volatile, bool const &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const volatile, int const, bool const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const volatile, int const, int const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const volatile, double const volatile, bool const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const volatile, double &, bool volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const volatile, void* volatile, int volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const volatile, void* const &, int const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const volatile, int*, int volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const volatile, int* const volatile &, int const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, int, int const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, int volatile, bool volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, int const & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, void* const, bool volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, void* volatile, int const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, void* volatile &, int & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, void* const volatile &, int >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, bool const &, bool & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, bool volatile &, bool const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, bool volatile &, bool & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int, int volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int const &, int const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, double volatile, bool volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, double &, int volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, double volatile &, int & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, void*, bool const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, void* volatile, bool const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, void* const volatile, bool >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int*, bool const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int*, bool const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int* const volatile &, bool volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* volatile &, bool &, int volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* volatile &, int const volatile, bool volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* volatile &, double const volatile, int const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* volatile &, void*, bool const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* volatile &, void*, bool volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* volatile &, void* const volatile, bool const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* volatile &, void* &, int const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* volatile &, void* const volatile &, bool const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* volatile &, int* volatile &, int const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* volatile &, int* const volatile &, int const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const volatile &, bool, int const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const volatile &, int const volatile, int const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const volatile &, int const &, int volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const volatile &, double const volatile &, int const volatile & >::value), 0);
 
+}
 
 TT_TEST_BEGIN(BOOST_TT_TRAIT_NAME)
- run1();
- run2();
+ common();
    specific();
 TT_TEST_END

Deleted: sandbox/type_traits/libs/type_traits/test/can_call_addition_test.hpp
==============================================================================
--- sandbox/type_traits/libs/type_traits/test/can_call_addition_test.hpp 2011-07-09 16:29:47 EDT (Sat, 09 Jul 2011)
+++ (empty file)
@@ -1,1250 +0,0 @@
-// (C) Copyright Frederic Bron 2009-2011.
-// Use, modification and distribution are subject to the
-// Boost Software License, Version 1.0. (See accompanying file
-// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-namespace {
-
-void run2() {
- // test with only one template parameter
- TEST_T(void, false);
- TEST_T(bool, true);
- TEST_T(char, true);
- TEST_T(signed char, true);
- TEST_T(short int, true);
- TEST_T(int, true);
- TEST_T(long int, true);
- TEST_T(unsigned char, true);
- TEST_T(unsigned short int, true);
- TEST_T(unsigned int, true);
- TEST_T(unsigned long int, true);
- TEST_T(wchar_t, true);
- TEST_T(float, true);
- TEST_T(double, true);
- TEST_T(long double, true);
- TEST_T(void, false);
-# undef CV
-# define CV(T) const T
- TEST_T(CV(bool), true);
- TEST_T(CV(int), true);
- TEST_T(CV(double), true);
-# undef CV
-# define CV(T) volatile T
- TEST_T(CV(bool), true);
- TEST_T(CV(int), true);
- TEST_T(CV(double), true);
-# undef CV
-# define CV(T) const volatile T
- TEST_T(CV(bool), true);
- TEST_T(CV(int), true);
- TEST_T(CV(double), true);
-# undef CV
-# define CV(T) const T&
- TEST_T(CV(bool), true);
- TEST_T(CV(int), true);
- TEST_T(CV(double), true);
-# undef CV
-# define CV(T) volatile T&
- TEST_T(CV(bool), true);
- TEST_T(CV(int), true);
- TEST_T(CV(double), true);
-# undef CV
-# define CV(T) const volatile T&
- TEST_T(CV(bool), true);
- TEST_T(CV(int), true);
- TEST_T(CV(double), true);
-
- // test with only two template parameters
- TEST_TT(void, int, false);
- TEST_TT(int, void, false);
- TEST_TT(void, void, false);
- TEST_TT(bool, bool, true);
- TEST_TT(bool, char, true);
- TEST_TT(bool, signed char, true);
- TEST_TT(bool, short int, true);
- TEST_TT(bool, int, true);
- TEST_TT(bool, long int, true);
- TEST_TT(bool, unsigned char, true);
- TEST_TT(bool, unsigned short int, true);
- TEST_TT(bool, unsigned int, true);
- TEST_TT(bool, unsigned long int, true);
- TEST_TT(bool, wchar_t, true);
- TEST_TT(bool, float, true);
- TEST_TT(bool, double, true);
- TEST_TT(bool, long double, true);
- TEST_TT(char, bool, true);
- TEST_TT(char, char, true);
- TEST_TT(char, signed char, true);
- TEST_TT(char, short int, true);
- TEST_TT(char, int, true);
- TEST_TT(char, long int, true);
- TEST_TT(char, unsigned char, true);
- TEST_TT(char, unsigned short int, true);
- TEST_TT(char, unsigned int, true);
- TEST_TT(char, unsigned long int, true);
- TEST_TT(char, wchar_t, true);
- TEST_TT(char, float, true);
- TEST_TT(char, double, true);
- TEST_TT(char, long double, true);
- TEST_TT(signed char, bool, true);
- TEST_TT(signed char, char, true);
- TEST_TT(signed char, signed char, true);
- TEST_TT(signed char, short int, true);
- TEST_TT(signed char, int, true);
- TEST_TT(signed char, long int, true);
- TEST_TT(signed char, unsigned char, true);
- TEST_TT(signed char, unsigned short int, true);
- TEST_TT(signed char, unsigned int, true);
- TEST_TT(signed char, unsigned long int, true);
- TEST_TT(signed char, wchar_t, true);
- TEST_TT(signed char, float, true);
- TEST_TT(signed char, double, true);
- TEST_TT(signed char, long double, true);
- TEST_TT(short int, bool, true);
- TEST_TT(short int, char, true);
- TEST_TT(short int, signed char, true);
- TEST_TT(short int, short int, true);
- TEST_TT(short int, int, true);
- TEST_TT(short int, long int, true);
- TEST_TT(short int, unsigned char, true);
- TEST_TT(short int, unsigned short int, true);
- TEST_TT(short int, unsigned int, true);
- TEST_TT(short int, unsigned long int, true);
- TEST_TT(short int, wchar_t, true);
- TEST_TT(short int, float, true);
- TEST_TT(short int, double, true);
- TEST_TT(short int, long double, true);
- TEST_TT(int, bool, true);
- TEST_TT(int, char, true);
- TEST_TT(int, signed char, true);
- TEST_TT(int, short int, true);
- TEST_TT(int, int, true);
- TEST_TT(int, long int, true);
- TEST_TT(int, unsigned char, true);
- TEST_TT(int, unsigned short int, true);
- TEST_TT(int, unsigned int, true);
- TEST_TT(int, unsigned long int, true);
- TEST_TT(int, wchar_t, true);
- TEST_TT(int, float, true);
- TEST_TT(int, double, true);
- TEST_TT(int, long double, true);
- TEST_TT(long int, bool, true);
- TEST_TT(long int, char, true);
- TEST_TT(long int, signed char, true);
- TEST_TT(long int, short int, true);
- TEST_TT(long int, int, true);
- TEST_TT(long int, long int, true);
- TEST_TT(long int, unsigned char, true);
- TEST_TT(long int, unsigned short int, true);
- TEST_TT(long int, unsigned int, true);
- TEST_TT(long int, unsigned long int, true);
- TEST_TT(long int, wchar_t, true);
- TEST_TT(long int, float, true);
- TEST_TT(long int, double, true);
- TEST_TT(long int, long double, true);
- TEST_TT(unsigned char, bool, true);
- TEST_TT(unsigned char, char, true);
- TEST_TT(unsigned char, signed char, true);
- TEST_TT(unsigned char, short int, true);
- TEST_TT(unsigned char, int, true);
- TEST_TT(unsigned char, long int, true);
- TEST_TT(unsigned char, unsigned char, true);
- TEST_TT(unsigned char, unsigned short int, true);
- TEST_TT(unsigned char, unsigned int, true);
- TEST_TT(unsigned char, unsigned long int, true);
- TEST_TT(unsigned char, wchar_t, true);
- TEST_TT(unsigned char, float, true);
- TEST_TT(unsigned char, double, true);
- TEST_TT(unsigned char, long double, true);
- TEST_TT(unsigned short int, bool, true);
- TEST_TT(unsigned short int, char, true);
- TEST_TT(unsigned short int, signed char, true);
- TEST_TT(unsigned short int, short int, true);
- TEST_TT(unsigned short int, int, true);
- TEST_TT(unsigned short int, long int, true);
- TEST_TT(unsigned short int, unsigned char, true);
- TEST_TT(unsigned short int, unsigned short int, true);
- TEST_TT(unsigned short int, unsigned int, true);
- TEST_TT(unsigned short int, unsigned long int, true);
- TEST_TT(unsigned short int, wchar_t, true);
- TEST_TT(unsigned short int, float, true);
- TEST_TT(unsigned short int, double, true);
- TEST_TT(unsigned short int, long double, true);
- TEST_TT(unsigned int, bool, true);
- TEST_TT(unsigned int, char, true);
- TEST_TT(unsigned int, signed char, true);
- TEST_TT(unsigned int, short int, true);
- TEST_TT(unsigned int, int, true);
- TEST_TT(unsigned int, long int, true);
- TEST_TT(unsigned int, unsigned char, true);
- TEST_TT(unsigned int, unsigned short int, true);
- TEST_TT(unsigned int, unsigned int, true);
- TEST_TT(unsigned int, unsigned long int, true);
- TEST_TT(unsigned int, wchar_t, true);
- TEST_TT(unsigned int, float, true);
- TEST_TT(unsigned int, double, true);
- TEST_TT(unsigned int, long double, true);
- TEST_TT(unsigned long int, bool, true);
- TEST_TT(unsigned long int, char, true);
- TEST_TT(unsigned long int, signed char, true);
- TEST_TT(unsigned long int, short int, true);
- TEST_TT(unsigned long int, int, true);
- TEST_TT(unsigned long int, long int, true);
- TEST_TT(unsigned long int, unsigned char, true);
- TEST_TT(unsigned long int, unsigned short int, true);
- TEST_TT(unsigned long int, unsigned int, true);
- TEST_TT(unsigned long int, unsigned long int, true);
- TEST_TT(unsigned long int, wchar_t, true);
- TEST_TT(unsigned long int, float, true);
- TEST_TT(unsigned long int, double, true);
- TEST_TT(unsigned long int, long double, true);
- TEST_TT(wchar_t, bool, true);
- TEST_TT(wchar_t, char, true);
- TEST_TT(wchar_t, signed char, true);
- TEST_TT(wchar_t, short int, true);
- TEST_TT(wchar_t, int, true);
- TEST_TT(wchar_t, long int, true);
- TEST_TT(wchar_t, unsigned char, true);
- TEST_TT(wchar_t, unsigned short int, true);
- TEST_TT(wchar_t, unsigned int, true);
- TEST_TT(wchar_t, unsigned long int, true);
- TEST_TT(wchar_t, wchar_t, true);
- TEST_TT(wchar_t, float, true);
- TEST_TT(wchar_t, double, true);
- TEST_TT(wchar_t, long double, true);
- TEST_TT(float, bool, true);
- TEST_TT(float, char, true);
- TEST_TT(float, signed char, true);
- TEST_TT(float, short int, true);
- TEST_TT(float, int, true);
- TEST_TT(float, long int, true);
- TEST_TT(float, unsigned char, true);
- TEST_TT(float, unsigned short int, true);
- TEST_TT(float, unsigned int, true);
- TEST_TT(float, unsigned long int, true);
- TEST_TT(float, wchar_t, true);
- TEST_TT(float, float, true);
- TEST_TT(float, double, true);
- TEST_TT(float, long double, true);
- TEST_TT(double, bool, true);
- TEST_TT(double, char, true);
- TEST_TT(double, signed char, true);
- TEST_TT(double, short int, true);
- TEST_TT(double, int, true);
- TEST_TT(double, long int, true);
- TEST_TT(double, unsigned char, true);
- TEST_TT(double, unsigned short int, true);
- TEST_TT(double, unsigned int, true);
- TEST_TT(double, unsigned long int, true);
- TEST_TT(double, wchar_t, true);
- TEST_TT(double, float, true);
- TEST_TT(double, double, true);
- TEST_TT(double, long double, true);
- TEST_TT(long double, bool, true);
- TEST_TT(long double, char, true);
- TEST_TT(long double, signed char, true);
- TEST_TT(long double, short int, true);
- TEST_TT(long double, int, true);
- TEST_TT(long double, long int, true);
- TEST_TT(long double, unsigned char, true);
- TEST_TT(long double, unsigned short int, true);
- TEST_TT(long double, unsigned int, true);
- TEST_TT(long double, unsigned long int, true);
- TEST_TT(long double, wchar_t, true);
- TEST_TT(long double, float, true);
- TEST_TT(long double, double, true);
- TEST_TT(long double, long double, true);
- TEST_TT(bool, void, false);
- TEST_TT(void, bool, false);
- TEST_TT(char, void, false);
- TEST_TT(void, char, false);
- TEST_TT(signed char, void, false);
- TEST_TT(void, signed char, false);
- TEST_TT(short int, void, false);
- TEST_TT(void, short int, false);
- TEST_TT(int, void, false);
- TEST_TT(void, int, false);
- TEST_TT(long int, void, false);
- TEST_TT(void, long int, false);
- TEST_TT(unsigned char, void, false);
- TEST_TT(void, unsigned char, false);
- TEST_TT(unsigned short int, void, false);
- TEST_TT(void, unsigned short int, false);
- TEST_TT(unsigned int, void, false);
- TEST_TT(void, unsigned int, false);
- TEST_TT(unsigned long int, void, false);
- TEST_TT(void, unsigned long int, false);
- TEST_TT(wchar_t, void, false);
- TEST_TT(void, wchar_t, false);
- TEST_TT(float, void, false);
- TEST_TT(void, float, false);
- TEST_TT(double, void, false);
- TEST_TT(void, double, false);
- TEST_TT(long double, void, false);
- TEST_TT(void, long double, false);
-
-// test with three template parameters
- TEST_TTR(bool, bool, bool, true);
- TEST_TTR(bool, char, bool, true);
- TEST_TTR(bool, signed char, bool, true);
- TEST_TTR(bool, short int, bool, true);
- TEST_TTR(bool, int, bool, true);
- TEST_TTR(bool, long int, bool, true);
- TEST_TTR(bool, unsigned char, bool, true);
- TEST_TTR(bool, unsigned short int, bool, true);
- TEST_TTR(bool, unsigned int, bool, true);
- TEST_TTR(bool, unsigned long int, bool, true);
- TEST_TTR(bool, wchar_t, bool, true);
- TEST_TTR(bool, float, bool, true);
- TEST_TTR(bool, double, bool, true);
- TEST_TTR(bool, long double, bool, true);
- TEST_TTR(char, bool, bool, true);
- TEST_TTR(char, char, bool, true);
- TEST_TTR(char, signed char, bool, true);
- TEST_TTR(char, short int, bool, true);
- TEST_TTR(char, int, bool, true);
- TEST_TTR(char, long int, bool, true);
- TEST_TTR(char, unsigned char, bool, true);
- TEST_TTR(char, unsigned short int, bool, true);
- TEST_TTR(char, unsigned int, bool, true);
- TEST_TTR(char, unsigned long int, bool, true);
- TEST_TTR(char, wchar_t, bool, true);
- TEST_TTR(char, float, bool, true);
- TEST_TTR(char, double, bool, true);
- TEST_TTR(char, long double, bool, true);
- TEST_TTR(signed char, bool, bool, true);
- TEST_TTR(signed char, char, bool, true);
- TEST_TTR(signed char, signed char, bool, true);
- TEST_TTR(signed char, short int, bool, true);
- TEST_TTR(signed char, int, bool, true);
- TEST_TTR(signed char, long int, bool, true);
- TEST_TTR(signed char, unsigned char, bool, true);
- TEST_TTR(signed char, unsigned short int, bool, true);
- TEST_TTR(signed char, unsigned int, bool, true);
- TEST_TTR(signed char, unsigned long int, bool, true);
- TEST_TTR(signed char, wchar_t, bool, true);
- TEST_TTR(signed char, float, bool, true);
- TEST_TTR(signed char, double, bool, true);
- TEST_TTR(signed char, long double, bool, true);
- TEST_TTR(short int, bool, bool, true);
- TEST_TTR(short int, char, bool, true);
- TEST_TTR(short int, signed char, bool, true);
- TEST_TTR(short int, short int, bool, true);
- TEST_TTR(short int, int, bool, true);
- TEST_TTR(short int, long int, bool, true);
- TEST_TTR(short int, unsigned char, bool, true);
- TEST_TTR(short int, unsigned short int, bool, true);
- TEST_TTR(short int, unsigned int, bool, true);
- TEST_TTR(short int, unsigned long int, bool, true);
- TEST_TTR(short int, wchar_t, bool, true);
- TEST_TTR(short int, float, bool, true);
- TEST_TTR(short int, double, bool, true);
- TEST_TTR(short int, long double, bool, true);
- TEST_TTR(int, bool, bool, true);
- TEST_TTR(int, char, bool, true);
- TEST_TTR(int, signed char, bool, true);
- TEST_TTR(int, short int, bool, true);
- TEST_TTR(int, int, bool, true);
- TEST_TTR(int, long int, bool, true);
- TEST_TTR(int, unsigned char, bool, true);
- TEST_TTR(int, unsigned short int, bool, true);
- TEST_TTR(int, unsigned int, bool, true);
- TEST_TTR(int, unsigned long int, bool, true);
- TEST_TTR(int, wchar_t, bool, true);
- TEST_TTR(int, float, bool, true);
- TEST_TTR(int, double, bool, true);
- TEST_TTR(int, long double, bool, true);
- TEST_TTR(long int, bool, bool, true);
- TEST_TTR(long int, char, bool, true);
- TEST_TTR(long int, signed char, bool, true);
- TEST_TTR(long int, short int, bool, true);
- TEST_TTR(long int, int, bool, true);
- TEST_TTR(long int, long int, bool, true);
- TEST_TTR(long int, unsigned char, bool, true);
- TEST_TTR(long int, unsigned short int, bool, true);
- TEST_TTR(long int, unsigned int, bool, true);
- TEST_TTR(long int, unsigned long int, bool, true);
- TEST_TTR(long int, wchar_t, bool, true);
- TEST_TTR(long int, float, bool, true);
- TEST_TTR(long int, double, bool, true);
- TEST_TTR(long int, long double, bool, true);
- TEST_TTR(unsigned char, bool, bool, true);
- TEST_TTR(unsigned char, char, bool, true);
- TEST_TTR(unsigned char, signed char, bool, true);
- TEST_TTR(unsigned char, short int, bool, true);
- TEST_TTR(unsigned char, int, bool, true);
- TEST_TTR(unsigned char, long int, bool, true);
- TEST_TTR(unsigned char, unsigned char, bool, true);
- TEST_TTR(unsigned char, unsigned short int, bool, true);
- TEST_TTR(unsigned char, unsigned int, bool, true);
- TEST_TTR(unsigned char, unsigned long int, bool, true);
- TEST_TTR(unsigned char, wchar_t, bool, true);
- TEST_TTR(unsigned char, float, bool, true);
- TEST_TTR(unsigned char, double, bool, true);
- TEST_TTR(unsigned char, long double, bool, true);
- TEST_TTR(unsigned short int, bool, bool, true);
- TEST_TTR(unsigned short int, char, bool, true);
- TEST_TTR(unsigned short int, signed char, bool, true);
- TEST_TTR(unsigned short int, short int, bool, true);
- TEST_TTR(unsigned short int, int, bool, true);
- TEST_TTR(unsigned short int, long int, bool, true);
- TEST_TTR(unsigned short int, unsigned char, bool, true);
- TEST_TTR(unsigned short int, unsigned short int, bool, true);
- TEST_TTR(unsigned short int, unsigned int, bool, true);
- TEST_TTR(unsigned short int, unsigned long int, bool, true);
- TEST_TTR(unsigned short int, wchar_t, bool, true);
- TEST_TTR(unsigned short int, float, bool, true);
- TEST_TTR(unsigned short int, double, bool, true);
- TEST_TTR(unsigned short int, long double, bool, true);
- TEST_TTR(unsigned int, bool, bool, true);
- TEST_TTR(unsigned int, char, bool, true);
- TEST_TTR(unsigned int, signed char, bool, true);
- TEST_TTR(unsigned int, short int, bool, true);
- TEST_TTR(unsigned int, int, bool, true);
- TEST_TTR(unsigned int, long int, bool, true);
- TEST_TTR(unsigned int, unsigned char, bool, true);
- TEST_TTR(unsigned int, unsigned short int, bool, true);
- TEST_TTR(unsigned int, unsigned int, bool, true);
- TEST_TTR(unsigned int, unsigned long int, bool, true);
- TEST_TTR(unsigned int, wchar_t, bool, true);
- TEST_TTR(unsigned int, float, bool, true);
- TEST_TTR(unsigned int, double, bool, true);
- TEST_TTR(unsigned int, long double, bool, true);
- TEST_TTR(unsigned long int, bool, bool, true);
- TEST_TTR(unsigned long int, char, bool, true);
- TEST_TTR(unsigned long int, signed char, bool, true);
- TEST_TTR(unsigned long int, short int, bool, true);
- TEST_TTR(unsigned long int, int, bool, true);
- TEST_TTR(unsigned long int, long int, bool, true);
- TEST_TTR(unsigned long int, unsigned char, bool, true);
- TEST_TTR(unsigned long int, unsigned short int, bool, true);
- TEST_TTR(unsigned long int, unsigned int, bool, true);
- TEST_TTR(unsigned long int, unsigned long int, bool, true);
- TEST_TTR(unsigned long int, wchar_t, bool, true);
- TEST_TTR(unsigned long int, float, bool, true);
- TEST_TTR(unsigned long int, double, bool, true);
- TEST_TTR(unsigned long int, long double, bool, true);
- TEST_TTR(wchar_t, bool, bool, true);
- TEST_TTR(wchar_t, char, bool, true);
- TEST_TTR(wchar_t, signed char, bool, true);
- TEST_TTR(wchar_t, short int, bool, true);
- TEST_TTR(wchar_t, int, bool, true);
- TEST_TTR(wchar_t, long int, bool, true);
- TEST_TTR(wchar_t, unsigned char, bool, true);
- TEST_TTR(wchar_t, unsigned short int, bool, true);
- TEST_TTR(wchar_t, unsigned int, bool, true);
- TEST_TTR(wchar_t, unsigned long int, bool, true);
- TEST_TTR(wchar_t, wchar_t, bool, true);
- TEST_TTR(wchar_t, float, bool, true);
- TEST_TTR(wchar_t, double, bool, true);
- TEST_TTR(wchar_t, long double, bool, true);
- TEST_TTR(float, bool, bool, true);
- TEST_TTR(float, char, bool, true);
- TEST_TTR(float, signed char, bool, true);
- TEST_TTR(float, short int, bool, true);
- TEST_TTR(float, int, bool, true);
- TEST_TTR(float, long int, bool, true);
- TEST_TTR(float, unsigned char, bool, true);
- TEST_TTR(float, unsigned short int, bool, true);
- TEST_TTR(float, unsigned int, bool, true);
- TEST_TTR(float, unsigned long int, bool, true);
- TEST_TTR(float, wchar_t, bool, true);
- TEST_TTR(float, float, bool, true);
- TEST_TTR(float, double, bool, true);
- TEST_TTR(float, long double, bool, true);
- TEST_TTR(double, bool, bool, true);
- TEST_TTR(double, char, bool, true);
- TEST_TTR(double, signed char, bool, true);
- TEST_TTR(double, short int, bool, true);
- TEST_TTR(double, int, bool, true);
- TEST_TTR(double, long int, bool, true);
- TEST_TTR(double, unsigned char, bool, true);
- TEST_TTR(double, unsigned short int, bool, true);
- TEST_TTR(double, unsigned int, bool, true);
- TEST_TTR(double, unsigned long int, bool, true);
- TEST_TTR(double, wchar_t, bool, true);
- TEST_TTR(double, float, bool, true);
- TEST_TTR(double, double, bool, true);
- TEST_TTR(double, long double, bool, true);
- TEST_TTR(long double, bool, bool, true);
- TEST_TTR(long double, char, bool, true);
- TEST_TTR(long double, signed char, bool, true);
- TEST_TTR(long double, short int, bool, true);
- TEST_TTR(long double, int, bool, true);
- TEST_TTR(long double, long int, bool, true);
- TEST_TTR(long double, unsigned char, bool, true);
- TEST_TTR(long double, unsigned short int, bool, true);
- TEST_TTR(long double, unsigned int, bool, true);
- TEST_TTR(long double, unsigned long int, bool, true);
- TEST_TTR(long double, wchar_t, bool, true);
- TEST_TTR(long double, float, bool, true);
- TEST_TTR(long double, double, bool, true);
- TEST_TTR(long double, long double, bool, true);
- TEST_TTR(bool, bool, tag, false);
- TEST_TTR(bool, char, tag, false);
- TEST_TTR(bool, signed char, tag, false);
- TEST_TTR(bool, short int, tag, false);
- TEST_TTR(bool, int, tag, false);
- TEST_TTR(bool, long int, tag, false);
- TEST_TTR(bool, unsigned char, tag, false);
- TEST_TTR(bool, unsigned short int, tag, false);
- TEST_TTR(bool, unsigned int, tag, false);
- TEST_TTR(bool, unsigned long int, tag, false);
- TEST_TTR(bool, wchar_t, tag, false);
- TEST_TTR(bool, float, tag, false);
- TEST_TTR(bool, double, tag, false);
- TEST_TTR(bool, long double, tag, false);
- TEST_TTR(char, bool, tag, false);
- TEST_TTR(char, char, tag, false);
- TEST_TTR(char, signed char, tag, false);
- TEST_TTR(char, short int, tag, false);
- TEST_TTR(char, int, tag, false);
- TEST_TTR(char, long int, tag, false);
- TEST_TTR(char, unsigned char, tag, false);
- TEST_TTR(char, unsigned short int, tag, false);
- TEST_TTR(char, unsigned int, tag, false);
- TEST_TTR(char, unsigned long int, tag, false);
- TEST_TTR(char, wchar_t, tag, false);
- TEST_TTR(char, float, tag, false);
- TEST_TTR(char, double, tag, false);
- TEST_TTR(char, long double, tag, false);
- TEST_TTR(signed char, bool, tag, false);
- TEST_TTR(signed char, char, tag, false);
- TEST_TTR(signed char, signed char, tag, false);
- TEST_TTR(signed char, short int, tag, false);
- TEST_TTR(signed char, int, tag, false);
- TEST_TTR(signed char, long int, tag, false);
- TEST_TTR(signed char, unsigned char, tag, false);
- TEST_TTR(signed char, unsigned short int, tag, false);
- TEST_TTR(signed char, unsigned int, tag, false);
- TEST_TTR(signed char, unsigned long int, tag, false);
- TEST_TTR(signed char, wchar_t, tag, false);
- TEST_TTR(signed char, float, tag, false);
- TEST_TTR(signed char, double, tag, false);
- TEST_TTR(signed char, long double, tag, false);
- TEST_TTR(short int, bool, tag, false);
- TEST_TTR(short int, char, tag, false);
- TEST_TTR(short int, signed char, tag, false);
- TEST_TTR(short int, short int, tag, false);
- TEST_TTR(short int, int, tag, false);
- TEST_TTR(short int, long int, tag, false);
- TEST_TTR(short int, unsigned char, tag, false);
- TEST_TTR(short int, unsigned short int, tag, false);
- TEST_TTR(short int, unsigned int, tag, false);
- TEST_TTR(short int, unsigned long int, tag, false);
- TEST_TTR(short int, wchar_t, tag, false);
- TEST_TTR(short int, float, tag, false);
- TEST_TTR(short int, double, tag, false);
- TEST_TTR(short int, long double, tag, false);
- TEST_TTR(int, bool, tag, false);
- TEST_TTR(int, char, tag, false);
- TEST_TTR(int, signed char, tag, false);
- TEST_TTR(int, short int, tag, false);
- TEST_TTR(int, int, tag, false);
- TEST_TTR(int, long int, tag, false);
- TEST_TTR(int, unsigned char, tag, false);
- TEST_TTR(int, unsigned short int, tag, false);
- TEST_TTR(int, unsigned int, tag, false);
- TEST_TTR(int, unsigned long int, tag, false);
- TEST_TTR(int, wchar_t, tag, false);
- TEST_TTR(int, float, tag, false);
- TEST_TTR(int, double, tag, false);
- TEST_TTR(int, long double, tag, false);
- TEST_TTR(long int, bool, tag, false);
- TEST_TTR(long int, char, tag, false);
- TEST_TTR(long int, signed char, tag, false);
- TEST_TTR(long int, short int, tag, false);
- TEST_TTR(long int, int, tag, false);
- TEST_TTR(long int, long int, tag, false);
- TEST_TTR(long int, unsigned char, tag, false);
- TEST_TTR(long int, unsigned short int, tag, false);
- TEST_TTR(long int, unsigned int, tag, false);
- TEST_TTR(long int, unsigned long int, tag, false);
- TEST_TTR(long int, wchar_t, tag, false);
- TEST_TTR(long int, float, tag, false);
- TEST_TTR(long int, double, tag, false);
- TEST_TTR(long int, long double, tag, false);
- TEST_TTR(unsigned char, bool, tag, false);
- TEST_TTR(unsigned char, char, tag, false);
- TEST_TTR(unsigned char, signed char, tag, false);
- TEST_TTR(unsigned char, short int, tag, false);
- TEST_TTR(unsigned char, int, tag, false);
- TEST_TTR(unsigned char, long int, tag, false);
- TEST_TTR(unsigned char, unsigned char, tag, false);
- TEST_TTR(unsigned char, unsigned short int, tag, false);
- TEST_TTR(unsigned char, unsigned int, tag, false);
- TEST_TTR(unsigned char, unsigned long int, tag, false);
- TEST_TTR(unsigned char, wchar_t, tag, false);
- TEST_TTR(unsigned char, float, tag, false);
- TEST_TTR(unsigned char, double, tag, false);
- TEST_TTR(unsigned char, long double, tag, false);
- TEST_TTR(unsigned short int, bool, tag, false);
- TEST_TTR(unsigned short int, char, tag, false);
- TEST_TTR(unsigned short int, signed char, tag, false);
- TEST_TTR(unsigned short int, short int, tag, false);
- TEST_TTR(unsigned short int, int, tag, false);
- TEST_TTR(unsigned short int, long int, tag, false);
- TEST_TTR(unsigned short int, unsigned char, tag, false);
- TEST_TTR(unsigned short int, unsigned short int, tag, false);
- TEST_TTR(unsigned short int, unsigned int, tag, false);
- TEST_TTR(unsigned short int, unsigned long int, tag, false);
- TEST_TTR(unsigned short int, wchar_t, tag, false);
- TEST_TTR(unsigned short int, float, tag, false);
- TEST_TTR(unsigned short int, double, tag, false);
- TEST_TTR(unsigned short int, long double, tag, false);
- TEST_TTR(unsigned int, bool, tag, false);
- TEST_TTR(unsigned int, char, tag, false);
- TEST_TTR(unsigned int, signed char, tag, false);
- TEST_TTR(unsigned int, short int, tag, false);
- TEST_TTR(unsigned int, int, tag, false);
- TEST_TTR(unsigned int, long int, tag, false);
- TEST_TTR(unsigned int, unsigned char, tag, false);
- TEST_TTR(unsigned int, unsigned short int, tag, false);
- TEST_TTR(unsigned int, unsigned int, tag, false);
- TEST_TTR(unsigned int, unsigned long int, tag, false);
- TEST_TTR(unsigned int, wchar_t, tag, false);
- TEST_TTR(unsigned int, float, tag, false);
- TEST_TTR(unsigned int, double, tag, false);
- TEST_TTR(unsigned int, long double, tag, false);
- TEST_TTR(unsigned long int, bool, tag, false);
- TEST_TTR(unsigned long int, char, tag, false);
- TEST_TTR(unsigned long int, signed char, tag, false);
- TEST_TTR(unsigned long int, short int, tag, false);
- TEST_TTR(unsigned long int, int, tag, false);
- TEST_TTR(unsigned long int, long int, tag, false);
- TEST_TTR(unsigned long int, unsigned char, tag, false);
- TEST_TTR(unsigned long int, unsigned short int, tag, false);
- TEST_TTR(unsigned long int, unsigned int, tag, false);
- TEST_TTR(unsigned long int, unsigned long int, tag, false);
- TEST_TTR(unsigned long int, wchar_t, tag, false);
- TEST_TTR(unsigned long int, float, tag, false);
- TEST_TTR(unsigned long int, double, tag, false);
- TEST_TTR(unsigned long int, long double, tag, false);
- TEST_TTR(wchar_t, bool, tag, false);
- TEST_TTR(wchar_t, char, tag, false);
- TEST_TTR(wchar_t, signed char, tag, false);
- TEST_TTR(wchar_t, short int, tag, false);
- TEST_TTR(wchar_t, int, tag, false);
- TEST_TTR(wchar_t, long int, tag, false);
- TEST_TTR(wchar_t, unsigned char, tag, false);
- TEST_TTR(wchar_t, unsigned short int, tag, false);
- TEST_TTR(wchar_t, unsigned int, tag, false);
- TEST_TTR(wchar_t, unsigned long int, tag, false);
- TEST_TTR(wchar_t, wchar_t, tag, false);
- TEST_TTR(wchar_t, float, tag, false);
- TEST_TTR(wchar_t, double, tag, false);
- TEST_TTR(wchar_t, long double, tag, false);
- TEST_TTR(float, bool, tag, false);
- TEST_TTR(float, char, tag, false);
- TEST_TTR(float, signed char, tag, false);
- TEST_TTR(float, short int, tag, false);
- TEST_TTR(float, int, tag, false);
- TEST_TTR(float, long int, tag, false);
- TEST_TTR(float, unsigned char, tag, false);
- TEST_TTR(float, unsigned short int, tag, false);
- TEST_TTR(float, unsigned int, tag, false);
- TEST_TTR(float, unsigned long int, tag, false);
- TEST_TTR(float, wchar_t, tag, false);
- TEST_TTR(float, float, tag, false);
- TEST_TTR(float, double, tag, false);
- TEST_TTR(float, long double, tag, false);
- TEST_TTR(double, bool, tag, false);
- TEST_TTR(double, char, tag, false);
- TEST_TTR(double, signed char, tag, false);
- TEST_TTR(double, short int, tag, false);
- TEST_TTR(double, int, tag, false);
- TEST_TTR(double, long int, tag, false);
- TEST_TTR(double, unsigned char, tag, false);
- TEST_TTR(double, unsigned short int, tag, false);
- TEST_TTR(double, unsigned int, tag, false);
- TEST_TTR(double, unsigned long int, tag, false);
- TEST_TTR(double, wchar_t, tag, false);
- TEST_TTR(double, float, tag, false);
- TEST_TTR(double, double, tag, false);
- TEST_TTR(double, long double, tag, false);
- TEST_TTR(long double, bool, tag, false);
- TEST_TTR(long double, char, tag, false);
- TEST_TTR(long double, signed char, tag, false);
- TEST_TTR(long double, short int, tag, false);
- TEST_TTR(long double, int, tag, false);
- TEST_TTR(long double, long int, tag, false);
- TEST_TTR(long double, unsigned char, tag, false);
- TEST_TTR(long double, unsigned short int, tag, false);
- TEST_TTR(long double, unsigned int, tag, false);
- TEST_TTR(long double, unsigned long int, tag, false);
- TEST_TTR(long double, wchar_t, tag, false);
- TEST_TTR(long double, float, tag, false);
- TEST_TTR(long double, double, tag, false);
- TEST_TTR(long double, long double, tag, false);
-# undef CV1
-# define CV1(T) const T
-# undef CV2
-# define CV2(T) T
- // test with only two template parameters
- TEST_TT(CV1(bool), CV2(int), true);
- TEST_TT(CV1(bool), CV2(double), true);
- TEST_TT(CV1(int), CV2(bool), true);
- TEST_TT(CV1(int), CV2(double), true);
- TEST_TT(CV1(double), CV2(bool), true);
- TEST_TT(CV1(double), CV2(int), true);
-
- // test with three template parameters
- TEST_TTR(CV1(bool), CV2(int), bool, true);
- TEST_TTR(CV1(bool), CV2(double), bool, true);
- TEST_TTR(CV1(int), CV2(bool), bool, true);
- TEST_TTR(CV1(int), CV2(double), bool, true);
- TEST_TTR(CV1(double), CV2(bool), bool, true);
- TEST_TTR(CV1(double), CV2(int), bool, true);
- TEST_TTR(CV1(bool), CV2(int), tag, false);
- TEST_TTR(CV1(bool), CV2(double), tag, false);
- TEST_TTR(CV1(int), CV2(bool), tag, false);
- TEST_TTR(CV1(int), CV2(double), tag, false);
- TEST_TTR(CV1(double), CV2(bool), tag, false);
- TEST_TTR(CV1(double), CV2(int), tag, false);
-
-# undef CV1
-# define CV1(T) volatile T
-# undef CV2
-# define CV2(T) T
- // test with only two template parameters
- TEST_TT(CV1(bool), CV2(int), true);
- TEST_TT(CV1(bool), CV2(double), true);
- TEST_TT(CV1(int), CV2(bool), true);
- TEST_TT(CV1(int), CV2(double), true);
- TEST_TT(CV1(double), CV2(bool), true);
- TEST_TT(CV1(double), CV2(int), true);
-
- // test with three template parameters
- TEST_TTR(CV1(bool), CV2(int), bool, true);
- TEST_TTR(CV1(bool), CV2(double), bool, true);
- TEST_TTR(CV1(int), CV2(bool), bool, true);
- TEST_TTR(CV1(int), CV2(double), bool, true);
- TEST_TTR(CV1(double), CV2(bool), bool, true);
- TEST_TTR(CV1(double), CV2(int), bool, true);
- TEST_TTR(CV1(bool), CV2(int), tag, false);
- TEST_TTR(CV1(bool), CV2(double), tag, false);
- TEST_TTR(CV1(int), CV2(bool), tag, false);
- TEST_TTR(CV1(int), CV2(double), tag, false);
- TEST_TTR(CV1(double), CV2(bool), tag, false);
- TEST_TTR(CV1(double), CV2(int), tag, false);
-
-# undef CV1
-# define CV1(T) const volatile T
-# undef CV2
-# define CV2(T) T
- // test with only two template parameters
- TEST_TT(CV1(bool), CV2(int), true);
- TEST_TT(CV1(bool), CV2(double), true);
- TEST_TT(CV1(int), CV2(bool), true);
- TEST_TT(CV1(int), CV2(double), true);
- TEST_TT(CV1(double), CV2(bool), true);
- TEST_TT(CV1(double), CV2(int), true);
-
- // test with three template parameters
- TEST_TTR(CV1(bool), CV2(int), bool, true);
- TEST_TTR(CV1(bool), CV2(double), bool, true);
- TEST_TTR(CV1(int), CV2(bool), bool, true);
- TEST_TTR(CV1(int), CV2(double), bool, true);
- TEST_TTR(CV1(double), CV2(bool), bool, true);
- TEST_TTR(CV1(double), CV2(int), bool, true);
- TEST_TTR(CV1(bool), CV2(int), tag, false);
- TEST_TTR(CV1(bool), CV2(double), tag, false);
- TEST_TTR(CV1(int), CV2(bool), tag, false);
- TEST_TTR(CV1(int), CV2(double), tag, false);
- TEST_TTR(CV1(double), CV2(bool), tag, false);
- TEST_TTR(CV1(double), CV2(int), tag, false);
-
-# undef CV1
-# define CV1(T) const T&
-# undef CV2
-# define CV2(T) T
- // test with only two template parameters
- TEST_TT(CV1(bool), CV2(int), true);
- TEST_TT(CV1(bool), CV2(double), true);
- TEST_TT(CV1(int), CV2(bool), true);
- TEST_TT(CV1(int), CV2(double), true);
- TEST_TT(CV1(double), CV2(bool), true);
- TEST_TT(CV1(double), CV2(int), true);
-
- // test with three template parameters
- TEST_TTR(CV1(bool), CV2(int), bool, true);
- TEST_TTR(CV1(bool), CV2(double), bool, true);
- TEST_TTR(CV1(int), CV2(bool), bool, true);
- TEST_TTR(CV1(int), CV2(double), bool, true);
- TEST_TTR(CV1(double), CV2(bool), bool, true);
- TEST_TTR(CV1(double), CV2(int), bool, true);
- TEST_TTR(CV1(bool), CV2(int), tag, false);
- TEST_TTR(CV1(bool), CV2(double), tag, false);
- TEST_TTR(CV1(int), CV2(bool), tag, false);
- TEST_TTR(CV1(int), CV2(double), tag, false);
- TEST_TTR(CV1(double), CV2(bool), tag, false);
- TEST_TTR(CV1(double), CV2(int), tag, false);
-
-# undef CV1
-# define CV1(T) volatile T&
-# undef CV2
-# define CV2(T) T
- // test with only two template parameters
- TEST_TT(CV1(bool), CV2(int), true);
- TEST_TT(CV1(bool), CV2(double), true);
- TEST_TT(CV1(int), CV2(bool), true);
- TEST_TT(CV1(int), CV2(double), true);
- TEST_TT(CV1(double), CV2(bool), true);
- TEST_TT(CV1(double), CV2(int), true);
-
- // test with three template parameters
- TEST_TTR(CV1(bool), CV2(int), bool, true);
- TEST_TTR(CV1(bool), CV2(double), bool, true);
- TEST_TTR(CV1(int), CV2(bool), bool, true);
- TEST_TTR(CV1(int), CV2(double), bool, true);
- TEST_TTR(CV1(double), CV2(bool), bool, true);
- TEST_TTR(CV1(double), CV2(int), bool, true);
- TEST_TTR(CV1(bool), CV2(int), tag, false);
- TEST_TTR(CV1(bool), CV2(double), tag, false);
- TEST_TTR(CV1(int), CV2(bool), tag, false);
- TEST_TTR(CV1(int), CV2(double), tag, false);
- TEST_TTR(CV1(double), CV2(bool), tag, false);
- TEST_TTR(CV1(double), CV2(int), tag, false);
-
-# undef CV1
-# define CV1(T) const volatile T&
-# undef CV2
-# define CV2(T) T
- // test with only two template parameters
- TEST_TT(CV1(bool), CV2(int), true);
- TEST_TT(CV1(bool), CV2(double), true);
- TEST_TT(CV1(int), CV2(bool), true);
- TEST_TT(CV1(int), CV2(double), true);
- TEST_TT(CV1(double), CV2(bool), true);
- TEST_TT(CV1(double), CV2(int), true);
-
- // test with three template parameters
- TEST_TTR(CV1(bool), CV2(int), bool, true);
- TEST_TTR(CV1(bool), CV2(double), bool, true);
- TEST_TTR(CV1(int), CV2(bool), bool, true);
- TEST_TTR(CV1(int), CV2(double), bool, true);
- TEST_TTR(CV1(double), CV2(bool), bool, true);
- TEST_TTR(CV1(double), CV2(int), bool, true);
- TEST_TTR(CV1(bool), CV2(int), tag, false);
- TEST_TTR(CV1(bool), CV2(double), tag, false);
- TEST_TTR(CV1(int), CV2(bool), tag, false);
- TEST_TTR(CV1(int), CV2(double), tag, false);
- TEST_TTR(CV1(double), CV2(bool), tag, false);
- TEST_TTR(CV1(double), CV2(int), tag, false);
-
-# undef CV1
-# define CV1(T) T
-# undef CV2
-# define CV2(T) const T
- // test with only two template parameters
- TEST_TT(CV1(bool), CV2(int), true);
- TEST_TT(CV1(bool), CV2(double), true);
- TEST_TT(CV1(int), CV2(bool), true);
- TEST_TT(CV1(int), CV2(double), true);
- TEST_TT(CV1(double), CV2(bool), true);
- TEST_TT(CV1(double), CV2(int), true);
-
- // test with three template parameters
- TEST_TTR(CV1(bool), CV2(int), bool, true);
- TEST_TTR(CV1(bool), CV2(double), bool, true);
- TEST_TTR(CV1(int), CV2(bool), bool, true);
- TEST_TTR(CV1(int), CV2(double), bool, true);
- TEST_TTR(CV1(double), CV2(bool), bool, true);
- TEST_TTR(CV1(double), CV2(int), bool, true);
- TEST_TTR(CV1(bool), CV2(int), tag, false);
- TEST_TTR(CV1(bool), CV2(double), tag, false);
- TEST_TTR(CV1(int), CV2(bool), tag, false);
- TEST_TTR(CV1(int), CV2(double), tag, false);
- TEST_TTR(CV1(double), CV2(bool), tag, false);
- TEST_TTR(CV1(double), CV2(int), tag, false);
-
-# undef CV1
-# define CV1(T) T
-# undef CV2
-# define CV2(T) volatile T
- // test with only two template parameters
- TEST_TT(CV1(bool), CV2(int), true);
- TEST_TT(CV1(bool), CV2(double), true);
- TEST_TT(CV1(int), CV2(bool), true);
- TEST_TT(CV1(int), CV2(double), true);
- TEST_TT(CV1(double), CV2(bool), true);
- TEST_TT(CV1(double), CV2(int), true);
-
- // test with three template parameters
- TEST_TTR(CV1(bool), CV2(int), bool, true);
- TEST_TTR(CV1(bool), CV2(double), bool, true);
- TEST_TTR(CV1(int), CV2(bool), bool, true);
- TEST_TTR(CV1(int), CV2(double), bool, true);
- TEST_TTR(CV1(double), CV2(bool), bool, true);
- TEST_TTR(CV1(double), CV2(int), bool, true);
- TEST_TTR(CV1(bool), CV2(int), tag, false);
- TEST_TTR(CV1(bool), CV2(double), tag, false);
- TEST_TTR(CV1(int), CV2(bool), tag, false);
- TEST_TTR(CV1(int), CV2(double), tag, false);
- TEST_TTR(CV1(double), CV2(bool), tag, false);
- TEST_TTR(CV1(double), CV2(int), tag, false);
-
-# undef CV1
-# define CV1(T) T
-# undef CV2
-# define CV2(T) const volatile T
- // test with only two template parameters
- TEST_TT(CV1(bool), CV2(int), true);
- TEST_TT(CV1(bool), CV2(double), true);
- TEST_TT(CV1(int), CV2(bool), true);
- TEST_TT(CV1(int), CV2(double), true);
- TEST_TT(CV1(double), CV2(bool), true);
- TEST_TT(CV1(double), CV2(int), true);
-
- // test with three template parameters
- TEST_TTR(CV1(bool), CV2(int), bool, true);
- TEST_TTR(CV1(bool), CV2(double), bool, true);
- TEST_TTR(CV1(int), CV2(bool), bool, true);
- TEST_TTR(CV1(int), CV2(double), bool, true);
- TEST_TTR(CV1(double), CV2(bool), bool, true);
- TEST_TTR(CV1(double), CV2(int), bool, true);
- TEST_TTR(CV1(bool), CV2(int), tag, false);
- TEST_TTR(CV1(bool), CV2(double), tag, false);
- TEST_TTR(CV1(int), CV2(bool), tag, false);
- TEST_TTR(CV1(int), CV2(double), tag, false);
- TEST_TTR(CV1(double), CV2(bool), tag, false);
- TEST_TTR(CV1(double), CV2(int), tag, false);
-
-# undef CV1
-# define CV1(T) T
-# undef CV2
-# define CV2(T) const T&
- // test with only two template parameters
- TEST_TT(CV1(bool), CV2(int), true);
- TEST_TT(CV1(bool), CV2(double), true);
- TEST_TT(CV1(int), CV2(bool), true);
- TEST_TT(CV1(int), CV2(double), true);
- TEST_TT(CV1(double), CV2(bool), true);
- TEST_TT(CV1(double), CV2(int), true);
-
- // test with three template parameters
- TEST_TTR(CV1(bool), CV2(int), bool, true);
- TEST_TTR(CV1(bool), CV2(double), bool, true);
- TEST_TTR(CV1(int), CV2(bool), bool, true);
- TEST_TTR(CV1(int), CV2(double), bool, true);
- TEST_TTR(CV1(double), CV2(bool), bool, true);
- TEST_TTR(CV1(double), CV2(int), bool, true);
- TEST_TTR(CV1(bool), CV2(int), tag, false);
- TEST_TTR(CV1(bool), CV2(double), tag, false);
- TEST_TTR(CV1(int), CV2(bool), tag, false);
- TEST_TTR(CV1(int), CV2(double), tag, false);
- TEST_TTR(CV1(double), CV2(bool), tag, false);
- TEST_TTR(CV1(double), CV2(int), tag, false);
-
-# undef CV1
-# define CV1(T) T
-# undef CV2
-# define CV2(T) volatile T&
- // test with only two template parameters
- TEST_TT(CV1(bool), CV2(int), true);
- TEST_TT(CV1(bool), CV2(double), true);
- TEST_TT(CV1(int), CV2(bool), true);
- TEST_TT(CV1(int), CV2(double), true);
- TEST_TT(CV1(double), CV2(bool), true);
- TEST_TT(CV1(double), CV2(int), true);
-
- // test with three template parameters
- TEST_TTR(CV1(bool), CV2(int), bool, true);
- TEST_TTR(CV1(bool), CV2(double), bool, true);
- TEST_TTR(CV1(int), CV2(bool), bool, true);
- TEST_TTR(CV1(int), CV2(double), bool, true);
- TEST_TTR(CV1(double), CV2(bool), bool, true);
- TEST_TTR(CV1(double), CV2(int), bool, true);
- TEST_TTR(CV1(bool), CV2(int), tag, false);
- TEST_TTR(CV1(bool), CV2(double), tag, false);
- TEST_TTR(CV1(int), CV2(bool), tag, false);
- TEST_TTR(CV1(int), CV2(double), tag, false);
- TEST_TTR(CV1(double), CV2(bool), tag, false);
- TEST_TTR(CV1(double), CV2(int), tag, false);
-
-# undef CV1
-# define CV1(T) T
-# undef CV2
-# define CV2(T) const volatile T&
- // test with only two template parameters
- TEST_TT(CV1(bool), CV2(int), true);
- TEST_TT(CV1(bool), CV2(double), true);
- TEST_TT(CV1(int), CV2(bool), true);
- TEST_TT(CV1(int), CV2(double), true);
- TEST_TT(CV1(double), CV2(bool), true);
- TEST_TT(CV1(double), CV2(int), true);
-
- // test with three template parameters
- TEST_TTR(CV1(bool), CV2(int), bool, true);
- TEST_TTR(CV1(bool), CV2(double), bool, true);
- TEST_TTR(CV1(int), CV2(bool), bool, true);
- TEST_TTR(CV1(int), CV2(double), bool, true);
- TEST_TTR(CV1(double), CV2(bool), bool, true);
- TEST_TTR(CV1(double), CV2(int), bool, true);
- TEST_TTR(CV1(bool), CV2(int), tag, false);
- TEST_TTR(CV1(bool), CV2(double), tag, false);
- TEST_TTR(CV1(int), CV2(bool), tag, false);
- TEST_TTR(CV1(int), CV2(double), tag, false);
- TEST_TTR(CV1(double), CV2(bool), tag, false);
- TEST_TTR(CV1(double), CV2(int), tag, false);
-
-# undef CV1
-# define CV1(T) const T
-# undef CV2
-# define CV2(T) const T
- // test with only two template parameters
- TEST_TT(CV1(bool), CV2(int), true);
- TEST_TT(CV1(bool), CV2(double), true);
- TEST_TT(CV1(int), CV2(bool), true);
- TEST_TT(CV1(int), CV2(double), true);
- TEST_TT(CV1(double), CV2(bool), true);
- TEST_TT(CV1(double), CV2(int), true);
-
- // test with three template parameters
- TEST_TTR(CV1(bool), CV2(int), bool, true);
- TEST_TTR(CV1(bool), CV2(double), bool, true);
- TEST_TTR(CV1(int), CV2(bool), bool, true);
- TEST_TTR(CV1(int), CV2(double), bool, true);
- TEST_TTR(CV1(double), CV2(bool), bool, true);
- TEST_TTR(CV1(double), CV2(int), bool, true);
- TEST_TTR(CV1(bool), CV2(int), tag, false);
- TEST_TTR(CV1(bool), CV2(double), tag, false);
- TEST_TTR(CV1(int), CV2(bool), tag, false);
- TEST_TTR(CV1(int), CV2(double), tag, false);
- TEST_TTR(CV1(double), CV2(bool), tag, false);
- TEST_TTR(CV1(double), CV2(int), tag, false);
-
-# undef CV1
-# define CV1(T) const T&
-# undef CV2
-# define CV2(T) const T&
- // test with only two template parameters
- TEST_TT(CV1(bool), CV2(int), true);
- TEST_TT(CV1(bool), CV2(double), true);
- TEST_TT(CV1(int), CV2(bool), true);
- TEST_TT(CV1(int), CV2(double), true);
- TEST_TT(CV1(double), CV2(bool), true);
- TEST_TT(CV1(double), CV2(int), true);
-
- // test with three template parameters
- TEST_TTR(CV1(bool), CV2(int), bool, true);
- TEST_TTR(CV1(bool), CV2(double), bool, true);
- TEST_TTR(CV1(int), CV2(bool), bool, true);
- TEST_TTR(CV1(int), CV2(double), bool, true);
- TEST_TTR(CV1(double), CV2(bool), bool, true);
- TEST_TTR(CV1(double), CV2(int), bool, true);
- TEST_TTR(CV1(bool), CV2(int), tag, false);
- TEST_TTR(CV1(bool), CV2(double), tag, false);
- TEST_TTR(CV1(int), CV2(bool), tag, false);
- TEST_TTR(CV1(int), CV2(double), tag, false);
- TEST_TTR(CV1(double), CV2(bool), tag, false);
- TEST_TTR(CV1(double), CV2(int), tag, false);
-
-# undef CV1
-# define CV1(T) volatile T
-# undef CV2
-# define CV2(T) volatile T
- // test with only two template parameters
- TEST_TT(CV1(bool), CV2(int), true);
- TEST_TT(CV1(bool), CV2(double), true);
- TEST_TT(CV1(int), CV2(bool), true);
- TEST_TT(CV1(int), CV2(double), true);
- TEST_TT(CV1(double), CV2(bool), true);
- TEST_TT(CV1(double), CV2(int), true);
-
- // test with three template parameters
- TEST_TTR(CV1(bool), CV2(int), bool, true);
- TEST_TTR(CV1(bool), CV2(double), bool, true);
- TEST_TTR(CV1(int), CV2(bool), bool, true);
- TEST_TTR(CV1(int), CV2(double), bool, true);
- TEST_TTR(CV1(double), CV2(bool), bool, true);
- TEST_TTR(CV1(double), CV2(int), bool, true);
- TEST_TTR(CV1(bool), CV2(int), tag, false);
- TEST_TTR(CV1(bool), CV2(double), tag, false);
- TEST_TTR(CV1(int), CV2(bool), tag, false);
- TEST_TTR(CV1(int), CV2(double), tag, false);
- TEST_TTR(CV1(double), CV2(bool), tag, false);
- TEST_TTR(CV1(double), CV2(int), tag, false);
-
-# undef CV1
-# define CV1(T) volatile T&
-# undef CV2
-# define CV2(T) volatile T&
- // test with only two template parameters
- TEST_TT(CV1(bool), CV2(int), true);
- TEST_TT(CV1(bool), CV2(double), true);
- TEST_TT(CV1(int), CV2(bool), true);
- TEST_TT(CV1(int), CV2(double), true);
- TEST_TT(CV1(double), CV2(bool), true);
- TEST_TT(CV1(double), CV2(int), true);
-
- // test with three template parameters
- TEST_TTR(CV1(bool), CV2(int), bool, true);
- TEST_TTR(CV1(bool), CV2(double), bool, true);
- TEST_TTR(CV1(int), CV2(bool), bool, true);
- TEST_TTR(CV1(int), CV2(double), bool, true);
- TEST_TTR(CV1(double), CV2(bool), bool, true);
- TEST_TTR(CV1(double), CV2(int), bool, true);
- TEST_TTR(CV1(bool), CV2(int), tag, false);
- TEST_TTR(CV1(bool), CV2(double), tag, false);
- TEST_TTR(CV1(int), CV2(bool), tag, false);
- TEST_TTR(CV1(int), CV2(double), tag, false);
- TEST_TTR(CV1(double), CV2(bool), tag, false);
- TEST_TTR(CV1(double), CV2(int), tag, false);
-
-# undef CV1
-# define CV1(T) const volatile T
-# undef CV2
-# define CV2(T) const volatile T
- // test with only two template parameters
- TEST_TT(CV1(bool), CV2(int), true);
- TEST_TT(CV1(bool), CV2(double), true);
- TEST_TT(CV1(int), CV2(bool), true);
- TEST_TT(CV1(int), CV2(double), true);
- TEST_TT(CV1(double), CV2(bool), true);
- TEST_TT(CV1(double), CV2(int), true);
-
- // test with three template parameters
- TEST_TTR(CV1(bool), CV2(int), bool, true);
- TEST_TTR(CV1(bool), CV2(double), bool, true);
- TEST_TTR(CV1(int), CV2(bool), bool, true);
- TEST_TTR(CV1(int), CV2(double), bool, true);
- TEST_TTR(CV1(double), CV2(bool), bool, true);
- TEST_TTR(CV1(double), CV2(int), bool, true);
- TEST_TTR(CV1(bool), CV2(int), tag, false);
- TEST_TTR(CV1(bool), CV2(double), tag, false);
- TEST_TTR(CV1(int), CV2(bool), tag, false);
- TEST_TTR(CV1(int), CV2(double), tag, false);
- TEST_TTR(CV1(double), CV2(bool), tag, false);
- TEST_TTR(CV1(double), CV2(int), tag, false);
-
-# undef CV1
-# define CV1(T) const volatile T&
-# undef CV2
-# define CV2(T) const volatile T&
- // test with only two template parameters
- TEST_TT(CV1(bool), CV2(int), true);
- TEST_TT(CV1(bool), CV2(double), true);
- TEST_TT(CV1(int), CV2(bool), true);
- TEST_TT(CV1(int), CV2(double), true);
- TEST_TT(CV1(double), CV2(bool), true);
- TEST_TT(CV1(double), CV2(int), true);
-
- // test with three template parameters
- TEST_TTR(CV1(bool), CV2(int), bool, true);
- TEST_TTR(CV1(bool), CV2(double), bool, true);
- TEST_TTR(CV1(int), CV2(bool), bool, true);
- TEST_TTR(CV1(int), CV2(double), bool, true);
- TEST_TTR(CV1(double), CV2(bool), bool, true);
- TEST_TTR(CV1(double), CV2(int), bool, true);
- TEST_TTR(CV1(bool), CV2(int), tag, false);
- TEST_TTR(CV1(bool), CV2(double), tag, false);
- TEST_TTR(CV1(int), CV2(bool), tag, false);
- TEST_TTR(CV1(int), CV2(double), tag, false);
- TEST_TTR(CV1(double), CV2(bool), tag, false);
- TEST_TTR(CV1(double), CV2(int), tag, false);
-
- // pointers
- TEST_TT(void*, bool, false);
- TEST_TT(void*, int, false);
- TEST_TT(void*, double, false);
- TEST_TT(void*, A, false);
- TEST_TT(void*, B, false);
- TEST_TT(bool*, bool, true);
- TEST_TT(bool*, int, true);
- TEST_TT(bool*, double, false);
- TEST_TT(bool*, A, false);
- TEST_TT(bool*, B, false);
- TEST_TT(int*, bool, true);
- TEST_TT(int*, int, true);
- TEST_TT(int*, double, false);
- TEST_TT(int*, A, false);
- TEST_TT(int*, B, false);
- TEST_TT(double*, bool, true);
- TEST_TT(double*, int, true);
- TEST_TT(double*, double, false);
- TEST_TT(double*, A, false);
- TEST_TT(double*, B, false);
- TEST_TT(A*, bool, true);
- TEST_TT(A*, int, true);
- TEST_TT(A*, double, false);
- TEST_TT(A*, A, false);
- TEST_TT(A*, B, false);
- TEST_TT(B*, bool, true);
- TEST_TT(B*, int, true);
- TEST_TT(B*, double, false);
- TEST_TT(B*, A, false);
- TEST_TT(B*, B, false);
- TEST_TT(bool, void*, false);
- TEST_TT(bool, bool*, true);
- TEST_TT(bool, int*, true);
- TEST_TT(bool, double*, true);
- TEST_TT(bool, A*, true);
- TEST_TT(bool, B*, true);
- TEST_TT(int, void*, false);
- TEST_TT(int, bool*, true);
- TEST_TT(int, int*, true);
- TEST_TT(int, double*, true);
- TEST_TT(int, A*, true);
- TEST_TT(int, B*, true);
- TEST_TT(double, void*, false);
- TEST_TT(double, bool*, false);
- TEST_TT(double, int*, false);
- TEST_TT(double, double*, false);
- TEST_TT(double, A*, false);
- TEST_TT(double, B*, false);
- TEST_TT(A, void*, false);
- TEST_TT(A, bool*, false);
- TEST_TT(A, int*, false);
- TEST_TT(A, double*, false);
- TEST_TT(A, A*, false);
- TEST_TT(A, B*, false);
- TEST_TT(B, void*, false);
- TEST_TT(B, bool*, false);
- TEST_TT(B, int*, false);
- TEST_TT(B, double*, false);
- TEST_TT(B, A*, false);
- TEST_TT(B, B*, false);
- TEST_TT(void*, void*, false);
- TEST_TT(void*, bool*, false);
- TEST_TT(void*, int*, false);
- TEST_TT(void*, double*, false);
- TEST_TT(void*, A*, false);
- TEST_TT(void*, B*, false);
- TEST_TT(bool*, void*, false);
- TEST_TT(bool*, bool*, false);
- TEST_TT(bool*, int*, false);
- TEST_TT(bool*, double*, false);
- TEST_TT(bool*, A*, false);
- TEST_TT(bool*, B*, false);
- TEST_TT(int*, void*, false);
- TEST_TT(int*, bool*, false);
- TEST_TT(int*, int*, false);
- TEST_TT(int*, double*, false);
- TEST_TT(int*, A*, false);
- TEST_TT(int*, B*, false);
- TEST_TT(double*, void*, false);
- TEST_TT(double*, bool*, false);
- TEST_TT(double*, int*, false);
- TEST_TT(double*, double*, false);
- TEST_TT(double*, A*, false);
- TEST_TT(double*, B*, false);
- TEST_TT(A*, void*, false);
- TEST_TT(A*, bool*, false);
- TEST_TT(A*, int*, false);
- TEST_TT(A*, double*, false);
- TEST_TT(A*, A*, false);
- TEST_TT(A*, B*, false);
- TEST_TT(B*, void*, false);
- TEST_TT(B*, bool*, false);
- TEST_TT(B*, int*, false);
- TEST_TT(B*, double*, false);
- TEST_TT(B*, A*, false);
- TEST_TT(B*, B*, false);
- TEST_TT(C, void*, true);
- TEST_TT(D, void*, false);
- TEST_TT(void*, C, false);
- TEST_TT(void*, D, true);
- TEST_TT(C, D, true);
-}
-}

Modified: sandbox/type_traits/libs/type_traits/test/can_call_and_test.cpp
==============================================================================
--- sandbox/type_traits/libs/type_traits/test/can_call_and_test.cpp (original)
+++ sandbox/type_traits/libs/type_traits/test/can_call_and_test.cpp 2011-07-09 16:29:47 EDT (Sat, 09 Jul 2011)
@@ -15,19 +15,264 @@
 #define BOOST_TT_TRAIT_NAME can_call_and
 #define BOOST_TT_TRAIT_OP &&
 
+
 #include "can_call_binary_operators.hpp"
-#include "can_call_binary_logical_test.hpp"
 
-namespace {
 void specific() {
- /* nothing specific */
-}
-}
-
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void, int const volatile &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, bool, int const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, bool const volatile, bool >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, bool const volatile, bool const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, bool const volatile &, bool const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int const &, int volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, double, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, double const volatile &, int const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, void* volatile, bool const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, void* &, int const & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int* const &, bool const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, void*, bool volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, void*, bool & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, void* volatile, int volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, void* volatile & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int* const, int & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int* volatile, int const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool volatile, int &, int const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool volatile, double volatile &, bool & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool volatile, int* volatile, bool const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const volatile, bool, bool const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const volatile, int const, bool >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const volatile, double &, bool const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const volatile, int* const volatile &, bool const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, bool, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, bool const volatile, int volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, bool volatile, int volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, bool const volatile &, int & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, void* const volatile, int volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, void* const volatile &, bool volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool volatile &, bool &, int >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool volatile &, int &, bool volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool volatile &, void* const, bool >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool volatile &, void* const volatile, bool volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool volatile &, void* &, bool const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const volatile &, bool const volatile, int const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const volatile &, bool const volatile &, int >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const volatile &, void* const volatile, int >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const volatile &, void* &, int >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const volatile &, int* volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const volatile &, int* volatile, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const volatile &, int* volatile &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool const volatile, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool &, int & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, int volatile &, int const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, double const volatile &, int const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, int*, bool >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, int* volatile, bool & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, int* const volatile &, bool & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, bool const volatile &, bool >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, void* const volatile, bool & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, void* const & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, void* const &, int >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int*, int const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int volatile, bool const, bool volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int volatile, int, bool const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int volatile, int, bool volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int volatile, int volatile, bool const & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int volatile, int &, bool const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int volatile, int volatile &, bool volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int volatile, void* volatile, bool const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int volatile, void* const volatile &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int volatile, int*, bool volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int volatile, int* &, int const & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const volatile, double const volatile, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const volatile, void* volatile, int volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const volatile, void* const volatile, int const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const volatile, int* volatile &, int & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, int volatile, bool volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, double volatile, bool volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, double const volatile, bool const & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, void* const volatile, int volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, bool volatile &, int volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int volatile &, bool volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, double const, bool const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, double volatile, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int* const volatile, int >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int* &, bool >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int* const volatile &, int volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int volatile &, bool const, bool volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int volatile &, int, int const & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int volatile &, int volatile, int >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int volatile &, int const volatile &, int const & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int volatile &, double const, bool const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int volatile &, double const volatile, bool const & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int volatile &, void* const volatile, int volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int volatile &, int* volatile, int >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int volatile &, int* const volatile, int const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int volatile &, int* const &, int >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int volatile &, int* volatile &, bool & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int volatile &, int* const volatile &, bool const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int volatile &, int* const volatile &, bool const & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const volatile &, int, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const volatile &, double, bool & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const volatile &, double, bool volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const volatile &, double volatile, bool const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const volatile &, double const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const volatile &, double const volatile &, int const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const volatile &, void* volatile, int const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const volatile &, void* const &, bool volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, bool volatile &, int >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, int const &, bool volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, double const, int & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, void* const, bool const & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, void* volatile, int >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, void* const &, int const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, int* &, int volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, bool, int volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, double const &, bool const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, double const &, int const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, void* volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, void* const volatile, bool const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, void* const volatile, int const & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, int* const, int & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, int* const volatile, bool >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, int* const &, bool >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double volatile, bool const volatile &, int & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double volatile, int volatile &, bool const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double volatile, void*, int const & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double volatile, int* &, bool volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const volatile, bool, bool const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const volatile, int const volatile, int volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const volatile, void* &, bool volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const volatile, void* const &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const volatile, int* const, int const & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const volatile, int* &, bool >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, bool const &, bool & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, double const volatile &, int const & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, void*, bool const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, bool volatile, int & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, bool const volatile, bool volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, void*, bool const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int* &, bool volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double volatile &, double &, int const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double volatile &, double const &, bool const & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double volatile &, double const volatile &, bool const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double volatile &, void* &, int const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double volatile &, void* const &, int volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double volatile &, int*, bool const & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const volatile &, bool const, bool const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const volatile &, int, bool const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const volatile &, int const, bool const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const volatile &, int &, bool const & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const volatile &, double volatile, bool const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const volatile &, void* volatile &, int volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const volatile &, int* volatile &, bool const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, bool volatile, int const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int const volatile &, bool const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, void* const & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int*, int const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int* &, int volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, int volatile, int const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, int const &, int volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, double volatile, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, void* const &, bool volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* volatile, bool &, int >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* volatile, int const, bool const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* volatile, double const &, bool const & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* volatile, int* const volatile, int volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* volatile, int* volatile & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const volatile, bool, bool & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const volatile, double const, bool const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const volatile, double volatile, bool const & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const volatile, double &, bool volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const volatile, double volatile &, bool volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const volatile, double const volatile &, bool const & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const volatile, int* &, int >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, bool volatile, int volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int const volatile, int volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int const &, bool const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int volatile &, bool >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int const volatile &, int volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, double, int & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int* &, bool const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, double volatile, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, void* volatile, int const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, void* const volatile &, int const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* volatile &, bool &, bool & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* volatile &, bool &, int >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* volatile &, int, int volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* volatile &, int volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* volatile &, int &, bool >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* volatile &, int &, int volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const volatile &, bool const volatile, int const & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const volatile &, bool const &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const volatile &, int &, bool const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const volatile &, int volatile &, int volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const volatile &, double, bool const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const volatile &, double volatile &, int const & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const volatile &, void* const volatile, bool >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const volatile &, int* const & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int, bool >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int volatile, int const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, double, int const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, void* volatile, bool >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int*, int const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int* const, bool const & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int* const volatile, int volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int* &, bool >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, double const volatile &, int & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, void* const &, bool & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, int* const, bool const & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, int* const &, bool volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* volatile, bool, int >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* volatile, bool const, int const & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* volatile, int const volatile &, bool const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* volatile, void*, int volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* volatile, int* volatile &, int const & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const volatile, int const volatile, bool const & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const volatile, int &, bool & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const volatile, int const &, bool const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const volatile, double const volatile, bool & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const volatile, double const &, int const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const volatile, void* const volatile, int >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const volatile, void* volatile &, int volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const volatile, int* const volatile, bool const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const volatile, int* const & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, bool &, int & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, bool volatile &, int >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, bool const volatile &, int const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, int volatile &, bool & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, double, bool volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, double &, int const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, double volatile &, int const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, void*, bool & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, void* volatile, int volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, void* const volatile, bool & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, int* const volatile, int & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, int* &, bool const & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, int* &, bool const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, bool, int volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, bool const, bool const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int volatile, int const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int const volatile, int >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int volatile &, bool const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, double const &, bool const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, void* const volatile &, bool const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int* const, int const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int* volatile &, int const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* volatile &, bool const volatile, bool const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* volatile &, int &, int const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* volatile &, void* const &, int volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const volatile &, bool const volatile, int & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const volatile &, bool const volatile &, bool const & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const volatile &, int const, bool const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const volatile &, int volatile &, int volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const volatile &, void* const, bool const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const volatile &, void* const volatile &, int & >::value), 0);
 
+}
 
 TT_TEST_BEGIN(BOOST_TT_TRAIT_NAME)
- run1();
- run2();
+ common();
    specific();
 TT_TEST_END

Added: sandbox/type_traits/libs/type_traits/test/can_call_binary_classes.hpp
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/test/can_call_binary_classes.hpp 2011-07-09 16:29:47 EDT (Sat, 09 Jul 2011)
@@ -0,0 +1,1731 @@
+struct ret { };
+ret ret_val;
+
+class C000 { C000(); public: C000(int) { } };
+void operator+(C000, C000) { }
+
+class C001 { C001(); public: C001(int) { } };
+ret operator+(C001, C001) { return ret_val; }
+
+class C002 { C002(); public: C002(int) { } };
+ret const operator+(C002, C002) { return ret_val; }
+
+class C003 { C003(); public: C003(int) { } };
+ret volatile operator+(C003, C003) { return ret_val; }
+
+class C004 { C004(); public: C004(int) { } };
+ret const volatile operator+(C004, C004) { return ret_val; }
+
+class C005 { C005(); public: C005(int) { } };
+ret & operator+(C005, C005) { return ret_val; }
+
+class C006 { C006(); public: C006(int) { } };
+ret const & operator+(C006, C006) { return ret_val; }
+
+class C007 { C007(); public: C007(int) { } };
+ret volatile & operator+(C007, C007) { return ret_val; }
+
+class C008 { C008(); public: C008(int) { } };
+ret const volatile & operator+(C008, C008) { return ret_val; }
+
+class C009 { C009(); public: C009(int) { } };
+void operator+(C009, C009 const) { }
+
+class C010 { C010(); public: C010(int) { } };
+ret operator+(C010, C010 const) { return ret_val; }
+
+class C011 { C011(); public: C011(int) { } };
+ret const operator+(C011, C011 const) { return ret_val; }
+
+class C012 { C012(); public: C012(int) { } };
+ret volatile operator+(C012, C012 const) { return ret_val; }
+
+class C013 { C013(); public: C013(int) { } };
+ret const volatile operator+(C013, C013 const) { return ret_val; }
+
+class C014 { C014(); public: C014(int) { } };
+ret & operator+(C014, C014 const) { return ret_val; }
+
+class C015 { C015(); public: C015(int) { } };
+ret const & operator+(C015, C015 const) { return ret_val; }
+
+class C016 { C016(); public: C016(int) { } };
+ret volatile & operator+(C016, C016 const) { return ret_val; }
+
+class C017 { C017(); public: C017(int) { } };
+ret const volatile & operator+(C017, C017 const) { return ret_val; }
+
+class C018 { C018(); public: C018(int) { } };
+void operator+(C018, C018 volatile) { }
+
+class C019 { C019(); public: C019(int) { } };
+ret operator+(C019, C019 volatile) { return ret_val; }
+
+class C020 { C020(); public: C020(int) { } };
+ret const operator+(C020, C020 volatile) { return ret_val; }
+
+class C021 { C021(); public: C021(int) { } };
+ret volatile operator+(C021, C021 volatile) { return ret_val; }
+
+class C022 { C022(); public: C022(int) { } };
+ret const volatile operator+(C022, C022 volatile) { return ret_val; }
+
+class C023 { C023(); public: C023(int) { } };
+ret & operator+(C023, C023 volatile) { return ret_val; }
+
+class C024 { C024(); public: C024(int) { } };
+ret const & operator+(C024, C024 volatile) { return ret_val; }
+
+class C025 { C025(); public: C025(int) { } };
+ret volatile & operator+(C025, C025 volatile) { return ret_val; }
+
+class C026 { C026(); public: C026(int) { } };
+ret const volatile & operator+(C026, C026 volatile) { return ret_val; }
+
+class C027 { C027(); public: C027(int) { } };
+void operator+(C027, C027 const volatile) { }
+
+class C028 { C028(); public: C028(int) { } };
+ret operator+(C028, C028 const volatile) { return ret_val; }
+
+class C029 { C029(); public: C029(int) { } };
+ret const operator+(C029, C029 const volatile) { return ret_val; }
+
+class C030 { C030(); public: C030(int) { } };
+ret volatile operator+(C030, C030 const volatile) { return ret_val; }
+
+class C031 { C031(); public: C031(int) { } };
+ret const volatile operator+(C031, C031 const volatile) { return ret_val; }
+
+class C032 { C032(); public: C032(int) { } };
+ret & operator+(C032, C032 const volatile) { return ret_val; }
+
+class C033 { C033(); public: C033(int) { } };
+ret const & operator+(C033, C033 const volatile) { return ret_val; }
+
+class C034 { C034(); public: C034(int) { } };
+ret volatile & operator+(C034, C034 const volatile) { return ret_val; }
+
+class C035 { C035(); public: C035(int) { } };
+ret const volatile & operator+(C035, C035 const volatile) { return ret_val; }
+
+class C036 { C036(); public: C036(int) { } };
+void operator+(C036, C036 &) { }
+
+class C037 { C037(); public: C037(int) { } };
+ret operator+(C037, C037 &) { return ret_val; }
+
+class C038 { C038(); public: C038(int) { } };
+ret const operator+(C038, C038 &) { return ret_val; }
+
+class C039 { C039(); public: C039(int) { } };
+ret volatile operator+(C039, C039 &) { return ret_val; }
+
+class C040 { C040(); public: C040(int) { } };
+ret const volatile operator+(C040, C040 &) { return ret_val; }
+
+class C041 { C041(); public: C041(int) { } };
+ret & operator+(C041, C041 &) { return ret_val; }
+
+class C042 { C042(); public: C042(int) { } };
+ret const & operator+(C042, C042 &) { return ret_val; }
+
+class C043 { C043(); public: C043(int) { } };
+ret volatile & operator+(C043, C043 &) { return ret_val; }
+
+class C044 { C044(); public: C044(int) { } };
+ret const volatile & operator+(C044, C044 &) { return ret_val; }
+
+class C045 { C045(); public: C045(int) { } };
+void operator+(C045, C045 const &) { }
+
+class C046 { C046(); public: C046(int) { } };
+ret operator+(C046, C046 const &) { return ret_val; }
+
+class C047 { C047(); public: C047(int) { } };
+ret const operator+(C047, C047 const &) { return ret_val; }
+
+class C048 { C048(); public: C048(int) { } };
+ret volatile operator+(C048, C048 const &) { return ret_val; }
+
+class C049 { C049(); public: C049(int) { } };
+ret const volatile operator+(C049, C049 const &) { return ret_val; }
+
+class C050 { C050(); public: C050(int) { } };
+ret & operator+(C050, C050 const &) { return ret_val; }
+
+class C051 { C051(); public: C051(int) { } };
+ret const & operator+(C051, C051 const &) { return ret_val; }
+
+class C052 { C052(); public: C052(int) { } };
+ret volatile & operator+(C052, C052 const &) { return ret_val; }
+
+class C053 { C053(); public: C053(int) { } };
+ret const volatile & operator+(C053, C053 const &) { return ret_val; }
+
+class C054 { C054(); public: C054(int) { } };
+void operator+(C054, C054 volatile &) { }
+
+class C055 { C055(); public: C055(int) { } };
+ret operator+(C055, C055 volatile &) { return ret_val; }
+
+class C056 { C056(); public: C056(int) { } };
+ret const operator+(C056, C056 volatile &) { return ret_val; }
+
+class C057 { C057(); public: C057(int) { } };
+ret volatile operator+(C057, C057 volatile &) { return ret_val; }
+
+class C058 { C058(); public: C058(int) { } };
+ret const volatile operator+(C058, C058 volatile &) { return ret_val; }
+
+class C059 { C059(); public: C059(int) { } };
+ret & operator+(C059, C059 volatile &) { return ret_val; }
+
+class C060 { C060(); public: C060(int) { } };
+ret const & operator+(C060, C060 volatile &) { return ret_val; }
+
+class C061 { C061(); public: C061(int) { } };
+ret volatile & operator+(C061, C061 volatile &) { return ret_val; }
+
+class C062 { C062(); public: C062(int) { } };
+ret const volatile & operator+(C062, C062 volatile &) { return ret_val; }
+
+class C063 { C063(); public: C063(int) { } };
+void operator+(C063, C063 const volatile &) { }
+
+class C064 { C064(); public: C064(int) { } };
+ret operator+(C064, C064 const volatile &) { return ret_val; }
+
+class C065 { C065(); public: C065(int) { } };
+ret const operator+(C065, C065 const volatile &) { return ret_val; }
+
+class C066 { C066(); public: C066(int) { } };
+ret volatile operator+(C066, C066 const volatile &) { return ret_val; }
+
+class C067 { C067(); public: C067(int) { } };
+ret const volatile operator+(C067, C067 const volatile &) { return ret_val; }
+
+class C068 { C068(); public: C068(int) { } };
+ret & operator+(C068, C068 const volatile &) { return ret_val; }
+
+class C069 { C069(); public: C069(int) { } };
+ret const & operator+(C069, C069 const volatile &) { return ret_val; }
+
+class C070 { C070(); public: C070(int) { } };
+ret volatile & operator+(C070, C070 const volatile &) { return ret_val; }
+
+class C071 { C071(); public: C071(int) { } };
+ret const volatile & operator+(C071, C071 const volatile &) { return ret_val; }
+
+class C072 { C072(); public: C072(int) { } };
+void operator+(C072 const, C072) { }
+
+class C073 { C073(); public: C073(int) { } };
+ret operator+(C073 const, C073) { return ret_val; }
+
+class C074 { C074(); public: C074(int) { } };
+ret const operator+(C074 const, C074) { return ret_val; }
+
+class C075 { C075(); public: C075(int) { } };
+ret volatile operator+(C075 const, C075) { return ret_val; }
+
+class C076 { C076(); public: C076(int) { } };
+ret const volatile operator+(C076 const, C076) { return ret_val; }
+
+class C077 { C077(); public: C077(int) { } };
+ret & operator+(C077 const, C077) { return ret_val; }
+
+class C078 { C078(); public: C078(int) { } };
+ret const & operator+(C078 const, C078) { return ret_val; }
+
+class C079 { C079(); public: C079(int) { } };
+ret volatile & operator+(C079 const, C079) { return ret_val; }
+
+class C080 { C080(); public: C080(int) { } };
+ret const volatile & operator+(C080 const, C080) { return ret_val; }
+
+class C081 { C081(); public: C081(int) { } };
+void operator+(C081 const, C081 const) { }
+
+class C082 { C082(); public: C082(int) { } };
+ret operator+(C082 const, C082 const) { return ret_val; }
+
+class C083 { C083(); public: C083(int) { } };
+ret const operator+(C083 const, C083 const) { return ret_val; }
+
+class C084 { C084(); public: C084(int) { } };
+ret volatile operator+(C084 const, C084 const) { return ret_val; }
+
+class C085 { C085(); public: C085(int) { } };
+ret const volatile operator+(C085 const, C085 const) { return ret_val; }
+
+class C086 { C086(); public: C086(int) { } };
+ret & operator+(C086 const, C086 const) { return ret_val; }
+
+class C087 { C087(); public: C087(int) { } };
+ret const & operator+(C087 const, C087 const) { return ret_val; }
+
+class C088 { C088(); public: C088(int) { } };
+ret volatile & operator+(C088 const, C088 const) { return ret_val; }
+
+class C089 { C089(); public: C089(int) { } };
+ret const volatile & operator+(C089 const, C089 const) { return ret_val; }
+
+class C090 { C090(); public: C090(int) { } };
+void operator+(C090 const, C090 volatile) { }
+
+class C091 { C091(); public: C091(int) { } };
+ret operator+(C091 const, C091 volatile) { return ret_val; }
+
+class C092 { C092(); public: C092(int) { } };
+ret const operator+(C092 const, C092 volatile) { return ret_val; }
+
+class C093 { C093(); public: C093(int) { } };
+ret volatile operator+(C093 const, C093 volatile) { return ret_val; }
+
+class C094 { C094(); public: C094(int) { } };
+ret const volatile operator+(C094 const, C094 volatile) { return ret_val; }
+
+class C095 { C095(); public: C095(int) { } };
+ret & operator+(C095 const, C095 volatile) { return ret_val; }
+
+class C096 { C096(); public: C096(int) { } };
+ret const & operator+(C096 const, C096 volatile) { return ret_val; }
+
+class C097 { C097(); public: C097(int) { } };
+ret volatile & operator+(C097 const, C097 volatile) { return ret_val; }
+
+class C098 { C098(); public: C098(int) { } };
+ret const volatile & operator+(C098 const, C098 volatile) { return ret_val; }
+
+class C099 { C099(); public: C099(int) { } };
+void operator+(C099 const, C099 const volatile) { }
+
+class C100 { C100(); public: C100(int) { } };
+ret operator+(C100 const, C100 const volatile) { return ret_val; }
+
+class C101 { C101(); public: C101(int) { } };
+ret const operator+(C101 const, C101 const volatile) { return ret_val; }
+
+class C102 { C102(); public: C102(int) { } };
+ret volatile operator+(C102 const, C102 const volatile) { return ret_val; }
+
+class C103 { C103(); public: C103(int) { } };
+ret const volatile operator+(C103 const, C103 const volatile) { return ret_val; }
+
+class C104 { C104(); public: C104(int) { } };
+ret & operator+(C104 const, C104 const volatile) { return ret_val; }
+
+class C105 { C105(); public: C105(int) { } };
+ret const & operator+(C105 const, C105 const volatile) { return ret_val; }
+
+class C106 { C106(); public: C106(int) { } };
+ret volatile & operator+(C106 const, C106 const volatile) { return ret_val; }
+
+class C107 { C107(); public: C107(int) { } };
+ret const volatile & operator+(C107 const, C107 const volatile) { return ret_val; }
+
+class C108 { C108(); public: C108(int) { } };
+void operator+(C108 const, C108 &) { }
+
+class C109 { C109(); public: C109(int) { } };
+ret operator+(C109 const, C109 &) { return ret_val; }
+
+class C110 { C110(); public: C110(int) { } };
+ret const operator+(C110 const, C110 &) { return ret_val; }
+
+class C111 { C111(); public: C111(int) { } };
+ret volatile operator+(C111 const, C111 &) { return ret_val; }
+
+class C112 { C112(); public: C112(int) { } };
+ret const volatile operator+(C112 const, C112 &) { return ret_val; }
+
+class C113 { C113(); public: C113(int) { } };
+ret & operator+(C113 const, C113 &) { return ret_val; }
+
+class C114 { C114(); public: C114(int) { } };
+ret const & operator+(C114 const, C114 &) { return ret_val; }
+
+class C115 { C115(); public: C115(int) { } };
+ret volatile & operator+(C115 const, C115 &) { return ret_val; }
+
+class C116 { C116(); public: C116(int) { } };
+ret const volatile & operator+(C116 const, C116 &) { return ret_val; }
+
+class C117 { C117(); public: C117(int) { } };
+void operator+(C117 const, C117 const &) { }
+
+class C118 { C118(); public: C118(int) { } };
+ret operator+(C118 const, C118 const &) { return ret_val; }
+
+class C119 { C119(); public: C119(int) { } };
+ret const operator+(C119 const, C119 const &) { return ret_val; }
+
+class C120 { C120(); public: C120(int) { } };
+ret volatile operator+(C120 const, C120 const &) { return ret_val; }
+
+class C121 { C121(); public: C121(int) { } };
+ret const volatile operator+(C121 const, C121 const &) { return ret_val; }
+
+class C122 { C122(); public: C122(int) { } };
+ret & operator+(C122 const, C122 const &) { return ret_val; }
+
+class C123 { C123(); public: C123(int) { } };
+ret const & operator+(C123 const, C123 const &) { return ret_val; }
+
+class C124 { C124(); public: C124(int) { } };
+ret volatile & operator+(C124 const, C124 const &) { return ret_val; }
+
+class C125 { C125(); public: C125(int) { } };
+ret const volatile & operator+(C125 const, C125 const &) { return ret_val; }
+
+class C126 { C126(); public: C126(int) { } };
+void operator+(C126 const, C126 volatile &) { }
+
+class C127 { C127(); public: C127(int) { } };
+ret operator+(C127 const, C127 volatile &) { return ret_val; }
+
+class C128 { C128(); public: C128(int) { } };
+ret const operator+(C128 const, C128 volatile &) { return ret_val; }
+
+class C129 { C129(); public: C129(int) { } };
+ret volatile operator+(C129 const, C129 volatile &) { return ret_val; }
+
+class C130 { C130(); public: C130(int) { } };
+ret const volatile operator+(C130 const, C130 volatile &) { return ret_val; }
+
+class C131 { C131(); public: C131(int) { } };
+ret & operator+(C131 const, C131 volatile &) { return ret_val; }
+
+class C132 { C132(); public: C132(int) { } };
+ret const & operator+(C132 const, C132 volatile &) { return ret_val; }
+
+class C133 { C133(); public: C133(int) { } };
+ret volatile & operator+(C133 const, C133 volatile &) { return ret_val; }
+
+class C134 { C134(); public: C134(int) { } };
+ret const volatile & operator+(C134 const, C134 volatile &) { return ret_val; }
+
+class C135 { C135(); public: C135(int) { } };
+void operator+(C135 const, C135 const volatile &) { }
+
+class C136 { C136(); public: C136(int) { } };
+ret operator+(C136 const, C136 const volatile &) { return ret_val; }
+
+class C137 { C137(); public: C137(int) { } };
+ret const operator+(C137 const, C137 const volatile &) { return ret_val; }
+
+class C138 { C138(); public: C138(int) { } };
+ret volatile operator+(C138 const, C138 const volatile &) { return ret_val; }
+
+class C139 { C139(); public: C139(int) { } };
+ret const volatile operator+(C139 const, C139 const volatile &) { return ret_val; }
+
+class C140 { C140(); public: C140(int) { } };
+ret & operator+(C140 const, C140 const volatile &) { return ret_val; }
+
+class C141 { C141(); public: C141(int) { } };
+ret const & operator+(C141 const, C141 const volatile &) { return ret_val; }
+
+class C142 { C142(); public: C142(int) { } };
+ret volatile & operator+(C142 const, C142 const volatile &) { return ret_val; }
+
+class C143 { C143(); public: C143(int) { } };
+ret const volatile & operator+(C143 const, C143 const volatile &) { return ret_val; }
+
+class C144 { C144(); public: C144(int) { } };
+void operator+(C144 volatile, C144) { }
+
+class C145 { C145(); public: C145(int) { } };
+ret operator+(C145 volatile, C145) { return ret_val; }
+
+class C146 { C146(); public: C146(int) { } };
+ret const operator+(C146 volatile, C146) { return ret_val; }
+
+class C147 { C147(); public: C147(int) { } };
+ret volatile operator+(C147 volatile, C147) { return ret_val; }
+
+class C148 { C148(); public: C148(int) { } };
+ret const volatile operator+(C148 volatile, C148) { return ret_val; }
+
+class C149 { C149(); public: C149(int) { } };
+ret & operator+(C149 volatile, C149) { return ret_val; }
+
+class C150 { C150(); public: C150(int) { } };
+ret const & operator+(C150 volatile, C150) { return ret_val; }
+
+class C151 { C151(); public: C151(int) { } };
+ret volatile & operator+(C151 volatile, C151) { return ret_val; }
+
+class C152 { C152(); public: C152(int) { } };
+ret const volatile & operator+(C152 volatile, C152) { return ret_val; }
+
+class C153 { C153(); public: C153(int) { } };
+void operator+(C153 volatile, C153 const) { }
+
+class C154 { C154(); public: C154(int) { } };
+ret operator+(C154 volatile, C154 const) { return ret_val; }
+
+class C155 { C155(); public: C155(int) { } };
+ret const operator+(C155 volatile, C155 const) { return ret_val; }
+
+class C156 { C156(); public: C156(int) { } };
+ret volatile operator+(C156 volatile, C156 const) { return ret_val; }
+
+class C157 { C157(); public: C157(int) { } };
+ret const volatile operator+(C157 volatile, C157 const) { return ret_val; }
+
+class C158 { C158(); public: C158(int) { } };
+ret & operator+(C158 volatile, C158 const) { return ret_val; }
+
+class C159 { C159(); public: C159(int) { } };
+ret const & operator+(C159 volatile, C159 const) { return ret_val; }
+
+class C160 { C160(); public: C160(int) { } };
+ret volatile & operator+(C160 volatile, C160 const) { return ret_val; }
+
+class C161 { C161(); public: C161(int) { } };
+ret const volatile & operator+(C161 volatile, C161 const) { return ret_val; }
+
+class C162 { C162(); public: C162(int) { } };
+void operator+(C162 volatile, C162 volatile) { }
+
+class C163 { C163(); public: C163(int) { } };
+ret operator+(C163 volatile, C163 volatile) { return ret_val; }
+
+class C164 { C164(); public: C164(int) { } };
+ret const operator+(C164 volatile, C164 volatile) { return ret_val; }
+
+class C165 { C165(); public: C165(int) { } };
+ret volatile operator+(C165 volatile, C165 volatile) { return ret_val; }
+
+class C166 { C166(); public: C166(int) { } };
+ret const volatile operator+(C166 volatile, C166 volatile) { return ret_val; }
+
+class C167 { C167(); public: C167(int) { } };
+ret & operator+(C167 volatile, C167 volatile) { return ret_val; }
+
+class C168 { C168(); public: C168(int) { } };
+ret const & operator+(C168 volatile, C168 volatile) { return ret_val; }
+
+class C169 { C169(); public: C169(int) { } };
+ret volatile & operator+(C169 volatile, C169 volatile) { return ret_val; }
+
+class C170 { C170(); public: C170(int) { } };
+ret const volatile & operator+(C170 volatile, C170 volatile) { return ret_val; }
+
+class C171 { C171(); public: C171(int) { } };
+void operator+(C171 volatile, C171 const volatile) { }
+
+class C172 { C172(); public: C172(int) { } };
+ret operator+(C172 volatile, C172 const volatile) { return ret_val; }
+
+class C173 { C173(); public: C173(int) { } };
+ret const operator+(C173 volatile, C173 const volatile) { return ret_val; }
+
+class C174 { C174(); public: C174(int) { } };
+ret volatile operator+(C174 volatile, C174 const volatile) { return ret_val; }
+
+class C175 { C175(); public: C175(int) { } };
+ret const volatile operator+(C175 volatile, C175 const volatile) { return ret_val; }
+
+class C176 { C176(); public: C176(int) { } };
+ret & operator+(C176 volatile, C176 const volatile) { return ret_val; }
+
+class C177 { C177(); public: C177(int) { } };
+ret const & operator+(C177 volatile, C177 const volatile) { return ret_val; }
+
+class C178 { C178(); public: C178(int) { } };
+ret volatile & operator+(C178 volatile, C178 const volatile) { return ret_val; }
+
+class C179 { C179(); public: C179(int) { } };
+ret const volatile & operator+(C179 volatile, C179 const volatile) { return ret_val; }
+
+class C180 { C180(); public: C180(int) { } };
+void operator+(C180 volatile, C180 &) { }
+
+class C181 { C181(); public: C181(int) { } };
+ret operator+(C181 volatile, C181 &) { return ret_val; }
+
+class C182 { C182(); public: C182(int) { } };
+ret const operator+(C182 volatile, C182 &) { return ret_val; }
+
+class C183 { C183(); public: C183(int) { } };
+ret volatile operator+(C183 volatile, C183 &) { return ret_val; }
+
+class C184 { C184(); public: C184(int) { } };
+ret const volatile operator+(C184 volatile, C184 &) { return ret_val; }
+
+class C185 { C185(); public: C185(int) { } };
+ret & operator+(C185 volatile, C185 &) { return ret_val; }
+
+class C186 { C186(); public: C186(int) { } };
+ret const & operator+(C186 volatile, C186 &) { return ret_val; }
+
+class C187 { C187(); public: C187(int) { } };
+ret volatile & operator+(C187 volatile, C187 &) { return ret_val; }
+
+class C188 { C188(); public: C188(int) { } };
+ret const volatile & operator+(C188 volatile, C188 &) { return ret_val; }
+
+class C189 { C189(); public: C189(int) { } };
+void operator+(C189 volatile, C189 const &) { }
+
+class C190 { C190(); public: C190(int) { } };
+ret operator+(C190 volatile, C190 const &) { return ret_val; }
+
+class C191 { C191(); public: C191(int) { } };
+ret const operator+(C191 volatile, C191 const &) { return ret_val; }
+
+class C192 { C192(); public: C192(int) { } };
+ret volatile operator+(C192 volatile, C192 const &) { return ret_val; }
+
+class C193 { C193(); public: C193(int) { } };
+ret const volatile operator+(C193 volatile, C193 const &) { return ret_val; }
+
+class C194 { C194(); public: C194(int) { } };
+ret & operator+(C194 volatile, C194 const &) { return ret_val; }
+
+class C195 { C195(); public: C195(int) { } };
+ret const & operator+(C195 volatile, C195 const &) { return ret_val; }
+
+class C196 { C196(); public: C196(int) { } };
+ret volatile & operator+(C196 volatile, C196 const &) { return ret_val; }
+
+class C197 { C197(); public: C197(int) { } };
+ret const volatile & operator+(C197 volatile, C197 const &) { return ret_val; }
+
+class C198 { C198(); public: C198(int) { } };
+void operator+(C198 volatile, C198 volatile &) { }
+
+class C199 { C199(); public: C199(int) { } };
+ret operator+(C199 volatile, C199 volatile &) { return ret_val; }
+
+class C200 { C200(); public: C200(int) { } };
+ret const operator+(C200 volatile, C200 volatile &) { return ret_val; }
+
+class C201 { C201(); public: C201(int) { } };
+ret volatile operator+(C201 volatile, C201 volatile &) { return ret_val; }
+
+class C202 { C202(); public: C202(int) { } };
+ret const volatile operator+(C202 volatile, C202 volatile &) { return ret_val; }
+
+class C203 { C203(); public: C203(int) { } };
+ret & operator+(C203 volatile, C203 volatile &) { return ret_val; }
+
+class C204 { C204(); public: C204(int) { } };
+ret const & operator+(C204 volatile, C204 volatile &) { return ret_val; }
+
+class C205 { C205(); public: C205(int) { } };
+ret volatile & operator+(C205 volatile, C205 volatile &) { return ret_val; }
+
+class C206 { C206(); public: C206(int) { } };
+ret const volatile & operator+(C206 volatile, C206 volatile &) { return ret_val; }
+
+class C207 { C207(); public: C207(int) { } };
+void operator+(C207 volatile, C207 const volatile &) { }
+
+class C208 { C208(); public: C208(int) { } };
+ret operator+(C208 volatile, C208 const volatile &) { return ret_val; }
+
+class C209 { C209(); public: C209(int) { } };
+ret const operator+(C209 volatile, C209 const volatile &) { return ret_val; }
+
+class C210 { C210(); public: C210(int) { } };
+ret volatile operator+(C210 volatile, C210 const volatile &) { return ret_val; }
+
+class C211 { C211(); public: C211(int) { } };
+ret const volatile operator+(C211 volatile, C211 const volatile &) { return ret_val; }
+
+class C212 { C212(); public: C212(int) { } };
+ret & operator+(C212 volatile, C212 const volatile &) { return ret_val; }
+
+class C213 { C213(); public: C213(int) { } };
+ret const & operator+(C213 volatile, C213 const volatile &) { return ret_val; }
+
+class C214 { C214(); public: C214(int) { } };
+ret volatile & operator+(C214 volatile, C214 const volatile &) { return ret_val; }
+
+class C215 { C215(); public: C215(int) { } };
+ret const volatile & operator+(C215 volatile, C215 const volatile &) { return ret_val; }
+
+class C216 { C216(); public: C216(int) { } };
+void operator+(C216 const volatile, C216) { }
+
+class C217 { C217(); public: C217(int) { } };
+ret operator+(C217 const volatile, C217) { return ret_val; }
+
+class C218 { C218(); public: C218(int) { } };
+ret const operator+(C218 const volatile, C218) { return ret_val; }
+
+class C219 { C219(); public: C219(int) { } };
+ret volatile operator+(C219 const volatile, C219) { return ret_val; }
+
+class C220 { C220(); public: C220(int) { } };
+ret const volatile operator+(C220 const volatile, C220) { return ret_val; }
+
+class C221 { C221(); public: C221(int) { } };
+ret & operator+(C221 const volatile, C221) { return ret_val; }
+
+class C222 { C222(); public: C222(int) { } };
+ret const & operator+(C222 const volatile, C222) { return ret_val; }
+
+class C223 { C223(); public: C223(int) { } };
+ret volatile & operator+(C223 const volatile, C223) { return ret_val; }
+
+class C224 { C224(); public: C224(int) { } };
+ret const volatile & operator+(C224 const volatile, C224) { return ret_val; }
+
+class C225 { C225(); public: C225(int) { } };
+void operator+(C225 const volatile, C225 const) { }
+
+class C226 { C226(); public: C226(int) { } };
+ret operator+(C226 const volatile, C226 const) { return ret_val; }
+
+class C227 { C227(); public: C227(int) { } };
+ret const operator+(C227 const volatile, C227 const) { return ret_val; }
+
+class C228 { C228(); public: C228(int) { } };
+ret volatile operator+(C228 const volatile, C228 const) { return ret_val; }
+
+class C229 { C229(); public: C229(int) { } };
+ret const volatile operator+(C229 const volatile, C229 const) { return ret_val; }
+
+class C230 { C230(); public: C230(int) { } };
+ret & operator+(C230 const volatile, C230 const) { return ret_val; }
+
+class C231 { C231(); public: C231(int) { } };
+ret const & operator+(C231 const volatile, C231 const) { return ret_val; }
+
+class C232 { C232(); public: C232(int) { } };
+ret volatile & operator+(C232 const volatile, C232 const) { return ret_val; }
+
+class C233 { C233(); public: C233(int) { } };
+ret const volatile & operator+(C233 const volatile, C233 const) { return ret_val; }
+
+class C234 { C234(); public: C234(int) { } };
+void operator+(C234 const volatile, C234 volatile) { }
+
+class C235 { C235(); public: C235(int) { } };
+ret operator+(C235 const volatile, C235 volatile) { return ret_val; }
+
+class C236 { C236(); public: C236(int) { } };
+ret const operator+(C236 const volatile, C236 volatile) { return ret_val; }
+
+class C237 { C237(); public: C237(int) { } };
+ret volatile operator+(C237 const volatile, C237 volatile) { return ret_val; }
+
+class C238 { C238(); public: C238(int) { } };
+ret const volatile operator+(C238 const volatile, C238 volatile) { return ret_val; }
+
+class C239 { C239(); public: C239(int) { } };
+ret & operator+(C239 const volatile, C239 volatile) { return ret_val; }
+
+class C240 { C240(); public: C240(int) { } };
+ret const & operator+(C240 const volatile, C240 volatile) { return ret_val; }
+
+class C241 { C241(); public: C241(int) { } };
+ret volatile & operator+(C241 const volatile, C241 volatile) { return ret_val; }
+
+class C242 { C242(); public: C242(int) { } };
+ret const volatile & operator+(C242 const volatile, C242 volatile) { return ret_val; }
+
+class C243 { C243(); public: C243(int) { } };
+void operator+(C243 const volatile, C243 const volatile) { }
+
+class C244 { C244(); public: C244(int) { } };
+ret operator+(C244 const volatile, C244 const volatile) { return ret_val; }
+
+class C245 { C245(); public: C245(int) { } };
+ret const operator+(C245 const volatile, C245 const volatile) { return ret_val; }
+
+class C246 { C246(); public: C246(int) { } };
+ret volatile operator+(C246 const volatile, C246 const volatile) { return ret_val; }
+
+class C247 { C247(); public: C247(int) { } };
+ret const volatile operator+(C247 const volatile, C247 const volatile) { return ret_val; }
+
+class C248 { C248(); public: C248(int) { } };
+ret & operator+(C248 const volatile, C248 const volatile) { return ret_val; }
+
+class C249 { C249(); public: C249(int) { } };
+ret const & operator+(C249 const volatile, C249 const volatile) { return ret_val; }
+
+class C250 { C250(); public: C250(int) { } };
+ret volatile & operator+(C250 const volatile, C250 const volatile) { return ret_val; }
+
+class C251 { C251(); public: C251(int) { } };
+ret const volatile & operator+(C251 const volatile, C251 const volatile) { return ret_val; }
+
+class C252 { C252(); public: C252(int) { } };
+void operator+(C252 const volatile, C252 &) { }
+
+class C253 { C253(); public: C253(int) { } };
+ret operator+(C253 const volatile, C253 &) { return ret_val; }
+
+class C254 { C254(); public: C254(int) { } };
+ret const operator+(C254 const volatile, C254 &) { return ret_val; }
+
+class C255 { C255(); public: C255(int) { } };
+ret volatile operator+(C255 const volatile, C255 &) { return ret_val; }
+
+class C256 { C256(); public: C256(int) { } };
+ret const volatile operator+(C256 const volatile, C256 &) { return ret_val; }
+
+class C257 { C257(); public: C257(int) { } };
+ret & operator+(C257 const volatile, C257 &) { return ret_val; }
+
+class C258 { C258(); public: C258(int) { } };
+ret const & operator+(C258 const volatile, C258 &) { return ret_val; }
+
+class C259 { C259(); public: C259(int) { } };
+ret volatile & operator+(C259 const volatile, C259 &) { return ret_val; }
+
+class C260 { C260(); public: C260(int) { } };
+ret const volatile & operator+(C260 const volatile, C260 &) { return ret_val; }
+
+class C261 { C261(); public: C261(int) { } };
+void operator+(C261 const volatile, C261 const &) { }
+
+class C262 { C262(); public: C262(int) { } };
+ret operator+(C262 const volatile, C262 const &) { return ret_val; }
+
+class C263 { C263(); public: C263(int) { } };
+ret const operator+(C263 const volatile, C263 const &) { return ret_val; }
+
+class C264 { C264(); public: C264(int) { } };
+ret volatile operator+(C264 const volatile, C264 const &) { return ret_val; }
+
+class C265 { C265(); public: C265(int) { } };
+ret const volatile operator+(C265 const volatile, C265 const &) { return ret_val; }
+
+class C266 { C266(); public: C266(int) { } };
+ret & operator+(C266 const volatile, C266 const &) { return ret_val; }
+
+class C267 { C267(); public: C267(int) { } };
+ret const & operator+(C267 const volatile, C267 const &) { return ret_val; }
+
+class C268 { C268(); public: C268(int) { } };
+ret volatile & operator+(C268 const volatile, C268 const &) { return ret_val; }
+
+class C269 { C269(); public: C269(int) { } };
+ret const volatile & operator+(C269 const volatile, C269 const &) { return ret_val; }
+
+class C270 { C270(); public: C270(int) { } };
+void operator+(C270 const volatile, C270 volatile &) { }
+
+class C271 { C271(); public: C271(int) { } };
+ret operator+(C271 const volatile, C271 volatile &) { return ret_val; }
+
+class C272 { C272(); public: C272(int) { } };
+ret const operator+(C272 const volatile, C272 volatile &) { return ret_val; }
+
+class C273 { C273(); public: C273(int) { } };
+ret volatile operator+(C273 const volatile, C273 volatile &) { return ret_val; }
+
+class C274 { C274(); public: C274(int) { } };
+ret const volatile operator+(C274 const volatile, C274 volatile &) { return ret_val; }
+
+class C275 { C275(); public: C275(int) { } };
+ret & operator+(C275 const volatile, C275 volatile &) { return ret_val; }
+
+class C276 { C276(); public: C276(int) { } };
+ret const & operator+(C276 const volatile, C276 volatile &) { return ret_val; }
+
+class C277 { C277(); public: C277(int) { } };
+ret volatile & operator+(C277 const volatile, C277 volatile &) { return ret_val; }
+
+class C278 { C278(); public: C278(int) { } };
+ret const volatile & operator+(C278 const volatile, C278 volatile &) { return ret_val; }
+
+class C279 { C279(); public: C279(int) { } };
+void operator+(C279 const volatile, C279 const volatile &) { }
+
+class C280 { C280(); public: C280(int) { } };
+ret operator+(C280 const volatile, C280 const volatile &) { return ret_val; }
+
+class C281 { C281(); public: C281(int) { } };
+ret const operator+(C281 const volatile, C281 const volatile &) { return ret_val; }
+
+class C282 { C282(); public: C282(int) { } };
+ret volatile operator+(C282 const volatile, C282 const volatile &) { return ret_val; }
+
+class C283 { C283(); public: C283(int) { } };
+ret const volatile operator+(C283 const volatile, C283 const volatile &) { return ret_val; }
+
+class C284 { C284(); public: C284(int) { } };
+ret & operator+(C284 const volatile, C284 const volatile &) { return ret_val; }
+
+class C285 { C285(); public: C285(int) { } };
+ret const & operator+(C285 const volatile, C285 const volatile &) { return ret_val; }
+
+class C286 { C286(); public: C286(int) { } };
+ret volatile & operator+(C286 const volatile, C286 const volatile &) { return ret_val; }
+
+class C287 { C287(); public: C287(int) { } };
+ret const volatile & operator+(C287 const volatile, C287 const volatile &) { return ret_val; }
+
+class C288 { C288(); public: C288(int) { } };
+void operator+(C288 &, C288) { }
+
+class C289 { C289(); public: C289(int) { } };
+ret operator+(C289 &, C289) { return ret_val; }
+
+class C290 { C290(); public: C290(int) { } };
+ret const operator+(C290 &, C290) { return ret_val; }
+
+class C291 { C291(); public: C291(int) { } };
+ret volatile operator+(C291 &, C291) { return ret_val; }
+
+class C292 { C292(); public: C292(int) { } };
+ret const volatile operator+(C292 &, C292) { return ret_val; }
+
+class C293 { C293(); public: C293(int) { } };
+ret & operator+(C293 &, C293) { return ret_val; }
+
+class C294 { C294(); public: C294(int) { } };
+ret const & operator+(C294 &, C294) { return ret_val; }
+
+class C295 { C295(); public: C295(int) { } };
+ret volatile & operator+(C295 &, C295) { return ret_val; }
+
+class C296 { C296(); public: C296(int) { } };
+ret const volatile & operator+(C296 &, C296) { return ret_val; }
+
+class C297 { C297(); public: C297(int) { } };
+void operator+(C297 &, C297 const) { }
+
+class C298 { C298(); public: C298(int) { } };
+ret operator+(C298 &, C298 const) { return ret_val; }
+
+class C299 { C299(); public: C299(int) { } };
+ret const operator+(C299 &, C299 const) { return ret_val; }
+
+class C300 { C300(); public: C300(int) { } };
+ret volatile operator+(C300 &, C300 const) { return ret_val; }
+
+class C301 { C301(); public: C301(int) { } };
+ret const volatile operator+(C301 &, C301 const) { return ret_val; }
+
+class C302 { C302(); public: C302(int) { } };
+ret & operator+(C302 &, C302 const) { return ret_val; }
+
+class C303 { C303(); public: C303(int) { } };
+ret const & operator+(C303 &, C303 const) { return ret_val; }
+
+class C304 { C304(); public: C304(int) { } };
+ret volatile & operator+(C304 &, C304 const) { return ret_val; }
+
+class C305 { C305(); public: C305(int) { } };
+ret const volatile & operator+(C305 &, C305 const) { return ret_val; }
+
+class C306 { C306(); public: C306(int) { } };
+void operator+(C306 &, C306 volatile) { }
+
+class C307 { C307(); public: C307(int) { } };
+ret operator+(C307 &, C307 volatile) { return ret_val; }
+
+class C308 { C308(); public: C308(int) { } };
+ret const operator+(C308 &, C308 volatile) { return ret_val; }
+
+class C309 { C309(); public: C309(int) { } };
+ret volatile operator+(C309 &, C309 volatile) { return ret_val; }
+
+class C310 { C310(); public: C310(int) { } };
+ret const volatile operator+(C310 &, C310 volatile) { return ret_val; }
+
+class C311 { C311(); public: C311(int) { } };
+ret & operator+(C311 &, C311 volatile) { return ret_val; }
+
+class C312 { C312(); public: C312(int) { } };
+ret const & operator+(C312 &, C312 volatile) { return ret_val; }
+
+class C313 { C313(); public: C313(int) { } };
+ret volatile & operator+(C313 &, C313 volatile) { return ret_val; }
+
+class C314 { C314(); public: C314(int) { } };
+ret const volatile & operator+(C314 &, C314 volatile) { return ret_val; }
+
+class C315 { C315(); public: C315(int) { } };
+void operator+(C315 &, C315 const volatile) { }
+
+class C316 { C316(); public: C316(int) { } };
+ret operator+(C316 &, C316 const volatile) { return ret_val; }
+
+class C317 { C317(); public: C317(int) { } };
+ret const operator+(C317 &, C317 const volatile) { return ret_val; }
+
+class C318 { C318(); public: C318(int) { } };
+ret volatile operator+(C318 &, C318 const volatile) { return ret_val; }
+
+class C319 { C319(); public: C319(int) { } };
+ret const volatile operator+(C319 &, C319 const volatile) { return ret_val; }
+
+class C320 { C320(); public: C320(int) { } };
+ret & operator+(C320 &, C320 const volatile) { return ret_val; }
+
+class C321 { C321(); public: C321(int) { } };
+ret const & operator+(C321 &, C321 const volatile) { return ret_val; }
+
+class C322 { C322(); public: C322(int) { } };
+ret volatile & operator+(C322 &, C322 const volatile) { return ret_val; }
+
+class C323 { C323(); public: C323(int) { } };
+ret const volatile & operator+(C323 &, C323 const volatile) { return ret_val; }
+
+class C324 { C324(); public: C324(int) { } };
+void operator+(C324 &, C324 &) { }
+
+class C325 { C325(); public: C325(int) { } };
+ret operator+(C325 &, C325 &) { return ret_val; }
+
+class C326 { C326(); public: C326(int) { } };
+ret const operator+(C326 &, C326 &) { return ret_val; }
+
+class C327 { C327(); public: C327(int) { } };
+ret volatile operator+(C327 &, C327 &) { return ret_val; }
+
+class C328 { C328(); public: C328(int) { } };
+ret const volatile operator+(C328 &, C328 &) { return ret_val; }
+
+class C329 { C329(); public: C329(int) { } };
+ret & operator+(C329 &, C329 &) { return ret_val; }
+
+class C330 { C330(); public: C330(int) { } };
+ret const & operator+(C330 &, C330 &) { return ret_val; }
+
+class C331 { C331(); public: C331(int) { } };
+ret volatile & operator+(C331 &, C331 &) { return ret_val; }
+
+class C332 { C332(); public: C332(int) { } };
+ret const volatile & operator+(C332 &, C332 &) { return ret_val; }
+
+class C333 { C333(); public: C333(int) { } };
+void operator+(C333 &, C333 const &) { }
+
+class C334 { C334(); public: C334(int) { } };
+ret operator+(C334 &, C334 const &) { return ret_val; }
+
+class C335 { C335(); public: C335(int) { } };
+ret const operator+(C335 &, C335 const &) { return ret_val; }
+
+class C336 { C336(); public: C336(int) { } };
+ret volatile operator+(C336 &, C336 const &) { return ret_val; }
+
+class C337 { C337(); public: C337(int) { } };
+ret const volatile operator+(C337 &, C337 const &) { return ret_val; }
+
+class C338 { C338(); public: C338(int) { } };
+ret & operator+(C338 &, C338 const &) { return ret_val; }
+
+class C339 { C339(); public: C339(int) { } };
+ret const & operator+(C339 &, C339 const &) { return ret_val; }
+
+class C340 { C340(); public: C340(int) { } };
+ret volatile & operator+(C340 &, C340 const &) { return ret_val; }
+
+class C341 { C341(); public: C341(int) { } };
+ret const volatile & operator+(C341 &, C341 const &) { return ret_val; }
+
+class C342 { C342(); public: C342(int) { } };
+void operator+(C342 &, C342 volatile &) { }
+
+class C343 { C343(); public: C343(int) { } };
+ret operator+(C343 &, C343 volatile &) { return ret_val; }
+
+class C344 { C344(); public: C344(int) { } };
+ret const operator+(C344 &, C344 volatile &) { return ret_val; }
+
+class C345 { C345(); public: C345(int) { } };
+ret volatile operator+(C345 &, C345 volatile &) { return ret_val; }
+
+class C346 { C346(); public: C346(int) { } };
+ret const volatile operator+(C346 &, C346 volatile &) { return ret_val; }
+
+class C347 { C347(); public: C347(int) { } };
+ret & operator+(C347 &, C347 volatile &) { return ret_val; }
+
+class C348 { C348(); public: C348(int) { } };
+ret const & operator+(C348 &, C348 volatile &) { return ret_val; }
+
+class C349 { C349(); public: C349(int) { } };
+ret volatile & operator+(C349 &, C349 volatile &) { return ret_val; }
+
+class C350 { C350(); public: C350(int) { } };
+ret const volatile & operator+(C350 &, C350 volatile &) { return ret_val; }
+
+class C351 { C351(); public: C351(int) { } };
+void operator+(C351 &, C351 const volatile &) { }
+
+class C352 { C352(); public: C352(int) { } };
+ret operator+(C352 &, C352 const volatile &) { return ret_val; }
+
+class C353 { C353(); public: C353(int) { } };
+ret const operator+(C353 &, C353 const volatile &) { return ret_val; }
+
+class C354 { C354(); public: C354(int) { } };
+ret volatile operator+(C354 &, C354 const volatile &) { return ret_val; }
+
+class C355 { C355(); public: C355(int) { } };
+ret const volatile operator+(C355 &, C355 const volatile &) { return ret_val; }
+
+class C356 { C356(); public: C356(int) { } };
+ret & operator+(C356 &, C356 const volatile &) { return ret_val; }
+
+class C357 { C357(); public: C357(int) { } };
+ret const & operator+(C357 &, C357 const volatile &) { return ret_val; }
+
+class C358 { C358(); public: C358(int) { } };
+ret volatile & operator+(C358 &, C358 const volatile &) { return ret_val; }
+
+class C359 { C359(); public: C359(int) { } };
+ret const volatile & operator+(C359 &, C359 const volatile &) { return ret_val; }
+
+class C360 { C360(); public: C360(int) { } };
+void operator+(C360 const &, C360) { }
+
+class C361 { C361(); public: C361(int) { } };
+ret operator+(C361 const &, C361) { return ret_val; }
+
+class C362 { C362(); public: C362(int) { } };
+ret const operator+(C362 const &, C362) { return ret_val; }
+
+class C363 { C363(); public: C363(int) { } };
+ret volatile operator+(C363 const &, C363) { return ret_val; }
+
+class C364 { C364(); public: C364(int) { } };
+ret const volatile operator+(C364 const &, C364) { return ret_val; }
+
+class C365 { C365(); public: C365(int) { } };
+ret & operator+(C365 const &, C365) { return ret_val; }
+
+class C366 { C366(); public: C366(int) { } };
+ret const & operator+(C366 const &, C366) { return ret_val; }
+
+class C367 { C367(); public: C367(int) { } };
+ret volatile & operator+(C367 const &, C367) { return ret_val; }
+
+class C368 { C368(); public: C368(int) { } };
+ret const volatile & operator+(C368 const &, C368) { return ret_val; }
+
+class C369 { C369(); public: C369(int) { } };
+void operator+(C369 const &, C369 const) { }
+
+class C370 { C370(); public: C370(int) { } };
+ret operator+(C370 const &, C370 const) { return ret_val; }
+
+class C371 { C371(); public: C371(int) { } };
+ret const operator+(C371 const &, C371 const) { return ret_val; }
+
+class C372 { C372(); public: C372(int) { } };
+ret volatile operator+(C372 const &, C372 const) { return ret_val; }
+
+class C373 { C373(); public: C373(int) { } };
+ret const volatile operator+(C373 const &, C373 const) { return ret_val; }
+
+class C374 { C374(); public: C374(int) { } };
+ret & operator+(C374 const &, C374 const) { return ret_val; }
+
+class C375 { C375(); public: C375(int) { } };
+ret const & operator+(C375 const &, C375 const) { return ret_val; }
+
+class C376 { C376(); public: C376(int) { } };
+ret volatile & operator+(C376 const &, C376 const) { return ret_val; }
+
+class C377 { C377(); public: C377(int) { } };
+ret const volatile & operator+(C377 const &, C377 const) { return ret_val; }
+
+class C378 { C378(); public: C378(int) { } };
+void operator+(C378 const &, C378 volatile) { }
+
+class C379 { C379(); public: C379(int) { } };
+ret operator+(C379 const &, C379 volatile) { return ret_val; }
+
+class C380 { C380(); public: C380(int) { } };
+ret const operator+(C380 const &, C380 volatile) { return ret_val; }
+
+class C381 { C381(); public: C381(int) { } };
+ret volatile operator+(C381 const &, C381 volatile) { return ret_val; }
+
+class C382 { C382(); public: C382(int) { } };
+ret const volatile operator+(C382 const &, C382 volatile) { return ret_val; }
+
+class C383 { C383(); public: C383(int) { } };
+ret & operator+(C383 const &, C383 volatile) { return ret_val; }
+
+class C384 { C384(); public: C384(int) { } };
+ret const & operator+(C384 const &, C384 volatile) { return ret_val; }
+
+class C385 { C385(); public: C385(int) { } };
+ret volatile & operator+(C385 const &, C385 volatile) { return ret_val; }
+
+class C386 { C386(); public: C386(int) { } };
+ret const volatile & operator+(C386 const &, C386 volatile) { return ret_val; }
+
+class C387 { C387(); public: C387(int) { } };
+void operator+(C387 const &, C387 const volatile) { }
+
+class C388 { C388(); public: C388(int) { } };
+ret operator+(C388 const &, C388 const volatile) { return ret_val; }
+
+class C389 { C389(); public: C389(int) { } };
+ret const operator+(C389 const &, C389 const volatile) { return ret_val; }
+
+class C390 { C390(); public: C390(int) { } };
+ret volatile operator+(C390 const &, C390 const volatile) { return ret_val; }
+
+class C391 { C391(); public: C391(int) { } };
+ret const volatile operator+(C391 const &, C391 const volatile) { return ret_val; }
+
+class C392 { C392(); public: C392(int) { } };
+ret & operator+(C392 const &, C392 const volatile) { return ret_val; }
+
+class C393 { C393(); public: C393(int) { } };
+ret const & operator+(C393 const &, C393 const volatile) { return ret_val; }
+
+class C394 { C394(); public: C394(int) { } };
+ret volatile & operator+(C394 const &, C394 const volatile) { return ret_val; }
+
+class C395 { C395(); public: C395(int) { } };
+ret const volatile & operator+(C395 const &, C395 const volatile) { return ret_val; }
+
+class C396 { C396(); public: C396(int) { } };
+void operator+(C396 const &, C396 &) { }
+
+class C397 { C397(); public: C397(int) { } };
+ret operator+(C397 const &, C397 &) { return ret_val; }
+
+class C398 { C398(); public: C398(int) { } };
+ret const operator+(C398 const &, C398 &) { return ret_val; }
+
+class C399 { C399(); public: C399(int) { } };
+ret volatile operator+(C399 const &, C399 &) { return ret_val; }
+
+class C400 { C400(); public: C400(int) { } };
+ret const volatile operator+(C400 const &, C400 &) { return ret_val; }
+
+class C401 { C401(); public: C401(int) { } };
+ret & operator+(C401 const &, C401 &) { return ret_val; }
+
+class C402 { C402(); public: C402(int) { } };
+ret const & operator+(C402 const &, C402 &) { return ret_val; }
+
+class C403 { C403(); public: C403(int) { } };
+ret volatile & operator+(C403 const &, C403 &) { return ret_val; }
+
+class C404 { C404(); public: C404(int) { } };
+ret const volatile & operator+(C404 const &, C404 &) { return ret_val; }
+
+class C405 { C405(); public: C405(int) { } };
+void operator+(C405 const &, C405 const &) { }
+
+class C406 { C406(); public: C406(int) { } };
+ret operator+(C406 const &, C406 const &) { return ret_val; }
+
+class C407 { C407(); public: C407(int) { } };
+ret const operator+(C407 const &, C407 const &) { return ret_val; }
+
+class C408 { C408(); public: C408(int) { } };
+ret volatile operator+(C408 const &, C408 const &) { return ret_val; }
+
+class C409 { C409(); public: C409(int) { } };
+ret const volatile operator+(C409 const &, C409 const &) { return ret_val; }
+
+class C410 { C410(); public: C410(int) { } };
+ret & operator+(C410 const &, C410 const &) { return ret_val; }
+
+class C411 { C411(); public: C411(int) { } };
+ret const & operator+(C411 const &, C411 const &) { return ret_val; }
+
+class C412 { C412(); public: C412(int) { } };
+ret volatile & operator+(C412 const &, C412 const &) { return ret_val; }
+
+class C413 { C413(); public: C413(int) { } };
+ret const volatile & operator+(C413 const &, C413 const &) { return ret_val; }
+
+class C414 { C414(); public: C414(int) { } };
+void operator+(C414 const &, C414 volatile &) { }
+
+class C415 { C415(); public: C415(int) { } };
+ret operator+(C415 const &, C415 volatile &) { return ret_val; }
+
+class C416 { C416(); public: C416(int) { } };
+ret const operator+(C416 const &, C416 volatile &) { return ret_val; }
+
+class C417 { C417(); public: C417(int) { } };
+ret volatile operator+(C417 const &, C417 volatile &) { return ret_val; }
+
+class C418 { C418(); public: C418(int) { } };
+ret const volatile operator+(C418 const &, C418 volatile &) { return ret_val; }
+
+class C419 { C419(); public: C419(int) { } };
+ret & operator+(C419 const &, C419 volatile &) { return ret_val; }
+
+class C420 { C420(); public: C420(int) { } };
+ret const & operator+(C420 const &, C420 volatile &) { return ret_val; }
+
+class C421 { C421(); public: C421(int) { } };
+ret volatile & operator+(C421 const &, C421 volatile &) { return ret_val; }
+
+class C422 { C422(); public: C422(int) { } };
+ret const volatile & operator+(C422 const &, C422 volatile &) { return ret_val; }
+
+class C423 { C423(); public: C423(int) { } };
+void operator+(C423 const &, C423 const volatile &) { }
+
+class C424 { C424(); public: C424(int) { } };
+ret operator+(C424 const &, C424 const volatile &) { return ret_val; }
+
+class C425 { C425(); public: C425(int) { } };
+ret const operator+(C425 const &, C425 const volatile &) { return ret_val; }
+
+class C426 { C426(); public: C426(int) { } };
+ret volatile operator+(C426 const &, C426 const volatile &) { return ret_val; }
+
+class C427 { C427(); public: C427(int) { } };
+ret const volatile operator+(C427 const &, C427 const volatile &) { return ret_val; }
+
+class C428 { C428(); public: C428(int) { } };
+ret & operator+(C428 const &, C428 const volatile &) { return ret_val; }
+
+class C429 { C429(); public: C429(int) { } };
+ret const & operator+(C429 const &, C429 const volatile &) { return ret_val; }
+
+class C430 { C430(); public: C430(int) { } };
+ret volatile & operator+(C430 const &, C430 const volatile &) { return ret_val; }
+
+class C431 { C431(); public: C431(int) { } };
+ret const volatile & operator+(C431 const &, C431 const volatile &) { return ret_val; }
+
+class C432 { C432(); public: C432(int) { } };
+void operator+(C432 volatile &, C432) { }
+
+class C433 { C433(); public: C433(int) { } };
+ret operator+(C433 volatile &, C433) { return ret_val; }
+
+class C434 { C434(); public: C434(int) { } };
+ret const operator+(C434 volatile &, C434) { return ret_val; }
+
+class C435 { C435(); public: C435(int) { } };
+ret volatile operator+(C435 volatile &, C435) { return ret_val; }
+
+class C436 { C436(); public: C436(int) { } };
+ret const volatile operator+(C436 volatile &, C436) { return ret_val; }
+
+class C437 { C437(); public: C437(int) { } };
+ret & operator+(C437 volatile &, C437) { return ret_val; }
+
+class C438 { C438(); public: C438(int) { } };
+ret const & operator+(C438 volatile &, C438) { return ret_val; }
+
+class C439 { C439(); public: C439(int) { } };
+ret volatile & operator+(C439 volatile &, C439) { return ret_val; }
+
+class C440 { C440(); public: C440(int) { } };
+ret const volatile & operator+(C440 volatile &, C440) { return ret_val; }
+
+class C441 { C441(); public: C441(int) { } };
+void operator+(C441 volatile &, C441 const) { }
+
+class C442 { C442(); public: C442(int) { } };
+ret operator+(C442 volatile &, C442 const) { return ret_val; }
+
+class C443 { C443(); public: C443(int) { } };
+ret const operator+(C443 volatile &, C443 const) { return ret_val; }
+
+class C444 { C444(); public: C444(int) { } };
+ret volatile operator+(C444 volatile &, C444 const) { return ret_val; }
+
+class C445 { C445(); public: C445(int) { } };
+ret const volatile operator+(C445 volatile &, C445 const) { return ret_val; }
+
+class C446 { C446(); public: C446(int) { } };
+ret & operator+(C446 volatile &, C446 const) { return ret_val; }
+
+class C447 { C447(); public: C447(int) { } };
+ret const & operator+(C447 volatile &, C447 const) { return ret_val; }
+
+class C448 { C448(); public: C448(int) { } };
+ret volatile & operator+(C448 volatile &, C448 const) { return ret_val; }
+
+class C449 { C449(); public: C449(int) { } };
+ret const volatile & operator+(C449 volatile &, C449 const) { return ret_val; }
+
+class C450 { C450(); public: C450(int) { } };
+void operator+(C450 volatile &, C450 volatile) { }
+
+class C451 { C451(); public: C451(int) { } };
+ret operator+(C451 volatile &, C451 volatile) { return ret_val; }
+
+class C452 { C452(); public: C452(int) { } };
+ret const operator+(C452 volatile &, C452 volatile) { return ret_val; }
+
+class C453 { C453(); public: C453(int) { } };
+ret volatile operator+(C453 volatile &, C453 volatile) { return ret_val; }
+
+class C454 { C454(); public: C454(int) { } };
+ret const volatile operator+(C454 volatile &, C454 volatile) { return ret_val; }
+
+class C455 { C455(); public: C455(int) { } };
+ret & operator+(C455 volatile &, C455 volatile) { return ret_val; }
+
+class C456 { C456(); public: C456(int) { } };
+ret const & operator+(C456 volatile &, C456 volatile) { return ret_val; }
+
+class C457 { C457(); public: C457(int) { } };
+ret volatile & operator+(C457 volatile &, C457 volatile) { return ret_val; }
+
+class C458 { C458(); public: C458(int) { } };
+ret const volatile & operator+(C458 volatile &, C458 volatile) { return ret_val; }
+
+class C459 { C459(); public: C459(int) { } };
+void operator+(C459 volatile &, C459 const volatile) { }
+
+class C460 { C460(); public: C460(int) { } };
+ret operator+(C460 volatile &, C460 const volatile) { return ret_val; }
+
+class C461 { C461(); public: C461(int) { } };
+ret const operator+(C461 volatile &, C461 const volatile) { return ret_val; }
+
+class C462 { C462(); public: C462(int) { } };
+ret volatile operator+(C462 volatile &, C462 const volatile) { return ret_val; }
+
+class C463 { C463(); public: C463(int) { } };
+ret const volatile operator+(C463 volatile &, C463 const volatile) { return ret_val; }
+
+class C464 { C464(); public: C464(int) { } };
+ret & operator+(C464 volatile &, C464 const volatile) { return ret_val; }
+
+class C465 { C465(); public: C465(int) { } };
+ret const & operator+(C465 volatile &, C465 const volatile) { return ret_val; }
+
+class C466 { C466(); public: C466(int) { } };
+ret volatile & operator+(C466 volatile &, C466 const volatile) { return ret_val; }
+
+class C467 { C467(); public: C467(int) { } };
+ret const volatile & operator+(C467 volatile &, C467 const volatile) { return ret_val; }
+
+class C468 { C468(); public: C468(int) { } };
+void operator+(C468 volatile &, C468 &) { }
+
+class C469 { C469(); public: C469(int) { } };
+ret operator+(C469 volatile &, C469 &) { return ret_val; }
+
+class C470 { C470(); public: C470(int) { } };
+ret const operator+(C470 volatile &, C470 &) { return ret_val; }
+
+class C471 { C471(); public: C471(int) { } };
+ret volatile operator+(C471 volatile &, C471 &) { return ret_val; }
+
+class C472 { C472(); public: C472(int) { } };
+ret const volatile operator+(C472 volatile &, C472 &) { return ret_val; }
+
+class C473 { C473(); public: C473(int) { } };
+ret & operator+(C473 volatile &, C473 &) { return ret_val; }
+
+class C474 { C474(); public: C474(int) { } };
+ret const & operator+(C474 volatile &, C474 &) { return ret_val; }
+
+class C475 { C475(); public: C475(int) { } };
+ret volatile & operator+(C475 volatile &, C475 &) { return ret_val; }
+
+class C476 { C476(); public: C476(int) { } };
+ret const volatile & operator+(C476 volatile &, C476 &) { return ret_val; }
+
+class C477 { C477(); public: C477(int) { } };
+void operator+(C477 volatile &, C477 const &) { }
+
+class C478 { C478(); public: C478(int) { } };
+ret operator+(C478 volatile &, C478 const &) { return ret_val; }
+
+class C479 { C479(); public: C479(int) { } };
+ret const operator+(C479 volatile &, C479 const &) { return ret_val; }
+
+class C480 { C480(); public: C480(int) { } };
+ret volatile operator+(C480 volatile &, C480 const &) { return ret_val; }
+
+class C481 { C481(); public: C481(int) { } };
+ret const volatile operator+(C481 volatile &, C481 const &) { return ret_val; }
+
+class C482 { C482(); public: C482(int) { } };
+ret & operator+(C482 volatile &, C482 const &) { return ret_val; }
+
+class C483 { C483(); public: C483(int) { } };
+ret const & operator+(C483 volatile &, C483 const &) { return ret_val; }
+
+class C484 { C484(); public: C484(int) { } };
+ret volatile & operator+(C484 volatile &, C484 const &) { return ret_val; }
+
+class C485 { C485(); public: C485(int) { } };
+ret const volatile & operator+(C485 volatile &, C485 const &) { return ret_val; }
+
+class C486 { C486(); public: C486(int) { } };
+void operator+(C486 volatile &, C486 volatile &) { }
+
+class C487 { C487(); public: C487(int) { } };
+ret operator+(C487 volatile &, C487 volatile &) { return ret_val; }
+
+class C488 { C488(); public: C488(int) { } };
+ret const operator+(C488 volatile &, C488 volatile &) { return ret_val; }
+
+class C489 { C489(); public: C489(int) { } };
+ret volatile operator+(C489 volatile &, C489 volatile &) { return ret_val; }
+
+class C490 { C490(); public: C490(int) { } };
+ret const volatile operator+(C490 volatile &, C490 volatile &) { return ret_val; }
+
+class C491 { C491(); public: C491(int) { } };
+ret & operator+(C491 volatile &, C491 volatile &) { return ret_val; }
+
+class C492 { C492(); public: C492(int) { } };
+ret const & operator+(C492 volatile &, C492 volatile &) { return ret_val; }
+
+class C493 { C493(); public: C493(int) { } };
+ret volatile & operator+(C493 volatile &, C493 volatile &) { return ret_val; }
+
+class C494 { C494(); public: C494(int) { } };
+ret const volatile & operator+(C494 volatile &, C494 volatile &) { return ret_val; }
+
+class C495 { C495(); public: C495(int) { } };
+void operator+(C495 volatile &, C495 const volatile &) { }
+
+class C496 { C496(); public: C496(int) { } };
+ret operator+(C496 volatile &, C496 const volatile &) { return ret_val; }
+
+class C497 { C497(); public: C497(int) { } };
+ret const operator+(C497 volatile &, C497 const volatile &) { return ret_val; }
+
+class C498 { C498(); public: C498(int) { } };
+ret volatile operator+(C498 volatile &, C498 const volatile &) { return ret_val; }
+
+class C499 { C499(); public: C499(int) { } };
+ret const volatile operator+(C499 volatile &, C499 const volatile &) { return ret_val; }
+
+class C500 { C500(); public: C500(int) { } };
+ret & operator+(C500 volatile &, C500 const volatile &) { return ret_val; }
+
+class C501 { C501(); public: C501(int) { } };
+ret const & operator+(C501 volatile &, C501 const volatile &) { return ret_val; }
+
+class C502 { C502(); public: C502(int) { } };
+ret volatile & operator+(C502 volatile &, C502 const volatile &) { return ret_val; }
+
+class C503 { C503(); public: C503(int) { } };
+ret const volatile & operator+(C503 volatile &, C503 const volatile &) { return ret_val; }
+
+class C504 { C504(); public: C504(int) { } };
+void operator+(C504 const volatile &, C504) { }
+
+class C505 { C505(); public: C505(int) { } };
+ret operator+(C505 const volatile &, C505) { return ret_val; }
+
+class C506 { C506(); public: C506(int) { } };
+ret const operator+(C506 const volatile &, C506) { return ret_val; }
+
+class C507 { C507(); public: C507(int) { } };
+ret volatile operator+(C507 const volatile &, C507) { return ret_val; }
+
+class C508 { C508(); public: C508(int) { } };
+ret const volatile operator+(C508 const volatile &, C508) { return ret_val; }
+
+class C509 { C509(); public: C509(int) { } };
+ret & operator+(C509 const volatile &, C509) { return ret_val; }
+
+class C510 { C510(); public: C510(int) { } };
+ret const & operator+(C510 const volatile &, C510) { return ret_val; }
+
+class C511 { C511(); public: C511(int) { } };
+ret volatile & operator+(C511 const volatile &, C511) { return ret_val; }
+
+class C512 { C512(); public: C512(int) { } };
+ret const volatile & operator+(C512 const volatile &, C512) { return ret_val; }
+
+class C513 { C513(); public: C513(int) { } };
+void operator+(C513 const volatile &, C513 const) { }
+
+class C514 { C514(); public: C514(int) { } };
+ret operator+(C514 const volatile &, C514 const) { return ret_val; }
+
+class C515 { C515(); public: C515(int) { } };
+ret const operator+(C515 const volatile &, C515 const) { return ret_val; }
+
+class C516 { C516(); public: C516(int) { } };
+ret volatile operator+(C516 const volatile &, C516 const) { return ret_val; }
+
+class C517 { C517(); public: C517(int) { } };
+ret const volatile operator+(C517 const volatile &, C517 const) { return ret_val; }
+
+class C518 { C518(); public: C518(int) { } };
+ret & operator+(C518 const volatile &, C518 const) { return ret_val; }
+
+class C519 { C519(); public: C519(int) { } };
+ret const & operator+(C519 const volatile &, C519 const) { return ret_val; }
+
+class C520 { C520(); public: C520(int) { } };
+ret volatile & operator+(C520 const volatile &, C520 const) { return ret_val; }
+
+class C521 { C521(); public: C521(int) { } };
+ret const volatile & operator+(C521 const volatile &, C521 const) { return ret_val; }
+
+class C522 { C522(); public: C522(int) { } };
+void operator+(C522 const volatile &, C522 volatile) { }
+
+class C523 { C523(); public: C523(int) { } };
+ret operator+(C523 const volatile &, C523 volatile) { return ret_val; }
+
+class C524 { C524(); public: C524(int) { } };
+ret const operator+(C524 const volatile &, C524 volatile) { return ret_val; }
+
+class C525 { C525(); public: C525(int) { } };
+ret volatile operator+(C525 const volatile &, C525 volatile) { return ret_val; }
+
+class C526 { C526(); public: C526(int) { } };
+ret const volatile operator+(C526 const volatile &, C526 volatile) { return ret_val; }
+
+class C527 { C527(); public: C527(int) { } };
+ret & operator+(C527 const volatile &, C527 volatile) { return ret_val; }
+
+class C528 { C528(); public: C528(int) { } };
+ret const & operator+(C528 const volatile &, C528 volatile) { return ret_val; }
+
+class C529 { C529(); public: C529(int) { } };
+ret volatile & operator+(C529 const volatile &, C529 volatile) { return ret_val; }
+
+class C530 { C530(); public: C530(int) { } };
+ret const volatile & operator+(C530 const volatile &, C530 volatile) { return ret_val; }
+
+class C531 { C531(); public: C531(int) { } };
+void operator+(C531 const volatile &, C531 const volatile) { }
+
+class C532 { C532(); public: C532(int) { } };
+ret operator+(C532 const volatile &, C532 const volatile) { return ret_val; }
+
+class C533 { C533(); public: C533(int) { } };
+ret const operator+(C533 const volatile &, C533 const volatile) { return ret_val; }
+
+class C534 { C534(); public: C534(int) { } };
+ret volatile operator+(C534 const volatile &, C534 const volatile) { return ret_val; }
+
+class C535 { C535(); public: C535(int) { } };
+ret const volatile operator+(C535 const volatile &, C535 const volatile) { return ret_val; }
+
+class C536 { C536(); public: C536(int) { } };
+ret & operator+(C536 const volatile &, C536 const volatile) { return ret_val; }
+
+class C537 { C537(); public: C537(int) { } };
+ret const & operator+(C537 const volatile &, C537 const volatile) { return ret_val; }
+
+class C538 { C538(); public: C538(int) { } };
+ret volatile & operator+(C538 const volatile &, C538 const volatile) { return ret_val; }
+
+class C539 { C539(); public: C539(int) { } };
+ret const volatile & operator+(C539 const volatile &, C539 const volatile) { return ret_val; }
+
+class C540 { C540(); public: C540(int) { } };
+void operator+(C540 const volatile &, C540 &) { }
+
+class C541 { C541(); public: C541(int) { } };
+ret operator+(C541 const volatile &, C541 &) { return ret_val; }
+
+class C542 { C542(); public: C542(int) { } };
+ret const operator+(C542 const volatile &, C542 &) { return ret_val; }
+
+class C543 { C543(); public: C543(int) { } };
+ret volatile operator+(C543 const volatile &, C543 &) { return ret_val; }
+
+class C544 { C544(); public: C544(int) { } };
+ret const volatile operator+(C544 const volatile &, C544 &) { return ret_val; }
+
+class C545 { C545(); public: C545(int) { } };
+ret & operator+(C545 const volatile &, C545 &) { return ret_val; }
+
+class C546 { C546(); public: C546(int) { } };
+ret const & operator+(C546 const volatile &, C546 &) { return ret_val; }
+
+class C547 { C547(); public: C547(int) { } };
+ret volatile & operator+(C547 const volatile &, C547 &) { return ret_val; }
+
+class C548 { C548(); public: C548(int) { } };
+ret const volatile & operator+(C548 const volatile &, C548 &) { return ret_val; }
+
+class C549 { C549(); public: C549(int) { } };
+void operator+(C549 const volatile &, C549 const &) { }
+
+class C550 { C550(); public: C550(int) { } };
+ret operator+(C550 const volatile &, C550 const &) { return ret_val; }
+
+class C551 { C551(); public: C551(int) { } };
+ret const operator+(C551 const volatile &, C551 const &) { return ret_val; }
+
+class C552 { C552(); public: C552(int) { } };
+ret volatile operator+(C552 const volatile &, C552 const &) { return ret_val; }
+
+class C553 { C553(); public: C553(int) { } };
+ret const volatile operator+(C553 const volatile &, C553 const &) { return ret_val; }
+
+class C554 { C554(); public: C554(int) { } };
+ret & operator+(C554 const volatile &, C554 const &) { return ret_val; }
+
+class C555 { C555(); public: C555(int) { } };
+ret const & operator+(C555 const volatile &, C555 const &) { return ret_val; }
+
+class C556 { C556(); public: C556(int) { } };
+ret volatile & operator+(C556 const volatile &, C556 const &) { return ret_val; }
+
+class C557 { C557(); public: C557(int) { } };
+ret const volatile & operator+(C557 const volatile &, C557 const &) { return ret_val; }
+
+class C558 { C558(); public: C558(int) { } };
+void operator+(C558 const volatile &, C558 volatile &) { }
+
+class C559 { C559(); public: C559(int) { } };
+ret operator+(C559 const volatile &, C559 volatile &) { return ret_val; }
+
+class C560 { C560(); public: C560(int) { } };
+ret const operator+(C560 const volatile &, C560 volatile &) { return ret_val; }
+
+class C561 { C561(); public: C561(int) { } };
+ret volatile operator+(C561 const volatile &, C561 volatile &) { return ret_val; }
+
+class C562 { C562(); public: C562(int) { } };
+ret const volatile operator+(C562 const volatile &, C562 volatile &) { return ret_val; }
+
+class C563 { C563(); public: C563(int) { } };
+ret & operator+(C563 const volatile &, C563 volatile &) { return ret_val; }
+
+class C564 { C564(); public: C564(int) { } };
+ret const & operator+(C564 const volatile &, C564 volatile &) { return ret_val; }
+
+class C565 { C565(); public: C565(int) { } };
+ret volatile & operator+(C565 const volatile &, C565 volatile &) { return ret_val; }
+
+class C566 { C566(); public: C566(int) { } };
+ret const volatile & operator+(C566 const volatile &, C566 volatile &) { return ret_val; }
+
+class C567 { C567(); public: C567(int) { } };
+void operator+(C567 const volatile &, C567 const volatile &) { }
+
+class C568 { C568(); public: C568(int) { } };
+ret operator+(C568 const volatile &, C568 const volatile &) { return ret_val; }
+
+class C569 { C569(); public: C569(int) { } };
+ret const operator+(C569 const volatile &, C569 const volatile &) { return ret_val; }
+
+class C570 { C570(); public: C570(int) { } };
+ret volatile operator+(C570 const volatile &, C570 const volatile &) { return ret_val; }
+
+class C571 { C571(); public: C571(int) { } };
+ret const volatile operator+(C571 const volatile &, C571 const volatile &) { return ret_val; }
+
+class C572 { C572(); public: C572(int) { } };
+ret & operator+(C572 const volatile &, C572 const volatile &) { return ret_val; }
+
+class C573 { C573(); public: C573(int) { } };
+ret const & operator+(C573 const volatile &, C573 const volatile &) { return ret_val; }
+
+class C574 { C574(); public: C574(int) { } };
+ret volatile & operator+(C574 const volatile &, C574 const volatile &) { return ret_val; }
+
+class C575 { C575(); public: C575(int) { } };
+ret const volatile & operator+(C575 const volatile &, C575 const volatile &) { return ret_val; }
+

Added: sandbox/type_traits/libs/type_traits/test/can_call_binary_classes0_test.cpp
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/test/can_call_binary_classes0_test.cpp 2011-07-09 16:29:47 EDT (Sat, 09 Jul 2011)
@@ -0,0 +1,263 @@
+// (C) Copyright 2009-2011 Frederic Bron.
+// Use, modification and distribution are subject to the
+// Boost Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#include "test.hpp"
+#include "check_integral_constant.hpp"
+
+#include <boost/type_traits/can_call.hpp>
+#include "can_call_binary_classes.hpp"
+
+TT_TEST_BEGIN(BOOST_TT_TRAIT_NAME)
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C000, C000 const, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C000, C000 const &, void >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C000, C000 const &, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C000 const, C000 volatile &, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C000 volatile, C000 const volatile &, ret >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C000 volatile, C000 const volatile &, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C000 const volatile, C000 volatile &, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C000 &, C000 const volatile, ret volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C000 &, C000 &, ret const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C000 &, C000 const &, ret >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C000 const &, C000, ret >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C001 volatile, C001 const &, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C001 const volatile, C001 &, ret const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C001 const volatile, C001 &, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C001 const volatile &, C001 volatile, ret const & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C002, C002 &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C002 const, C002 volatile &, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C002 const &, C002, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C002 volatile &, C002, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C003, C003 volatile &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C003 const volatile &, C003, ret const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C004, C004, ret const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C004 volatile, C004 volatile, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C004 &, C004 volatile, ret const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C004 const &, C004 &, ret const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C005, C005 const volatile &, ret const & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C005 volatile, C005 volatile &, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C005 &, C005 const volatile, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C005 &, C005 const volatile &, ret const volatile & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C005 volatile &, C005 const &, ret volatile & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C006 const &, C006 const, ret const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C006 const volatile &, C006 const &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C007 const, C007 &, ret const volatile & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C007 const, C007 volatile &, ret const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C007 const volatile, C007 const volatile, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C007 const volatile, C007 const &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C007 volatile &, C007 volatile, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C007 volatile &, C007 &, ret volatile & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C008, C008, ret >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C008 const, C008 const volatile, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C008 volatile, C008 const &, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C008 &, C008, ret const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C008 &, C008 const, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C008 volatile &, C008 const &, ret const volatile & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C008 const volatile &, C008 volatile, ret const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C009, C009 const, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C009 volatile &, C009 const &, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C009 const volatile &, C009 const, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C010, C010 const volatile, ret const & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C010, C010 &, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C010 const, C010 const volatile, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C010 const &, C010, ret >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C010 const volatile &, C010 const &, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C011, C011 &, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C011, C011 const volatile &, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C011 const volatile, C011, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C011 const volatile, C011 volatile &, ret >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C011 const &, C011 volatile, ret const & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C011 volatile &, C011, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C011 const volatile &, C011 &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C012, C012 const, ret const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C012, C012 volatile &, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C012 volatile, C012 const &, ret const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C012 const &, C012 volatile, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C013, C013 const, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C013 const volatile, C013 const &, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C013 const volatile &, C013 const, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C014, C014, ret volatile & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C014 volatile &, C014, ret volatile & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C014 const volatile &, C014, ret const & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C015, C015 const &, ret >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C015 const, C015 volatile, ret const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C015 &, C015 volatile &, ret const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C015 &, C015 const volatile &, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C015 const volatile &, C015 volatile, ret const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C016 const, C016 const volatile &, ret const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C016 const volatile, C016 const, ret >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C017 const volatile &, C017 &, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C018, C018 volatile &, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C018 const volatile, C018 const volatile, ret const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C018 &, C018 &, ret const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C018 const volatile &, C018 const, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C019 const, C019 const volatile, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C019 const, C019 &, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C019 const volatile, C019, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C019 &, C019 const, ret const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C019 &, C019 volatile &, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C020, C020, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C020, C020 const, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C020, C020 const, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C020 volatile, C020 const, ret const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C020 volatile &, C020, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C020 const volatile &, C020 const &, ret const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C021, C021 volatile, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C021 &, C021, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C021 &, C021, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C021 &, C021 const volatile, ret const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C021 &, C021 &, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C022 const volatile, C022, ret const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C022 &, C022 volatile &, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C022 const &, C022 const &, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C023 volatile &, C023 volatile, ret const volatile & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C024 const, C024 const volatile, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C024 const, C024 &, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C025, C025 volatile &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C025 const, C025 const volatile, ret >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C025 volatile, C025 const &, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C025 volatile, C025 const &, ret const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C025 const volatile, C025 const &, ret >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C025 const volatile, C025 const volatile &, ret const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C025 const &, C025 &, ret const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C025 const volatile &, C025 volatile, ret volatile & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C026, C026 const volatile, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C026 const, C026 const volatile &, ret const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C026 volatile, C026 volatile &, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C026 const volatile, C026 const &, ret const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C026 &, C026 &, ret const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C026 const &, C026 volatile &, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C026 const volatile &, C026 const volatile &, ret const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C027 volatile, C027 const volatile, ret volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C028 const, C028 volatile &, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C028 volatile, C028 const &, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C028 const volatile, C028 volatile &, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C028 volatile &, C028 const volatile, ret >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C028 const volatile &, C028 const &, ret const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C029, C029 volatile, ret >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C029 const, C029 volatile, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C029 volatile, C029 const volatile &, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C029 const volatile, C029 const &, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C029 const volatile, C029 volatile &, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C029 &, C029, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C029 &, C029 const, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C029 const &, C029, ret const & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C029 const &, C029 const volatile, ret >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C029 const &, C029 const volatile &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C029 volatile &, C029 volatile, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C029 volatile &, C029 &, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C030 const, C030, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C030 volatile, C030 const &, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C030 &, C030 const volatile &, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C030 const &, C030 volatile, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C031, C031 const, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C031 const, C031 volatile &, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C031 const, C031 const volatile &, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C031 const volatile, C031 const &, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C031 volatile &, C031 const volatile &, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C031 const volatile &, C031 const volatile, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C032 volatile, C032 const volatile, ret const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C032 &, C032 const, ret const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C032 volatile &, C032 const volatile &, ret >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C033 volatile, C033 const, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C033 const volatile, C033 const, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C033 &, C033 const, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C033 const &, C033, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C033 volatile &, C033 const volatile, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C033 volatile &, C033 &, ret const volatile & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C033 volatile &, C033 volatile &, ret const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C034 const, C034 const volatile &, ret >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C034 const volatile, C034 const, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C034 const volatile, C034 &, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C034 volatile &, C034 const, ret >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C034 volatile &, C034 volatile &, ret const volatile & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C035, C035 const, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C035, C035 volatile, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C035, C035 volatile &, ret >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C035 volatile, C035, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C035 volatile, C035 const volatile, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C035 volatile, C035 const volatile &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C035 const &, C035 const volatile, ret const volatile & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C035 volatile &, C035 volatile, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C035 volatile &, C035 const volatile &, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C036 volatile, C036 &, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C036 const volatile, C036, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C036 const volatile, C036 const &, ret volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C036 volatile &, C036 const volatile, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C036 const volatile &, C036 const &, ret volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C037 volatile &, C037 volatile, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C038 volatile, C038 const volatile, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C038 const volatile, C038 volatile, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C038 const volatile, C038 const &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C038 const volatile &, C038 volatile &, ret volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C039, C039 const volatile, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C039 const, C039 &, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C039 &, C039 const volatile, ret volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C039 &, C039 const &, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C039 volatile &, C039, ret >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C039 const volatile &, C039 &, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C040, C040, ret >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C040 const, C040 const, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C040 volatile, C040 const volatile, ret >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C040 const volatile, C040 volatile &, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C040 const volatile, C040 const volatile &, ret const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C040 volatile &, C040 volatile, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C040 volatile &, C040 const &, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C041 volatile, C041 const volatile, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C041 volatile, C041 const &, ret >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C041 volatile, C041 volatile &, ret volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C041 const volatile, C041 volatile &, ret >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C041 const volatile, C041 volatile &, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C041 const volatile &, C041, ret const & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C043 volatile, C043 const volatile, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C043 &, C043 volatile, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C043 const &, C043 &, ret const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C043 volatile &, C043 volatile &, ret >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C043 const volatile &, C043 const volatile, ret const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C043 const volatile &, C043 &, ret const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C043 const volatile &, C043 const &, ret const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C044 const volatile, C044 volatile, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C045, C045 const volatile, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C045 volatile, C045 volatile, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C045 const volatile, C045 &, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C046 volatile, C046 volatile &, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C046 const volatile, C046 const volatile, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C046 &, C046 &, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C047, C047 volatile, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C047 const &, C047 const &, ret const & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C048 const, C048 volatile, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C048 &, C048, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C048 &, C048 const &, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C048 const &, C048 const volatile, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C049 volatile &, C049 const, ret const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C050, C050 const volatile, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C050 const, C050, ret volatile & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C050 volatile, C050 volatile &, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C050 volatile, C050 volatile &, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C050 &, C050 &, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C050 const &, C050 volatile &, ret >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C050 const volatile &, C050 volatile, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C051 const, C051, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C051 const, C051 const volatile &, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C052 const, C052 const &, ret >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C052 volatile, C052 const volatile, ret >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C052 &, C052 &, ret const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C052 const volatile &, C052 &, ret const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C053 &, C053, ret >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C053 volatile &, C053 const volatile, ret volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C053 volatile &, C053 const &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C054, C054 const &, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C054 volatile, C054 const, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C054 const volatile &, C054 const &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C054 const volatile &, C054 const volatile &, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C055, C055 &, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C055, C055 &, ret const & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C055 const, C055 volatile, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C055 &, C055 volatile, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C055 &, C055 const volatile &, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C055 const &, C055 &, ret const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C055 volatile &, C055 const &, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C055 const volatile &, C055, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C055 const volatile &, C055 const, ret const volatile & >::value), 0);
+TT_TEST_END

Added: sandbox/type_traits/libs/type_traits/test/can_call_binary_classes1_test.cpp
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/test/can_call_binary_classes1_test.cpp 2011-07-09 16:29:47 EDT (Sat, 09 Jul 2011)
@@ -0,0 +1,263 @@
+// (C) Copyright 2009-2011 Frederic Bron.
+// Use, modification and distribution are subject to the
+// Boost Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#include "test.hpp"
+#include "check_integral_constant.hpp"
+
+#include <boost/type_traits/can_call.hpp>
+#include "can_call_binary_classes.hpp"
+
+TT_TEST_BEGIN(BOOST_TT_TRAIT_NAME)
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C055 const volatile &, C055 volatile, ret >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C056 const, C056 volatile, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C056 &, C056 volatile, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C056 volatile &, C056 const, ret >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C056 const volatile &, C056 const, ret volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C056 const volatile &, C056 &, ret const & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C057, C057 const volatile, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C057 const, C057 &, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C057 volatile, C057 const, ret const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C057 volatile &, C057 const, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C058 volatile, C058 &, ret const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C058 const &, C058 const volatile, ret const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C058 volatile &, C058, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C058 volatile &, C058 const volatile, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C058 const volatile &, C058 volatile, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C059 volatile, C059 &, ret const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C059 const volatile, C059 volatile &, ret const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C059 &, C059 &, ret volatile & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C060 const, C060 &, ret >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C060 const, C060 const &, ret volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C060 &, C060 volatile &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C060 volatile &, C060 const, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C060 volatile &, C060 &, ret const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C060 const volatile &, C060 volatile, ret const & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C060 const volatile &, C060 const volatile &, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C061, C061, ret const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C061 const, C061 const volatile &, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C061 volatile, C061 const volatile &, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C061 const volatile, C061 volatile, ret const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C061 volatile &, C061, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C061 volatile &, C061 &, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C062 const volatile, C062 volatile &, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C062 const &, C062 const &, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C063 const, C063 const &, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C063 const, C063 volatile &, ret volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C063 const volatile, C063, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C063 volatile &, C063 volatile, ret >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C064, C064 const volatile, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C064 const, C064 volatile, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C064 const &, C064 &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C064 volatile &, C064 &, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C065, C065, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C065, C065 const &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C065 &, C065 const &, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C066 const volatile, C066 &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C066 &, C066 const &, ret const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C066 volatile &, C066 const volatile, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C066 volatile &, C066 const &, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C066 const volatile &, C066 volatile, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C067 const, C067 volatile, ret >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C067 &, C067 const &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C067 &, C067 volatile &, ret const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C067 &, C067 volatile &, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C067 volatile &, C067 const, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C068, C068 volatile, ret const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C068 const volatile, C068 volatile, ret >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C068 const volatile, C068 const volatile, ret const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C069 const volatile, C069 const volatile, ret const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C069 const &, C069 const &, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C069 const volatile &, C069 volatile &, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C070 volatile, C070 const volatile &, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C070 &, C070 const volatile &, ret const volatile & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C070 const &, C070 volatile &, ret const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C070 volatile &, C070 volatile, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C070 volatile &, C070 &, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C071 const, C071 const &, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C071 const volatile, C071 const volatile &, ret const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C071 &, C071, ret const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C071 &, C071 const volatile, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C071 volatile &, C071 volatile, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C071 volatile &, C071 const volatile &, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C072 const, C072 volatile &, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C072 volatile, C072, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C072 volatile, C072 const, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C072 const volatile, C072 const volatile, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C072 const volatile &, C072, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C072 const volatile &, C072 &, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C073 volatile, C073 volatile, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C073 volatile, C073 const volatile, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C073 &, C073 volatile, ret const & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C073 volatile &, C073 &, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C073 volatile &, C073 volatile &, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C073 const volatile &, C073 const &, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C074 &, C074 const volatile &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C074 volatile &, C074 const volatile &, ret const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C074 const volatile &, C074 const &, ret const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C075 &, C075 &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C075 volatile &, C075 volatile &, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C076 const volatile, C076 volatile, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C076 volatile &, C076, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C077 volatile, C077 const, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C077 volatile, C077 volatile &, ret const & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C077 const volatile, C077 volatile, ret const & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C077 const &, C077 volatile, ret const & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C077 volatile &, C077 &, ret const & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C077 volatile &, C077 volatile &, ret >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C078 const, C078 const volatile, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C078 volatile, C078 volatile, ret const & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C078 &, C078 &, ret const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C078 const &, C078 const, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C078 volatile &, C078 &, ret >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C078 const volatile &, C078 &, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C079 const, C079 volatile, ret const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C079 volatile, C079 const volatile &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C079 volatile &, C079 const, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C079 volatile &, C079 const volatile, ret const volatile & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C080 const, C080 volatile &, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C080 volatile &, C080 const volatile, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C080 const volatile &, C080 volatile, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C080 const volatile &, C080 const volatile &, ret const volatile & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C081, C081 volatile &, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C081 const, C081 volatile, ret const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C081 &, C081 const, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C081 const volatile &, C081, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C081 const volatile &, C081 &, ret const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C082, C082 const, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C082 volatile &, C082 const volatile &, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C083 const volatile, C083 &, ret >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C083 const &, C083 volatile &, ret const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C084, C084, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C084 &, C084 const volatile, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C084 const &, C084 volatile, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C084 volatile &, C084, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C085, C085 volatile &, ret const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C085 const, C085 &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C085 volatile, C085 &, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C085 volatile, C085 volatile &, ret >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C086 const volatile, C086 const &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C086 const &, C086 volatile, ret const volatile & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C087, C087 const volatile, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C087 const volatile &, C087 volatile &, ret const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C089 volatile, C089 const volatile &, ret const volatile & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C089 const volatile, C089 const, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C089 const volatile, C089 volatile, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C090, C090 const &, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C090 const &, C090 volatile, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C090 volatile &, C090, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C091, C091 volatile, ret const & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C091 volatile &, C091 volatile &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C092 volatile &, C092 const, ret const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C093 volatile, C093 volatile, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C093 &, C093, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C093 &, C093 volatile &, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C094, C094, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C094, C094 &, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C094 const volatile, C094 const volatile &, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C094 const &, C094 &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C094 volatile &, C094 volatile, ret const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C095, C095 const volatile, ret const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C095 const volatile, C095 volatile, ret volatile & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C095 const volatile, C095 &, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C095 &, C095, ret const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C095 &, C095, ret const & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C095 &, C095 &, ret >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C095 const &, C095 const volatile &, ret const volatile & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C095 volatile &, C095 const, ret const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C096 const, C096 const volatile, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C097 const volatile, C097, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C097 const volatile, C097 volatile &, ret volatile & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C097 &, C097 const, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C098, C098, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C098 const volatile, C098 &, ret const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C098 const &, C098 volatile &, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C098 volatile &, C098 &, ret const volatile & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C099 const volatile, C099 volatile &, ret >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C099 const &, C099 volatile &, ret volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C100, C100, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C100 const volatile &, C100, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C101, C101 const &, ret const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C101, C101 const &, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C101 volatile, C101, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C101 &, C101 volatile &, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C102 const, C102, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C102 volatile, C102, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C102 volatile, C102 const volatile &, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C102 const volatile, C102 const volatile, ret const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C102 const volatile, C102 volatile &, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C102 &, C102 const volatile, ret >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C102 &, C102 const &, ret const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C102 volatile &, C102, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C102 volatile &, C102 const &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C102 const volatile &, C102 const, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C102 const volatile &, C102 &, ret const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C103 const, C103 volatile &, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C103 volatile, C103 volatile, ret const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C103 volatile, C103 &, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C103 const volatile &, C103 const volatile, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C104 volatile &, C104 const volatile &, ret const & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C104 const volatile &, C104 volatile, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C104 const volatile &, C104 volatile &, ret const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C105, C105 &, ret >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C105 const volatile, C105, ret >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C106 volatile, C106 const volatile &, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C106 volatile &, C106 const &, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C107 const, C107 volatile, ret const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C107 volatile, C107, ret >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C107 &, C107 const, ret const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C107 const volatile &, C107 const &, ret const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C108 volatile, C108 volatile &, ret >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C108 &, C108, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C108 const &, C108 const volatile, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C108 volatile &, C108 const volatile, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C108 const volatile &, C108 &, ret >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C110, C110 volatile, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C110 &, C110 volatile, ret volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C110 volatile &, C110 volatile &, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C110 const volatile &, C110 volatile &, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C111, C111 volatile, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C111 const volatile, C111 const volatile &, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C111 &, C111 &, ret const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C111 volatile &, C111 const, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C111 volatile &, C111 const volatile &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C112 const &, C112 const volatile &, ret const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C112 volatile &, C112 volatile &, ret volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C113 const, C113 const volatile, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C113 const, C113 const volatile, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C113 volatile, C113 const, ret const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C113 volatile, C113 &, ret & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C113 const &, C113 volatile &, ret >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C113 const volatile &, C113 &, ret const & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C114, C114 volatile, ret volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C114, C114 const volatile, ret >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C114 &, C114 const volatile &, ret const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C114 volatile &, C114 volatile, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C115, C115 const, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C115 volatile, C115 &, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C115 &, C115 volatile &, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C115 volatile &, C115 const &, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C116 volatile, C116 volatile, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C116 const volatile, C116 const volatile &, ret >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C116 const &, C116 volatile &, ret volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C116 const volatile &, C116 const, ret const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C117, C117 volatile, ret >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C117 const, C117 &, ret const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C117 const volatile, C117 volatile, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C117 const volatile, C117 const volatile &, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C117 &, C117, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C117 const &, C117 const &, ret volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C118, C118 volatile &, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C118 &, C118, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C118 &, C118 volatile, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C118 volatile &, C118 const volatile &, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C119 const, C119 &, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C119 const, C119 const volatile &, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C119 &, C119 const, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C119 &, C119 volatile &, ret const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C119 const &, C119, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C119 const &, C119 const volatile, ret const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C119 const &, C119 volatile &, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C119 volatile &, C119 const &, ret const volatile >::value), 1);
+TT_TEST_END

Added: sandbox/type_traits/libs/type_traits/test/can_call_binary_classes2_test.cpp
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/test/can_call_binary_classes2_test.cpp 2011-07-09 16:29:47 EDT (Sat, 09 Jul 2011)
@@ -0,0 +1,263 @@
+// (C) Copyright 2009-2011 Frederic Bron.
+// Use, modification and distribution are subject to the
+// Boost Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#include "test.hpp"
+#include "check_integral_constant.hpp"
+
+#include <boost/type_traits/can_call.hpp>
+#include "can_call_binary_classes.hpp"
+
+TT_TEST_BEGIN(BOOST_TT_TRAIT_NAME)
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C119 volatile &, C119 volatile &, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C120 const, C120 const volatile, ret volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C120 volatile, C120 const, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C120 const &, C120 &, ret >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C121 const, C121 const volatile &, ret const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C121 const volatile, C121, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C121 const volatile, C121 const &, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C121 const volatile, C121 const volatile &, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C121 &, C121 const volatile &, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C121 const &, C121 volatile &, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C122, C122, ret const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C122, C122, ret const & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C122 const, C122 const volatile, ret volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C122 volatile, C122 const volatile, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C122 const volatile, C122, ret const & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C122 const volatile, C122 volatile, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C123 const, C123 volatile &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C123 const &, C123, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C124 volatile, C124, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C124 &, C124 volatile, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C124 &, C124 const &, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C124 const &, C124 const, ret const volatile & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C124 const &, C124 const &, ret const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C124 volatile &, C124 &, ret const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C124 const volatile &, C124 volatile &, ret const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C125 volatile, C125 const volatile &, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C125 &, C125 const volatile, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C125 const &, C125, ret const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C125 const volatile &, C125, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C126 &, C126 const, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C126 volatile &, C126 const volatile, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C126 const volatile &, C126 const, ret const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C127, C127 volatile, ret const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C127, C127 const volatile, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C127 volatile, C127, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C127 const &, C127 const volatile &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C128 const, C128, ret const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C128 const, C128 volatile &, ret >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C128 volatile, C128 const volatile, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C128 const volatile, C128 volatile &, ret const & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C129 volatile, C129 volatile, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C129 const volatile, C129 volatile, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C129 const volatile, C129 const volatile, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C130, C130 const &, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C130 const volatile &, C130 volatile, ret >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C130 const volatile &, C130 &, ret const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C131 const, C131, ret const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C131 const, C131 const &, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C131 const volatile, C131 const, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C132, C132 const, ret const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C132 const, C132 volatile, ret const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C132 const, C132 const &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C132 &, C132 const volatile &, ret >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C132 &, C132 const volatile &, ret volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C132 const &, C132 volatile &, ret const & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C133 volatile, C133 const volatile, ret volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C133 const &, C133 &, ret const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C133 const &, C133 const volatile &, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C133 volatile &, C133 volatile, ret const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C133 const volatile &, C133 volatile, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C134 const, C134 const volatile, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C134 volatile, C134 volatile, ret const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C134 volatile, C134 volatile &, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C134 const &, C134 const, ret >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C135, C135 const, ret volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C135 const, C135 const volatile, void >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C135 const &, C135 const &, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C135 volatile &, C135 const, ret const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C136, C136, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C136 const, C136 &, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C136 const, C136 const volatile &, ret const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C136 const &, C136 const volatile, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C136 const volatile &, C136, ret const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C137 const &, C137 volatile, ret const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C138, C138 volatile &, ret const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C138 volatile, C138, ret >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C138 const volatile, C138 const &, ret const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C138 &, C138 const volatile, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C138 &, C138 const volatile, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C138 volatile &, C138 const volatile &, ret const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C138 const volatile &, C138 const volatile, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C139 volatile, C139 const volatile, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C139 volatile &, C139, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C140 volatile, C140 volatile &, ret const & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C140 volatile &, C140 volatile, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C140 const volatile &, C140, ret const & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C141 const, C141 volatile, ret const & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C141 const &, C141 volatile &, ret const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C143 &, C143, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C143 const &, C143 const volatile, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C143 volatile &, C143, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C144 const, C144 volatile &, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C144 &, C144, ret const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C144 &, C144 const &, ret >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C144 const &, C144 const, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C144 const volatile &, C144 &, ret const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C145, C145 const volatile, ret const & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C145, C145 &, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C145 const, C145 volatile &, ret >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C145 const volatile, C145 const volatile &, ret >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C145 &, C145 volatile &, ret const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C145 volatile &, C145, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C145 volatile &, C145 &, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C145 const volatile &, C145, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C146 volatile &, C146 const volatile &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C146 const volatile &, C146 const volatile &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C147 const volatile, C147 volatile &, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C147 volatile &, C147 &, ret const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C147 volatile &, C147 &, ret const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C148, C148 volatile, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C148 &, C148 const volatile, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C148 const &, C148 volatile, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C148 const &, C148 const volatile &, ret >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C149 volatile, C149 const volatile, ret const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C149 volatile, C149 const &, ret const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C150 const volatile, C150 volatile, ret const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C150 const volatile, C150 const volatile, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C150 const volatile &, C150, ret >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C151 const, C151 &, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C151 volatile &, C151, ret const volatile & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C151 const volatile &, C151 const, ret const volatile & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C151 const volatile &, C151 const &, ret const volatile & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C152, C152 &, ret const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C152 const, C152 const volatile &, ret >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C152 volatile, C152 const volatile &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C152 volatile, C152 const volatile &, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C152 const &, C152 const volatile &, ret const volatile & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C153 const volatile, C153 &, ret volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C153 &, C153, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C153 const &, C153 volatile &, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C153 const volatile &, C153 const volatile, ret const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C154, C154 &, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C154 &, C154 volatile, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C154 const volatile &, C154 const volatile &, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C155, C155 const volatile, ret const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C155 const volatile, C155 &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C155 &, C155 const volatile, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C155 const &, C155, ret const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C155 volatile &, C155 const volatile, ret const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C155 volatile &, C155 const volatile &, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C156 const, C156 volatile &, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C156 &, C156 volatile, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C156 const &, C156 &, ret >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C156 volatile &, C156 volatile &, ret >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C157 const volatile, C157 const &, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C157 const &, C157 const volatile &, ret const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C157 const volatile &, C157 const &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C158 const volatile, C158, ret const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C158 volatile &, C158 const &, ret const & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C158 const volatile &, C158 const volatile &, ret volatile & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C159, C159 &, ret const volatile & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C159 const, C159 &, ret const volatile & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C159 volatile, C159, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C159 volatile, C159, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C159 const &, C159 const volatile, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C160, C160 const volatile &, ret volatile & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C160 const volatile, C160 const, ret const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C160 const volatile, C160 &, ret volatile & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C160 volatile &, C160, ret >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C160 volatile &, C160 const volatile &, ret >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C161 const &, C161 volatile, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C161 const &, C161 &, ret >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C162 volatile, C162, void >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C162 volatile, C162 const volatile, void >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C162 volatile, C162 const volatile, ret >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C162 const volatile, C162 const, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C162 &, C162 volatile &, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C162 const &, C162 &, ret >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C162 const &, C162 &, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C162 volatile &, C162 volatile, void >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C162 const volatile &, C162 &, ret >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C163 volatile, C163 const volatile, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C163 volatile, C163 volatile &, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C163 &, C163, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C163 volatile &, C163 volatile &, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C164 const, C164 const &, ret const & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C164 volatile, C164 const &, ret >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C164 &, C164 &, ret const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C164 volatile &, C164 const, ret >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C165, C165, ret const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C165, C165 const volatile, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C165 volatile, C165 const, ret const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C165 const volatile, C165 volatile, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C165 &, C165 const &, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C165 const volatile &, C165 const &, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C166, C166 const volatile, ret >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C166 const volatile, C166 const volatile, ret >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C166 &, C166 volatile, ret const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C166 &, C166 const &, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C166 const &, C166 const volatile, ret >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C166 volatile &, C166 const &, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C167, C167 const &, ret & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C167 volatile, C167 &, ret const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C167 &, C167 const &, ret const volatile & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C167 volatile &, C167 const volatile, ret const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C168, C168 &, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C168 const, C168 const &, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C168 &, C168 const volatile &, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C168 const &, C168 &, ret const volatile & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C169, C169, ret const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C169, C169 volatile, ret const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C169 &, C169 const, ret const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C169 const &, C169 const volatile, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C169 const volatile &, C169, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C169 const volatile &, C169 const, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C169 const volatile &, C169 const volatile &, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C170, C170 const volatile &, ret >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C170 volatile, C170 const volatile &, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C170 const volatile, C170 const volatile, ret >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C170 &, C170 const &, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C170 const &, C170 volatile &, ret const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C170 volatile &, C170 const, ret const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C170 const volatile &, C170 &, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C171 volatile, C171 const, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C171 volatile, C171 volatile &, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C171 &, C171 volatile, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C171 volatile &, C171, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C172 const, C172 volatile &, ret const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C172 const &, C172 volatile, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C173 const volatile, C173, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C173 volatile &, C173 volatile &, ret const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C174, C174 &, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C174 const volatile, C174 const volatile, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C174 const volatile, C174 &, ret >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C174 const &, C174, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C174 const &, C174 const, ret const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C174 volatile &, C174, ret const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C174 const volatile &, C174, ret const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C175 volatile, C175 volatile, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C175 const volatile &, C175 const, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C176 const &, C176 const, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C176 const &, C176 volatile, ret const & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C176 const volatile &, C176 volatile &, ret >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C177 const volatile, C177 const volatile, ret const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C177 const volatile, C177 &, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C178 const, C178 &, ret const volatile & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C178 volatile, C178 const, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C178 const &, C178 volatile &, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C178 volatile &, C178 const volatile &, ret volatile & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C179 const, C179 const volatile, ret const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C179 const, C179 const &, ret const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C179 volatile, C179 const, ret const volatile & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C179 &, C179 volatile &, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C179 &, C179 const volatile &, ret const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C179 volatile &, C179 const volatile, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C180 const, C180 const volatile, ret >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C180 volatile, C180 const volatile &, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C180 const volatile, C180 volatile, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C180 const &, C180, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C181, C181 const, ret const volatile & >::value), 0);
+TT_TEST_END

Added: sandbox/type_traits/libs/type_traits/test/can_call_binary_classes3_test.cpp
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/test/can_call_binary_classes3_test.cpp 2011-07-09 16:29:47 EDT (Sat, 09 Jul 2011)
@@ -0,0 +1,263 @@
+// (C) Copyright 2009-2011 Frederic Bron.
+// Use, modification and distribution are subject to the
+// Boost Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#include "test.hpp"
+#include "check_integral_constant.hpp"
+
+#include <boost/type_traits/can_call.hpp>
+#include "can_call_binary_classes.hpp"
+
+TT_TEST_BEGIN(BOOST_TT_TRAIT_NAME)
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C181 const, C181 const volatile, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C181 const, C181 &, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C181 &, C181 const &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C181 volatile &, C181 const, ret volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C182 volatile, C182 volatile, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C182 const &, C182 const volatile, ret >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C182 const volatile &, C182 const volatile &, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C183, C183 const volatile &, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C184, C184 volatile &, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C184 const volatile, C184 volatile &, ret volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C184 const volatile, C184 volatile &, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C184 &, C184 const, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C184 &, C184 const volatile &, ret >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C184 const &, C184 &, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C184 volatile &, C184 const, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C184 volatile &, C184 const volatile &, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C185, C185 const volatile, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C185 const, C185, ret & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C185 const volatile, C185 const volatile &, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C185 const &, C185 const volatile &, ret const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C185 volatile &, C185 volatile, ret >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C186 volatile, C186 volatile &, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C186 const volatile, C186 &, ret const volatile & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C186 &, C186 const &, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C187, C187 volatile, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C187 volatile, C187 const &, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C187 const volatile &, C187 const volatile, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C188 const, C188 &, ret const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C188 const volatile, C188, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C188 const &, C188 const &, ret volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C188 const volatile &, C188 volatile, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C188 const volatile &, C188 const volatile, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C189 volatile, C189 volatile &, ret volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C189 &, C189 const volatile &, ret volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C189 const volatile &, C189, ret const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C189 const volatile &, C189 const, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C189 const volatile &, C189 volatile, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C189 const volatile &, C189 &, ret >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C190 const, C190 const volatile, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C190 volatile, C190 volatile, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C190 volatile, C190 volatile &, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C190 const volatile &, C190, ret >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C191 &, C191 const &, ret const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C191 const &, C191 volatile, ret volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C191 const volatile &, C191, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C191 const volatile &, C191 const volatile, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C192, C192 volatile &, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C192 const, C192 const volatile, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C192 const volatile, C192 const volatile &, ret volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C192 const &, C192, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C192 const volatile &, C192 const, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C193 volatile, C193 &, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C193 &, C193 const &, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C193 const &, C193 const &, ret >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C193 const &, C193 const volatile &, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C193 volatile &, C193 volatile &, ret >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C193 volatile &, C193 const volatile &, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C194, C194 const &, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C194 const, C194 const, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C194 const volatile, C194 volatile, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C194 const &, C194, ret >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C194 volatile &, C194 const &, ret >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C195, C195 const volatile &, ret >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C195 const, C195, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C195 const, C195, ret const volatile & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C195 const, C195 volatile &, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C195 volatile &, C195 const volatile &, ret volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C195 const volatile &, C195 const volatile &, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C196, C196 const &, ret const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C196 volatile, C196 &, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C196 const volatile, C196, ret const volatile & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C196 const volatile, C196 const, ret const volatile & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C197, C197 volatile, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C197, C197 &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C197 const, C197 volatile, ret >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C197 const &, C197 &, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C197 const volatile &, C197 &, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C198 &, C198 volatile &, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C198 const &, C198, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C199, C199 volatile &, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C199 const, C199 const, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C199 &, C199 volatile &, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C200 volatile, C200 const volatile, ret const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C200 &, C200, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C200 &, C200 &, ret const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C200 const &, C200, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C200 const &, C200 const volatile, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C200 const volatile &, C200 const, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C200 const volatile &, C200 const, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C200 const volatile &, C200 const volatile, ret const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C201 volatile, C201 const volatile, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C201 volatile, C201 const &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C201 const volatile, C201 const volatile, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C201 &, C201 const &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C201 &, C201 const volatile &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C201 volatile &, C201 volatile, ret const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C202 const, C202 const, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C202 const, C202 volatile &, ret const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C202 const volatile, C202 const, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C202 &, C202 const volatile, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C202 const &, C202, ret const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C203 const, C203, ret >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C203 const, C203 const volatile, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C203 const, C203 const &, ret >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C203 volatile, C203 const, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C203 volatile, C203 &, ret const & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C203 const volatile, C203 &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C203 &, C203 const volatile, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C203 &, C203 volatile &, ret const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C203 volatile &, C203 volatile &, ret >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C204 volatile, C204 volatile &, ret >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C204 const volatile, C204 &, ret >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C204 const volatile, C204 volatile &, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C204 const volatile &, C204 volatile &, ret const volatile & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C205 volatile, C205 const volatile &, ret >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C205 volatile, C205 const volatile &, ret const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C205 volatile, C205 const volatile &, ret volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C205 const volatile, C205 const, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C205 &, C205, ret >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C205 const &, C205, ret const volatile & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C205 const volatile &, C205 volatile, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C206 const volatile, C206, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C206 const volatile, C206 &, ret const volatile & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C206 const volatile &, C206 &, ret const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C207, C207 const volatile, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C207 volatile, C207, ret >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C207 const volatile, C207 volatile, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C207 &, C207, ret volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C207 const &, C207 const volatile, ret const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C207 const volatile &, C207 &, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C208, C208 &, ret const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C208 volatile, C208 volatile &, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C208 &, C208 &, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C208 const &, C208 volatile &, ret >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C208 const volatile &, C208 volatile &, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C209 const &, C209 const, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C209 volatile &, C209 const, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C210, C210, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C210 volatile, C210 const volatile &, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C210 &, C210 const volatile &, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C211 const, C211 const volatile &, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C211 volatile, C211 const &, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C211 volatile &, C211, ret const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C212 const, C212 volatile &, ret const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C212 &, C212, ret const & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C212 const volatile &, C212 volatile, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C212 const volatile &, C212 &, ret volatile & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C213 volatile, C213 const volatile &, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C213 const volatile, C213 volatile, ret >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C213 const volatile &, C213 const volatile &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C214, C214 volatile &, ret const volatile & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C214 const, C214 volatile, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C214 volatile, C214, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C214 const volatile &, C214 &, ret volatile & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C215 &, C215 volatile &, ret const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C215 volatile &, C215 const &, ret >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C215 const volatile &, C215, ret const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C215 const volatile &, C215, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C216 const, C216, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C216 &, C216, ret volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C216 const &, C216 volatile, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C216 volatile &, C216 volatile, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C217 volatile, C217, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C217 const volatile, C217 const, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C217 &, C217 const, ret const & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C217 const &, C217, ret >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C217 const &, C217 const volatile &, ret const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C217 volatile &, C217, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C217 volatile &, C217 volatile &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C218, C218 const volatile, ret >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C218 volatile, C218 volatile, ret const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C218 const volatile, C218 volatile &, ret const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C218 &, C218 const, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C218 const &, C218 const volatile &, ret const & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C219, C219 &, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C219 const, C219 const volatile, ret >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C219 const, C219 &, ret >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C219 volatile, C219 &, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C219 &, C219, ret const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C219 const &, C219 const volatile &, ret >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C219 volatile &, C219, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C219 volatile &, C219 &, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C219 volatile &, C219 const volatile &, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C219 const volatile &, C219 volatile, ret const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C219 const volatile &, C219 const volatile &, ret const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C220 volatile, C220 volatile, ret const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C220 const volatile, C220 volatile, ret const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C220 const &, C220 const &, ret >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C220 const volatile &, C220 &, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C221, C221 volatile, ret const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C221 const, C221 volatile &, ret const volatile & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C221 const volatile, C221 const, ret const volatile & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C221 const volatile, C221 &, ret const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C221 &, C221 volatile &, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C221 volatile &, C221 volatile, ret volatile & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C221 const volatile &, C221 const volatile, ret const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C221 const volatile &, C221 &, ret const volatile & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C222 const volatile, C222 const &, ret const volatile & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C222 &, C222 const, ret const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C222 &, C222 volatile, ret const & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C222 &, C222 &, ret const & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C222 volatile &, C222, ret >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C222 const volatile &, C222 const, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C223, C223 volatile, ret volatile & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C223, C223 volatile &, ret const volatile & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C223 const volatile &, C223 const volatile &, ret const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C224 const volatile, C224 volatile, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C224 const volatile, C224 &, ret const volatile & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C224 volatile &, C224 &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C225, C225 const volatile, void >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C225 const, C225 const, void >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C225 volatile, C225 volatile, ret const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C226, C226 volatile, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C226, C226 const volatile, ret >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C226 const, C226 volatile &, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C226 &, C226 const, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C226 volatile &, C226 const &, ret >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C226 const volatile &, C226 const, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C227 const, C227 &, ret const & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C227 const, C227 &, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C227 const &, C227 const volatile, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C227 volatile &, C227 const &, ret const & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C228 const, C228 volatile &, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C228 const volatile &, C228 volatile &, ret const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C229, C229 &, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C229 volatile, C229 volatile &, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C229 const volatile, C229 const volatile, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C229 const &, C229 volatile, ret const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C229 const &, C229 volatile, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C229 volatile &, C229, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C230, C230 &, ret const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C230 const, C230, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C230 const volatile, C230 const, ret const & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C230 const volatile, C230 &, ret volatile & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C230 &, C230 const volatile, ret >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C230 volatile &, C230 const volatile &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C230 const volatile &, C230 const, ret volatile & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C231, C231 const, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C231, C231 const volatile, ret const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C231, C231 const volatile &, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C231 &, C231 const volatile &, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C231 const &, C231 const volatile, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C232 volatile, C232 const volatile &, ret const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C232 const volatile, C232, ret volatile & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C233 &, C233, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C234, C234 volatile, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C234, C234 const volatile, ret volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C234 const, C234, ret const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C234 const, C234 const volatile &, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C235 const volatile, C235, ret >::value), 1);
+TT_TEST_END

Added: sandbox/type_traits/libs/type_traits/test/can_call_binary_classes4_test.cpp
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/test/can_call_binary_classes4_test.cpp 2011-07-09 16:29:47 EDT (Sat, 09 Jul 2011)
@@ -0,0 +1,263 @@
+// (C) Copyright 2009-2011 Frederic Bron.
+// Use, modification and distribution are subject to the
+// Boost Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#include "test.hpp"
+#include "check_integral_constant.hpp"
+
+#include <boost/type_traits/can_call.hpp>
+#include "can_call_binary_classes.hpp"
+
+TT_TEST_BEGIN(BOOST_TT_TRAIT_NAME)
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C235 volatile &, C235, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C236 volatile, C236, ret const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C236 &, C236 const, ret const & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C237 volatile, C237 volatile, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C237 volatile, C237 volatile &, ret const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C237 const volatile, C237 &, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C237 volatile &, C237 volatile &, ret const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C238, C238 const, ret const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C238 volatile, C238 &, ret >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C238 const volatile, C238 const &, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C238 volatile &, C238 const volatile &, ret const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C239 &, C239 volatile &, ret volatile & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C239 const &, C239 const, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C239 const volatile &, C239, ret const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C240 const volatile, C240, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C240 &, C240 const volatile &, ret const & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C240 volatile &, C240 const volatile, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C240 const volatile &, C240 const &, ret const & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C241 const, C241 const volatile, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C241 volatile, C241 volatile &, ret const volatile & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C241 volatile, C241 const volatile &, ret const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C241 const volatile, C241 const volatile &, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C241 &, C241 const volatile, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C242 volatile &, C242 const volatile, ret const volatile & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C242 const volatile &, C242, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C243, C243 const &, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C243, C243 volatile &, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C243 volatile, C243 volatile, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C243 volatile, C243 const &, ret volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C243 const volatile &, C243 const, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C244, C244 const, ret >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C244 const, C244 volatile &, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C244 volatile, C244 volatile &, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C244 volatile &, C244, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C244 volatile &, C244 const volatile &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C244 const volatile &, C244 volatile &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C245, C245 const &, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C245, C245 const volatile &, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C245 const, C245, ret >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C245 const, C245 const volatile &, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C245 volatile, C245 const &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C245 volatile, C245 volatile &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C245 &, C245 const &, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C246 const, C246 const volatile &, ret const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C246 const, C246 const volatile &, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C246 const &, C246, ret const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C246 const &, C246 const &, ret >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C247, C247 volatile &, ret const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C247 const volatile, C247 const volatile &, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C247 volatile &, C247 const, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C248 const, C248 volatile &, ret volatile & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C248 &, C248 const &, ret const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C248 volatile &, C248 &, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C248 const volatile &, C248 volatile, ret & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C248 const volatile &, C248 &, ret const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C249 const, C249 volatile, ret const volatile & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C249 const volatile, C249 const volatile &, ret const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C249 &, C249 volatile &, ret const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C249 volatile &, C249 const &, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C249 const volatile &, C249 &, ret >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C249 const volatile &, C249 const volatile &, ret >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C250 const, C250 const volatile &, ret const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C250 volatile, C250, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C250 const volatile, C250 const &, ret const volatile & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C250 const volatile, C250 const volatile &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C250 &, C250 volatile, ret const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C250 &, C250 volatile &, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C250 volatile &, C250, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C251 const &, C251 const volatile, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C251 const volatile &, C251 const &, ret >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C252 const, C252 &, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C252 const, C252 volatile &, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C252 volatile &, C252 volatile &, ret volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C252 volatile &, C252 volatile &, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C253 const, C253, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C253 volatile, C253 &, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C253 &, C253, ret >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C254 &, C254 const volatile, ret >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C254 &, C254 const volatile &, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C254 const &, C254, ret >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C254 const &, C254 const &, ret volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C254 volatile &, C254, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C255 &, C255 &, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C255 volatile &, C255 const, ret const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C255 const volatile &, C255 const volatile, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C256, C256 const, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C256, C256 volatile &, ret const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C256 volatile, C256 const, ret const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C256 &, C256 const &, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C256 const &, C256 volatile &, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C257 volatile, C257 volatile, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C257 volatile &, C257 volatile, ret >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C257 volatile &, C257 volatile &, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C258 &, C258 const volatile, ret volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C258 volatile &, C258 &, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C259, C259 &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C259 volatile, C259 &, ret const volatile & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C259 volatile, C259 const volatile &, ret const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C259 const volatile, C259 const volatile, ret volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C259 &, C259 const &, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C260, C260 const &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C260 &, C260 const &, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C260 volatile &, C260 const &, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C260 const volatile &, C260 const, ret const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C261 &, C261 const &, ret >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C262 const &, C262 volatile, ret const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C262 volatile &, C262 volatile &, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C262 const volatile &, C262 &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C263, C263 const, ret const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C263 const, C263, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C263 const, C263, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C263 const, C263 const volatile &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C263 &, C263 volatile, ret volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C263 volatile &, C263 &, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C264 const, C264, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C265, C265 const volatile &, ret >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C265 volatile, C265, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C265 volatile, C265 &, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C265 const &, C265 const &, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C266 const volatile, C266 const, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C266 const volatile, C266 const &, ret >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C266 const volatile, C266 volatile &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C266 const &, C266, ret const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C266 volatile &, C266, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C266 volatile &, C266 volatile, ret >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C266 const volatile &, C266 const, ret const & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C266 const volatile &, C266 const &, ret const & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C267 const, C267 volatile, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C267 const &, C267, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C267 const &, C267 &, ret >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C267 const &, C267 const &, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C267 const &, C267 volatile &, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C267 const volatile &, C267 &, ret const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C268 &, C268 const volatile &, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C268 const &, C268 const volatile, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C269, C269 &, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C269 const volatile, C269 const &, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C269 &, C269, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C269 &, C269 &, ret >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C269 const &, C269 const, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C269 const &, C269 &, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C269 const &, C269 volatile &, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C269 const volatile &, C269 const volatile &, ret const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C270, C270 const volatile &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C270 volatile, C270 volatile, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C270 volatile, C270 const volatile, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C270 volatile, C270 volatile &, ret volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C270 const &, C270 &, ret volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C270 const &, C270 const &, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C270 volatile &, C270 const &, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C270 const volatile &, C270, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C271 const volatile, C271 const volatile, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C271 const &, C271 volatile, ret const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C271 volatile &, C271 const volatile, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C271 const volatile &, C271 const volatile, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C271 const volatile &, C271 volatile &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C272, C272 const, ret const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C272 volatile, C272 volatile, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C272 const &, C272 const volatile, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C272 const &, C272 &, ret const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C272 const volatile &, C272 const, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C273, C273 &, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C273 const volatile, C273 &, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C273 const volatile, C273 const volatile &, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C273 &, C273, ret const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C273 volatile &, C273 volatile, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C273 volatile &, C273 const volatile, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C273 volatile &, C273 volatile &, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C273 volatile &, C273 const volatile &, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C273 const volatile &, C273 &, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C274 const, C274, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C274 const, C274 const volatile, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C274 const, C274 const &, ret >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C274 volatile, C274 volatile &, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C274 volatile &, C274, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C274 volatile &, C274 const volatile &, ret volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C275, C275 const volatile, ret >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C275 const volatile, C275 volatile &, ret volatile & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C275 &, C275 const, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C275 const &, C275 const &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C276, C276 volatile, ret const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C276, C276 volatile &, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C276 &, C276 volatile &, ret const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C276 const volatile &, C276 const volatile &, ret const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C277 volatile, C277 const, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C277 &, C277, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C277 &, C277 const, ret >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C278 const, C278 volatile &, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C278 const volatile, C278, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C278 &, C278 volatile &, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C279 volatile, C279 volatile &, ret >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C279 const volatile, C279, ret const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C279 const volatile, C279, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C279 const volatile, C279 volatile, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C279 const &, C279 volatile, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C279 volatile &, C279 volatile, void >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C280, C280, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C280 volatile, C280 volatile &, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C280 &, C280 volatile, ret const & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C280 const volatile &, C280 volatile &, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C281, C281 const volatile &, ret const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C281 const, C281 const, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C281 &, C281 const volatile &, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C281 const &, C281 volatile &, ret const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C282, C282 const &, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C282 const, C282 volatile &, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C282 const volatile &, C282 volatile &, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C283, C283 &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C283 volatile, C283, ret const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C283 volatile, C283 const, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C283 volatile &, C283, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C284 const, C284 &, ret const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C284 volatile, C284 const volatile &, ret >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C284 &, C284 const volatile &, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C284 &, C284 const volatile &, ret const & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C284 const &, C284, ret & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C284 const volatile &, C284 const, ret const & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C285 const, C285 const volatile, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C285 const, C285 const &, ret >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C285 const volatile, C285, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C285 const volatile, C285 const volatile, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C285 const &, C285 const, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C285 const &, C285 volatile, ret const volatile & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C285 const &, C285 volatile &, ret >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C285 volatile &, C285, ret const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C286 const, C286 const &, ret >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C286 volatile, C286 const &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C286 const volatile, C286, ret >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C286 const volatile, C286 &, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C286 const volatile &, C286 const &, ret volatile & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C287, C287 const &, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C287 volatile, C287, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C287 const volatile, C287 &, ret const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C287 const volatile, C287 const &, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C288 const volatile, C288 &, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C288 const &, C288 const volatile, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C288 const &, C288 volatile &, ret const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C288 volatile &, C288 &, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C289 const, C289 const volatile, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C289 const &, C289, ret const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C289 const &, C289 const volatile, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C289 const &, C289 const volatile &, ret volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C289 const volatile &, C289 volatile &, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C290 volatile, C290 const &, ret >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C291 const &, C291 const volatile &, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C292, C292 volatile &, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C292 volatile, C292 const, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C292 const volatile, C292 &, ret >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C292 const &, C292 const, ret const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C293, C293 const volatile &, ret const & >::value), 1);
+TT_TEST_END

Added: sandbox/type_traits/libs/type_traits/test/can_call_binary_classes5_test.cpp
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/test/can_call_binary_classes5_test.cpp 2011-07-09 16:29:47 EDT (Sat, 09 Jul 2011)
@@ -0,0 +1,263 @@
+// (C) Copyright 2009-2011 Frederic Bron.
+// Use, modification and distribution are subject to the
+// Boost Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#include "test.hpp"
+#include "check_integral_constant.hpp"
+
+#include <boost/type_traits/can_call.hpp>
+#include "can_call_binary_classes.hpp"
+
+TT_TEST_BEGIN(BOOST_TT_TRAIT_NAME)
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C293 &, C293 volatile, ret const & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C294 const, C294 const, ret const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C294 const, C294 const, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C294 volatile, C294 volatile, ret const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C294 const volatile, C294, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C295, C295 volatile, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C295, C295 const volatile, ret const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C295 const volatile &, C295, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C295 const volatile &, C295 &, ret const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C296, C296 const &, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C296 const, C296 const &, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C296 volatile, C296 &, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C296 volatile &, C296 const volatile &, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C296 const volatile &, C296 volatile &, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C297 const, C297 const volatile &, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C297 volatile, C297 &, ret >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C297 const volatile, C297 volatile, ret const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C297 volatile &, C297 volatile, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C297 volatile &, C297 const volatile, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C297 volatile &, C297 volatile &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C298, C298 volatile, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C298 volatile &, C298 volatile &, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C299 volatile, C299 const, ret volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C299 volatile, C299 const volatile, ret >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C299 volatile, C299 &, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C299 volatile, C299 const volatile &, ret >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C299 const &, C299 const &, ret >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C299 const volatile &, C299 &, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C299 const volatile &, C299 const volatile &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C300 volatile, C300 &, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C300 const volatile, C300 &, ret volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C300 &, C300 &, ret const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C300 const volatile &, C300 const, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C301 const volatile, C301 const volatile &, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C301 const &, C301 const &, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C302 const, C302 const, ret volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C302 const &, C302 volatile &, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C302 volatile &, C302 const volatile &, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C302 const volatile &, C302, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C303 const, C303 volatile &, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C303 const volatile, C303 volatile, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C303 const volatile, C303 const &, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C303 const volatile, C303 const volatile &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C303 &, C303 const volatile, ret const volatile & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C304, C304 const, ret const volatile & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C304 const, C304, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C304 const, C304 const, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C304 const volatile, C304 const volatile, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C304 const volatile, C304 &, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C304 const volatile, C304 const volatile &, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C304 volatile &, C304, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C304 volatile &, C304 const volatile &, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C304 const volatile &, C304 const volatile &, ret >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C305, C305 volatile, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C305, C305 const &, ret >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C305, C305 volatile &, ret >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C305 const volatile, C305 const, ret >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C306 const, C306 volatile &, ret >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C307 &, C307 volatile, ret const & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C307 &, C307 const volatile, ret const & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C307 const &, C307 volatile &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C307 const &, C307 const volatile &, ret const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C308 &, C308 const &, ret const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C308 const &, C308, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C308 volatile &, C308 volatile &, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C309 volatile, C309 volatile &, ret >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C309 &, C309, ret >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C310, C310 const volatile &, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C310 const, C310 const &, ret const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C310 const volatile, C310 const volatile &, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C310 &, C310 const volatile, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C311 const, C311 const volatile, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C311 const &, C311 volatile &, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C312 volatile, C312 volatile, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C312 const volatile, C312 const volatile, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C312 const &, C312, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C312 volatile &, C312, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C312 volatile &, C312 volatile, ret volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C312 volatile &, C312 const volatile, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C312 volatile &, C312 &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C313 const, C313, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C313 const &, C313 volatile, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C313 const &, C313 const volatile, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C313 const &, C313 const volatile &, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C313 const volatile &, C313, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C313 const volatile &, C313 volatile &, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C315 &, C315 const volatile, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C315 const &, C315, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C315 const volatile &, C315 const, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C316, C316 const volatile &, ret >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C316 const, C316, ret volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C316 volatile &, C316 const volatile, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C316 const volatile &, C316 const &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C317 const, C317 const &, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C317 &, C317 const volatile &, ret const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C318, C318 const, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C318, C318 const volatile, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C318 const volatile, C318 const, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C318 &, C318, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C318 const &, C318, ret volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C318 volatile &, C318 volatile &, ret const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C318 const volatile &, C318 volatile, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C319 &, C319 const volatile, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C319 const &, C319 const, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C319 const volatile &, C319 volatile &, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C320 const volatile, C320 const, ret const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C320 const volatile, C320 volatile, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C321, C321, ret const & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C321 volatile, C321 volatile, ret volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C321 const volatile, C321 &, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C321 &, C321 volatile &, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C322 volatile, C322 const volatile &, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C322 const volatile, C322 const &, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C322 const volatile &, C322 const, ret volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C323 const, C323 volatile, ret const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C323 volatile, C323 volatile &, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C323 &, C323 &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C324 volatile, C324 const volatile, ret volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C324 volatile, C324 &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C324 &, C324 const volatile, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C324 const volatile &, C324 const &, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C325 const, C325 volatile, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C325 const volatile, C325 &, ret const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C325 const &, C325 const &, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C325 volatile &, C325 const, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C325 volatile &, C325 &, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C326 volatile, C326 const &, ret >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C326 const volatile, C326 volatile &, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C326 volatile &, C326 volatile, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C327, C327 volatile &, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C327 const, C327 const, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C327 const volatile &, C327 volatile &, ret >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C328, C328 volatile, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C328, C328 const &, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C328 const, C328 const, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C328 &, C328 const &, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C329 volatile, C329, ret >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C329 const volatile, C329 volatile &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C329 &, C329 &, ret const & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C329 volatile &, C329 const volatile &, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C329 const volatile &, C329 volatile, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C330, C330 const, ret volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C330 const, C330 const volatile, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C330 &, C330 const volatile, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C331 volatile, C331 const, ret >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C331 volatile, C331 &, ret const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C331 volatile, C331 &, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C331 const volatile, C331 const volatile, ret volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C331 const volatile, C331 &, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C332, C332, ret const volatile & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C332 const &, C332 const, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C332 const &, C332 const &, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C332 const volatile &, C332 const &, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C333, C333, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C333 const, C333, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C333 const volatile, C333 const volatile &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C333 &, C333, ret const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C333 const &, C333, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C333 const volatile &, C333 const volatile, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C333 const volatile &, C333 const volatile, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C334, C334 const, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C334 const, C334 const volatile, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C334 const volatile, C334 volatile, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C334 const &, C334 &, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C334 volatile &, C334 const, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C334 const volatile &, C334 &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C335 volatile, C335 const &, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C335 const &, C335 &, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C335 const &, C335 volatile &, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C335 volatile &, C335 const volatile &, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C335 const volatile &, C335 &, ret const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C336, C336 &, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C336 const volatile, C336 volatile &, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C336 &, C336 const volatile &, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C336 const &, C336 volatile &, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C337, C337 volatile, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C337, C337 const &, ret >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C337 const, C337 volatile, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C337 const &, C337 &, ret const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C337 volatile &, C337 const, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C337 volatile &, C337 const, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C337 const volatile &, C337 volatile, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C338, C338 const &, ret & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C338 const, C338 const volatile, ret const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C338 const, C338 &, ret volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C338 const, C338 volatile &, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C338 volatile, C338 volatile, ret >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C338 const volatile, C338 const, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C338 &, C338 const volatile &, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C338 const &, C338 volatile, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C338 const &, C338 &, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C338 const &, C338 const &, ret >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C339, C339 const, ret const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C339 const, C339 &, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C339 volatile &, C339 &, ret >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C339 const volatile &, C339 volatile &, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C340 &, C340 const, ret const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C340 volatile &, C340, ret >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C340 const volatile &, C340, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C341, C341 const volatile &, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C341 const, C341 const, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C341 const, C341 volatile &, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C341 volatile, C341, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C341 &, C341 volatile &, ret volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C341 const &, C341, ret >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C341 const &, C341, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C341 const &, C341 volatile, ret volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C343 const volatile &, C343 const &, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C344 volatile, C344 const volatile, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C344 const volatile, C344 const volatile &, ret >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C344 &, C344, ret >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C344 &, C344 volatile &, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C345 volatile, C345 const, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C345 &, C345 const volatile, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C345 volatile &, C345, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C345 const volatile &, C345 const volatile, ret volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C345 const volatile &, C345 &, ret const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C346, C346 const &, ret volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C346, C346 const &, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C346 volatile, C346 volatile &, ret >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C346 const volatile, C346 const volatile, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C346 const volatile, C346 const volatile &, ret >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C346 &, C346 const volatile &, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C346 const volatile &, C346, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C346 const volatile &, C346 const &, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C347 volatile, C347 volatile &, ret volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C347 const volatile, C347 const volatile &, ret >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C347 volatile &, C347 const volatile, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C347 const volatile &, C347 const, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C348, C348 &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C348 const, C348 const volatile &, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C348 volatile, C348 volatile, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C348 const volatile, C348 &, ret const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C348 &, C348 const volatile, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C348 const &, C348 &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C348 const volatile &, C348 volatile, ret >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C349 const, C349 const, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C349 volatile, C349 const volatile, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C349 const volatile, C349, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C349 &, C349 const volatile &, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C349 volatile &, C349 const &, ret >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C349 const volatile &, C349 const &, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C350 const, C350 const volatile &, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C350 volatile, C350 const volatile &, ret const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C351 volatile, C351 const &, ret volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C351 const volatile, C351 const &, ret >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C351 &, C351 const &, ret volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C351 volatile &, C351, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C351 const volatile &, C351 const &, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C351 const volatile &, C351 const volatile &, ret & >::value), 0);
+TT_TEST_END

Added: sandbox/type_traits/libs/type_traits/test/can_call_binary_classes6_test.cpp
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/test/can_call_binary_classes6_test.cpp 2011-07-09 16:29:47 EDT (Sat, 09 Jul 2011)
@@ -0,0 +1,263 @@
+// (C) Copyright 2009-2011 Frederic Bron.
+// Use, modification and distribution are subject to the
+// Boost Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#include "test.hpp"
+#include "check_integral_constant.hpp"
+
+#include <boost/type_traits/can_call.hpp>
+#include "can_call_binary_classes.hpp"
+
+TT_TEST_BEGIN(BOOST_TT_TRAIT_NAME)
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C352, C352 const &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C352 const &, C352 volatile &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C352 const &, C352 const volatile &, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C353 volatile, C353 volatile, ret >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C353 const volatile, C353, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C353 const volatile, C353 volatile &, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C353 const volatile &, C353 volatile, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C353 const volatile &, C353 &, ret const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C354, C354, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C354 volatile, C354 volatile &, ret const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C354 &, C354 volatile &, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C354 const volatile &, C354 volatile, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C354 const volatile &, C354 const &, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C355 const, C355 volatile &, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C355 volatile, C355, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C355 volatile, C355 const volatile, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C355 volatile, C355 const &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C355 const volatile, C355 volatile, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C355 &, C355, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C355 const &, C355 const volatile &, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C356 volatile, C356 const, ret volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C356 volatile, C356 volatile &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C356 &, C356 const, ret const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C356 &, C356 volatile, ret const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C356 const &, C356 volatile, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C356 const volatile &, C356 volatile, ret volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C357, C357 const volatile, ret const & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C357, C357 &, ret const volatile & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C357 volatile, C357 const volatile, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C358 volatile, C358 const volatile &, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C358 &, C358 const volatile, ret >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C358 &, C358 const &, ret const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C358 volatile &, C358 volatile, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C359, C359 const volatile, ret >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C359, C359 volatile &, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C359 const, C359 const volatile, ret const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C359 const volatile, C359 const volatile &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C360 const volatile &, C360 const volatile, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C361, C361 const volatile &, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C361 const, C361 const &, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C361 volatile, C361 volatile &, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C361 &, C361 &, ret const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C361 &, C361 volatile &, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C361 const &, C361 const, ret const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C362 const, C362 const &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C363, C363 volatile, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C363, C363 const &, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C363, C363 volatile &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C363 volatile, C363 const &, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C363 &, C363, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C363 const &, C363 const volatile, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C363 const &, C363 const volatile &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C363 volatile &, C363, ret >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C364 volatile, C364 volatile, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C365, C365 &, ret const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C365 const, C365 volatile, ret & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C365 const volatile, C365 const volatile &, ret >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C365 const &, C365 const volatile &, ret >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C365 volatile &, C365 const &, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C365 const volatile &, C365 const volatile, ret >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C366 const volatile, C366 &, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C366 const volatile, C366 &, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C366 &, C366 volatile, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C366 volatile &, C366 volatile &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C366 volatile &, C366 const volatile &, ret >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C366 const volatile &, C366 const volatile, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C367 const &, C367 const, ret >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C367 const &, C367 volatile, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C367 volatile &, C367, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C367 volatile &, C367 const volatile, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C367 volatile &, C367 &, ret >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C368 const, C368 const volatile &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C368 const &, C368 volatile &, ret const volatile & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C368 volatile &, C368 volatile &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C369 volatile, C369 const &, ret >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C369 const volatile, C369 const &, ret >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C370 const volatile, C370 volatile &, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C370 &, C370 &, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C370 volatile &, C370 const volatile, ret volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C370 volatile &, C370 volatile &, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C371 &, C371 volatile &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C372 const, C372 const volatile, ret const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C372 volatile &, C372 volatile, ret volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C372 volatile &, C372 &, ret >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C373 &, C373, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C373 const &, C373 const, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C373 const &, C373 volatile &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C373 const &, C373 volatile &, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C374 const, C374 volatile &, ret volatile & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C374 const volatile, C374 const, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C374 &, C374 const, ret const volatile & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C374 const volatile &, C374 &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C375 const volatile, C375 const volatile, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C375 const volatile, C375 volatile &, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C375 &, C375, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C375 &, C375 const &, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C375 volatile &, C375 &, ret volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C375 const volatile &, C375 volatile &, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C376 const, C376 const, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C376 const volatile, C376 const volatile &, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C376 const &, C376 volatile &, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C376 volatile &, C376 &, ret >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C377 volatile, C377 const, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C377 volatile, C377 volatile &, ret const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C377 &, C377 &, ret const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C377 const &, C377 &, ret const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C377 const &, C377 volatile &, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C377 volatile &, C377 const &, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C378, C378 const &, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C378 volatile, C378 volatile, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C378 const &, C378 volatile &, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C379 const &, C379, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C379 volatile &, C379 &, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C379 const volatile &, C379 volatile, ret const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C380, C380 volatile, ret >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C380 &, C380, ret const & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C380 &, C380 const volatile, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C380 &, C380 volatile &, ret const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C381 volatile, C381 &, ret >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C382, C382 const, ret >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C382, C382 &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C382, C382 const &, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C382 &, C382 const &, ret const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C382 volatile &, C382, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C383 const, C383 volatile, ret const volatile & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C383 const, C383 const volatile &, ret const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C383 const volatile, C383 volatile &, ret volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C383 const volatile &, C383, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C384 volatile, C384, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C384 volatile, C384 volatile, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C384 volatile &, C384 volatile &, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C385 volatile, C385 volatile &, ret const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C385 const volatile &, C385 volatile, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C386, C386 const, ret const volatile & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C386 const, C386 volatile &, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C386 const volatile, C386, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C386 const volatile &, C386 volatile, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C387, C387 volatile &, ret >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C387 volatile, C387 volatile, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C387 const volatile, C387 const, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C387 const volatile, C387 &, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C387 const volatile, C387 const volatile &, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C387 const &, C387 const &, ret >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C387 volatile &, C387 const, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C388 const &, C388 const, ret const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C388 const &, C388 const, ret const & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C388 const &, C388 const &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C388 const volatile &, C388 volatile, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C389 const &, C389 &, ret >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C390 volatile, C390 const volatile, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C390 volatile, C390 &, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C390 volatile, C390 const volatile &, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C390 const volatile, C390, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C390 &, C390 const volatile &, ret const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C391, C391 &, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C391 const &, C391 const volatile, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C392, C392 const volatile &, ret const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C392 const, C392 volatile, ret volatile & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C392 const volatile, C392 volatile, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C392 const volatile, C392 const &, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C393 const, C393 volatile &, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C393 const volatile, C393 volatile, ret >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C393 &, C393 volatile, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C393 const &, C393 const, ret const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C393 const volatile &, C393 volatile &, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C393 const volatile &, C393 const volatile &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C394 &, C394 const volatile, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C394 const &, C394 &, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C394 volatile &, C394 const, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C394 const volatile &, C394 const, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C394 const volatile &, C394 const volatile &, ret const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C395 &, C395 const, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C395 &, C395 const &, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C395 &, C395 const volatile &, ret const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C395 const &, C395 &, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C395 const &, C395 volatile &, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C396, C396 volatile &, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C396 volatile, C396, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C396 volatile, C396 const, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C396 const volatile, C396 const &, ret volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C396 const volatile, C396 const volatile &, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C396 &, C396 volatile, ret volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C396 const &, C396 const, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C396 volatile &, C396 const volatile, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C397 const volatile, C397 volatile &, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C398, C398 volatile, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C398 const, C398 &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C398 const volatile, C398 const volatile &, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C399 const, C399 volatile, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C399 const volatile, C399, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C399 const &, C399 const volatile, ret >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C399 const &, C399 const volatile, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C400 volatile, C400 &, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C400 const volatile, C400 const volatile &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C400 &, C400 const, ret volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C400 &, C400 volatile, ret const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C401, C401 const volatile, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C401, C401 volatile &, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C401 const volatile, C401, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C401 &, C401 &, ret >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C401 &, C401 &, ret volatile & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C401 const &, C401 const, ret >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C401 const &, C401 const volatile &, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C402 volatile, C402 volatile &, ret volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C402 const volatile, C402, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C402 volatile &, C402 const, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C403, C403 const volatile, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C403 const, C403 const &, ret volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C403 &, C403 const, ret volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C403 const &, C403 const, ret >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C403 const &, C403 const volatile, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C403 const &, C403 volatile &, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C403 volatile &, C403 const, ret volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C404 const, C404 volatile, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C404 const, C404 &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C404 volatile, C404 volatile, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C404 &, C404 const, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C404 &, C404 const volatile, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C404 volatile &, C404 &, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C405 const, C405 volatile &, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C405 const volatile &, C405, ret const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C406, C406 const volatile &, ret >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C406 const, C406 volatile, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C406 volatile, C406 volatile, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C406 volatile, C406 const &, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C406 const volatile, C406 volatile &, ret >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C407 const, C407, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C407 const, C407 volatile, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C407 const, C407 const &, ret const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C407 const volatile, C407 volatile, ret const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C407 &, C407 const volatile, ret >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C407 &, C407 const &, ret >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C407 const volatile &, C407 const volatile &, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C408 const, C408 const volatile &, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C408 volatile, C408, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C408 const volatile, C408, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C408 const volatile, C408 volatile, ret volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C408 const volatile, C408 const volatile &, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C408 const &, C408 const, ret >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C408 const volatile &, C408, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C409 volatile, C409 volatile &, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C410 volatile &, C410 const &, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C410 const volatile &, C410 volatile, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C410 const volatile &, C410 const &, ret const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C411 const, C411 const volatile, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C411 volatile, C411 const volatile, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C411 const volatile, C411 volatile &, ret >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C411 &, C411 &, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C412 volatile, C412 const volatile &, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C412 const volatile, C412 volatile, ret >::value), 0);
+TT_TEST_END

Added: sandbox/type_traits/libs/type_traits/test/can_call_binary_classes7_test.cpp
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/test/can_call_binary_classes7_test.cpp 2011-07-09 16:29:47 EDT (Sat, 09 Jul 2011)
@@ -0,0 +1,263 @@
+// (C) Copyright 2009-2011 Frederic Bron.
+// Use, modification and distribution are subject to the
+// Boost Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#include "test.hpp"
+#include "check_integral_constant.hpp"
+
+#include <boost/type_traits/can_call.hpp>
+#include "can_call_binary_classes.hpp"
+
+TT_TEST_BEGIN(BOOST_TT_TRAIT_NAME)
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C412 const volatile, C412 &, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C412 const &, C412 const volatile &, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C413, C413 const &, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C413 const, C413 volatile &, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C413 &, C413 const, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C413 volatile &, C413 const volatile, ret >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C414 const, C414 const volatile, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C414 const volatile, C414 volatile &, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C414 const &, C414 const, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C414 const &, C414 const volatile &, ret volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C415 const volatile, C415 const &, ret const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C415 const volatile, C415 const &, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C415 const volatile &, C415, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C416 const, C416, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C416 const, C416 const &, ret volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C416 const, C416 volatile &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C416 const, C416 const volatile &, ret >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C416 &, C416 const volatile &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C416 volatile &, C416 const, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C416 volatile &, C416 const volatile, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C417 const, C417 &, ret const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C417 const volatile, C417 volatile &, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C417 &, C417, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C417 &, C417 const volatile, ret volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C417 volatile &, C417 const volatile &, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C418, C418 const, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C418 const, C418 const volatile, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C418 const, C418 volatile &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C418 const, C418 volatile &, ret >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C419 volatile, C419, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C419 const &, C419 const &, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C419 const &, C419 volatile &, ret volatile & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C419 volatile &, C419 const &, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C420 const &, C420 const volatile, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C420 const &, C420 &, ret const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C420 const &, C420 const &, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C421 const, C421 volatile &, ret >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C421 const volatile, C421 volatile &, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C422 const, C422 volatile, ret const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C422 volatile, C422 const &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C422 volatile, C422 const volatile &, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C422 volatile &, C422 const volatile &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C422 const volatile &, C422 &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C423, C423 const, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C423 volatile, C423 const, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C423 const volatile, C423 volatile, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C423 &, C423 &, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C423 const &, C423, void >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C423 const &, C423, ret volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C423 const &, C423 const volatile, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C423 volatile &, C423, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C423 const volatile &, C423 const, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C424 const, C424 const &, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C424 const &, C424 const, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C425, C425 &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C426, C426 const volatile &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C426 const, C426 const volatile &, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C426 volatile, C426 const volatile, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C426 const volatile, C426, ret >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C426 const volatile, C426 const volatile, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C426 &, C426 volatile, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C426 &, C426 const &, ret const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C427, C427 &, ret >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C427 volatile, C427 const, ret volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C427 &, C427 const, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C427 volatile &, C427 const volatile, ret volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C428, C428 volatile, ret const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C428 const, C428, ret volatile & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C428 const &, C428 volatile, ret volatile & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C429 const, C429 const, ret const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C429 volatile, C429 const volatile, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C429 const volatile, C429, ret >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C429 const &, C429 volatile &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C429 const volatile &, C429 &, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C429 const volatile &, C429 const volatile &, ret >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C430, C430 const volatile, ret const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C430 const volatile, C430, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C430 const volatile, C430 volatile, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C430 const volatile, C430 volatile &, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C430 const volatile, C430 const volatile &, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C430 &, C430 const, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C430 volatile &, C430 volatile &, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C431 const volatile, C431 const &, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C431 const &, C431 const, ret const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C431 const volatile &, C431, ret const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C431 const volatile &, C431 const volatile, ret volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C432, C432 const, ret volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C432, C432 const volatile, ret >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C432 const volatile, C432 const &, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C432 const &, C432 const volatile, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C433 const &, C433, ret const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C434, C434 volatile &, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C434 volatile, C434 const &, ret const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C434 &, C434 volatile, ret const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C434 &, C434 const volatile &, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C434 volatile &, C434, ret const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C434 volatile &, C434 volatile, ret const & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C434 const volatile &, C434, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C434 const volatile &, C434 volatile, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C434 const volatile &, C434 const volatile &, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C435, C435 const, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C435 volatile, C435, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C435 volatile, C435 const &, ret const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C435 const &, C435 const, ret >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C435 const &, C435 const, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C435 volatile &, C435 volatile, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C435 const volatile &, C435 const, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C435 const volatile &, C435 const volatile &, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C436 const, C436 volatile, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C436 volatile, C436 const, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C436 const volatile, C436 const, ret const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C436 const &, C436 &, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C436 const volatile &, C436 &, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C437 const, C437, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C437 const, C437 const &, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C437 volatile, C437 volatile, ret const & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C437 const volatile, C437 volatile &, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C437 &, C437, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C437 &, C437 volatile, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C437 const &, C437 volatile, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C437 const &, C437 volatile, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C437 volatile &, C437, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C438 &, C438 const volatile &, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C438 const &, C438 &, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C438 const &, C438 volatile &, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C438 const &, C438 const volatile &, ret const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C439 const volatile, C439 const volatile, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C439 const volatile, C439 &, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C439 const &, C439 volatile, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C439 volatile &, C439 const, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C439 const volatile &, C439 volatile &, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C440, C440 &, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C440, C440 volatile &, ret const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C440 const volatile, C440 &, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C440 const volatile &, C440 const, ret const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C441 const, C441 volatile &, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C441 volatile, C441 volatile, ret const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C441 volatile, C441 volatile, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C442 const &, C442 const &, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C442 const &, C442 volatile &, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C442 volatile &, C442 const volatile &, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C443, C443, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C443, C443 volatile &, ret >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C443 const &, C443, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C443 const &, C443, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C443 const &, C443 const &, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C444, C444, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C444 const, C444 const, ret volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C444 const volatile, C444, ret >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C444 const volatile, C444 volatile, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C444 const volatile &, C444 const volatile, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C445, C445, ret >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C445, C445 const &, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C445 const, C445 const, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C445 volatile, C445 &, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C445 &, C445 &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C446 volatile, C446, ret >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C446 volatile, C446 &, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C446 const &, C446 volatile, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C446 volatile &, C446 const, ret const volatile & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C446 const volatile &, C446 volatile &, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C447 volatile, C447 const volatile, ret >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C447 const &, C447, ret const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C447 volatile &, C447 const volatile, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C447 volatile &, C447 volatile &, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C447 const volatile &, C447 &, ret >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C447 const volatile &, C447 const &, ret >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C447 const volatile &, C447 volatile &, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C448, C448 const volatile, ret >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C448, C448 volatile &, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C448, C448 volatile &, ret const volatile & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C448 const, C448 volatile &, ret >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C448 const volatile, C448 volatile &, ret >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C448 &, C448 volatile &, ret const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C449, C449 const volatile &, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C449 volatile, C449 volatile &, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C449 const &, C449 const volatile, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C450 const volatile &, C450 volatile &, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C451, C451 const, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C451, C451 volatile &, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C451 const, C451 volatile, ret const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C451 const volatile &, C451 volatile, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C452, C452, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C452, C452 volatile &, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C452 const, C452 &, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C452 volatile, C452 const &, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C452 const volatile, C452 const volatile, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C452 const volatile, C452 volatile &, ret volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C453 &, C453 const &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C454 volatile, C454 const &, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C454 const volatile, C454 const volatile, ret volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C454 const volatile, C454 const volatile, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C454 const volatile, C454 const &, ret >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C454 const volatile &, C454 const, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C454 const volatile &, C454 &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C455, C455 const &, ret & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C455 const, C455, ret >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C455 volatile, C455 &, ret const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C455 &, C455 volatile, ret >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C456 volatile, C456 volatile, ret const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C456 volatile, C456 const volatile, ret const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C456 const &, C456 const &, ret volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C456 const &, C456 volatile &, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C456 const volatile &, C456 &, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C457 volatile, C457 volatile &, ret volatile & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C457 const volatile, C457 volatile &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C457 volatile &, C457 const &, ret volatile & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C457 const volatile &, C457 volatile, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C458, C458, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C458, C458 volatile, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C458, C458 &, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C458, C458 volatile &, ret >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C458, C458 const volatile &, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C458 const, C458 const, ret volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C458 const volatile, C458, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C458 const volatile, C458 const volatile &, ret const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C458 &, C458, ret const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C458 const &, C458 const volatile, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C458 const volatile &, C458 const, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C458 const volatile &, C458 &, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C459 volatile &, C459 &, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C460 const, C460 const, ret volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C460 const, C460 volatile, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C460 const volatile, C460 const volatile, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C460 const volatile, C460 const volatile &, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C460 &, C460 volatile, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C460 &, C460 const volatile &, ret const & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C460 const volatile &, C460 volatile, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C460 const volatile &, C460 const volatile, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C461, C461 const, ret const & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C461, C461 const volatile &, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C461 volatile &, C461, ret const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C461 volatile &, C461 const volatile &, ret const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C462, C462, ret const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C462 const, C462 volatile &, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C462 volatile, C462 const &, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C462 const volatile, C462, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C462 const volatile, C462 const, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C462 const volatile, C462 &, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C462 volatile &, C462 &, ret const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C462 volatile &, C462 const &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C462 const volatile &, C462, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C463 const, C463 const &, ret >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C463 const, C463 volatile &, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C463 const volatile, C463 &, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C463 volatile &, C463 const, ret const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C463 const volatile &, C463, ret const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C464, C464 volatile, ret const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C464 const, C464 volatile, ret volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C464 const, C464 volatile &, void >::value), 0);
+TT_TEST_END

Added: sandbox/type_traits/libs/type_traits/test/can_call_binary_classes8_test.cpp
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/test/can_call_binary_classes8_test.cpp 2011-07-09 16:29:47 EDT (Sat, 09 Jul 2011)
@@ -0,0 +1,263 @@
+// (C) Copyright 2009-2011 Frederic Bron.
+// Use, modification and distribution are subject to the
+// Boost Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#include "test.hpp"
+#include "check_integral_constant.hpp"
+
+#include <boost/type_traits/can_call.hpp>
+#include "can_call_binary_classes.hpp"
+
+TT_TEST_BEGIN(BOOST_TT_TRAIT_NAME)
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C465 volatile, C465 const volatile, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C465 &, C465 volatile, ret >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C465 const &, C465 const volatile, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C466 const, C466 volatile, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C466 volatile, C466 const &, ret const volatile & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C466 const volatile, C466 const, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C466 const &, C466 volatile, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C467 const volatile &, C467 const volatile &, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C468 volatile, C468 &, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C468 const &, C468 const, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C468 const volatile &, C468, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C469 &, C469 &, ret const & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C469 &, C469 const &, ret >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C469 const volatile &, C469 volatile, ret const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C470 volatile, C470 const volatile, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C470 volatile, C470 const volatile &, ret >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C470 const volatile, C470 const &, ret >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C470 &, C470, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C470 &, C470 const, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C470 &, C470 volatile, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C470 &, C470 &, ret const & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C470 volatile &, C470 volatile, ret >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C471, C471 const, ret >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C471 volatile, C471 volatile, ret >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C471 const volatile, C471 volatile, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C471 const volatile &, C471 &, ret const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C471 const volatile &, C471 const &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C472 &, C472 const volatile &, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C472 const &, C472 const &, ret volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C472 volatile &, C472 volatile, ret >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C472 volatile &, C472 volatile, ret volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C472 const volatile &, C472 const &, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C473, C473 const &, ret const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C473 volatile, C473, ret const & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C473 volatile, C473 const, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C473 const volatile, C473 const &, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C473 const &, C473 const, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C473 const &, C473 const &, ret volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C474, C474, ret const volatile & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C474 volatile, C474 const, ret >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C474 volatile, C474 &, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C474 &, C474 &, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C474 volatile &, C474 const volatile, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C474 volatile &, C474 volatile &, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C474 const volatile &, C474 const, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C475 const volatile, C475 const volatile &, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C475 volatile &, C475 const &, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C476, C476, ret const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C476 const, C476 const volatile, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C476 const volatile &, C476 const volatile &, ret const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C477, C477 volatile, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C477, C477 &, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C477 const, C477 const, ret const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C477 const, C477 volatile &, ret const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C477 const, C477 volatile &, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C477 volatile, C477 &, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C477 const volatile, C477, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C477 &, C477 const, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C477 const &, C477 volatile, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C478 const, C478 const, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C478 const volatile, C478, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C478 const &, C478 const, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C478 volatile &, C478 const volatile, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C479 const, C479 const volatile &, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C479 const volatile, C479 volatile &, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C479 const volatile, C479 const volatile &, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C479 &, C479 const, ret >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C479 &, C479 volatile &, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C479 volatile &, C479 volatile, ret const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C479 const volatile &, C479, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C480, C480 const volatile &, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C480 const volatile, C480 volatile, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C480 &, C480 volatile &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C480 &, C480 const volatile &, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C480 const volatile &, C480 &, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C480 const volatile &, C480 volatile &, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C481, C481 const, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C481 const, C481 const volatile &, ret volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C481 const volatile, C481, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C481 const volatile, C481 volatile, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C481 const volatile, C481 const volatile, ret >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C481 volatile &, C481 &, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C481 const volatile &, C481 const &, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C482, C482, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C482 &, C482 volatile &, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C482 volatile &, C482 volatile &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C482 volatile &, C482 const volatile &, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C482 const volatile &, C482 const volatile, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C482 const volatile &, C482 &, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C483 volatile, C483 volatile, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C483 const volatile, C483 const &, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C483 const &, C483 volatile, ret const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C483 volatile &, C483, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C483 const volatile &, C483 const volatile &, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C484 const, C484 const, ret >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C484 volatile, C484 const, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C484 const volatile &, C484 &, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C485, C485 const volatile, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C485 const volatile, C485 const volatile, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C485 const &, C485 const &, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C485 const volatile &, C485 const, ret >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C486, C486, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C486 const, C486 const volatile &, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C486 const &, C486 const, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C487, C487 const &, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C487 volatile, C487 const volatile &, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C487 const volatile, C487 volatile &, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C487 &, C487 volatile, ret const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C487 volatile &, C487, ret >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C488 const volatile, C488 const volatile, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C488 const &, C488, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C488 const &, C488 volatile, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C489, C489 const, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C489 volatile, C489, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C489 volatile, C489 const volatile &, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C489 const volatile &, C489 volatile &, ret const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C489 const volatile &, C489 volatile &, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C489 const volatile &, C489 const volatile &, ret const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C490 const, C490 volatile &, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C490 &, C490 const &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C490 const &, C490 const &, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C490 const volatile &, C490 &, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C490 const volatile &, C490 const &, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C491, C491 volatile, ret const volatile & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C491, C491 &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C491 &, C491, ret >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C491 const &, C491 const, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C491 const volatile &, C491 const volatile, ret const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C492, C492 const &, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C492 volatile, C492 const &, ret volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C492 const &, C492 const volatile &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C492 const volatile &, C492 const volatile, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C493 volatile, C493 const volatile, ret >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C493 const volatile, C493, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C493 const volatile, C493 const &, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C493 const volatile, C493 const &, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C493 const volatile, C493 const volatile &, ret volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C493 &, C493, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C493 &, C493 &, ret const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C493 const volatile &, C493 const, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C493 const volatile &, C493 const volatile, ret >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C493 const volatile &, C493 &, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C493 const volatile &, C493 const &, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C493 const volatile &, C493 const volatile &, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C494, C494 volatile, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C494 volatile, C494, ret const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C494 volatile, C494, ret const volatile & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C494 const volatile, C494 const volatile, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C494 const &, C494 const volatile, ret const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C494 volatile &, C494 volatile, ret const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C495, C495, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C495, C495 const volatile &, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C495 volatile, C495 const &, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C495 volatile, C495 volatile &, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C495 &, C495 &, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C495 volatile &, C495, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C495 const volatile &, C495 &, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C496, C496 const, ret const & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C496, C496 volatile &, ret const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C496 const volatile, C496 &, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C496 volatile &, C496 const volatile &, ret const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C497, C497 const &, ret const & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C497 volatile, C497, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C497 volatile, C497 &, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C497 volatile, C497 const volatile &, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C497 volatile &, C497, ret const & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C497 volatile &, C497 const volatile, ret const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C498, C498 volatile, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C498, C498 const &, ret const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C498, C498 volatile &, ret >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C498, C498 volatile &, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C498 volatile, C498 volatile &, ret const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C498 const volatile &, C498 volatile &, ret >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C499, C499 volatile, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C499, C499 &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C499 volatile, C499 const volatile, ret >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C499 &, C499 &, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C500 const, C500 &, ret const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C500 volatile, C500 const volatile, ret & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C500 &, C500 volatile, ret const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C500 const volatile &, C500 volatile &, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C501 const, C501, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C501 volatile, C501 const volatile &, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C501 &, C501 const, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C502 const, C502, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C502 const, C502 &, ret >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C502 volatile, C502 const &, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C502 const volatile, C502 volatile, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C502 volatile &, C502 const volatile, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C502 volatile &, C502 const volatile, ret const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C503 const, C503 volatile, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C503 volatile &, C503 const volatile, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C504, C504 const &, ret volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C504 volatile, C504 const volatile, ret volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C504 &, C504 &, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C504 const &, C504, void >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C505 volatile, C505 volatile, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C506 volatile, C506 const, ret const & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C506 volatile &, C506 const &, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C506 const volatile &, C506 const volatile &, ret const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C507, C507 const &, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C507 volatile, C507 const &, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C507 &, C507 const volatile, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C507 volatile &, C507 const volatile &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C508 volatile, C508 volatile &, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C508 const volatile, C508 const volatile, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C508 volatile &, C508 volatile, ret const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C508 const volatile &, C508 volatile, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C509 const volatile, C509 const, ret const & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C509 const volatile, C509 const &, ret const volatile & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C510 const, C510 const &, ret const volatile & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C510 const, C510 const volatile &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C510 volatile, C510 const volatile, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C510 const volatile, C510 volatile, ret const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C510 &, C510 &, ret const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C511 const volatile, C511 volatile, ret const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C511 &, C511 const &, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C511 const &, C511 const volatile, ret >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C511 const &, C511 const &, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C512 volatile, C512 &, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C512 const volatile &, C512 &, ret const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C512 const volatile &, C512 &, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C513, C513 volatile, ret const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C513 volatile, C513, ret const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C513 volatile, C513 const, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C513 volatile &, C513 const volatile, ret >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C514, C514 const &, ret >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C514 const, C514 volatile, ret >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C514 volatile, C514 const, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C514 const volatile, C514 const, ret const & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C514 const volatile &, C514 const volatile, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C514 const volatile &, C514 volatile &, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C515 const, C515 const, ret >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C515 const volatile, C515 volatile, ret const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C515 &, C515 const, ret const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C515 &, C515 const volatile, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C515 const volatile &, C515, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C516 const, C516 &, ret const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C516 const, C516 &, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C516 const, C516 const &, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C516 const, C516 const volatile &, ret >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C516 const volatile, C516 const, ret >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C516 const volatile, C516 const volatile, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C516 volatile &, C516 volatile, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C516 volatile &, C516 const volatile, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C517, C517 const volatile &, ret >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C517 const volatile, C517, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C517 &, C517, ret const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C517 &, C517 const, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C517 const volatile &, C517 &, ret const & >::value), 0);
+TT_TEST_END

Added: sandbox/type_traits/libs/type_traits/test/can_call_binary_classes9_test.cpp
==============================================================================
--- (empty file)
+++ sandbox/type_traits/libs/type_traits/test/can_call_binary_classes9_test.cpp 2011-07-09 16:29:47 EDT (Sat, 09 Jul 2011)
@@ -0,0 +1,263 @@
+// (C) Copyright 2009-2011 Frederic Bron.
+// Use, modification and distribution are subject to the
+// Boost Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#include "test.hpp"
+#include "check_integral_constant.hpp"
+
+#include <boost/type_traits/can_call.hpp>
+#include "can_call_binary_classes.hpp"
+
+TT_TEST_BEGIN(BOOST_TT_TRAIT_NAME)
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C518 &, C518, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C518 &, C518 const &, ret volatile & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C518 const volatile &, C518 const volatile &, ret const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C519 const, C519 volatile, ret const volatile & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C519 volatile, C519 volatile, ret const volatile & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C519 volatile, C519 const &, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C519 volatile &, C519 volatile &, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C520 const, C520, ret volatile & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C520 const, C520 const, ret const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C520 &, C520 const volatile &, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C520 const &, C520 const &, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C520 const &, C520 volatile &, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C520 const volatile &, C520 const volatile, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C521 &, C521 const, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C521 const &, C521 &, ret const volatile & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C522 const, C522 &, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C522 const &, C522 &, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C522 const volatile &, C522 volatile, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C523 const, C523 &, ret const & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C523 const volatile, C523 const, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C523 &, C523 volatile, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C523 &, C523 volatile &, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C523 const &, C523 const volatile, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C524, C524 const volatile, ret const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C524, C524 &, ret >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C524 volatile, C524 const volatile &, ret const & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C524 const &, C524 volatile, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C525, C525 volatile &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C525 const, C525 volatile &, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C525 volatile, C525, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C525 volatile, C525 &, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C525 const volatile &, C525 const volatile, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C526 volatile, C526 const volatile &, ret const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C526 &, C526 volatile, ret const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C526 &, C526 const &, ret >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C526 &, C526 volatile &, ret const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C526 const volatile &, C526 const volatile &, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C527 volatile, C527 &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C528, C528 const &, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C528, C528 const &, ret const volatile & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C528 volatile, C528, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C528 volatile, C528, ret const & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C528 volatile, C528, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C528 volatile, C528 const &, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C528 const volatile, C528 const &, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C528 const volatile, C528 const &, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C528 const volatile &, C528, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C528 const volatile &, C528 const, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C528 const volatile &, C528 const volatile, ret const volatile & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C529 volatile, C529 const volatile, ret volatile & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C529 const volatile, C529 &, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C529 const volatile &, C529 &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C530 const volatile, C530 &, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C530 const volatile &, C530 &, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C530 const volatile &, C530 const volatile &, ret const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C531 const, C531 const volatile, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C531 volatile, C531 const volatile &, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C531 const volatile, C531, void >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C531 &, C531 const volatile, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C531 const &, C531 const volatile, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C532 const, C532 const volatile, ret const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C532 const, C532 volatile &, ret const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C532 volatile, C532 const volatile &, ret const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C532 const volatile, C532 const volatile &, ret >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C532 &, C532 const, ret const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C532 const &, C532 volatile, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C532 volatile &, C532 const volatile, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C533, C533, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C533, C533 const, ret const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C533 volatile, C533 volatile &, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C533 const &, C533 &, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C533 const volatile &, C533 const volatile, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C534, C534 volatile, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C534 &, C534 const &, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C534 &, C534 volatile &, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C534 volatile &, C534 const, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C535 const, C535 volatile, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C535 volatile, C535, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C535 volatile, C535 const, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C535 &, C535, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C536, C536 const volatile &, ret volatile & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C536 const, C536 volatile, ret const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C536 const, C536 &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C536 const &, C536 const, ret const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C536 volatile &, C536, ret >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C536 const volatile &, C536, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C537, C537 &, ret const & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C537 const, C537 const, ret const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C537 volatile, C537, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C537 volatile, C537 const volatile &, ret const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C537 const &, C537 const &, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C537 const volatile &, C537 const volatile, ret >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C538, C538 &, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C538 volatile, C538 volatile, ret const volatile & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C538 &, C538 const volatile, ret const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C538 &, C538 volatile &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C538 const &, C538 volatile, ret >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C538 const &, C538 const &, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C538 const volatile &, C538 volatile, ret const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C539 const, C539 const volatile, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C539 const volatile, C539 const &, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C539 const volatile, C539 const volatile &, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C539 const &, C539 const &, ret >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C540, C540 const volatile &, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C540 const volatile, C540 const, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C540 &, C540 volatile, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C541, C541 const &, ret volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C541 const volatile, C541 &, ret const & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C541 const &, C541, ret const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C541 const &, C541 const volatile &, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C542 const, C542 volatile &, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C542 const volatile &, C542 const volatile &, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C543 volatile, C543 const &, ret >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C543 volatile, C543 const volatile &, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C543 const volatile, C543 const volatile, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C543 &, C543 &, ret const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C543 const &, C543 volatile, ret >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C544, C544 const volatile, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C544 &, C544 volatile &, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C544 const &, C544 const &, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C544 volatile &, C544 const, ret const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C545, C545 const &, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C545 &, C545 const, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C546 const, C546 volatile, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C546 const, C546 volatile, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C546 const &, C546 const volatile, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C546 volatile &, C546 volatile &, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C546 const volatile &, C546 const, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C547 const volatile, C547, ret const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C547 const volatile, C547 const volatile &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C547 const &, C547 &, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C547 const volatile &, C547, ret const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C547 const volatile &, C547 volatile, ret >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C547 const volatile &, C547 const volatile, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C547 const volatile &, C547 const volatile &, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C548, C548 const volatile, ret const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C548, C548 const volatile &, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C548 const &, C548 const, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C549 const, C549, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C549 const, C549 const, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C549 const, C549 const &, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C549 volatile, C549 volatile &, ret volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C549 volatile, C549 const volatile &, ret volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C549 &, C549, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C549 &, C549 const volatile, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C549 volatile &, C549 const, ret const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C550, C550 volatile &, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C550 const, C550, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C550 volatile, C550 const, ret const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C550 const volatile, C550 const, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C550 const volatile, C550 const, ret const & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C550 volatile &, C550 const &, ret const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C551 &, C551 &, ret const & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C552 const volatile, C552 const volatile, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C552 &, C552, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C552 &, C552 volatile, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C552 const &, C552 const volatile, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C552 volatile &, C552 const &, ret const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C552 const volatile &, C552 const, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C553 const volatile, C553 volatile, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C554, C554 const volatile, ret volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C554 volatile &, C554 const &, ret & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C555, C555 const &, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C555 const, C555 const volatile, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C555 const volatile, C555 &, ret const & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C555 const &, C555 volatile &, ret const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C555 const volatile &, C555 const, ret const volatile & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C556, C556 const volatile, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C556 volatile, C556 volatile &, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C556 const volatile &, C556 const volatile, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C557, C557 const volatile &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C557 const, C557, ret const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C557 &, C557 const volatile, ret const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C557 const &, C557, ret const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C557 const &, C557 volatile &, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C557 volatile &, C557 const, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C558 volatile, C558 volatile &, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C558 const volatile &, C558 volatile &, void >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C559 volatile, C559 volatile &, ret >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C559 const &, C559 const, ret const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C560 &, C560 const &, ret const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C560 const volatile &, C560 const volatile, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C561 const, C561 const volatile &, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C561 const volatile, C561, ret const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C561 const volatile, C561 const, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C561 const &, C561 volatile, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C562, C562 volatile &, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C562 const, C562 volatile, ret const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C562 const, C562 const volatile &, ret >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C562 volatile, C562 volatile, ret const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C562 const volatile &, C562 volatile, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C563, C563 const volatile &, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C563 const, C563 volatile &, ret & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C563 volatile, C563 volatile, ret volatile & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C563 volatile, C563 const &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C563 const volatile, C563 volatile &, ret >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C563 &, C563 const volatile &, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C564 const volatile, C564 const &, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C564 &, C564 volatile &, ret const & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C565 const, C565 volatile, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C565 const volatile, C565 const &, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C565 &, C565 const volatile &, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C565 const &, C565 volatile &, ret const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C565 volatile &, C565 const volatile &, ret const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C565 const volatile &, C565 const volatile, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C566, C566 &, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C566 const volatile, C566, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C566 const volatile, C566 const, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C566 const volatile, C566 const volatile &, ret const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C566 volatile &, C566 &, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C566 const volatile &, C566 const volatile &, ret const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C567, C567 const volatile &, ret const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C567 const volatile, C567 const, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C568, C568, ret const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C568, C568 volatile, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C568, C568 &, ret const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C568 const, C568 &, ret >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C568 const, C568 &, ret const & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C568 volatile, C568 const volatile &, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C568 const volatile, C568 &, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C568 const volatile, C568 const volatile &, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C568 const &, C568, ret const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C569 const volatile &, C569 const volatile &, ret const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C570, C570 &, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C570 const, C570 const volatile, ret >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C570 const, C570 const &, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C570 volatile, C570 const &, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C570 const volatile, C570, ret const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C570 &, C570 const volatile &, ret const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C570 const &, C570 const, ret const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C570 const volatile &, C570 volatile &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C571 volatile, C571, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C571 const volatile, C571 &, ret >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C571 &, C571 const, ret & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C571 &, C571 volatile, ret const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C571 const &, C571 &, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C571 const &, C571 volatile &, ret >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C571 volatile &, C571 volatile &, ret >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C572 const, C572 const, ret const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C572 volatile, C572 const volatile &, ret >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C572 &, C572 const volatile &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C572 volatile &, C572 const &, ret const volatile & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C573 volatile, C573 const volatile &, ret volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C573 &, C573, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C573 volatile &, C573, ret const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C573 const volatile &, C573 &, ret volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C574 const, C574 volatile &, ret const volatile & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C575 volatile, C575 const, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C575 &, C575 const volatile, ret >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::can_call_addition< C575 const &, C575 const volatile, ret volatile >::value), 1);
+TT_TEST_END

Deleted: sandbox/type_traits/libs/type_traits/test/can_call_binary_logical_test.hpp
==============================================================================
--- sandbox/type_traits/libs/type_traits/test/can_call_binary_logical_test.hpp 2011-07-09 16:29:47 EDT (Sat, 09 Jul 2011)
+++ (empty file)
@@ -1,1250 +0,0 @@
-// (C) Copyright Frederic Bron 2009-2011.
-// Use, modification and distribution are subject to the
-// Boost Software License, Version 1.0. (See accompanying file
-// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-namespace {
-
-void run2() {
- // test with only one template parameter
- TEST_T(void, false);
- TEST_T(bool, true);
- TEST_T(char, true);
- TEST_T(signed char, true);
- TEST_T(short int, true);
- TEST_T(int, true);
- TEST_T(long int, true);
- TEST_T(unsigned char, true);
- TEST_T(unsigned short int, true);
- TEST_T(unsigned int, true);
- TEST_T(unsigned long int, true);
- TEST_T(wchar_t, true);
- TEST_T(float, true);
- TEST_T(double, true);
- TEST_T(long double, true);
- TEST_T(void, false);
-# undef CV
-# define CV(T) const T
- TEST_T(CV(bool), true);
- TEST_T(CV(int), true);
- TEST_T(CV(double), true);
-# undef CV
-# define CV(T) volatile T
- TEST_T(CV(bool), true);
- TEST_T(CV(int), true);
- TEST_T(CV(double), true);
-# undef CV
-# define CV(T) const volatile T
- TEST_T(CV(bool), true);
- TEST_T(CV(int), true);
- TEST_T(CV(double), true);
-# undef CV
-# define CV(T) const T&
- TEST_T(CV(bool), true);
- TEST_T(CV(int), true);
- TEST_T(CV(double), true);
-# undef CV
-# define CV(T) volatile T&
- TEST_T(CV(bool), true);
- TEST_T(CV(int), true);
- TEST_T(CV(double), true);
-# undef CV
-# define CV(T) const volatile T&
- TEST_T(CV(bool), true);
- TEST_T(CV(int), true);
- TEST_T(CV(double), true);
-
- // test with only two template parameters
- TEST_TT(void, int, false);
- TEST_TT(int, void, false);
- TEST_TT(void, void, false);
- TEST_TT(bool, bool, true);
- TEST_TT(bool, char, true);
- TEST_TT(bool, signed char, true);
- TEST_TT(bool, short int, true);
- TEST_TT(bool, int, true);
- TEST_TT(bool, long int, true);
- TEST_TT(bool, unsigned char, true);
- TEST_TT(bool, unsigned short int, true);
- TEST_TT(bool, unsigned int, true);
- TEST_TT(bool, unsigned long int, true);
- TEST_TT(bool, wchar_t, true);
- TEST_TT(bool, float, true);
- TEST_TT(bool, double, true);
- TEST_TT(bool, long double, true);
- TEST_TT(char, bool, true);
- TEST_TT(char, char, true);
- TEST_TT(char, signed char, true);
- TEST_TT(char, short int, true);
- TEST_TT(char, int, true);
- TEST_TT(char, long int, true);
- TEST_TT(char, unsigned char, true);
- TEST_TT(char, unsigned short int, true);
- TEST_TT(char, unsigned int, true);
- TEST_TT(char, unsigned long int, true);
- TEST_TT(char, wchar_t, true);
- TEST_TT(char, float, true);
- TEST_TT(char, double, true);
- TEST_TT(char, long double, true);
- TEST_TT(signed char, bool, true);
- TEST_TT(signed char, char, true);
- TEST_TT(signed char, signed char, true);
- TEST_TT(signed char, short int, true);
- TEST_TT(signed char, int, true);
- TEST_TT(signed char, long int, true);
- TEST_TT(signed char, unsigned char, true);
- TEST_TT(signed char, unsigned short int, true);
- TEST_TT(signed char, unsigned int, true);
- TEST_TT(signed char, unsigned long int, true);
- TEST_TT(signed char, wchar_t, true);
- TEST_TT(signed char, float, true);
- TEST_TT(signed char, double, true);
- TEST_TT(signed char, long double, true);
- TEST_TT(short int, bool, true);
- TEST_TT(short int, char, true);
- TEST_TT(short int, signed char, true);
- TEST_TT(short int, short int, true);
- TEST_TT(short int, int, true);
- TEST_TT(short int, long int, true);
- TEST_TT(short int, unsigned char, true);
- TEST_TT(short int, unsigned short int, true);
- TEST_TT(short int, unsigned int, true);
- TEST_TT(short int, unsigned long int, true);
- TEST_TT(short int, wchar_t, true);
- TEST_TT(short int, float, true);
- TEST_TT(short int, double, true);
- TEST_TT(short int, long double, true);
- TEST_TT(int, bool, true);
- TEST_TT(int, char, true);
- TEST_TT(int, signed char, true);
- TEST_TT(int, short int, true);
- TEST_TT(int, int, true);
- TEST_TT(int, long int, true);
- TEST_TT(int, unsigned char, true);
- TEST_TT(int, unsigned short int, true);
- TEST_TT(int, unsigned int, true);
- TEST_TT(int, unsigned long int, true);
- TEST_TT(int, wchar_t, true);
- TEST_TT(int, float, true);
- TEST_TT(int, double, true);
- TEST_TT(int, long double, true);
- TEST_TT(long int, bool, true);
- TEST_TT(long int, char, true);
- TEST_TT(long int, signed char, true);
- TEST_TT(long int, short int, true);
- TEST_TT(long int, int, true);
- TEST_TT(long int, long int, true);
- TEST_TT(long int, unsigned char, true);
- TEST_TT(long int, unsigned short int, true);
- TEST_TT(long int, unsigned int, true);
- TEST_TT(long int, unsigned long int, true);
- TEST_TT(long int, wchar_t, true);
- TEST_TT(long int, float, true);
- TEST_TT(long int, double, true);
- TEST_TT(long int, long double, true);
- TEST_TT(unsigned char, bool, true);
- TEST_TT(unsigned char, char, true);
- TEST_TT(unsigned char, signed char, true);
- TEST_TT(unsigned char, short int, true);
- TEST_TT(unsigned char, int, true);
- TEST_TT(unsigned char, long int, true);
- TEST_TT(unsigned char, unsigned char, true);
- TEST_TT(unsigned char, unsigned short int, true);
- TEST_TT(unsigned char, unsigned int, true);
- TEST_TT(unsigned char, unsigned long int, true);
- TEST_TT(unsigned char, wchar_t, true);
- TEST_TT(unsigned char, float, true);
- TEST_TT(unsigned char, double, true);
- TEST_TT(unsigned char, long double, true);
- TEST_TT(unsigned short int, bool, true);
- TEST_TT(unsigned short int, char, true);
- TEST_TT(unsigned short int, signed char, true);
- TEST_TT(unsigned short int, short int, true);
- TEST_TT(unsigned short int, int, true);
- TEST_TT(unsigned short int, long int, true);
- TEST_TT(unsigned short int, unsigned char, true);
- TEST_TT(unsigned short int, unsigned short int, true);
- TEST_TT(unsigned short int, unsigned int, true);
- TEST_TT(unsigned short int, unsigned long int, true);
- TEST_TT(unsigned short int, wchar_t, true);
- TEST_TT(unsigned short int, float, true);
- TEST_TT(unsigned short int, double, true);
- TEST_TT(unsigned short int, long double, true);
- TEST_TT(unsigned int, bool, true);
- TEST_TT(unsigned int, char, true);
- TEST_TT(unsigned int, signed char, true);
- TEST_TT(unsigned int, short int, true);
- TEST_TT(unsigned int, int, true);
- TEST_TT(unsigned int, long int, true);
- TEST_TT(unsigned int, unsigned char, true);
- TEST_TT(unsigned int, unsigned short int, true);
- TEST_TT(unsigned int, unsigned int, true);
- TEST_TT(unsigned int, unsigned long int, true);
- TEST_TT(unsigned int, wchar_t, true);
- TEST_TT(unsigned int, float, true);
- TEST_TT(unsigned int, double, true);
- TEST_TT(unsigned int, long double, true);
- TEST_TT(unsigned long int, bool, true);
- TEST_TT(unsigned long int, char, true);
- TEST_TT(unsigned long int, signed char, true);
- TEST_TT(unsigned long int, short int, true);
- TEST_TT(unsigned long int, int, true);
- TEST_TT(unsigned long int, long int, true);
- TEST_TT(unsigned long int, unsigned char, true);
- TEST_TT(unsigned long int, unsigned short int, true);
- TEST_TT(unsigned long int, unsigned int, true);
- TEST_TT(unsigned long int, unsigned long int, true);
- TEST_TT(unsigned long int, wchar_t, true);
- TEST_TT(unsigned long int, float, true);
- TEST_TT(unsigned long int, double, true);
- TEST_TT(unsigned long int, long double, true);
- TEST_TT(wchar_t, bool, true);
- TEST_TT(wchar_t, char, true);
- TEST_TT(wchar_t, signed char, true);
- TEST_TT(wchar_t, short int, true);
- TEST_TT(wchar_t, int, true);
- TEST_TT(wchar_t, long int, true);
- TEST_TT(wchar_t, unsigned char, true);
- TEST_TT(wchar_t, unsigned short int, true);
- TEST_TT(wchar_t, unsigned int, true);
- TEST_TT(wchar_t, unsigned long int, true);
- TEST_TT(wchar_t, wchar_t, true);
- TEST_TT(wchar_t, float, true);
- TEST_TT(wchar_t, double, true);
- TEST_TT(wchar_t, long double, true);
- TEST_TT(float, bool, true);
- TEST_TT(float, char, true);
- TEST_TT(float, signed char, true);
- TEST_TT(float, short int, true);
- TEST_TT(float, int, true);
- TEST_TT(float, long int, true);
- TEST_TT(float, unsigned char, true);
- TEST_TT(float, unsigned short int, true);
- TEST_TT(float, unsigned int, true);
- TEST_TT(float, unsigned long int, true);
- TEST_TT(float, wchar_t, true);
- TEST_TT(float, float, true);
- TEST_TT(float, double, true);
- TEST_TT(float, long double, true);
- TEST_TT(double, bool, true);
- TEST_TT(double, char, true);
- TEST_TT(double, signed char, true);
- TEST_TT(double, short int, true);
- TEST_TT(double, int, true);
- TEST_TT(double, long int, true);
- TEST_TT(double, unsigned char, true);
- TEST_TT(double, unsigned short int, true);
- TEST_TT(double, unsigned int, true);
- TEST_TT(double, unsigned long int, true);
- TEST_TT(double, wchar_t, true);
- TEST_TT(double, float, true);
- TEST_TT(double, double, true);
- TEST_TT(double, long double, true);
- TEST_TT(long double, bool, true);
- TEST_TT(long double, char, true);
- TEST_TT(long double, signed char, true);
- TEST_TT(long double, short int, true);
- TEST_TT(long double, int, true);
- TEST_TT(long double, long int, true);
- TEST_TT(long double, unsigned char, true);
- TEST_TT(long double, unsigned short int, true);
- TEST_TT(long double, unsigned int, true);
- TEST_TT(long double, unsigned long int, true);
- TEST_TT(long double, wchar_t, true);
- TEST_TT(long double, float, true);
- TEST_TT(long double, double, true);
- TEST_TT(long double, long double, true);
- TEST_TT(bool, void, false);
- TEST_TT(void, bool, false);
- TEST_TT(char, void, false);
- TEST_TT(void, char, false);
- TEST_TT(signed char, void, false);
- TEST_TT(void, signed char, false);
- TEST_TT(short int, void, false);
- TEST_TT(void, short int, false);
- TEST_TT(int, void, false);
- TEST_TT(void, int, false);
- TEST_TT(long int, void, false);
- TEST_TT(void, long int, false);
- TEST_TT(unsigned char, void, false);
- TEST_TT(void, unsigned char, false);
- TEST_TT(unsigned short int, void, false);
- TEST_TT(void, unsigned short int, false);
- TEST_TT(unsigned int, void, false);
- TEST_TT(void, unsigned int, false);
- TEST_TT(unsigned long int, void, false);
- TEST_TT(void, unsigned long int, false);
- TEST_TT(wchar_t, void, false);
- TEST_TT(void, wchar_t, false);
- TEST_TT(float, void, false);
- TEST_TT(void, float, false);
- TEST_TT(double, void, false);
- TEST_TT(void, double, false);
- TEST_TT(long double, void, false);
- TEST_TT(void, long double, false);
-
-// test with three template parameters
- TEST_TTR(bool, bool, bool, true);
- TEST_TTR(bool, char, bool, true);
- TEST_TTR(bool, signed char, bool, true);
- TEST_TTR(bool, short int, bool, true);
- TEST_TTR(bool, int, bool, true);
- TEST_TTR(bool, long int, bool, true);
- TEST_TTR(bool, unsigned char, bool, true);
- TEST_TTR(bool, unsigned short int, bool, true);
- TEST_TTR(bool, unsigned int, bool, true);
- TEST_TTR(bool, unsigned long int, bool, true);
- TEST_TTR(bool, wchar_t, bool, true);
- TEST_TTR(bool, float, bool, true);
- TEST_TTR(bool, double, bool, true);
- TEST_TTR(bool, long double, bool, true);
- TEST_TTR(char, bool, bool, true);
- TEST_TTR(char, char, bool, true);
- TEST_TTR(char, signed char, bool, true);
- TEST_TTR(char, short int, bool, true);
- TEST_TTR(char, int, bool, true);
- TEST_TTR(char, long int, bool, true);
- TEST_TTR(char, unsigned char, bool, true);
- TEST_TTR(char, unsigned short int, bool, true);
- TEST_TTR(char, unsigned int, bool, true);
- TEST_TTR(char, unsigned long int, bool, true);
- TEST_TTR(char, wchar_t, bool, true);
- TEST_TTR(char, float, bool, true);
- TEST_TTR(char, double, bool, true);
- TEST_TTR(char, long double, bool, true);
- TEST_TTR(signed char, bool, bool, true);
- TEST_TTR(signed char, char, bool, true);
- TEST_TTR(signed char, signed char, bool, true);
- TEST_TTR(signed char, short int, bool, true);
- TEST_TTR(signed char, int, bool, true);
- TEST_TTR(signed char, long int, bool, true);
- TEST_TTR(signed char, unsigned char, bool, true);
- TEST_TTR(signed char, unsigned short int, bool, true);
- TEST_TTR(signed char, unsigned int, bool, true);
- TEST_TTR(signed char, unsigned long int, bool, true);
- TEST_TTR(signed char, wchar_t, bool, true);
- TEST_TTR(signed char, float, bool, true);
- TEST_TTR(signed char, double, bool, true);
- TEST_TTR(signed char, long double, bool, true);
- TEST_TTR(short int, bool, bool, true);
- TEST_TTR(short int, char, bool, true);
- TEST_TTR(short int, signed char, bool, true);
- TEST_TTR(short int, short int, bool, true);
- TEST_TTR(short int, int, bool, true);
- TEST_TTR(short int, long int, bool, true);
- TEST_TTR(short int, unsigned char, bool, true);
- TEST_TTR(short int, unsigned short int, bool, true);
- TEST_TTR(short int, unsigned int, bool, true);
- TEST_TTR(short int, unsigned long int, bool, true);
- TEST_TTR(short int, wchar_t, bool, true);
- TEST_TTR(short int, float, bool, true);
- TEST_TTR(short int, double, bool, true);
- TEST_TTR(short int, long double, bool, true);
- TEST_TTR(int, bool, bool, true);
- TEST_TTR(int, char, bool, true);
- TEST_TTR(int, signed char, bool, true);
- TEST_TTR(int, short int, bool, true);
- TEST_TTR(int, int, bool, true);
- TEST_TTR(int, long int, bool, true);
- TEST_TTR(int, unsigned char, bool, true);
- TEST_TTR(int, unsigned short int, bool, true);
- TEST_TTR(int, unsigned int, bool, true);
- TEST_TTR(int, unsigned long int, bool, true);
- TEST_TTR(int, wchar_t, bool, true);
- TEST_TTR(int, float, bool, true);
- TEST_TTR(int, double, bool, true);
- TEST_TTR(int, long double, bool, true);
- TEST_TTR(long int, bool, bool, true);
- TEST_TTR(long int, char, bool, true);
- TEST_TTR(long int, signed char, bool, true);
- TEST_TTR(long int, short int, bool, true);
- TEST_TTR(long int, int, bool, true);
- TEST_TTR(long int, long int, bool, true);
- TEST_TTR(long int, unsigned char, bool, true);
- TEST_TTR(long int, unsigned short int, bool, true);
- TEST_TTR(long int, unsigned int, bool, true);
- TEST_TTR(long int, unsigned long int, bool, true);
- TEST_TTR(long int, wchar_t, bool, true);
- TEST_TTR(long int, float, bool, true);
- TEST_TTR(long int, double, bool, true);
- TEST_TTR(long int, long double, bool, true);
- TEST_TTR(unsigned char, bool, bool, true);
- TEST_TTR(unsigned char, char, bool, true);
- TEST_TTR(unsigned char, signed char, bool, true);
- TEST_TTR(unsigned char, short int, bool, true);
- TEST_TTR(unsigned char, int, bool, true);
- TEST_TTR(unsigned char, long int, bool, true);
- TEST_TTR(unsigned char, unsigned char, bool, true);
- TEST_TTR(unsigned char, unsigned short int, bool, true);
- TEST_TTR(unsigned char, unsigned int, bool, true);
- TEST_TTR(unsigned char, unsigned long int, bool, true);
- TEST_TTR(unsigned char, wchar_t, bool, true);
- TEST_TTR(unsigned char, float, bool, true);
- TEST_TTR(unsigned char, double, bool, true);
- TEST_TTR(unsigned char, long double, bool, true);
- TEST_TTR(unsigned short int, bool, bool, true);
- TEST_TTR(unsigned short int, char, bool, true);
- TEST_TTR(unsigned short int, signed char, bool, true);
- TEST_TTR(unsigned short int, short int, bool, true);
- TEST_TTR(unsigned short int, int, bool, true);
- TEST_TTR(unsigned short int, long int, bool, true);
- TEST_TTR(unsigned short int, unsigned char, bool, true);
- TEST_TTR(unsigned short int, unsigned short int, bool, true);
- TEST_TTR(unsigned short int, unsigned int, bool, true);
- TEST_TTR(unsigned short int, unsigned long int, bool, true);
- TEST_TTR(unsigned short int, wchar_t, bool, true);
- TEST_TTR(unsigned short int, float, bool, true);
- TEST_TTR(unsigned short int, double, bool, true);
- TEST_TTR(unsigned short int, long double, bool, true);
- TEST_TTR(unsigned int, bool, bool, true);
- TEST_TTR(unsigned int, char, bool, true);
- TEST_TTR(unsigned int, signed char, bool, true);
- TEST_TTR(unsigned int, short int, bool, true);
- TEST_TTR(unsigned int, int, bool, true);
- TEST_TTR(unsigned int, long int, bool, true);
- TEST_TTR(unsigned int, unsigned char, bool, true);
- TEST_TTR(unsigned int, unsigned short int, bool, true);
- TEST_TTR(unsigned int, unsigned int, bool, true);
- TEST_TTR(unsigned int, unsigned long int, bool, true);
- TEST_TTR(unsigned int, wchar_t, bool, true);
- TEST_TTR(unsigned int, float, bool, true);
- TEST_TTR(unsigned int, double, bool, true);
- TEST_TTR(unsigned int, long double, bool, true);
- TEST_TTR(unsigned long int, bool, bool, true);
- TEST_TTR(unsigned long int, char, bool, true);
- TEST_TTR(unsigned long int, signed char, bool, true);
- TEST_TTR(unsigned long int, short int, bool, true);
- TEST_TTR(unsigned long int, int, bool, true);
- TEST_TTR(unsigned long int, long int, bool, true);
- TEST_TTR(unsigned long int, unsigned char, bool, true);
- TEST_TTR(unsigned long int, unsigned short int, bool, true);
- TEST_TTR(unsigned long int, unsigned int, bool, true);
- TEST_TTR(unsigned long int, unsigned long int, bool, true);
- TEST_TTR(unsigned long int, wchar_t, bool, true);
- TEST_TTR(unsigned long int, float, bool, true);
- TEST_TTR(unsigned long int, double, bool, true);
- TEST_TTR(unsigned long int, long double, bool, true);
- TEST_TTR(wchar_t, bool, bool, true);
- TEST_TTR(wchar_t, char, bool, true);
- TEST_TTR(wchar_t, signed char, bool, true);
- TEST_TTR(wchar_t, short int, bool, true);
- TEST_TTR(wchar_t, int, bool, true);
- TEST_TTR(wchar_t, long int, bool, true);
- TEST_TTR(wchar_t, unsigned char, bool, true);
- TEST_TTR(wchar_t, unsigned short int, bool, true);
- TEST_TTR(wchar_t, unsigned int, bool, true);
- TEST_TTR(wchar_t, unsigned long int, bool, true);
- TEST_TTR(wchar_t, wchar_t, bool, true);
- TEST_TTR(wchar_t, float, bool, true);
- TEST_TTR(wchar_t, double, bool, true);
- TEST_TTR(wchar_t, long double, bool, true);
- TEST_TTR(float, bool, bool, true);
- TEST_TTR(float, char, bool, true);
- TEST_TTR(float, signed char, bool, true);
- TEST_TTR(float, short int, bool, true);
- TEST_TTR(float, int, bool, true);
- TEST_TTR(float, long int, bool, true);
- TEST_TTR(float, unsigned char, bool, true);
- TEST_TTR(float, unsigned short int, bool, true);
- TEST_TTR(float, unsigned int, bool, true);
- TEST_TTR(float, unsigned long int, bool, true);
- TEST_TTR(float, wchar_t, bool, true);
- TEST_TTR(float, float, bool, true);
- TEST_TTR(float, double, bool, true);
- TEST_TTR(float, long double, bool, true);
- TEST_TTR(double, bool, bool, true);
- TEST_TTR(double, char, bool, true);
- TEST_TTR(double, signed char, bool, true);
- TEST_TTR(double, short int, bool, true);
- TEST_TTR(double, int, bool, true);
- TEST_TTR(double, long int, bool, true);
- TEST_TTR(double, unsigned char, bool, true);
- TEST_TTR(double, unsigned short int, bool, true);
- TEST_TTR(double, unsigned int, bool, true);
- TEST_TTR(double, unsigned long int, bool, true);
- TEST_TTR(double, wchar_t, bool, true);
- TEST_TTR(double, float, bool, true);
- TEST_TTR(double, double, bool, true);
- TEST_TTR(double, long double, bool, true);
- TEST_TTR(long double, bool, bool, true);
- TEST_TTR(long double, char, bool, true);
- TEST_TTR(long double, signed char, bool, true);
- TEST_TTR(long double, short int, bool, true);
- TEST_TTR(long double, int, bool, true);
- TEST_TTR(long double, long int, bool, true);
- TEST_TTR(long double, unsigned char, bool, true);
- TEST_TTR(long double, unsigned short int, bool, true);
- TEST_TTR(long double, unsigned int, bool, true);
- TEST_TTR(long double, unsigned long int, bool, true);
- TEST_TTR(long double, wchar_t, bool, true);
- TEST_TTR(long double, float, bool, true);
- TEST_TTR(long double, double, bool, true);
- TEST_TTR(long double, long double, bool, true);
- TEST_TTR(bool, bool, tag, false);
- TEST_TTR(bool, char, tag, false);
- TEST_TTR(bool, signed char, tag, false);
- TEST_TTR(bool, short int, tag, false);
- TEST_TTR(bool, int, tag, false);
- TEST_TTR(bool, long int, tag, false);
- TEST_TTR(bool, unsigned char, tag, false);
- TEST_TTR(bool, unsigned short int, tag, false);
- TEST_TTR(bool, unsigned int, tag, false);
- TEST_TTR(bool, unsigned long int, tag, false);
- TEST_TTR(bool, wchar_t, tag, false);
- TEST_TTR(bool, float, tag, false);
- TEST_TTR(bool, double, tag, false);
- TEST_TTR(bool, long double, tag, false);
- TEST_TTR(char, bool, tag, false);
- TEST_TTR(char, char, tag, false);
- TEST_TTR(char, signed char, tag, false);
- TEST_TTR(char, short int, tag, false);
- TEST_TTR(char, int, tag, false);
- TEST_TTR(char, long int, tag, false);
- TEST_TTR(char, unsigned char, tag, false);
- TEST_TTR(char, unsigned short int, tag, false);
- TEST_TTR(char, unsigned int, tag, false);
- TEST_TTR(char, unsigned long int, tag, false);
- TEST_TTR(char, wchar_t, tag, false);
- TEST_TTR(char, float, tag, false);
- TEST_TTR(char, double, tag, false);
- TEST_TTR(char, long double, tag, false);
- TEST_TTR(signed char, bool, tag, false);
- TEST_TTR(signed char, char, tag, false);
- TEST_TTR(signed char, signed char, tag, false);
- TEST_TTR(signed char, short int, tag, false);
- TEST_TTR(signed char, int, tag, false);
- TEST_TTR(signed char, long int, tag, false);
- TEST_TTR(signed char, unsigned char, tag, false);
- TEST_TTR(signed char, unsigned short int, tag, false);
- TEST_TTR(signed char, unsigned int, tag, false);
- TEST_TTR(signed char, unsigned long int, tag, false);
- TEST_TTR(signed char, wchar_t, tag, false);
- TEST_TTR(signed char, float, tag, false);
- TEST_TTR(signed char, double, tag, false);
- TEST_TTR(signed char, long double, tag, false);
- TEST_TTR(short int, bool, tag, false);
- TEST_TTR(short int, char, tag, false);
- TEST_TTR(short int, signed char, tag, false);
- TEST_TTR(short int, short int, tag, false);
- TEST_TTR(short int, int, tag, false);
- TEST_TTR(short int, long int, tag, false);
- TEST_TTR(short int, unsigned char, tag, false);
- TEST_TTR(short int, unsigned short int, tag, false);
- TEST_TTR(short int, unsigned int, tag, false);
- TEST_TTR(short int, unsigned long int, tag, false);
- TEST_TTR(short int, wchar_t, tag, false);
- TEST_TTR(short int, float, tag, false);
- TEST_TTR(short int, double, tag, false);
- TEST_TTR(short int, long double, tag, false);
- TEST_TTR(int, bool, tag, false);
- TEST_TTR(int, char, tag, false);
- TEST_TTR(int, signed char, tag, false);
- TEST_TTR(int, short int, tag, false);
- TEST_TTR(int, int, tag, false);
- TEST_TTR(int, long int, tag, false);
- TEST_TTR(int, unsigned char, tag, false);
- TEST_TTR(int, unsigned short int, tag, false);
- TEST_TTR(int, unsigned int, tag, false);
- TEST_TTR(int, unsigned long int, tag, false);
- TEST_TTR(int, wchar_t, tag, false);
- TEST_TTR(int, float, tag, false);
- TEST_TTR(int, double, tag, false);
- TEST_TTR(int, long double, tag, false);
- TEST_TTR(long int, bool, tag, false);
- TEST_TTR(long int, char, tag, false);
- TEST_TTR(long int, signed char, tag, false);
- TEST_TTR(long int, short int, tag, false);
- TEST_TTR(long int, int, tag, false);
- TEST_TTR(long int, long int, tag, false);
- TEST_TTR(long int, unsigned char, tag, false);
- TEST_TTR(long int, unsigned short int, tag, false);
- TEST_TTR(long int, unsigned int, tag, false);
- TEST_TTR(long int, unsigned long int, tag, false);
- TEST_TTR(long int, wchar_t, tag, false);
- TEST_TTR(long int, float, tag, false);
- TEST_TTR(long int, double, tag, false);
- TEST_TTR(long int, long double, tag, false);
- TEST_TTR(unsigned char, bool, tag, false);
- TEST_TTR(unsigned char, char, tag, false);
- TEST_TTR(unsigned char, signed char, tag, false);
- TEST_TTR(unsigned char, short int, tag, false);
- TEST_TTR(unsigned char, int, tag, false);
- TEST_TTR(unsigned char, long int, tag, false);
- TEST_TTR(unsigned char, unsigned char, tag, false);
- TEST_TTR(unsigned char, unsigned short int, tag, false);
- TEST_TTR(unsigned char, unsigned int, tag, false);
- TEST_TTR(unsigned char, unsigned long int, tag, false);
- TEST_TTR(unsigned char, wchar_t, tag, false);
- TEST_TTR(unsigned char, float, tag, false);
- TEST_TTR(unsigned char, double, tag, false);
- TEST_TTR(unsigned char, long double, tag, false);
- TEST_TTR(unsigned short int, bool, tag, false);
- TEST_TTR(unsigned short int, char, tag, false);
- TEST_TTR(unsigned short int, signed char, tag, false);
- TEST_TTR(unsigned short int, short int, tag, false);
- TEST_TTR(unsigned short int, int, tag, false);
- TEST_TTR(unsigned short int, long int, tag, false);
- TEST_TTR(unsigned short int, unsigned char, tag, false);
- TEST_TTR(unsigned short int, unsigned short int, tag, false);
- TEST_TTR(unsigned short int, unsigned int, tag, false);
- TEST_TTR(unsigned short int, unsigned long int, tag, false);
- TEST_TTR(unsigned short int, wchar_t, tag, false);
- TEST_TTR(unsigned short int, float, tag, false);
- TEST_TTR(unsigned short int, double, tag, false);
- TEST_TTR(unsigned short int, long double, tag, false);
- TEST_TTR(unsigned int, bool, tag, false);
- TEST_TTR(unsigned int, char, tag, false);
- TEST_TTR(unsigned int, signed char, tag, false);
- TEST_TTR(unsigned int, short int, tag, false);
- TEST_TTR(unsigned int, int, tag, false);
- TEST_TTR(unsigned int, long int, tag, false);
- TEST_TTR(unsigned int, unsigned char, tag, false);
- TEST_TTR(unsigned int, unsigned short int, tag, false);
- TEST_TTR(unsigned int, unsigned int, tag, false);
- TEST_TTR(unsigned int, unsigned long int, tag, false);
- TEST_TTR(unsigned int, wchar_t, tag, false);
- TEST_TTR(unsigned int, float, tag, false);
- TEST_TTR(unsigned int, double, tag, false);
- TEST_TTR(unsigned int, long double, tag, false);
- TEST_TTR(unsigned long int, bool, tag, false);
- TEST_TTR(unsigned long int, char, tag, false);
- TEST_TTR(unsigned long int, signed char, tag, false);
- TEST_TTR(unsigned long int, short int, tag, false);
- TEST_TTR(unsigned long int, int, tag, false);
- TEST_TTR(unsigned long int, long int, tag, false);
- TEST_TTR(unsigned long int, unsigned char, tag, false);
- TEST_TTR(unsigned long int, unsigned short int, tag, false);
- TEST_TTR(unsigned long int, unsigned int, tag, false);
- TEST_TTR(unsigned long int, unsigned long int, tag, false);
- TEST_TTR(unsigned long int, wchar_t, tag, false);
- TEST_TTR(unsigned long int, float, tag, false);
- TEST_TTR(unsigned long int, double, tag, false);
- TEST_TTR(unsigned long int, long double, tag, false);
- TEST_TTR(wchar_t, bool, tag, false);
- TEST_TTR(wchar_t, char, tag, false);
- TEST_TTR(wchar_t, signed char, tag, false);
- TEST_TTR(wchar_t, short int, tag, false);
- TEST_TTR(wchar_t, int, tag, false);
- TEST_TTR(wchar_t, long int, tag, false);
- TEST_TTR(wchar_t, unsigned char, tag, false);
- TEST_TTR(wchar_t, unsigned short int, tag, false);
- TEST_TTR(wchar_t, unsigned int, tag, false);
- TEST_TTR(wchar_t, unsigned long int, tag, false);
- TEST_TTR(wchar_t, wchar_t, tag, false);
- TEST_TTR(wchar_t, float, tag, false);
- TEST_TTR(wchar_t, double, tag, false);
- TEST_TTR(wchar_t, long double, tag, false);
- TEST_TTR(float, bool, tag, false);
- TEST_TTR(float, char, tag, false);
- TEST_TTR(float, signed char, tag, false);
- TEST_TTR(float, short int, tag, false);
- TEST_TTR(float, int, tag, false);
- TEST_TTR(float, long int, tag, false);
- TEST_TTR(float, unsigned char, tag, false);
- TEST_TTR(float, unsigned short int, tag, false);
- TEST_TTR(float, unsigned int, tag, false);
- TEST_TTR(float, unsigned long int, tag, false);
- TEST_TTR(float, wchar_t, tag, false);
- TEST_TTR(float, float, tag, false);
- TEST_TTR(float, double, tag, false);
- TEST_TTR(float, long double, tag, false);
- TEST_TTR(double, bool, tag, false);
- TEST_TTR(double, char, tag, false);
- TEST_TTR(double, signed char, tag, false);
- TEST_TTR(double, short int, tag, false);
- TEST_TTR(double, int, tag, false);
- TEST_TTR(double, long int, tag, false);
- TEST_TTR(double, unsigned char, tag, false);
- TEST_TTR(double, unsigned short int, tag, false);
- TEST_TTR(double, unsigned int, tag, false);
- TEST_TTR(double, unsigned long int, tag, false);
- TEST_TTR(double, wchar_t, tag, false);
- TEST_TTR(double, float, tag, false);
- TEST_TTR(double, double, tag, false);
- TEST_TTR(double, long double, tag, false);
- TEST_TTR(long double, bool, tag, false);
- TEST_TTR(long double, char, tag, false);
- TEST_TTR(long double, signed char, tag, false);
- TEST_TTR(long double, short int, tag, false);
- TEST_TTR(long double, int, tag, false);
- TEST_TTR(long double, long int, tag, false);
- TEST_TTR(long double, unsigned char, tag, false);
- TEST_TTR(long double, unsigned short int, tag, false);
- TEST_TTR(long double, unsigned int, tag, false);
- TEST_TTR(long double, unsigned long int, tag, false);
- TEST_TTR(long double, wchar_t, tag, false);
- TEST_TTR(long double, float, tag, false);
- TEST_TTR(long double, double, tag, false);
- TEST_TTR(long double, long double, tag, false);
-# undef CV1
-# define CV1(T) const T
-# undef CV2
-# define CV2(T) T
- // test with only two template parameters
- TEST_TT(CV1(bool), CV2(int), true);
- TEST_TT(CV1(bool), CV2(double), true);
- TEST_TT(CV1(int), CV2(bool), true);
- TEST_TT(CV1(int), CV2(double), true);
- TEST_TT(CV1(double), CV2(bool), true);
- TEST_TT(CV1(double), CV2(int), true);
-
- // test with three template parameters
- TEST_TTR(CV1(bool), CV2(int), bool, true);
- TEST_TTR(CV1(bool), CV2(double), bool, true);
- TEST_TTR(CV1(int), CV2(bool), bool, true);
- TEST_TTR(CV1(int), CV2(double), bool, true);
- TEST_TTR(CV1(double), CV2(bool), bool, true);
- TEST_TTR(CV1(double), CV2(int), bool, true);
- TEST_TTR(CV1(bool), CV2(int), tag, false);
- TEST_TTR(CV1(bool), CV2(double), tag, false);
- TEST_TTR(CV1(int), CV2(bool), tag, false);
- TEST_TTR(CV1(int), CV2(double), tag, false);
- TEST_TTR(CV1(double), CV2(bool), tag, false);
- TEST_TTR(CV1(double), CV2(int), tag, false);
-
-# undef CV1
-# define CV1(T) volatile T
-# undef CV2
-# define CV2(T) T
- // test with only two template parameters
- TEST_TT(CV1(bool), CV2(int), true);
- TEST_TT(CV1(bool), CV2(double), true);
- TEST_TT(CV1(int), CV2(bool), true);
- TEST_TT(CV1(int), CV2(double), true);
- TEST_TT(CV1(double), CV2(bool), true);
- TEST_TT(CV1(double), CV2(int), true);
-
- // test with three template parameters
- TEST_TTR(CV1(bool), CV2(int), bool, true);
- TEST_TTR(CV1(bool), CV2(double), bool, true);
- TEST_TTR(CV1(int), CV2(bool), bool, true);
- TEST_TTR(CV1(int), CV2(double), bool, true);
- TEST_TTR(CV1(double), CV2(bool), bool, true);
- TEST_TTR(CV1(double), CV2(int), bool, true);
- TEST_TTR(CV1(bool), CV2(int), tag, false);
- TEST_TTR(CV1(bool), CV2(double), tag, false);
- TEST_TTR(CV1(int), CV2(bool), tag, false);
- TEST_TTR(CV1(int), CV2(double), tag, false);
- TEST_TTR(CV1(double), CV2(bool), tag, false);
- TEST_TTR(CV1(double), CV2(int), tag, false);
-
-# undef CV1
-# define CV1(T) const volatile T
-# undef CV2
-# define CV2(T) T
- // test with only two template parameters
- TEST_TT(CV1(bool), CV2(int), true);
- TEST_TT(CV1(bool), CV2(double), true);
- TEST_TT(CV1(int), CV2(bool), true);
- TEST_TT(CV1(int), CV2(double), true);
- TEST_TT(CV1(double), CV2(bool), true);
- TEST_TT(CV1(double), CV2(int), true);
-
- // test with three template parameters
- TEST_TTR(CV1(bool), CV2(int), bool, true);
- TEST_TTR(CV1(bool), CV2(double), bool, true);
- TEST_TTR(CV1(int), CV2(bool), bool, true);
- TEST_TTR(CV1(int), CV2(double), bool, true);
- TEST_TTR(CV1(double), CV2(bool), bool, true);
- TEST_TTR(CV1(double), CV2(int), bool, true);
- TEST_TTR(CV1(bool), CV2(int), tag, false);
- TEST_TTR(CV1(bool), CV2(double), tag, false);
- TEST_TTR(CV1(int), CV2(bool), tag, false);
- TEST_TTR(CV1(int), CV2(double), tag, false);
- TEST_TTR(CV1(double), CV2(bool), tag, false);
- TEST_TTR(CV1(double), CV2(int), tag, false);
-
-# undef CV1
-# define CV1(T) const T&
-# undef CV2
-# define CV2(T) T
- // test with only two template parameters
- TEST_TT(CV1(bool), CV2(int), true);
- TEST_TT(CV1(bool), CV2(double), true);
- TEST_TT(CV1(int), CV2(bool), true);
- TEST_TT(CV1(int), CV2(double), true);
- TEST_TT(CV1(double), CV2(bool), true);
- TEST_TT(CV1(double), CV2(int), true);
-
- // test with three template parameters
- TEST_TTR(CV1(bool), CV2(int), bool, true);
- TEST_TTR(CV1(bool), CV2(double), bool, true);
- TEST_TTR(CV1(int), CV2(bool), bool, true);
- TEST_TTR(CV1(int), CV2(double), bool, true);
- TEST_TTR(CV1(double), CV2(bool), bool, true);
- TEST_TTR(CV1(double), CV2(int), bool, true);
- TEST_TTR(CV1(bool), CV2(int), tag, false);
- TEST_TTR(CV1(bool), CV2(double), tag, false);
- TEST_TTR(CV1(int), CV2(bool), tag, false);
- TEST_TTR(CV1(int), CV2(double), tag, false);
- TEST_TTR(CV1(double), CV2(bool), tag, false);
- TEST_TTR(CV1(double), CV2(int), tag, false);
-
-# undef CV1
-# define CV1(T) volatile T&
-# undef CV2
-# define CV2(T) T
- // test with only two template parameters
- TEST_TT(CV1(bool), CV2(int), true);
- TEST_TT(CV1(bool), CV2(double), true);
- TEST_TT(CV1(int), CV2(bool), true);
- TEST_TT(CV1(int), CV2(double), true);
- TEST_TT(CV1(double), CV2(bool), true);
- TEST_TT(CV1(double), CV2(int), true);
-
- // test with three template parameters
- TEST_TTR(CV1(bool), CV2(int), bool, true);
- TEST_TTR(CV1(bool), CV2(double), bool, true);
- TEST_TTR(CV1(int), CV2(bool), bool, true);
- TEST_TTR(CV1(int), CV2(double), bool, true);
- TEST_TTR(CV1(double), CV2(bool), bool, true);
- TEST_TTR(CV1(double), CV2(int), bool, true);
- TEST_TTR(CV1(bool), CV2(int), tag, false);
- TEST_TTR(CV1(bool), CV2(double), tag, false);
- TEST_TTR(CV1(int), CV2(bool), tag, false);
- TEST_TTR(CV1(int), CV2(double), tag, false);
- TEST_TTR(CV1(double), CV2(bool), tag, false);
- TEST_TTR(CV1(double), CV2(int), tag, false);
-
-# undef CV1
-# define CV1(T) const volatile T&
-# undef CV2
-# define CV2(T) T
- // test with only two template parameters
- TEST_TT(CV1(bool), CV2(int), true);
- TEST_TT(CV1(bool), CV2(double), true);
- TEST_TT(CV1(int), CV2(bool), true);
- TEST_TT(CV1(int), CV2(double), true);
- TEST_TT(CV1(double), CV2(bool), true);
- TEST_TT(CV1(double), CV2(int), true);
-
- // test with three template parameters
- TEST_TTR(CV1(bool), CV2(int), bool, true);
- TEST_TTR(CV1(bool), CV2(double), bool, true);
- TEST_TTR(CV1(int), CV2(bool), bool, true);
- TEST_TTR(CV1(int), CV2(double), bool, true);
- TEST_TTR(CV1(double), CV2(bool), bool, true);
- TEST_TTR(CV1(double), CV2(int), bool, true);
- TEST_TTR(CV1(bool), CV2(int), tag, false);
- TEST_TTR(CV1(bool), CV2(double), tag, false);
- TEST_TTR(CV1(int), CV2(bool), tag, false);
- TEST_TTR(CV1(int), CV2(double), tag, false);
- TEST_TTR(CV1(double), CV2(bool), tag, false);
- TEST_TTR(CV1(double), CV2(int), tag, false);
-
-# undef CV1
-# define CV1(T) T
-# undef CV2
-# define CV2(T) const T
- // test with only two template parameters
- TEST_TT(CV1(bool), CV2(int), true);
- TEST_TT(CV1(bool), CV2(double), true);
- TEST_TT(CV1(int), CV2(bool), true);
- TEST_TT(CV1(int), CV2(double), true);
- TEST_TT(CV1(double), CV2(bool), true);
- TEST_TT(CV1(double), CV2(int), true);
-
- // test with three template parameters
- TEST_TTR(CV1(bool), CV2(int), bool, true);
- TEST_TTR(CV1(bool), CV2(double), bool, true);
- TEST_TTR(CV1(int), CV2(bool), bool, true);
- TEST_TTR(CV1(int), CV2(double), bool, true);
- TEST_TTR(CV1(double), CV2(bool), bool, true);
- TEST_TTR(CV1(double), CV2(int), bool, true);
- TEST_TTR(CV1(bool), CV2(int), tag, false);
- TEST_TTR(CV1(bool), CV2(double), tag, false);
- TEST_TTR(CV1(int), CV2(bool), tag, false);
- TEST_TTR(CV1(int), CV2(double), tag, false);
- TEST_TTR(CV1(double), CV2(bool), tag, false);
- TEST_TTR(CV1(double), CV2(int), tag, false);
-
-# undef CV1
-# define CV1(T) T
-# undef CV2
-# define CV2(T) volatile T
- // test with only two template parameters
- TEST_TT(CV1(bool), CV2(int), true);
- TEST_TT(CV1(bool), CV2(double), true);
- TEST_TT(CV1(int), CV2(bool), true);
- TEST_TT(CV1(int), CV2(double), true);
- TEST_TT(CV1(double), CV2(bool), true);
- TEST_TT(CV1(double), CV2(int), true);
-
- // test with three template parameters
- TEST_TTR(CV1(bool), CV2(int), bool, true);
- TEST_TTR(CV1(bool), CV2(double), bool, true);
- TEST_TTR(CV1(int), CV2(bool), bool, true);
- TEST_TTR(CV1(int), CV2(double), bool, true);
- TEST_TTR(CV1(double), CV2(bool), bool, true);
- TEST_TTR(CV1(double), CV2(int), bool, true);
- TEST_TTR(CV1(bool), CV2(int), tag, false);
- TEST_TTR(CV1(bool), CV2(double), tag, false);
- TEST_TTR(CV1(int), CV2(bool), tag, false);
- TEST_TTR(CV1(int), CV2(double), tag, false);
- TEST_TTR(CV1(double), CV2(bool), tag, false);
- TEST_TTR(CV1(double), CV2(int), tag, false);
-
-# undef CV1
-# define CV1(T) T
-# undef CV2
-# define CV2(T) const volatile T
- // test with only two template parameters
- TEST_TT(CV1(bool), CV2(int), true);
- TEST_TT(CV1(bool), CV2(double), true);
- TEST_TT(CV1(int), CV2(bool), true);
- TEST_TT(CV1(int), CV2(double), true);
- TEST_TT(CV1(double), CV2(bool), true);
- TEST_TT(CV1(double), CV2(int), true);
-
- // test with three template parameters
- TEST_TTR(CV1(bool), CV2(int), bool, true);
- TEST_TTR(CV1(bool), CV2(double), bool, true);
- TEST_TTR(CV1(int), CV2(bool), bool, true);
- TEST_TTR(CV1(int), CV2(double), bool, true);
- TEST_TTR(CV1(double), CV2(bool), bool, true);
- TEST_TTR(CV1(double), CV2(int), bool, true);
- TEST_TTR(CV1(bool), CV2(int), tag, false);
- TEST_TTR(CV1(bool), CV2(double), tag, false);
- TEST_TTR(CV1(int), CV2(bool), tag, false);
- TEST_TTR(CV1(int), CV2(double), tag, false);
- TEST_TTR(CV1(double), CV2(bool), tag, false);
- TEST_TTR(CV1(double), CV2(int), tag, false);
-
-# undef CV1
-# define CV1(T) T
-# undef CV2
-# define CV2(T) const T&
- // test with only two template parameters
- TEST_TT(CV1(bool), CV2(int), true);
- TEST_TT(CV1(bool), CV2(double), true);
- TEST_TT(CV1(int), CV2(bool), true);
- TEST_TT(CV1(int), CV2(double), true);
- TEST_TT(CV1(double), CV2(bool), true);
- TEST_TT(CV1(double), CV2(int), true);
-
- // test with three template parameters
- TEST_TTR(CV1(bool), CV2(int), bool, true);
- TEST_TTR(CV1(bool), CV2(double), bool, true);
- TEST_TTR(CV1(int), CV2(bool), bool, true);
- TEST_TTR(CV1(int), CV2(double), bool, true);
- TEST_TTR(CV1(double), CV2(bool), bool, true);
- TEST_TTR(CV1(double), CV2(int), bool, true);
- TEST_TTR(CV1(bool), CV2(int), tag, false);
- TEST_TTR(CV1(bool), CV2(double), tag, false);
- TEST_TTR(CV1(int), CV2(bool), tag, false);
- TEST_TTR(CV1(int), CV2(double), tag, false);
- TEST_TTR(CV1(double), CV2(bool), tag, false);
- TEST_TTR(CV1(double), CV2(int), tag, false);
-
-# undef CV1
-# define CV1(T) T
-# undef CV2
-# define CV2(T) volatile T&
- // test with only two template parameters
- TEST_TT(CV1(bool), CV2(int), true);
- TEST_TT(CV1(bool), CV2(double), true);
- TEST_TT(CV1(int), CV2(bool), true);
- TEST_TT(CV1(int), CV2(double), true);
- TEST_TT(CV1(double), CV2(bool), true);
- TEST_TT(CV1(double), CV2(int), true);
-
- // test with three template parameters
- TEST_TTR(CV1(bool), CV2(int), bool, true);
- TEST_TTR(CV1(bool), CV2(double), bool, true);
- TEST_TTR(CV1(int), CV2(bool), bool, true);
- TEST_TTR(CV1(int), CV2(double), bool, true);
- TEST_TTR(CV1(double), CV2(bool), bool, true);
- TEST_TTR(CV1(double), CV2(int), bool, true);
- TEST_TTR(CV1(bool), CV2(int), tag, false);
- TEST_TTR(CV1(bool), CV2(double), tag, false);
- TEST_TTR(CV1(int), CV2(bool), tag, false);
- TEST_TTR(CV1(int), CV2(double), tag, false);
- TEST_TTR(CV1(double), CV2(bool), tag, false);
- TEST_TTR(CV1(double), CV2(int), tag, false);
-
-# undef CV1
-# define CV1(T) T
-# undef CV2
-# define CV2(T) const volatile T&
- // test with only two template parameters
- TEST_TT(CV1(bool), CV2(int), true);
- TEST_TT(CV1(bool), CV2(double), true);
- TEST_TT(CV1(int), CV2(bool), true);
- TEST_TT(CV1(int), CV2(double), true);
- TEST_TT(CV1(double), CV2(bool), true);
- TEST_TT(CV1(double), CV2(int), true);
-
- // test with three template parameters
- TEST_TTR(CV1(bool), CV2(int), bool, true);
- TEST_TTR(CV1(bool), CV2(double), bool, true);
- TEST_TTR(CV1(int), CV2(bool), bool, true);
- TEST_TTR(CV1(int), CV2(double), bool, true);
- TEST_TTR(CV1(double), CV2(bool), bool, true);
- TEST_TTR(CV1(double), CV2(int), bool, true);
- TEST_TTR(CV1(bool), CV2(int), tag, false);
- TEST_TTR(CV1(bool), CV2(double), tag, false);
- TEST_TTR(CV1(int), CV2(bool), tag, false);
- TEST_TTR(CV1(int), CV2(double), tag, false);
- TEST_TTR(CV1(double), CV2(bool), tag, false);
- TEST_TTR(CV1(double), CV2(int), tag, false);
-
-# undef CV1
-# define CV1(T) const T
-# undef CV2
-# define CV2(T) const T
- // test with only two template parameters
- TEST_TT(CV1(bool), CV2(int), true);
- TEST_TT(CV1(bool), CV2(double), true);
- TEST_TT(CV1(int), CV2(bool), true);
- TEST_TT(CV1(int), CV2(double), true);
- TEST_TT(CV1(double), CV2(bool), true);
- TEST_TT(CV1(double), CV2(int), true);
-
- // test with three template parameters
- TEST_TTR(CV1(bool), CV2(int), bool, true);
- TEST_TTR(CV1(bool), CV2(double), bool, true);
- TEST_TTR(CV1(int), CV2(bool), bool, true);
- TEST_TTR(CV1(int), CV2(double), bool, true);
- TEST_TTR(CV1(double), CV2(bool), bool, true);
- TEST_TTR(CV1(double), CV2(int), bool, true);
- TEST_TTR(CV1(bool), CV2(int), tag, false);
- TEST_TTR(CV1(bool), CV2(double), tag, false);
- TEST_TTR(CV1(int), CV2(bool), tag, false);
- TEST_TTR(CV1(int), CV2(double), tag, false);
- TEST_TTR(CV1(double), CV2(bool), tag, false);
- TEST_TTR(CV1(double), CV2(int), tag, false);
-
-# undef CV1
-# define CV1(T) const T&
-# undef CV2
-# define CV2(T) const T&
- // test with only two template parameters
- TEST_TT(CV1(bool), CV2(int), true);
- TEST_TT(CV1(bool), CV2(double), true);
- TEST_TT(CV1(int), CV2(bool), true);
- TEST_TT(CV1(int), CV2(double), true);
- TEST_TT(CV1(double), CV2(bool), true);
- TEST_TT(CV1(double), CV2(int), true);
-
- // test with three template parameters
- TEST_TTR(CV1(bool), CV2(int), bool, true);
- TEST_TTR(CV1(bool), CV2(double), bool, true);
- TEST_TTR(CV1(int), CV2(bool), bool, true);
- TEST_TTR(CV1(int), CV2(double), bool, true);
- TEST_TTR(CV1(double), CV2(bool), bool, true);
- TEST_TTR(CV1(double), CV2(int), bool, true);
- TEST_TTR(CV1(bool), CV2(int), tag, false);
- TEST_TTR(CV1(bool), CV2(double), tag, false);
- TEST_TTR(CV1(int), CV2(bool), tag, false);
- TEST_TTR(CV1(int), CV2(double), tag, false);
- TEST_TTR(CV1(double), CV2(bool), tag, false);
- TEST_TTR(CV1(double), CV2(int), tag, false);
-
-# undef CV1
-# define CV1(T) volatile T
-# undef CV2
-# define CV2(T) volatile T
- // test with only two template parameters
- TEST_TT(CV1(bool), CV2(int), true);
- TEST_TT(CV1(bool), CV2(double), true);
- TEST_TT(CV1(int), CV2(bool), true);
- TEST_TT(CV1(int), CV2(double), true);
- TEST_TT(CV1(double), CV2(bool), true);
- TEST_TT(CV1(double), CV2(int), true);
-
- // test with three template parameters
- TEST_TTR(CV1(bool), CV2(int), bool, true);
- TEST_TTR(CV1(bool), CV2(double), bool, true);
- TEST_TTR(CV1(int), CV2(bool), bool, true);
- TEST_TTR(CV1(int), CV2(double), bool, true);
- TEST_TTR(CV1(double), CV2(bool), bool, true);
- TEST_TTR(CV1(double), CV2(int), bool, true);
- TEST_TTR(CV1(bool), CV2(int), tag, false);
- TEST_TTR(CV1(bool), CV2(double), tag, false);
- TEST_TTR(CV1(int), CV2(bool), tag, false);
- TEST_TTR(CV1(int), CV2(double), tag, false);
- TEST_TTR(CV1(double), CV2(bool), tag, false);
- TEST_TTR(CV1(double), CV2(int), tag, false);
-
-# undef CV1
-# define CV1(T) volatile T&
-# undef CV2
-# define CV2(T) volatile T&
- // test with only two template parameters
- TEST_TT(CV1(bool), CV2(int), true);
- TEST_TT(CV1(bool), CV2(double), true);
- TEST_TT(CV1(int), CV2(bool), true);
- TEST_TT(CV1(int), CV2(double), true);
- TEST_TT(CV1(double), CV2(bool), true);
- TEST_TT(CV1(double), CV2(int), true);
-
- // test with three template parameters
- TEST_TTR(CV1(bool), CV2(int), bool, true);
- TEST_TTR(CV1(bool), CV2(double), bool, true);
- TEST_TTR(CV1(int), CV2(bool), bool, true);
- TEST_TTR(CV1(int), CV2(double), bool, true);
- TEST_TTR(CV1(double), CV2(bool), bool, true);
- TEST_TTR(CV1(double), CV2(int), bool, true);
- TEST_TTR(CV1(bool), CV2(int), tag, false);
- TEST_TTR(CV1(bool), CV2(double), tag, false);
- TEST_TTR(CV1(int), CV2(bool), tag, false);
- TEST_TTR(CV1(int), CV2(double), tag, false);
- TEST_TTR(CV1(double), CV2(bool), tag, false);
- TEST_TTR(CV1(double), CV2(int), tag, false);
-
-# undef CV1
-# define CV1(T) const volatile T
-# undef CV2
-# define CV2(T) const volatile T
- // test with only two template parameters
- TEST_TT(CV1(bool), CV2(int), true);
- TEST_TT(CV1(bool), CV2(double), true);
- TEST_TT(CV1(int), CV2(bool), true);
- TEST_TT(CV1(int), CV2(double), true);
- TEST_TT(CV1(double), CV2(bool), true);
- TEST_TT(CV1(double), CV2(int), true);
-
- // test with three template parameters
- TEST_TTR(CV1(bool), CV2(int), bool, true);
- TEST_TTR(CV1(bool), CV2(double), bool, true);
- TEST_TTR(CV1(int), CV2(bool), bool, true);
- TEST_TTR(CV1(int), CV2(double), bool, true);
- TEST_TTR(CV1(double), CV2(bool), bool, true);
- TEST_TTR(CV1(double), CV2(int), bool, true);
- TEST_TTR(CV1(bool), CV2(int), tag, false);
- TEST_TTR(CV1(bool), CV2(double), tag, false);
- TEST_TTR(CV1(int), CV2(bool), tag, false);
- TEST_TTR(CV1(int), CV2(double), tag, false);
- TEST_TTR(CV1(double), CV2(bool), tag, false);
- TEST_TTR(CV1(double), CV2(int), tag, false);
-
-# undef CV1
-# define CV1(T) const volatile T&
-# undef CV2
-# define CV2(T) const volatile T&
- // test with only two template parameters
- TEST_TT(CV1(bool), CV2(int), true);
- TEST_TT(CV1(bool), CV2(double), true);
- TEST_TT(CV1(int), CV2(bool), true);
- TEST_TT(CV1(int), CV2(double), true);
- TEST_TT(CV1(double), CV2(bool), true);
- TEST_TT(CV1(double), CV2(int), true);
-
- // test with three template parameters
- TEST_TTR(CV1(bool), CV2(int), bool, true);
- TEST_TTR(CV1(bool), CV2(double), bool, true);
- TEST_TTR(CV1(int), CV2(bool), bool, true);
- TEST_TTR(CV1(int), CV2(double), bool, true);
- TEST_TTR(CV1(double), CV2(bool), bool, true);
- TEST_TTR(CV1(double), CV2(int), bool, true);
- TEST_TTR(CV1(bool), CV2(int), tag, false);
- TEST_TTR(CV1(bool), CV2(double), tag, false);
- TEST_TTR(CV1(int), CV2(bool), tag, false);
- TEST_TTR(CV1(int), CV2(double), tag, false);
- TEST_TTR(CV1(double), CV2(bool), tag, false);
- TEST_TTR(CV1(double), CV2(int), tag, false);
-
- // pointers
- TEST_TT(void*, bool, true);
- TEST_TT(void*, int, true);
- TEST_TT(void*, double, true);
- TEST_TT(void*, A, false);
- TEST_TT(void*, B, false);
- TEST_TT(bool*, bool, true);
- TEST_TT(bool*, int, true);
- TEST_TT(bool*, double, true);
- TEST_TT(bool*, A, false);
- TEST_TT(bool*, B, false);
- TEST_TT(int*, bool, true);
- TEST_TT(int*, int, true);
- TEST_TT(int*, double, true);
- TEST_TT(int*, A, false);
- TEST_TT(int*, B, false);
- TEST_TT(double*, bool, true);
- TEST_TT(double*, int, true);
- TEST_TT(double*, double, true);
- TEST_TT(double*, A, false);
- TEST_TT(double*, B, false);
- TEST_TT(A*, bool, true);
- TEST_TT(A*, int, true);
- TEST_TT(A*, double, true);
- TEST_TT(A*, A, false);
- TEST_TT(A*, B, false);
- TEST_TT(B*, bool, true);
- TEST_TT(B*, int, true);
- TEST_TT(B*, double, true);
- TEST_TT(B*, A, false);
- TEST_TT(B*, B, false);
- TEST_TT(bool, void*, true);
- TEST_TT(bool, bool*, true);
- TEST_TT(bool, int*, true);
- TEST_TT(bool, double*, true);
- TEST_TT(bool, A*, true);
- TEST_TT(bool, B*, true);
- TEST_TT(int, void*, true);
- TEST_TT(int, bool*, true);
- TEST_TT(int, int*, true);
- TEST_TT(int, double*, true);
- TEST_TT(int, A*, true);
- TEST_TT(int, B*, true);
- TEST_TT(double, void*, true);
- TEST_TT(double, bool*, true);
- TEST_TT(double, int*, true);
- TEST_TT(double, double*, true);
- TEST_TT(double, A*, true);
- TEST_TT(double, B*, true);
- TEST_TT(A, void*, false);
- TEST_TT(A, bool*, false);
- TEST_TT(A, int*, false);
- TEST_TT(A, double*, false);
- TEST_TT(A, A*, false);
- TEST_TT(A, B*, false);
- TEST_TT(B, void*, false);
- TEST_TT(B, bool*, false);
- TEST_TT(B, int*, false);
- TEST_TT(B, double*, false);
- TEST_TT(B, A*, false);
- TEST_TT(B, B*, false);
- TEST_TT(void*, void*, true);
- TEST_TT(void*, bool*, true);
- TEST_TT(void*, int*, true);
- TEST_TT(void*, double*, true);
- TEST_TT(void*, A*, true);
- TEST_TT(void*, B*, true);
- TEST_TT(bool*, void*, true);
- TEST_TT(bool*, bool*, true);
- TEST_TT(bool*, int*, true);
- TEST_TT(bool*, double*, true);
- TEST_TT(bool*, A*, true);
- TEST_TT(bool*, B*, true);
- TEST_TT(int*, void*, true);
- TEST_TT(int*, bool*, true);
- TEST_TT(int*, int*, true);
- TEST_TT(int*, double*, true);
- TEST_TT(int*, A*, true);
- TEST_TT(int*, B*, true);
- TEST_TT(double*, void*, true);
- TEST_TT(double*, bool*, true);
- TEST_TT(double*, int*, true);
- TEST_TT(double*, double*, true);
- TEST_TT(double*, A*, true);
- TEST_TT(double*, B*, true);
- TEST_TT(A*, void*, true);
- TEST_TT(A*, bool*, true);
- TEST_TT(A*, int*, true);
- TEST_TT(A*, double*, true);
- TEST_TT(A*, A*, true);
- TEST_TT(A*, B*, true);
- TEST_TT(B*, void*, true);
- TEST_TT(B*, bool*, true);
- TEST_TT(B*, int*, true);
- TEST_TT(B*, double*, true);
- TEST_TT(B*, A*, true);
- TEST_TT(B*, B*, true);
- TEST_TT(C, void*, true);
- TEST_TT(D, void*, false);
- TEST_TT(void*, C, false);
- TEST_TT(void*, D, true);
- TEST_TT(C, D, true);
-}
-}

Modified: sandbox/type_traits/libs/type_traits/test/can_call_binary_operators.hpp
==============================================================================
--- sandbox/type_traits/libs/type_traits/test/can_call_binary_operators.hpp (original)
+++ sandbox/type_traits/libs/type_traits/test/can_call_binary_operators.hpp 2011-07-09 16:29:47 EDT (Sat, 09 Jul 2011)
@@ -4,13 +4,13 @@
 // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
 // test with one template parameter
-#define TEST_T(TYPE,RESULT) BOOST_CHECK_INTEGRAL_CONSTANT((::tt::BOOST_TT_TRAIT_NAME<TYPE>::value), RESULT)
+#define TEST_T(TYPE,RESULT) BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME<TYPE>::value), RESULT)
 // test with one template parameter plus return value
-#define TEST_TR(TYPE,RET,RESULT) BOOST_CHECK_INTEGRAL_CONSTANT((::tt::BOOST_TT_TRAIT_NAME<TYPE,TYPE,RET>::value), RESULT)
+#define TEST_TR(TYPE,RET,RESULT) BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME<TYPE,TYPE,RET>::value), RESULT)
 // test with two template parameters
-#define TEST_TT(TYPE1,TYPE2,RESULT) BOOST_CHECK_INTEGRAL_CONSTANT((::tt::BOOST_TT_TRAIT_NAME<TYPE1,TYPE2>::value), RESULT)
+#define TEST_TT(TYPE1,TYPE2,RESULT) BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME<TYPE1,TYPE2>::value), RESULT)
 // test with two template parameters plus return value
-#define TEST_TTR(TYPE1,TYPE2,RET,RESULT) BOOST_CHECK_INTEGRAL_CONSTANT((::tt::BOOST_TT_TRAIT_NAME<TYPE1,TYPE2,RET>::value), RESULT)
+#define TEST_TTR(TYPE1,TYPE2,RET,RESULT) BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME<TYPE1,TYPE2,RET>::value), RESULT)
 
 namespace {
 
@@ -79,7 +79,7 @@
 
 //class internal_private { ret operator BOOST_TT_TRAIT_OP (const internal_private&) const; };
 
-void run1() {
+void common() {
    TEST_T(void, false);
    TEST_TT(void, void, false);
    TEST_TTR(void, void, void, false);

Modified: sandbox/type_traits/libs/type_traits/test/can_call_bitwise_and_assignment_test.cpp
==============================================================================
--- sandbox/type_traits/libs/type_traits/test/can_call_bitwise_and_assignment_test.cpp (original)
+++ sandbox/type_traits/libs/type_traits/test/can_call_bitwise_and_assignment_test.cpp 2011-07-09 16:29:47 EDT (Sat, 09 Jul 2011)
@@ -15,19 +15,264 @@
 #define BOOST_TT_TRAIT_NAME can_call_bitwise_and_assignment
 #define BOOST_TT_TRAIT_OP &=
 
+
 #include "can_call_binary_operators.hpp"
-#include "can_call_integral_no_constlhs_test.hpp"
 
-namespace {
 void specific() {
- /* nothing specific */
-}
-}
-
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const volatile, void, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int volatile, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int const volatile, int >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, double const, bool const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, double volatile, int volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, double const volatile, bool const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, void* >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int* const &, bool >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int const volatile, bool & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, double const volatile, bool >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int* &, bool volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool volatile, bool &, bool volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool volatile, int const, int volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool volatile, int &, bool const volatile & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool volatile, double, int const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool volatile, void* volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const volatile, int &, bool >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const volatile, int const volatile &, int & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const volatile, double &, bool const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const volatile, void* const, bool volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const volatile, void* & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const volatile, int*, bool volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const volatile, int* volatile &, bool volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, void*, bool const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, void* const, bool const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, void* volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, int const, bool const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, int const volatile, bool const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, double const volatile &, int const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool volatile &, bool volatile, int const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool volatile &, int &, bool >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool volatile &, double const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool volatile &, double const volatile &, int const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool volatile &, void* const volatile, int & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool volatile &, int* const &, bool & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool volatile &, int* const &, int const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool volatile &, int* volatile &, int const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const volatile &, int volatile, int const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const volatile &, int const volatile, bool const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const volatile &, int &, bool volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const volatile &, double const volatile, int const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const volatile &, double volatile &, int volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const volatile &, void* &, int const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const volatile &, void* &, int volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const volatile &, int* &, bool volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const volatile &, int* volatile &, int const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool const &, int & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, int, bool const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, void* const volatile, int const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int, bool const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int const &, int const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int* const volatile &, bool >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int* const volatile &, int const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int volatile, int const, bool >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int volatile, int volatile, bool & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int volatile, int const &, bool volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int volatile, void* &, int & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int volatile, int*, int const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int volatile, int* volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int volatile, int* const volatile, bool const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const volatile, bool const volatile, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const volatile, bool volatile &, bool volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const volatile, void* const volatile, int const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const volatile, int* &, bool >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const volatile, int* volatile &, bool const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const volatile, int* const volatile &, int const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, int, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, int volatile &, bool & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, double const &, bool const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, double volatile &, int volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, int* volatile, bool const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, bool & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, bool const &, int const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, bool const &, int const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int const, bool const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int const volatile, int >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int const volatile &, int >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, double const volatile, int volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, double const &, int volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, double const volatile &, bool const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, void* >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, void* const, int >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, void* volatile, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, void* const volatile, bool & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int* const, bool const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int* volatile, int const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int* &, int const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int volatile &, bool, bool const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int volatile &, int volatile, bool const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int volatile &, int const &, bool const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int volatile &, void* const volatile &, bool >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int volatile &, int*, int const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const volatile &, bool const, int & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const volatile &, bool volatile &, bool volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const volatile &, int volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const volatile &, double &, int & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const volatile &, void* const, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const volatile &, void* const &, bool const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const volatile &, void* const &, int & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const volatile &, int* volatile, bool volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const volatile &, int* volatile, int volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const volatile &, int* const volatile, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, bool volatile, int const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, bool const volatile, bool const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, int const, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, int const volatile, int const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, int const &, int const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, double, int >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, void*, int const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, void* &, bool const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, int volatile, int const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, double &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, double &, bool & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, void* volatile, int const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double volatile, bool const volatile &, int volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double volatile, double volatile, bool const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double volatile, int* const volatile, bool const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double volatile, int* volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const volatile, bool volatile, bool volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const volatile, bool volatile &, int const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const volatile, int const &, int const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const volatile, double const volatile, bool const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const volatile, int*, bool volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const volatile, int* const volatile &, bool volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, bool const &, int const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, void* const, bool const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, int* const &, int const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, int* const volatile &, int volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, bool const, int const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, double volatile, bool const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int* const &, int const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double volatile &, bool volatile, int const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double volatile &, bool const volatile &, bool & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double volatile &, int const, int const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double volatile &, int const volatile, bool >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double volatile &, double & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double volatile &, void* const volatile, int const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double volatile &, int* volatile, int volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double volatile &, int* volatile &, int >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const volatile &, bool volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const volatile &, int const volatile &, bool const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const volatile &, int const volatile &, int & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const volatile &, double const, int >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const volatile &, double const, int const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int &, bool const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int &, bool volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int &, int & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int const &, bool volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, double const &, int const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, void* volatile &, int const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int*, int volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int* volatile, int const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int* const volatile &, bool >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, bool &, bool const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, bool volatile &, int & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, int const &, bool >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, int const &, int const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, int volatile &, int volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, double const, int & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, void* const &, int const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, void* volatile &, int & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* volatile, bool, bool & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* volatile, bool const volatile &, bool const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* volatile, int const volatile, int >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* volatile, int const &, int volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* volatile, double const volatile, bool const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* volatile, double const volatile &, bool >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* volatile, void* const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* volatile, void* const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* volatile, int* volatile &, bool volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* volatile, int* volatile &, bool volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const volatile, bool volatile, bool >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const volatile, double const, int const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const volatile, void* const, int const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const volatile, void* & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const volatile, int* & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int volatile &, int const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int const volatile &, bool const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, double const, bool & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, bool const volatile, bool const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, double volatile &, int volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, void* const volatile &, int volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int* volatile, bool >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int* const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* volatile &, bool const &, int & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* volatile &, bool const volatile &, int const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* volatile &, int volatile, int & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* volatile &, double volatile &, int >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* volatile &, void* const, bool volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* volatile &, void* const, bool const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* volatile &, void* volatile, int volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* volatile &, void* const volatile &, bool const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const volatile &, bool const &, int & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const volatile &, int const volatile, int & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const volatile &, void*, int >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const volatile &, void* &, bool & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const volatile &, void* volatile &, int >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const volatile &, int* const, int volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, bool const volatile &, bool & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int const volatile &, bool const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, void* &, int const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int*, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, int, bool & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, double const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, int* const &, bool const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* volatile, bool, bool const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* volatile, int const, bool >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* volatile, int const, int const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* volatile, int volatile, int const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* volatile, double const &, int volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* volatile, int* const, bool const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* volatile, int* const &, int const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const volatile, int const volatile &, bool volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const volatile, double, bool volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const volatile, double const, bool volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const volatile, double const volatile, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const volatile, int* &, int >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const volatile, int* &, int & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, bool const, bool const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, int, int const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, int volatile, int >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, int const &, bool >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, int const volatile &, int const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, double const, bool const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, double const volatile, bool & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, double const &, int const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, void* volatile, bool volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, void* &, int >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, int*, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, int* volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, int* volatile, int const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, int* const volatile, int const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, bool, bool const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, bool const volatile &, bool const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int const volatile &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, double & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, void*, int >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int* volatile &, int volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* volatile &, int, bool const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* volatile &, int volatile, bool >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* volatile &, int &, bool const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* volatile &, int const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* volatile &, double, bool const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* volatile &, double const, int volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* volatile &, void* const, bool volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const volatile &, double volatile, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const volatile &, double &, bool const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const volatile &, double volatile &, bool const volatile >::value), 0);
 
+}
 
 TT_TEST_BEGIN(BOOST_TT_TRAIT_NAME)
- run1();
- run2();
+ common();
    specific();
 TT_TEST_END

Modified: sandbox/type_traits/libs/type_traits/test/can_call_bitwise_and_test.cpp
==============================================================================
--- sandbox/type_traits/libs/type_traits/test/can_call_bitwise_and_test.cpp (original)
+++ sandbox/type_traits/libs/type_traits/test/can_call_bitwise_and_test.cpp 2011-07-09 16:29:47 EDT (Sat, 09 Jul 2011)
@@ -15,19 +15,264 @@
 #define BOOST_TT_TRAIT_NAME can_call_bitwise_and
 #define BOOST_TT_TRAIT_OP &
 
+
 #include "can_call_binary_operators.hpp"
-#include "can_call_integral_test.hpp"
 
-namespace {
 void specific() {
- /* nothing specific */
-}
-}
-
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const volatile, void, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int volatile, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int const volatile, int >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, double const, bool const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, double volatile, int volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, double const volatile, bool const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, void* >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int* const &, bool >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int const volatile, bool & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, double const volatile, bool >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int* &, bool volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool volatile, bool &, bool volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool volatile, int const, int volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool volatile, int &, bool const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool volatile, double, int const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool volatile, void* volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const volatile, int &, bool >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const volatile, int const volatile &, int & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const volatile, double &, bool const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const volatile, void* const, bool volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const volatile, void* & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const volatile, int*, bool volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const volatile, int* volatile &, bool volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, void*, bool const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, void* const, bool const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, void* volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, int const, bool const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, int const volatile, bool const & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, double const volatile &, int const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool volatile &, bool volatile, int const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool volatile &, int &, bool >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool volatile &, double const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool volatile &, double const volatile &, int const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool volatile &, void* const volatile, int & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool volatile &, int* const &, bool & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool volatile &, int* const &, int const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool volatile &, int* volatile &, int const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const volatile &, int volatile, int const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const volatile &, int const volatile, bool const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const volatile &, int &, bool volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const volatile &, double const volatile, int const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const volatile &, double volatile &, int volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const volatile &, void* &, int const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const volatile &, void* &, int volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const volatile &, int* &, bool volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const volatile &, int* volatile &, int const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool const &, int & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, int, bool const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, void* const volatile, int const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int, bool const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int const &, int const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int* const volatile &, bool >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int* const volatile &, int const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int volatile, int const, bool >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int volatile, int volatile, bool & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int volatile, int const &, bool volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int volatile, void* &, int & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int volatile, int*, int const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int volatile, int* volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int volatile, int* const volatile, bool const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const volatile, bool const volatile, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const volatile, bool volatile &, bool volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const volatile, void* const volatile, int const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const volatile, int* &, bool >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const volatile, int* volatile &, bool const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const volatile, int* const volatile &, int const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, int, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, int volatile &, bool & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, double const &, bool const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, double volatile &, int volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, int* volatile, bool const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, bool & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, bool const &, int const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, bool const &, int const & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int const, bool const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int const volatile, int >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int const & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int const volatile &, int >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, double const volatile, int volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, double const &, int volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, double const volatile &, bool const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, void* >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, void* const, int >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, void* volatile, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, void* const volatile, bool & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int* const, bool const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int* volatile, int const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int* &, int const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int volatile &, bool, bool const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int volatile &, int volatile, bool const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int volatile &, int const &, bool const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int volatile &, void* const volatile &, bool >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int volatile &, int*, int const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const volatile &, bool const, int & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const volatile &, bool volatile &, bool volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const volatile &, int volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const volatile &, double &, int & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const volatile &, void* const, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const volatile &, void* const &, bool const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const volatile &, void* const &, int & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const volatile &, int* volatile, bool volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const volatile &, int* volatile, int volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const volatile &, int* const volatile, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, bool volatile, int const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, bool const volatile, bool const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, int const, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, int const volatile, int const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, int const &, int const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, double, int >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, void*, int const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, void* &, bool const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, int volatile, int const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, double &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, double &, bool & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, void* volatile, int const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double volatile, bool const volatile &, int volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double volatile, double volatile, bool const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double volatile, int* const volatile, bool const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double volatile, int* volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const volatile, bool volatile, bool volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const volatile, bool volatile &, int const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const volatile, int const &, int const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const volatile, double const volatile, bool const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const volatile, int*, bool volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const volatile, int* const volatile &, bool volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, bool const &, int const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, void* const, bool const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, int* const &, int const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, int* const volatile &, int volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, bool const, int const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, double volatile, bool const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int* const &, int const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double volatile &, bool volatile, int const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double volatile &, bool const volatile &, bool & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double volatile &, int const, int const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double volatile &, int const volatile, bool >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double volatile &, double & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double volatile &, void* const volatile, int const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double volatile &, int* volatile, int volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double volatile &, int* volatile &, int >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const volatile &, bool volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const volatile &, int const volatile &, bool const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const volatile &, int const volatile &, int & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const volatile &, double const, int >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const volatile &, double const, int const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int &, bool const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int &, bool volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int &, int & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int const &, bool volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, double const &, int const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, void* volatile &, int const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int*, int volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int* volatile, int const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int* const volatile &, bool >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, bool &, bool const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, bool volatile &, int & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, int const &, bool >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, int const &, int const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, int volatile &, int volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, double const, int & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, void* const &, int const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, void* volatile &, int & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* volatile, bool, bool & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* volatile, bool const volatile &, bool const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* volatile, int const volatile, int >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* volatile, int const &, int volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* volatile, double const volatile, bool const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* volatile, double const volatile &, bool >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* volatile, void* const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* volatile, void* const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* volatile, int* volatile &, bool volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* volatile, int* volatile &, bool volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const volatile, bool volatile, bool >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const volatile, double const, int const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const volatile, void* const, int const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const volatile, void* & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const volatile, int* & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int volatile &, int const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int const volatile &, bool const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, double const, bool & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, bool const volatile, bool const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, double volatile &, int volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, void* const volatile &, int volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int* volatile, bool >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int* const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* volatile &, bool const &, int & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* volatile &, bool const volatile &, int const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* volatile &, int volatile, int & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* volatile &, double volatile &, int >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* volatile &, void* const, bool volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* volatile &, void* const, bool const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* volatile &, void* volatile, int volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* volatile &, void* const volatile &, bool const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const volatile &, bool const &, int & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const volatile &, int const volatile, int & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const volatile &, void*, int >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const volatile &, void* &, bool & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const volatile &, void* volatile &, int >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const volatile &, int* const, int volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, bool const volatile &, bool & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int const volatile &, bool const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, void* &, int const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int*, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, int, bool & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, double const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, int* const &, bool const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* volatile, bool, bool const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* volatile, int const, bool >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* volatile, int const, int const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* volatile, int volatile, int const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* volatile, double const &, int volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* volatile, int* const, bool const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* volatile, int* const &, int const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const volatile, int const volatile &, bool volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const volatile, double, bool volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const volatile, double const, bool volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const volatile, double const volatile, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const volatile, int* &, int >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const volatile, int* &, int & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, bool const, bool const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, int, int const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, int volatile, int >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, int const &, bool >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, int const volatile &, int const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, double const, bool const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, double const volatile, bool & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, double const &, int const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, void* volatile, bool volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, void* &, int >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, int*, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, int* volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, int* volatile, int const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, int* const volatile, int const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, bool, bool const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, bool const volatile &, bool const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int const volatile &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, double & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, void*, int >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int* volatile &, int volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* volatile &, int, bool const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* volatile &, int volatile, bool >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* volatile &, int &, bool const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* volatile &, int const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* volatile &, double, bool const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* volatile &, double const, int volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* volatile &, void* const, bool volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const volatile &, double volatile, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const volatile &, double &, bool const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const volatile &, double volatile &, bool const volatile >::value), 0);
 
+}
 
 TT_TEST_BEGIN(BOOST_TT_TRAIT_NAME)
- run1();
- run2();
+ common();
    specific();
 TT_TEST_END

Modified: sandbox/type_traits/libs/type_traits/test/can_call_bitwise_or_assignment_test.cpp
==============================================================================
--- sandbox/type_traits/libs/type_traits/test/can_call_bitwise_or_assignment_test.cpp (original)
+++ sandbox/type_traits/libs/type_traits/test/can_call_bitwise_or_assignment_test.cpp 2011-07-09 16:29:47 EDT (Sat, 09 Jul 2011)
@@ -15,19 +15,264 @@
 #define BOOST_TT_TRAIT_NAME can_call_bitwise_or_assignment
 #define BOOST_TT_TRAIT_OP |=
 
+
 #include "can_call_binary_operators.hpp"
-#include "can_call_integral_no_constlhs_test.hpp"
 
-namespace {
 void specific() {
- /* nothing specific */
-}
-}
-
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const volatile, void, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int volatile, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int const volatile, int >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, double const, bool const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, double volatile, int volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, double const volatile, bool const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, void* >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int* const &, bool >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int const volatile, bool & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, double const volatile, bool >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int* &, bool volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool volatile, bool &, bool volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool volatile, int const, int volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool volatile, int &, bool const volatile & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool volatile, double, int const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool volatile, void* volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const volatile, int &, bool >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const volatile, int const volatile &, int & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const volatile, double &, bool const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const volatile, void* const, bool volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const volatile, void* & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const volatile, int*, bool volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const volatile, int* volatile &, bool volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, void*, bool const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, void* const, bool const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, void* volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, int const, bool const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, int const volatile, bool const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, double const volatile &, int const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool volatile &, bool volatile, int const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool volatile &, int &, bool >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool volatile &, double const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool volatile &, double const volatile &, int const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool volatile &, void* const volatile, int & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool volatile &, int* const &, bool & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool volatile &, int* const &, int const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool volatile &, int* volatile &, int const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const volatile &, int volatile, int const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const volatile &, int const volatile, bool const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const volatile &, int &, bool volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const volatile &, double const volatile, int const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const volatile &, double volatile &, int volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const volatile &, void* &, int const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const volatile &, void* &, int volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const volatile &, int* &, bool volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const volatile &, int* volatile &, int const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool const &, int & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, int, bool const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, void* const volatile, int const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int, bool const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int const &, int const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int* const volatile &, bool >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int* const volatile &, int const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int volatile, int const, bool >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int volatile, int volatile, bool & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int volatile, int const &, bool volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int volatile, void* &, int & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int volatile, int*, int const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int volatile, int* volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int volatile, int* const volatile, bool const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const volatile, bool const volatile, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const volatile, bool volatile &, bool volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const volatile, void* const volatile, int const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const volatile, int* &, bool >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const volatile, int* volatile &, bool const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const volatile, int* const volatile &, int const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, int, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, int volatile &, bool & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, double const &, bool const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, double volatile &, int volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, int* volatile, bool const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, bool & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, bool const &, int const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, bool const &, int const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int const, bool const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int const volatile, int >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int const volatile &, int >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, double const volatile, int volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, double const &, int volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, double const volatile &, bool const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, void* >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, void* const, int >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, void* volatile, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, void* const volatile, bool & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int* const, bool const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int* volatile, int const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int* &, int const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int volatile &, bool, bool const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int volatile &, int volatile, bool const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int volatile &, int const &, bool const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int volatile &, void* const volatile &, bool >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int volatile &, int*, int const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const volatile &, bool const, int & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const volatile &, bool volatile &, bool volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const volatile &, int volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const volatile &, double &, int & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const volatile &, void* const, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const volatile &, void* const &, bool const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const volatile &, void* const &, int & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const volatile &, int* volatile, bool volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const volatile &, int* volatile, int volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const volatile &, int* const volatile, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, bool volatile, int const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, bool const volatile, bool const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, int const, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, int const volatile, int const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, int const &, int const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, double, int >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, void*, int const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, void* &, bool const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, int volatile, int const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, double &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, double &, bool & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, void* volatile, int const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double volatile, bool const volatile &, int volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double volatile, double volatile, bool const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double volatile, int* const volatile, bool const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double volatile, int* volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const volatile, bool volatile, bool volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const volatile, bool volatile &, int const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const volatile, int const &, int const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const volatile, double const volatile, bool const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const volatile, int*, bool volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const volatile, int* const volatile &, bool volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, bool const &, int const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, void* const, bool const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, int* const &, int const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, int* const volatile &, int volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, bool const, int const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, double volatile, bool const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int* const &, int const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double volatile &, bool volatile, int const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double volatile &, bool const volatile &, bool & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double volatile &, int const, int const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double volatile &, int const volatile, bool >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double volatile &, double & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double volatile &, void* const volatile, int const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double volatile &, int* volatile, int volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double volatile &, int* volatile &, int >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const volatile &, bool volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const volatile &, int const volatile &, bool const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const volatile &, int const volatile &, int & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const volatile &, double const, int >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const volatile &, double const, int const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int &, bool const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int &, bool volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int &, int & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int const &, bool volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, double const &, int const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, void* volatile &, int const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int*, int volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int* volatile, int const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int* const volatile &, bool >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, bool &, bool const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, bool volatile &, int & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, int const &, bool >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, int const &, int const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, int volatile &, int volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, double const, int & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, void* const &, int const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, void* volatile &, int & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* volatile, bool, bool & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* volatile, bool const volatile &, bool const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* volatile, int const volatile, int >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* volatile, int const &, int volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* volatile, double const volatile, bool const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* volatile, double const volatile &, bool >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* volatile, void* const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* volatile, void* const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* volatile, int* volatile &, bool volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* volatile, int* volatile &, bool volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const volatile, bool volatile, bool >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const volatile, double const, int const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const volatile, void* const, int const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const volatile, void* & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const volatile, int* & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int volatile &, int const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int const volatile &, bool const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, double const, bool & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, bool const volatile, bool const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, double volatile &, int volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, void* const volatile &, int volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int* volatile, bool >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int* const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* volatile &, bool const &, int & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* volatile &, bool const volatile &, int const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* volatile &, int volatile, int & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* volatile &, double volatile &, int >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* volatile &, void* const, bool volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* volatile &, void* const, bool const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* volatile &, void* volatile, int volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* volatile &, void* const volatile &, bool const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const volatile &, bool const &, int & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const volatile &, int const volatile, int & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const volatile &, void*, int >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const volatile &, void* &, bool & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const volatile &, void* volatile &, int >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const volatile &, int* const, int volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, bool const volatile &, bool & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int const volatile &, bool const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, void* &, int const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int*, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, int, bool & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, double const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, int* const &, bool const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* volatile, bool, bool const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* volatile, int const, bool >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* volatile, int const, int const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* volatile, int volatile, int const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* volatile, double const &, int volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* volatile, int* const, bool const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* volatile, int* const &, int const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const volatile, int const volatile &, bool volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const volatile, double, bool volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const volatile, double const, bool volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const volatile, double const volatile, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const volatile, int* &, int >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const volatile, int* &, int & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, bool const, bool const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, int, int const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, int volatile, int >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, int const &, bool >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, int const volatile &, int const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, double const, bool const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, double const volatile, bool & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, double const &, int const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, void* volatile, bool volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, void* &, int >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, int*, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, int* volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, int* volatile, int const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, int* const volatile, int const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, bool, bool const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, bool const volatile &, bool const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int const volatile &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, double & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, void*, int >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int* volatile &, int volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* volatile &, int, bool const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* volatile &, int volatile, bool >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* volatile &, int &, bool const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* volatile &, int const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* volatile &, double, bool const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* volatile &, double const, int volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* volatile &, void* const, bool volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const volatile &, double volatile, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const volatile &, double &, bool const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const volatile &, double volatile &, bool const volatile >::value), 0);
 
+}
 
 TT_TEST_BEGIN(BOOST_TT_TRAIT_NAME)
- run1();
- run2();
+ common();
    specific();
 TT_TEST_END

Modified: sandbox/type_traits/libs/type_traits/test/can_call_bitwise_or_test.cpp
==============================================================================
--- sandbox/type_traits/libs/type_traits/test/can_call_bitwise_or_test.cpp (original)
+++ sandbox/type_traits/libs/type_traits/test/can_call_bitwise_or_test.cpp 2011-07-09 16:29:47 EDT (Sat, 09 Jul 2011)
@@ -15,19 +15,264 @@
 #define BOOST_TT_TRAIT_NAME can_call_bitwise_or
 #define BOOST_TT_TRAIT_OP |
 
+
 #include "can_call_binary_operators.hpp"
-#include "can_call_integral_test.hpp"
 
-namespace {
 void specific() {
- /* nothing specific */
-}
-}
-
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const volatile, void, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int volatile, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int const volatile, int >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, double const, bool const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, double volatile, int volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, double const volatile, bool const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, void* >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int* const &, bool >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int const volatile, bool & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, double const volatile, bool >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int* &, bool volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool volatile, bool &, bool volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool volatile, int const, int volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool volatile, int &, bool const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool volatile, double, int const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool volatile, void* volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const volatile, int &, bool >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const volatile, int const volatile &, int & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const volatile, double &, bool const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const volatile, void* const, bool volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const volatile, void* & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const volatile, int*, bool volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const volatile, int* volatile &, bool volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, void*, bool const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, void* const, bool const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, void* volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, int const, bool const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, int const volatile, bool const & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, double const volatile &, int const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool volatile &, bool volatile, int const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool volatile &, int &, bool >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool volatile &, double const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool volatile &, double const volatile &, int const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool volatile &, void* const volatile, int & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool volatile &, int* const &, bool & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool volatile &, int* const &, int const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool volatile &, int* volatile &, int const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const volatile &, int volatile, int const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const volatile &, int const volatile, bool const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const volatile &, int &, bool volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const volatile &, double const volatile, int const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const volatile &, double volatile &, int volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const volatile &, void* &, int const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const volatile &, void* &, int volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const volatile &, int* &, bool volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const volatile &, int* volatile &, int const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool const &, int & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, int, bool const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, void* const volatile, int const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int, bool const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int const &, int const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int* const volatile &, bool >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int* const volatile &, int const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int volatile, int const, bool >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int volatile, int volatile, bool & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int volatile, int const &, bool volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int volatile, void* &, int & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int volatile, int*, int const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int volatile, int* volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int volatile, int* const volatile, bool const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const volatile, bool const volatile, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const volatile, bool volatile &, bool volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const volatile, void* const volatile, int const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const volatile, int* &, bool >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const volatile, int* volatile &, bool const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const volatile, int* const volatile &, int const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, int, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, int volatile &, bool & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, double const &, bool const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, double volatile &, int volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, int* volatile, bool const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, bool & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, bool const &, int const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, bool const &, int const & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int const, bool const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int const volatile, int >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int const & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int const volatile &, int >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, double const volatile, int volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, double const &, int volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, double const volatile &, bool const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, void* >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, void* const, int >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, void* volatile, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, void* const volatile, bool & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int* const, bool const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int* volatile, int const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int* &, int const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int volatile &, bool, bool const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int volatile &, int volatile, bool const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int volatile &, int const &, bool const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int volatile &, void* const volatile &, bool >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int volatile &, int*, int const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const volatile &, bool const, int & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const volatile &, bool volatile &, bool volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const volatile &, int volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const volatile &, double &, int & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const volatile &, void* const, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const volatile &, void* const &, bool const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const volatile &, void* const &, int & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const volatile &, int* volatile, bool volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const volatile &, int* volatile, int volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const volatile &, int* const volatile, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, bool volatile, int const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, bool const volatile, bool const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, int const, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, int const volatile, int const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, int const &, int const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, double, int >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, void*, int const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, void* &, bool const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, int volatile, int const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, double &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, double &, bool & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, void* volatile, int const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double volatile, bool const volatile &, int volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double volatile, double volatile, bool const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double volatile, int* const volatile, bool const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double volatile, int* volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const volatile, bool volatile, bool volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const volatile, bool volatile &, int const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const volatile, int const &, int const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const volatile, double const volatile, bool const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const volatile, int*, bool volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const volatile, int* const volatile &, bool volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, bool const &, int const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, void* const, bool const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, int* const &, int const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, int* const volatile &, int volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, bool const, int const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, double volatile, bool const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int* const &, int const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double volatile &, bool volatile, int const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double volatile &, bool const volatile &, bool & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double volatile &, int const, int const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double volatile &, int const volatile, bool >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double volatile &, double & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double volatile &, void* const volatile, int const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double volatile &, int* volatile, int volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double volatile &, int* volatile &, int >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const volatile &, bool volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const volatile &, int const volatile &, bool const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const volatile &, int const volatile &, int & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const volatile &, double const, int >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const volatile &, double const, int const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int &, bool const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int &, bool volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int &, int & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int const &, bool volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, double const &, int const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, void* volatile &, int const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int*, int volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int* volatile, int const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int* const volatile &, bool >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, bool &, bool const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, bool volatile &, int & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, int const &, bool >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, int const &, int const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, int volatile &, int volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, double const, int & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, void* const &, int const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, void* volatile &, int & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* volatile, bool, bool & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* volatile, bool const volatile &, bool const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* volatile, int const volatile, int >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* volatile, int const &, int volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* volatile, double const volatile, bool const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* volatile, double const volatile &, bool >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* volatile, void* const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* volatile, void* const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* volatile, int* volatile &, bool volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* volatile, int* volatile &, bool volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const volatile, bool volatile, bool >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const volatile, double const, int const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const volatile, void* const, int const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const volatile, void* & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const volatile, int* & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int volatile &, int const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int const volatile &, bool const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, double const, bool & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, bool const volatile, bool const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, double volatile &, int volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, void* const volatile &, int volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int* volatile, bool >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int* const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* volatile &, bool const &, int & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* volatile &, bool const volatile &, int const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* volatile &, int volatile, int & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* volatile &, double volatile &, int >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* volatile &, void* const, bool volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* volatile &, void* const, bool const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* volatile &, void* volatile, int volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* volatile &, void* const volatile &, bool const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const volatile &, bool const &, int & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const volatile &, int const volatile, int & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const volatile &, void*, int >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const volatile &, void* &, bool & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const volatile &, void* volatile &, int >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const volatile &, int* const, int volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, bool const volatile &, bool & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int const volatile &, bool const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, void* &, int const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int*, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, int, bool & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, double const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, int* const &, bool const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* volatile, bool, bool const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* volatile, int const, bool >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* volatile, int const, int const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* volatile, int volatile, int const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* volatile, double const &, int volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* volatile, int* const, bool const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* volatile, int* const &, int const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const volatile, int const volatile &, bool volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const volatile, double, bool volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const volatile, double const, bool volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const volatile, double const volatile, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const volatile, int* &, int >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const volatile, int* &, int & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, bool const, bool const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, int, int const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, int volatile, int >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, int const &, bool >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, int const volatile &, int const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, double const, bool const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, double const volatile, bool & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, double const &, int const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, void* volatile, bool volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, void* &, int >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, int*, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, int* volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, int* volatile, int const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, int* const volatile, int const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, bool, bool const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, bool const volatile &, bool const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int const volatile &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, double & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, void*, int >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int* volatile &, int volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* volatile &, int, bool const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* volatile &, int volatile, bool >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* volatile &, int &, bool const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* volatile &, int const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* volatile &, double, bool const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* volatile &, double const, int volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* volatile &, void* const, bool volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const volatile &, double volatile, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const volatile &, double &, bool const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const volatile &, double volatile &, bool const volatile >::value), 0);
 
+}
 
 TT_TEST_BEGIN(BOOST_TT_TRAIT_NAME)
- run1();
- run2();
+ common();
    specific();
 TT_TEST_END

Modified: sandbox/type_traits/libs/type_traits/test/can_call_bitwise_xor_assignment_test.cpp
==============================================================================
--- sandbox/type_traits/libs/type_traits/test/can_call_bitwise_xor_assignment_test.cpp (original)
+++ sandbox/type_traits/libs/type_traits/test/can_call_bitwise_xor_assignment_test.cpp 2011-07-09 16:29:47 EDT (Sat, 09 Jul 2011)
@@ -15,19 +15,264 @@
 #define BOOST_TT_TRAIT_NAME can_call_bitwise_xor_assignment
 #define BOOST_TT_TRAIT_OP ^=
 
+
 #include "can_call_binary_operators.hpp"
-#include "can_call_integral_no_constlhs_test.hpp"
 
-namespace {
 void specific() {
- /* nothing specific */
-}
-}
-
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int &, bool volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int const &, bool const volatile & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int volatile &, bool volatile & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int const volatile &, bool const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, double const, int & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, double volatile &, bool volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, void* >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, void* const, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, bool &, bool & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, bool const &, int & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int const, int & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, double, int const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, double volatile &, int volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, void* const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool volatile, bool, bool const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool volatile, bool volatile, bool volatile & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool volatile, int const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool volatile, double const volatile, int volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool volatile, void*, bool const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool volatile, void* const, bool volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool volatile, void* const volatile &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const volatile, bool volatile, bool & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const volatile, double volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const volatile, double &, int & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const volatile, double &, int volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const volatile, void* const volatile, int volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const volatile, void* const volatile &, bool >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const volatile, int*, int & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, bool const volatile &, bool const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int, int volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int const, bool const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, int &, bool & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, void* const volatile, bool const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, int, int >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, double, bool const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, double const volatile, int const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, double &, bool volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, void*, bool const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, int* volatile &, int >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool volatile &, bool volatile, int const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool volatile &, bool volatile, int volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool volatile &, bool volatile &, int >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool volatile &, void* const, int & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const volatile &, bool volatile &, bool const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const volatile &, bool const volatile &, bool volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const volatile &, int &, int volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const volatile &, int const &, bool const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const volatile &, double const &, bool volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const volatile &, void*, int const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const volatile &, int*, bool volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool volatile &, int volatile & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool const volatile &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, int const volatile, int volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, int*, int >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, int* &, int volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, bool const volatile &, int >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int volatile &, bool volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int* const volatile &, bool const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int volatile, bool const volatile &, int >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int volatile, int volatile, int volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int volatile, int const volatile, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int volatile, int &, bool >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int volatile, double &, int const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int volatile, int* const volatile, int const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const volatile, bool &, int >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const volatile, int const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const volatile, double volatile, int >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const volatile, double volatile, int volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const volatile, void* volatile, bool const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const volatile, void* &, bool const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const volatile, int* volatile, int >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, bool const volatile, bool const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, int, int & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, int const, bool >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, int const volatile, int const volatile & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, int const volatile &, int const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, double, int & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, double const, int const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, double volatile, bool volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, double &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, void* volatile, int >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, void* volatile, int const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, void* &, bool volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, void* volatile &, bool >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, void* volatile &, int volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, int* volatile &, bool const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int const, bool const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int volatile, bool >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, double volatile, int volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, double const volatile, bool const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, void* const volatile &, bool volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int volatile &, bool const volatile &, bool const & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int volatile &, int volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int volatile &, void* volatile &, int volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int volatile &, int* &, int >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int volatile &, int* const volatile &, int & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const volatile &, bool volatile, int volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const volatile &, int const &, bool const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const volatile &, int volatile &, int const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const volatile &, void* const, int volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const volatile &, void* const volatile &, bool const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const volatile &, void* const volatile &, int volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const volatile &, int* &, int volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const volatile &, int* const &, bool >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const volatile &, int* volatile &, bool & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const volatile &, int* volatile &, bool const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, bool, bool volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, bool volatile, int volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, int const, int const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, void* const volatile &, bool const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, int*, int volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, int* const &, int & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, bool volatile, bool const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, bool &, int volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, bool volatile &, int const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, int &, int const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, void* volatile, bool volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, void* const volatile, int >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const volatile, bool volatile, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const volatile, bool volatile, int const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const volatile, bool const volatile, bool const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const volatile, bool volatile &, bool & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const volatile, bool const volatile &, int const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const volatile, int, bool volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const volatile, int volatile, int const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const volatile, double const, bool volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const volatile, double volatile, bool const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const volatile, double &, bool >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const volatile, void* volatile &, bool const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const volatile, int* &, int volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, bool volatile, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, double const volatile &, bool volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, void* volatile &, bool const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, void* volatile &, bool volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, int* const volatile &, int >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int const, int const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int const, int const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, double, bool volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, double, bool const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, double const volatile &, bool & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double volatile &, int &, int const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double volatile &, double const &, bool const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double volatile &, int*, int const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const volatile &, bool const volatile, bool const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const volatile &, bool &, bool volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const volatile &, bool volatile &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const volatile &, bool const volatile &, bool & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const volatile &, int, bool const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const volatile &, int const volatile &, bool volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const volatile &, double const &, bool >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const volatile &, int* const, bool volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const volatile &, int* &, int const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const volatile &, int* const &, bool volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const volatile &, int* volatile &, int & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, bool &, bool volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, bool const volatile &, bool >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, double &, bool const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, double &, bool volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int* volatile &, bool const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, bool const volatile, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, int, int & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, int volatile, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, double const, int const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, double const &, int volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, void* const, bool const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, void* const &, bool const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, int* const volatile &, bool volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* volatile, bool &, int volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* volatile, int &, bool & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* volatile, int const &, int volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* volatile, double, bool volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* volatile, double, int >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* volatile, double const volatile, int const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* volatile, void* volatile, bool const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const volatile, int, int >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const volatile, int const volatile &, bool const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const volatile, double const &, int & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const volatile, int*, bool & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const volatile, int* &, int volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const volatile, int* const &, bool >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const volatile, int* const volatile &, bool & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, bool, int const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, bool const volatile &, int volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, bool const volatile &, int & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int const &, int const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, double const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, double &, bool const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, void* const volatile, int const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int* const, int const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int* volatile, int const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, bool const volatile, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, bool &, bool const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, bool volatile &, int & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, double, int volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, double const &, int const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* volatile &, bool volatile, int & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* volatile &, int const volatile &, int const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* volatile &, int*, bool >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* volatile &, int* const, int const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* volatile &, int* volatile, bool const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const volatile &, int const volatile, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const volatile &, double const volatile, int const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const volatile &, int* const, int >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, bool volatile, int const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int, int const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int const, bool const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, double >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, double const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, double const volatile, bool volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, void* const, int const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, void* &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, void* volatile &, int volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int* const &, int const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int* volatile &, int const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, int &, int const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, void* volatile, bool const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, void* const volatile, bool const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, void* const &, bool volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* volatile, bool &, bool const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* volatile, int volatile &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* volatile, int* volatile, int >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const volatile, bool &, int volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const volatile, int* const, int const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const volatile, int* const volatile, int volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const volatile, int* &, int const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, bool const, bool const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, bool &, bool volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, bool const &, bool const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, bool const volatile &, int volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, int const volatile, bool volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, void*, int const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, void* volatile, bool & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, int* const &, bool volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, bool &, int const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, bool volatile &, bool volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int &, int volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, double volatile, bool >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int* const volatile &, int & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* volatile &, bool const, int >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* volatile &, int const &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* volatile &, double const &, bool const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* volatile &, void* const &, int const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* volatile &, int* const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const volatile &, int const volatile, bool const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const volatile &, double volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const volatile &, void* volatile, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const volatile &, void* const &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const volatile &, int* const volatile &, bool volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const volatile &, int* const volatile &, int const volatile & >::value), 0);
 
+}
 
 TT_TEST_BEGIN(BOOST_TT_TRAIT_NAME)
- run1();
- run2();
+ common();
    specific();
 TT_TEST_END

Modified: sandbox/type_traits/libs/type_traits/test/can_call_bitwise_xor_test.cpp
==============================================================================
--- sandbox/type_traits/libs/type_traits/test/can_call_bitwise_xor_test.cpp (original)
+++ sandbox/type_traits/libs/type_traits/test/can_call_bitwise_xor_test.cpp 2011-07-09 16:29:47 EDT (Sat, 09 Jul 2011)
@@ -15,19 +15,264 @@
 #define BOOST_TT_TRAIT_NAME can_call_bitwise_xor
 #define BOOST_TT_TRAIT_OP ^
 
+
 #include "can_call_binary_operators.hpp"
-#include "can_call_integral_test.hpp"
 
-namespace {
 void specific() {
- /* nothing specific */
-}
-}
-
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const volatile, void, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int volatile, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int const volatile, int >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, double const, bool const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, double volatile, int volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, double const volatile, bool const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, void* >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool, int* const &, bool >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int const volatile, bool & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, double const volatile, bool >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const, int* &, bool volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool volatile, bool &, bool volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool volatile, int const, int volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool volatile, int &, bool const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool volatile, double, int const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool volatile, void* volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const volatile, int &, bool >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const volatile, int const volatile &, int & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const volatile, double &, bool const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const volatile, void* const, bool volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const volatile, void* & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const volatile, int*, bool volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const volatile, int* volatile &, bool volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, void*, bool const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, void* const, bool const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool &, void* volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, int const, bool const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, int const volatile, bool const & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const &, double const volatile &, int const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool volatile &, bool volatile, int const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool volatile &, int &, bool >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool volatile &, double const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool volatile &, double const volatile &, int const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool volatile &, void* const volatile, int & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool volatile &, int* const &, bool & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool volatile &, int* const &, int const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool volatile &, int* volatile &, int const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const volatile &, int volatile, int const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const volatile &, int const volatile, bool const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const volatile &, int &, bool volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const volatile &, double const volatile, int const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const volatile &, double volatile &, int volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const volatile &, void* &, int const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const volatile &, void* &, int volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const volatile &, int* &, bool volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< bool const volatile &, int* volatile &, int const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, bool const &, int & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, int, bool const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int, void* const volatile, int const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int, bool const >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int const &, int const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int* const volatile &, bool >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const, int* const volatile &, int const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int volatile, int const, bool >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int volatile, int volatile, bool & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int volatile, int const &, bool volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int volatile, void* &, int & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int volatile, int*, int const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int volatile, int* volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int volatile, int* const volatile, bool const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const volatile, bool const volatile, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const volatile, bool volatile &, bool volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const volatile, void* const volatile, int const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const volatile, int* &, bool >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const volatile, int* volatile &, bool const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const volatile, int* const volatile &, int const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, int, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, int volatile &, bool & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, double const &, bool const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, double volatile &, int volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int &, int* volatile, bool const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, bool & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, bool const &, int const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, bool const &, int const & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int const, bool const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int const volatile, int >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int const & >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int const volatile &, int >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, double const volatile, int volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, double const &, int volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, double const volatile &, bool const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, void* >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, void* const, int >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, void* volatile, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, void* const volatile, bool & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int* const, bool const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int* volatile, int const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const &, int* &, int const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int volatile &, bool, bool const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int volatile &, int volatile, bool const volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int volatile &, int const &, bool const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int volatile &, void* const volatile &, bool >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int volatile &, int*, int const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const volatile &, bool const, int & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const volatile &, bool volatile &, bool volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const volatile &, int volatile >::value), 1);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const volatile &, double &, int & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const volatile &, void* const, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const volatile &, void* const &, bool const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const volatile &, void* const &, int & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const volatile &, int* volatile, bool volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const volatile &, int* volatile, int volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int const volatile &, int* const volatile, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, bool volatile, int const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, bool const volatile, bool const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, int const, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, int const volatile, int const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, int const &, int const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, double, int >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, void*, int const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double, void* &, bool const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, int volatile, int const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, double &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, double &, bool & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const, void* volatile, int const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double volatile, bool const volatile &, int volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double volatile, double volatile, bool const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double volatile, int* const volatile, bool const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double volatile, int* volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const volatile, bool volatile, bool volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const volatile, bool volatile &, int const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const volatile, int const &, int const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const volatile, double const volatile, bool const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const volatile, int*, bool volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const volatile, int* const volatile &, bool volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, bool const &, int const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, void* const, bool const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, int* const &, int const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double &, int* const volatile &, int volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, bool const, int const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, double volatile, bool const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const &, int* const &, int const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double volatile &, bool volatile, int const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double volatile &, bool const volatile &, bool & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double volatile &, int const, int const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double volatile &, int const volatile, bool >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double volatile &, double & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double volatile &, void* const volatile, int const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double volatile &, int* volatile, int volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double volatile &, int* volatile &, int >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const volatile &, bool volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const volatile &, int const volatile &, bool const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const volatile &, int const volatile &, int & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const volatile &, double const, int >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< double const volatile &, double const, int const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int &, bool const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int &, bool volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int &, int & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int const &, bool volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, double const &, int const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, void* volatile &, int const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int*, int volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int* volatile, int const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void*, int* const volatile &, bool >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, bool &, bool const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, bool volatile &, int & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, int const &, bool >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, int const &, int const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, int volatile &, int volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, double const, int & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, void* const &, int const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const, void* volatile &, int & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* volatile, bool, bool & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* volatile, bool const volatile &, bool const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* volatile, int const volatile, int >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* volatile, int const &, int volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* volatile, double const volatile, bool const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* volatile, double const volatile &, bool >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* volatile, void* const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* volatile, void* const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* volatile, int* volatile &, bool volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* volatile, int* volatile &, bool volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const volatile, bool volatile, bool >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const volatile, double const, int const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const volatile, void* const, int const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const volatile, void* & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const volatile, int* & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int volatile &, int const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, int const volatile &, bool const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* &, double const, bool & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, bool const volatile, bool const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, double volatile &, int volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, void* const volatile &, int volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int* volatile, bool >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const &, int* const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* volatile &, bool const &, int & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* volatile &, bool const volatile &, int const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* volatile &, int volatile, int & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* volatile &, double volatile &, int >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* volatile &, void* const, bool volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* volatile &, void* const, bool const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* volatile &, void* volatile, int volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* volatile &, void* const volatile &, bool const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const volatile &, bool const &, int & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const volatile &, int const volatile, int & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const volatile &, void*, int >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const volatile &, void* &, bool & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const volatile &, void* volatile &, int >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< void* const volatile &, int* const, int volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, bool const volatile &, bool & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int const volatile &, bool const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, void* &, int const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int*, int*, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, int, bool & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, double const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const, int* const &, bool const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* volatile, bool, bool const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* volatile, int const, bool >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* volatile, int const, int const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* volatile, int volatile, int const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* volatile, double const &, int volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* volatile, int* const, bool const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* volatile, int* const &, int const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const volatile, int const volatile &, bool volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const volatile, double, bool volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const volatile, double const, bool volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const volatile, double const volatile, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const volatile, int* &, int >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const volatile, int* &, int & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, bool const, bool const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, int, int const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, int volatile, int >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, int const &, bool >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, int const volatile &, int const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, double const, bool const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, double const volatile, bool & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, double const &, int const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, void* volatile, bool volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, void* &, int >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, int*, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, int* volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, int* volatile, int const volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* &, int* const volatile, int const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, bool, bool const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, bool const volatile &, bool const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int const volatile &, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, double & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, void*, int >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const &, int* volatile &, int volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* volatile &, int, bool const >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* volatile &, int volatile, bool >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* volatile &, int &, bool const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* volatile &, int const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* volatile &, double, bool const & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* volatile &, double const, int volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* volatile &, void* const, bool volatile & >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const volatile &, double volatile, void >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const volatile &, double &, bool const volatile >::value), 0);
+ BOOST_CHECK_INTEGRAL_CONSTANT((::boost::BOOST_TT_TRAIT_NAME< int* const volatile &, double volatile &, bool const volatile >::value), 0);
 
+}
 
 TT_TEST_BEGIN(BOOST_TT_TRAIT_NAME)
- run1();
- run2();
+ common();
    specific();
 TT_TEST_END

Deleted: sandbox/type_traits/libs/type_traits/test/can_call_comparison_test.hpp
==============================================================================
--- sandbox/type_traits/libs/type_traits/test/can_call_comparison_test.hpp 2011-07-09 16:29:47 EDT (Sat, 09 Jul 2011)
+++ (empty file)
@@ -1,1250 +0,0 @@
-// (C) Copyright Frederic Bron 2009-2011.
-// Use, modification and distribution are subject to the
-// Boost Software License, Version 1.0. (See accompanying file
-// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-namespace {
-
-void run2() {
- // test with only one template parameter
- TEST_T(void, false);
- TEST_T(bool, true);
- TEST_T(char, true);
- TEST_T(signed char, true);
- TEST_T(short int, true);
- TEST_T(int, true);
- TEST_T(long int, true);
- TEST_T(unsigned char, true);
- TEST_T(unsigned short int, true);
- TEST_T(unsigned int, true);
- TEST_T(unsigned long int, true);
- TEST_T(wchar_t, true);
- TEST_T(float, true);
- TEST_T(double, true);
- TEST_T(long double, true);
- TEST_T(void, false);
-# undef CV
-# define CV(T) const T
- TEST_T(CV(bool), true);
- TEST_T(CV(int), true);
- TEST_T(CV(double), true);
-# undef CV
-# define CV(T) volatile T
- TEST_T(CV(bool), true);
- TEST_T(CV(int), true);
- TEST_T(CV(double), true);
-# undef CV
-# define CV(T) const volatile T
- TEST_T(CV(bool), true);
- TEST_T(CV(int), true);
- TEST_T(CV(double), true);
-# undef CV
-# define CV(T) const T&
- TEST_T(CV(bool), true);
- TEST_T(CV(int), true);
- TEST_T(CV(double), true);
-# undef CV
-# define CV(T) volatile T&
- TEST_T(CV(bool), true);
- TEST_T(CV(int), true);
- TEST_T(CV(double), true);
-# undef CV
-# define CV(T) const volatile T&
- TEST_T(CV(bool), true);
- TEST_T(CV(int), true);
- TEST_T(CV(double), true);
-
- // test with only two template parameters
- TEST_TT(void, int, false);
- TEST_TT(int, void, false);
- TEST_TT(void, void, false);
- TEST_TT(bool, bool, true);
- TEST_TT(bool, char, true);
- TEST_TT(bool, signed char, true);
- TEST_TT(bool, short int, true);
- TEST_TT(bool, int, true);
- TEST_TT(bool, long int, true);
- TEST_TT(bool, unsigned char, true);
- TEST_TT(bool, unsigned short int, true);
- TEST_TT(bool, unsigned int, true);
- TEST_TT(bool, unsigned long int, true);
- TEST_TT(bool, wchar_t, true);
- TEST_TT(bool, float, true);
- TEST_TT(bool, double, true);
- TEST_TT(bool, long double, true);
- TEST_TT(char, bool, true);
- TEST_TT(char, char, true);
- TEST_TT(char, signed char, true);
- TEST_TT(char, short int, true);
- TEST_TT(char, int, true);
- TEST_TT(char, long int, true);
- TEST_TT(char, unsigned char, true);
- TEST_TT(char, unsigned short int, true);
- TEST_TT(char, unsigned int, true);
- TEST_TT(char, unsigned long int, true);
- TEST_TT(char, wchar_t, true);
- TEST_TT(char, float, true);
- TEST_TT(char, double, true);
- TEST_TT(char, long double, true);
- TEST_TT(signed char, bool, true);
- TEST_TT(signed char, char, true);
- TEST_TT(signed char, signed char, true);
- TEST_TT(signed char, short int, true);
- TEST_TT(signed char, int, true);
- TEST_TT(signed char, long int, true);
- TEST_TT(signed char, unsigned char, true);
- TEST_TT(signed char, unsigned short int, true);
- TEST_TT(signed char, unsigned int, true);
- TEST_TT(signed char, unsigned long int, true);
- TEST_TT(signed char, wchar_t, true);
- TEST_TT(signed char, float, true);
- TEST_TT(signed char, double, true);
- TEST_TT(signed char, long double, true);
- TEST_TT(short int, bool, true);
- TEST_TT(short int, char, true);
- TEST_TT(short int, signed char, true);
- TEST_TT(short int, short int, true);
- TEST_TT(short int, int, true);
- TEST_TT(short int, long int, true);
- TEST_TT(short int, unsigned char, true);
- TEST_TT(short int, unsigned short int, true);
- TEST_TT(short int, unsigned int, true);
- TEST_TT(short int, unsigned long int, true);
- TEST_TT(short int, wchar_t, true);
- TEST_TT(short int, float, true);
- TEST_TT(short int, double, true);
- TEST_TT(short int, long double, true);
- TEST_TT(int, bool, true);
- TEST_TT(int, char, true);
- TEST_TT(int, signed char, true);
- TEST_TT(int, short int, true);
- TEST_TT(int, int, true);
- TEST_TT(int, long int, true);
- TEST_TT(int, unsigned char, true);
- TEST_TT(int, unsigned short int, true);
- TEST_TT(int, unsigned int, true);
- TEST_TT(int, unsigned long int, true);
- TEST_TT(int, wchar_t, true);
- TEST_TT(int, float, true);
- TEST_TT(int, double, true);
- TEST_TT(int, long double, true);
- TEST_TT(long int, bool, true);
- TEST_TT(long int, char, true);
- TEST_TT(long int, signed char, true);
- TEST_TT(long int, short int, true);
- TEST_TT(long int, int, true);
- TEST_TT(long int, long int, true);
- TEST_TT(long int, unsigned char, true);
- TEST_TT(long int, unsigned short int, true);
- TEST_TT(long int, unsigned int, true);
- TEST_TT(long int, unsigned long int, true);
- TEST_TT(long int, wchar_t, true);
- TEST_TT(long int, float, true);
- TEST_TT(long int, double, true);
- TEST_TT(long int, long double, true);
- TEST_TT(unsigned char, bool, true);
- TEST_TT(unsigned char, char, true);
- TEST_TT(unsigned char, signed char, true);
- TEST_TT(unsigned char, short int, true);
- TEST_TT(unsigned char, int, true);
- TEST_TT(unsigned char, long int, true);
- TEST_TT(unsigned char, unsigned char, true);
- TEST_TT(unsigned char, unsigned short int, true);
- TEST_TT(unsigned char, unsigned int, true);
- TEST_TT(unsigned char, unsigned long int, true);
- TEST_TT(unsigned char, wchar_t, true);
- TEST_TT(unsigned char, float, true);
- TEST_TT(unsigned char, double, true);
- TEST_TT(unsigned char, long double, true);
- TEST_TT(unsigned short int, bool, true);
- TEST_TT(unsigned short int, char, true);
- TEST_TT(unsigned short int, signed char, true);
- TEST_TT(unsigned short int, short int, true);
- TEST_TT(unsigned short int, int, true);
- TEST_TT(unsigned short int, long int, true);
-