Boost logo

Boost-Commit :

Subject: [Boost-commit] svn:boost r73224 - sandbox/conversion/libs/conversion_ext/test
From: vicente.botet_at_[hidden]
Date: 2011-07-18 19:57:24


Author: viboes
Date: 2011-07-18 19:57:21 EDT (Mon, 18 Jul 2011)
New Revision: 73224
URL: http://svn.boost.org/trac/boost/changeset/73224

Log:
conversion: cleanup of ENBALE_CND
Text files modified:
   sandbox/conversion/libs/conversion_ext/test/array.cpp | 4 ---
   sandbox/conversion/libs/conversion_ext/test/chrono_posix_time_duration.cpp | 2 -
   sandbox/conversion/libs/conversion_ext/test/chrono_posix_time_time.cpp | 2 -
   sandbox/conversion/libs/conversion_ext/test/extrinsec.cpp | 27 +++++-----------------
   sandbox/conversion/libs/conversion_ext/test/helper.hpp | 3 --
   sandbox/conversion/libs/conversion_ext/test/intrinsec.cpp | 24 +------------------
   sandbox/conversion/libs/conversion_ext/test/optional.cpp | 10 --------
   sandbox/conversion/libs/conversion_ext/test/pair.cpp | 7 -----
   sandbox/conversion/libs/conversion_ext/test/rational.cpp | 2 -
   sandbox/conversion/libs/conversion_ext/test/string.cpp | 2 -
   sandbox/conversion/libs/conversion_ext/test/tuple.cpp | 6 -----
   sandbox/conversion/libs/conversion_ext/test/vector.cpp | 48 ----------------------------------------
   12 files changed, 8 insertions(+), 129 deletions(-)

Modified: sandbox/conversion/libs/conversion_ext/test/array.cpp
==============================================================================
--- sandbox/conversion/libs/conversion_ext/test/array.cpp (original)
+++ sandbox/conversion/libs/conversion_ext/test/array.cpp 2011-07-18 19:57:21 EDT (Mon, 18 Jul 2011)
@@ -15,23 +15,19 @@
 #include "helper.hpp"
 #include <boost/static_assert.hpp>
 
-#if defined(BOOST_CONVERSION_ENABLE_CND)
 BOOST_STATIC_ASSERT(( boost::is_assignable< int&, short const&>::value));
 BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_assignable< int, short >::value));
 BOOST_STATIC_ASSERT(( boost::is_assignable< short&, int const& >::value));
 BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_assignable< short, int >::value));
 BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_assignable< A1, B1 >::value));
 BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_assignable< boost::array<A1,3>, boost::array<B1,3> >::value));
-#endif
 
 using namespace boost;
 
 void explicit_convert_to() {
     boost::array<B1,3> bs;
     boost::array<A1,3> as;
-#if defined(BOOST_CONVERSION_ENABLE_CND)|| !defined(BOOST_NO_SFINAE_EXPR)
     as = boost::conversion::convert_to<boost::array<A1,3> >(bs);
-#endif
     as = boost::conversion::implicit_convert_to<boost::array<A1,3> >(bs);
 
 }

Modified: sandbox/conversion/libs/conversion_ext/test/chrono_posix_time_duration.cpp
==============================================================================
--- sandbox/conversion/libs/conversion_ext/test/chrono_posix_time_duration.cpp (original)
+++ sandbox/conversion/libs/conversion_ext/test/chrono_posix_time_duration.cpp 2011-07-18 19:57:21 EDT (Mon, 18 Jul 2011)
@@ -21,12 +21,10 @@
 
 void explicit_convert_to() {
     boost::chrono::seconds a(3);
-#if defined(BOOST_CONVERSION_ENABLE_CND)|| !defined(BOOST_NO_SFINAE_EXPR)
     {
       boost::posix_time::time_duration b(boost::conversion::convert_to<boost::posix_time::time_duration >(a));
       boost::chrono::seconds c(boost::conversion::convert_to<boost::chrono::seconds>(b));
     }
-#endif
     boost::posix_time::time_duration b(boost::conversion::implicit_convert_to<boost::posix_time::time_duration >(a));
     boost::chrono::seconds c(boost::conversion::implicit_convert_to<boost::chrono::seconds>(b));
 }

Modified: sandbox/conversion/libs/conversion_ext/test/chrono_posix_time_time.cpp
==============================================================================
--- sandbox/conversion/libs/conversion_ext/test/chrono_posix_time_time.cpp (original)
+++ sandbox/conversion/libs/conversion_ext/test/chrono_posix_time_time.cpp 2011-07-18 19:57:21 EDT (Mon, 18 Jul 2011)
@@ -20,12 +20,10 @@
 
 void explicit_convert_to() {
     chrono::system_clock::time_point a=chrono::system_clock::now();
-#if defined(BOOST_CONVERSION_ENABLE_CND) || !defined(BOOST_NO_SFINAE_EXPR)
     {
       posix_time::ptime b(boost::conversion::convert_to<posix_time::ptime >(a));
       chrono::system_clock::time_point c(boost::conversion::convert_to<chrono::system_clock::time_point>(b));
     }
-#endif
     posix_time::ptime b(boost::conversion::implicit_convert_to<posix_time::ptime >(a));
     chrono::system_clock::time_point c(boost::conversion::implicit_convert_to<chrono::system_clock::time_point>(b));
 

Modified: sandbox/conversion/libs/conversion_ext/test/extrinsec.cpp
==============================================================================
--- sandbox/conversion/libs/conversion_ext/test/extrinsec.cpp (original)
+++ sandbox/conversion/libs/conversion_ext/test/extrinsec.cpp 2011-07-18 19:57:21 EDT (Mon, 18 Jul 2011)
@@ -126,9 +126,7 @@
 
 BOOST_STATIC_ASSERT(( !boost::is_convertible< X,ICF_X >::value));
 BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_convertible< X,ICF_X >::value));
-#if defined(BOOST_CONVERSION_ENABLE_CND) || !defined(BOOST_NO_SFINAE_EXPR)
- BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_explicit_convertible< X,ICF_X >::value));
-#endif
+BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_explicit_convertible< X,ICF_X >::value));
 
 struct ECF_X {};
 BOOST_CONVERSION_DCL_DEFAULTS(ECF_X)
@@ -192,7 +190,6 @@
 }
 
 
-#if defined(BOOST_CONVERSION_ENABLE_CND)
   BOOST_STATIC_ASSERT(( !boost::conversion::is_extrinsically_convertible< X,AF_X >::value));
   BOOST_STATIC_ASSERT(( !boost::conversion::is_extrinsically_explicit_convertible< X,AF_X >::value));
   BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_convertible< X , ICF_X >::value));
@@ -200,7 +197,6 @@
   BOOST_STATIC_ASSERT(( boost::is_copy_assignable< ICF_X >::value));
   BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_assignable< ICF_X, X >::value));
 
-#endif
 
 //////////////////////////
 
@@ -211,11 +207,10 @@
       ICF_X y1(implicit_convert_to<ICF_X>(x));
       (void)y1;// remove warning: unused variable
 
-#if defined(BOOST_CONVERSION_ENABLE_CND) || !defined(BOOST_NO_SFINAE_EXPR)
       ICF_X y1_1(convert_to<ICF_X>(x));
       (void)y1_1;// remove warning: unused variable
-#endif
-#if defined(BOOST_CONVERSION_MCF_ENABLED)
+
+#if defined(BOOST_CONVERSION_IMPLICITLY_ENABLED)
       ICF_X y2(implicitly(x));
       (void)y2;// remove warning: unused variable
 #endif
@@ -250,21 +245,17 @@
       ICT_X y;
       X x1(implicit_convert_to<X>(y));
       (void)x1;// remove warning: unused variable
-#if defined(BOOST_CONVERSION_ENABLE_CND) || !defined(BOOST_NO_SFINAE_EXPR)
       X x1_1(convert_to<X>(y));
       (void)x1_1;// remove warning: unused variable
-#endif
-#if defined(BOOST_CONVERSION_MCF_ENABLED)
+#if defined(BOOST_CONVERSION_IMPLICITLY_ENABLED)
       X x2(implicitly(y));
       (void)x2;// remove warning: unused variable
 #endif
       X x3=implicit_convert_to<X>(y);
       (void)x3;// remove warning: unused variable
-#if defined(BOOST_CONVERSION_ENABLE_CND) || !defined(BOOST_NO_SFINAE_EXPR)
       X x3_1=convert_to<X>(y);
       (void)x3_1;// remove warning: unused variable
-#endif
-#if defined(BOOST_CONVERSION_MCF_ENABLED)
+#if defined(BOOST_CONVERSION_IMPLICITLY_ENABLED)
       X x4=implicitly(y);
       (void)x4;// remove warning: unused variable
 #endif
@@ -296,9 +287,6 @@
   }
 ////
 
-#if defined(BOOST_CONVERSION_ENABLE_CND) || !defined(BOOST_NO_SFINAE_EXPR)
-
-
 void explicit_convert_to() {
   using namespace boost::conversion;
     B b;
@@ -336,7 +324,7 @@
 void implicit_conversion_via_implicitly() {
   using namespace boost::conversion;
   C c;
-#if defined(BOOST_CONVERSION_MCF_ENABLED)
+#if defined(BOOST_CONVERSION_IMPLICITLY_ENABLED)
   f(implicitly(c));
 #endif
   f(convertible_to<B>(c));
@@ -351,7 +339,6 @@
   C c;
   h(c);
 }
-#endif
 
 int main( )
 {
@@ -360,7 +347,6 @@
   xconvert_to_with_implicit_conversion_operator();
   xconvert_to_with_explicit_conversion_operator();
   xassign_to_with_assignemet_operator();
-#if defined(BOOST_CONVERSION_ENABLE_CND) || !defined(BOOST_NO_SFINAE_EXPR)
   explicit_convert_to();
   explicit_assign_to();
   explicit_chain_assign_to();
@@ -368,7 +354,6 @@
   implicit_conversion_via_implicitly();
   implicit_conversion_via_convertible_to();
   implicit_conversion_via_sfinae();
-#endif
   return boost::report_errors();
 }
 

Modified: sandbox/conversion/libs/conversion_ext/test/helper.hpp
==============================================================================
--- sandbox/conversion/libs/conversion_ext/test/helper.hpp (original)
+++ sandbox/conversion/libs/conversion_ext/test/helper.hpp 2011-07-18 19:57:21 EDT (Mon, 18 Jul 2011)
@@ -99,13 +99,10 @@
     BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_convertible<B1, A1>::value));
     BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_convertible<B2, A2>::value));
 
-
- #if defined(BOOST_CONVERSION_ENABLE_CND)
     BOOST_STATIC_ASSERT(( !boost::is_assignable<A1, B1>::value));
     BOOST_STATIC_ASSERT(( !boost::is_assignable<A2, B2>::value));
     BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_assignable<A1, B1>::value));
     BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_assignable<A2, B2>::value));
- #endif
 
 
 #endif //BOOST_CONVERSION_TEST_HELPER__HPP

Modified: sandbox/conversion/libs/conversion_ext/test/intrinsec.cpp
==============================================================================
--- sandbox/conversion/libs/conversion_ext/test/intrinsec.cpp (original)
+++ sandbox/conversion/libs/conversion_ext/test/intrinsec.cpp 2011-07-18 19:57:21 EDT (Mon, 18 Jul 2011)
@@ -118,18 +118,12 @@
 #endif
 
 
-#if defined(BOOST_CONVERSION_ENABLE_CND)
 BOOST_STATIC_ASSERT(( ! boost::is_convertible< X,ECF_X >::value));
 BOOST_STATIC_ASSERT(( boost::is_explicitly_convertible< X,ECF_X >::value));
 BOOST_STATIC_ASSERT(( ! boost::conversion::is_extrinsically_convertible< X,ECF_X >::value));
 BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_explicit_convertible< X,ECF_X >::value));
-#endif
-
-
-#if defined(BOOST_CONVERSION_ENABLE_CND)
 BOOST_STATIC_ASSERT(( ! boost::is_explicitly_convertible< X,AF_X >::value));
 BOOST_STATIC_ASSERT(( ! boost::conversion::is_extrinsically_convertible< X,AF_X >::value));
-#endif
 
 //////////////////////////
 
@@ -173,11 +167,11 @@
     BOOST_CONVERSION_CONSTRUCT(ECF_X, y, x); // Maybe a macro !!!
     ECF_X y1_1(explicit_convert_to<ECF_X>(x));
     (void)y1_1; // WARNING removal
-#if defined(BOOST_CONVERSION_MCF_ENABLED)
+#if defined(BOOST_CONVERSION_IMPLICITLY_ENABLED)
     //ECF_X y1_2(implicitly(x)); // should fail as ambiguous: ECF_X(X) and ECF_X(ECF_X&const). fails only with gcc4.3. 0x
 #endif
 
-#if defined(BOOST_CONVERSION_MCF_ENABLED)
+#if defined(BOOST_CONVERSION_IMPLICITLY_ENABLED)
     //impl_cnv(implicitly(x)); // fail as x is not implicit convertible to ECF_X.
 #endif
     ECF_X y3 = explicit_convert_to<ECF_X>(x);
@@ -225,30 +219,24 @@
     //AF_X y1(x); // compile fails
     AF_X y2;
     y2=x;
-#if defined(BOOST_CONVERSION_ENABLE_CND)
     assign_to(y2,x);
     lvalue(y2)=x;
-#endif
   }
   {
     A a(0);
     AA aa(0);
     aa=a;
     }
-#if defined(BOOST_CONVERSION_ENABLE_CND)
     {
     A a(0);
     AA aa(0);
     assign_to(aa,a);
     }
-#endif
 }
 void mca_with_assignemet_operator() {
-#if defined(BOOST_CONVERSION_ENABLE_CND)
     A a(0);
     AA aa(0);
     mca(aa) =a;
-#endif
 }
 
 void assign_to_with_assignemet_operator_and_implicit_constructor() {
@@ -257,21 +245,17 @@
     AA aa(1);
     aa=b;
     }
-#if defined(BOOST_CONVERSION_ENABLE_CND)
     {
     B b;
     AA aa(1);
     mca(aa)=b;
     assign_to(aa,b);
     }
-#endif
 }
 void mca_with_assignemet_operator_and_implicit_constructor() {
-#if defined(BOOST_CONVERSION_ENABLE_CND)
     B b;
     AA aa(1);
     mca(aa)=b;
-#endif
 }
 
 void assign_to_with_assignemet_operator_and_conversion_operator() {
@@ -280,22 +264,18 @@
     CC cc(1);
     cc=c;
     }
-#if defined(BOOST_CONVERSION_ENABLE_CND)
     {
     C c;
     CC cc(1);
     mca(cc)=c;
     //assign_to(cc,c);
     }
-#endif
 }
 
 void mca_with_assignemet_operator_and_conversion_operator() {
-#if defined(BOOST_CONVERSION_ENABLE_CND)
     C c;
     CC cc(1);
     mca(cc)=c;
-#endif
 }
 
 

Modified: sandbox/conversion/libs/conversion_ext/test/optional.cpp
==============================================================================
--- sandbox/conversion/libs/conversion_ext/test/optional.cpp (original)
+++ sandbox/conversion/libs/conversion_ext/test/optional.cpp 2011-07-18 19:57:21 EDT (Mon, 18 Jul 2011)
@@ -68,24 +68,20 @@
   {
     B1 b1;
     boost::optional<B1> b=b1;
-#if defined(BOOST_CONVERSION_ENABLE_CND) || !defined(BOOST_NO_SFINAE_EXPR)
     {
       boost::optional<A1> a(boost::conversion::convert_to<boost::optional<A1> >(b));
       BOOST_TEST(a);
     }
-#endif
     boost::optional<A1> a(boost::conversion::implicit_convert_to<boost::optional<A1> >(b));
     BOOST_TEST(a);
   }
 
   {
     B1 b1;
-#if defined(BOOST_CONVERSION_ENABLE_CND) || !defined(BOOST_NO_SFINAE_EXPR)
     {
       boost::optional<A1> a(boost::conversion::convert_to<boost::optional<A1> >(boost::optional<B1>(b1)));
       BOOST_TEST(a);
     }
-#endif
     boost::optional<A1> a(boost::conversion::implicit_convert_to<boost::optional<A1> >(boost::optional<B1>(b1)));
     BOOST_TEST(a);
   }
@@ -93,12 +89,10 @@
   { // target is not assigned when the source is not initialized
     boost::optional<B1> b;
     boost::optional<A1> a;
-#if defined(BOOST_CONVERSION_ENABLE_CND) || !defined(BOOST_NO_SFINAE_EXPR)
     {
       a=boost::conversion::convert_to<boost::optional<A1> >(b);
       BOOST_TEST(!a);
     }
-#endif
     a=boost::conversion::implicit_convert_to<boost::optional<A1> >(b);
     BOOST_TEST(!a);
   }
@@ -106,12 +100,10 @@
   { // target is not assigned when the source is not initialized
     boost::optional<C1> c;
     boost::optional<A1> a;
-#if defined(BOOST_CONVERSION_ENABLE_CND) || !defined(BOOST_NO_SFINAE_EXPR)
     {
       a=boost::conversion::convert_to<boost::optional<A1> >(c);
       BOOST_TEST(!a);
     }
-#endif
     a=boost::conversion::implicit_convert_to<boost::optional<A1> >(c);
     BOOST_TEST(!a);
   }
@@ -121,12 +113,10 @@
     boost::optional<C1> c=c1;
     boost::optional<A1> a;
     try {
-#if defined(BOOST_CONVERSION_ENABLE_CND) || !defined(BOOST_NO_SFINAE_EXPR)
       {
         a=boost::conversion::convert_to<boost::optional<A1> >(c);
         BOOST_TEST(false);
       }
-#endif
       a=boost::conversion::implicit_convert_to<boost::optional<A1> >(c);
       BOOST_TEST(false);
     } catch (...) { }

Modified: sandbox/conversion/libs/conversion_ext/test/pair.cpp
==============================================================================
--- sandbox/conversion/libs/conversion_ext/test/pair.cpp (original)
+++ sandbox/conversion/libs/conversion_ext/test/pair.cpp 2011-07-18 19:57:21 EDT (Mon, 18 Jul 2011)
@@ -24,30 +24,23 @@
 
 using namespace boost;
 
-#if defined(BOOST_CONVERSION_ENABLE_CND) || !defined(BOOST_NO_SFINAE_EXPR)
 BOOST_STATIC_ASSERT(( !boost::is_constructible<std::pair<A1,A2>, std::pair<B1,B2> >::value));
 BOOST_STATIC_ASSERT(( !boost::is_explicitly_convertible<std::pair<B1,B2>, std::pair<A1,A2> >::value));
 BOOST_STATIC_ASSERT(( !boost::is_convertible<std::pair<B1,B2>, std::pair<A1,A2> >::value));
-#endif
-
-#if defined(BOOST_CONVERSION_ENABLE_CND)
 BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_convertible<std::pair<B1,B2>, std::pair<A1,A2> >::value));
 BOOST_STATIC_ASSERT(( !boost::is_assignable<std::pair<A1,A2>, std::pair<B1,B2> >::value));
 BOOST_STATIC_ASSERT(( boost::conversion::assigner<std::pair<A1,A2>, std::pair<B1,B2> >::value));
 BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_assignable<std::pair<A1,A2>, std::pair<B1,B2> >::value));
-#endif
 
 void explicit_convert_to() {
     B1 b1;
     B2 b2;
     std::pair<B1,B2> b;
-#if defined(BOOST_CONVERSION_ENABLE_CND) || !defined(BOOST_NO_SFINAE_EXPR)
     {
     std::pair<A1,A2> a1(boost::conversion::convert_to<std::pair<A1,A2> >(b));
     std::pair<A1,A2> a2(boost::conversion::convert_to<std::pair<A1,A2> >(std::pair<B1,B2>(b1,b2)));
     std::pair<A1,A2> a3(boost::conversion::convert_to<std::pair<A1,A2> >(std::make_pair(b1,b2)));
     }
-#endif
     std::pair<A1,A2> a1(boost::conversion::implicit_convert_to<std::pair<A1,A2> >(b));
     std::pair<A1,A2> a2(boost::conversion::implicit_convert_to<std::pair<A1,A2> >(std::pair<B1,B2>(b1,b2)));
     std::pair<A1,A2> a3(boost::conversion::implicit_convert_to<std::pair<A1,A2> >(std::make_pair(b1,b2)));

Modified: sandbox/conversion/libs/conversion_ext/test/rational.cpp
==============================================================================
--- sandbox/conversion/libs/conversion_ext/test/rational.cpp (original)
+++ sandbox/conversion/libs/conversion_ext/test/rational.cpp 2011-07-18 19:57:21 EDT (Mon, 18 Jul 2011)
@@ -20,12 +20,10 @@
     B1 b1(3);
     B1 b2(2);
     boost::rational<B1> b(1,2);
-#if defined(BOOST_CONVERSION_ENABLE_CND) || !defined(BOOST_NO_SFINAE_EXPR)
     {
       boost::rational<A1> a1(boost::conversion::convert_to<boost::rational<A1> >(b));
       boost::rational<A1> a2(boost::conversion::convert_to<boost::rational<A1> >(boost::rational<B1>(b1,b2)));
     }
-#endif
     boost::rational<A1> a1(boost::conversion::implicit_convert_to<boost::rational<A1> >(b));
     boost::rational<A1> a2(boost::conversion::implicit_convert_to<boost::rational<A1> >(boost::rational<B1>(b1,b2)));
 

Modified: sandbox/conversion/libs/conversion_ext/test/string.cpp
==============================================================================
--- sandbox/conversion/libs/conversion_ext/test/string.cpp (original)
+++ sandbox/conversion/libs/conversion_ext/test/string.cpp 2011-07-18 19:57:21 EDT (Mon, 18 Jul 2011)
@@ -23,7 +23,6 @@
 typedef short B1;
 
 
-#if defined(BOOST_CONVERSION_ENABLE_CND)
 BOOST_STATIC_ASSERT(( boost::is_copy_assignable<bool >::value));
 BOOST_STATIC_ASSERT(( boost::is_copy_assignable<std::string >::value));
 BOOST_STATIC_ASSERT(( !boost::is_assignable<std::string, bool >::value));
@@ -32,7 +31,6 @@
 BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_explicit_convertible<bool, std::string>::value));
 BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_assignable<std::string, bool >::value));
 BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_assignable<bool, std::string >::value));
-#endif
 
 void explicit_convert_to() {
   bool b1=true;

Modified: sandbox/conversion/libs/conversion_ext/test/tuple.cpp
==============================================================================
--- sandbox/conversion/libs/conversion_ext/test/tuple.cpp (original)
+++ sandbox/conversion/libs/conversion_ext/test/tuple.cpp 2011-07-18 19:57:21 EDT (Mon, 18 Jul 2011)
@@ -17,7 +17,6 @@
 using namespace boost;
 #include <boost/static_assert.hpp>
 
-#if defined(BOOST_CONVERSION_ENABLE_CND)
 BOOST_STATIC_ASSERT(( boost::is_assignable<A1, A1 >::value));
 BOOST_STATIC_ASSERT(( boost::is_assignable<A2, A2 >::value));
 BOOST_STATIC_ASSERT(( boost::is_assignable<fusion::tuple<A1,A2>, fusion::tuple<A1,A2> >::value));
@@ -25,26 +24,22 @@
 BOOST_STATIC_ASSERT(( boost::is_copy_assignable<boost::fusion::tuple<A1,A2> >::value));
 BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_assignable<fusion::tuple<A1,A2>, fusion::tuple<B1,B2> >::value));
 BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_explicit_convertible<fusion::tuple<B1,B2>, fusion::tuple<A1,A2> >::value));
-#endif
 
 
 void explicit_convert_to() {
     B1 b1;
     B2 b2;
     fusion::tuple<B1,B2> b;
-#if defined(BOOST_CONVERSION_ENABLE_CND)
     {
       fusion::tuple<A1,A2> a1(boost::conversion::convert_to<fusion::tuple<A1,A2> >(b));
       fusion::tuple<A1,A2> a2(boost::conversion::convert_to<fusion::tuple<A1,A2> >(fusion::tuple<B1,B2>(b1,b2)));
       fusion::tuple<A1,A2> a3(boost::conversion::convert_to<fusion::tuple<A1,A2> >(fusion::make_tuple(b1,b2)));
     }
-#endif
     fusion::tuple<A1,A2> a1(boost::conversion::explicit_convert_to<fusion::tuple<A1,A2> >(b));
     fusion::tuple<A1,A2> a2(boost::conversion::explicit_convert_to<fusion::tuple<A1,A2> >(fusion::tuple<B1,B2>(b1,b2)));
     fusion::tuple<A1,A2> a3(boost::conversion::explicit_convert_to<fusion::tuple<A1,A2> >(fusion::make_tuple(b1,b2)));
 }
 void explicit_assign_to() {
-#if defined(BOOST_CONVERSION_ENABLE_CND)
     B1 b1;
     B2 b2;
     fusion::tuple<A1,A2> a;
@@ -52,7 +47,6 @@
     boost::conversion::assign_to(a, b);
     boost::conversion::assign_to(a, fusion::tuple<B1,B2>(b1,b2));
     boost::conversion::assign_to(a, fusion::make_tuple(b1,b2));
-#endif
 
 }
 

Modified: sandbox/conversion/libs/conversion_ext/test/vector.cpp
==============================================================================
--- sandbox/conversion/libs/conversion_ext/test/vector.cpp (original)
+++ sandbox/conversion/libs/conversion_ext/test/vector.cpp 2011-07-18 19:57:21 EDT (Mon, 18 Jul 2011)
@@ -18,31 +18,14 @@
 
 using namespace boost;
 
-#if defined(BOOST_CONVERSION_ENABLE_CND)
 BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_assignable< A1, B1 >::value));
 BOOST_STATIC_ASSERT(( boost::conversion::is_extrinsically_assignable< std::vector<A1>, std::vector<B1> >::value));
-#endif
-
-#if 0
-BOOST_STATIC_ASSERT((
- boost::is_same<
- boost::conversion::result_of::pack2<std::vector<B1,std::allocator<B1> > const, std::allocator<A1> const>::type,
- std::pair<
- //~ boost::fusion::tuple<
- boost::reference_wrapper<std::vector<B1,std::allocator<B1> > const>,
- boost::reference_wrapper<std::allocator<A1> const>
- >
- >::value
- ));
-#endif
 
 void explicit_convert_to() {
     std::vector<B1> vb1;
-#if defined(BOOST_CONVERSION_ENABLE_CND) || !defined(BOOST_NO_SFINAE_EXPR)
     {
       std::vector<A1> va1(boost::conversion::convert_to<std::vector<A1> >(vb1));
     }
-#endif
     std::vector<A1> va1(boost::conversion::implicit_convert_to<std::vector<A1> >(vb1));
     B1 b10, b11, b12, b13;
     std::vector<B1> vb2;
@@ -51,41 +34,10 @@
     vb2[1]=b11;
     vb2[2]=b12;
     vb2[3]=b13;
-#if defined(BOOST_CONVERSION_ENABLE_CND) || !defined(BOOST_NO_SFINAE_EXPR)
     {
       std::vector<A1> va2(boost::conversion::convert_to<std::vector<A1> >(vb2));
     }
-#endif
     std::vector<A1> va2(boost::conversion::implicit_convert_to<std::vector<A1> >(vb2));
-#if 0
-
- std::allocator<A1> all;
- std::vector<A1,std::allocator<A1> > va3(
- boost::conversion::convert_to<std::vector<A1,std::allocator<A1> > >(
- std::pair<
- boost::reference_wrapper<std::vector<B1> const>,
- boost::reference_wrapper<std::allocator<A1> const>
- >(boost::cref(vb2), boost::cref(all))));
-
- std::vector<A1,std::allocator<A1> > va32(
- boost::conversion::convert_to<std::vector<A1,std::allocator<A1> > >(
- std::make_pair(boost::cref(vb2), boost::cref(all))));
-
- boost::conversion::result_of::pack2<std::vector<B1> const, std::allocator<A1> const>::type v =
- boost::conversion::pack(vb2, all);
-
- //~ std::vector<A1,std::allocator<A1> > va4(
- //~ boost::conversion::convert_to<std::vector<A1,std::allocator<A1> > >(v));
-
- //~ std::vector<A1,std::allocator<A1> > va5(
- //~ boost::conversion::convert_to<std::vector<A1,std::allocator<A1> > >(
- //~ boost::conversion::pack(vb2, all)));
-
- std::vector<A1,std::allocator<A1> > va6(
- boost::conversion::convert_to<std::vector<A1,std::allocator<A1> > >(
- boost::conversion::pack(vb2, std::allocator<A1>())));
-#endif
-
 }
 void explicit_assign_to() {
     std::vector<B1> vb1;


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