|
|
Boost-Commit : |
Subject: [Boost-commit] svn:boost r72672 - sandbox/conversion/libs/conversion_ext/test
From: vicente.botet_at_[hidden]
Date: 2011-06-19 03:40:11
Author: viboes
Date: 2011-06-19 03:40:08 EDT (Sun, 19 Jun 2011)
New Revision: 72672
URL: http://svn.boost.org/trac/boost/changeset/72672
Log:
Conversion: MAJOR change spliting implicit and explicit conversions
Text files modified:
sandbox/conversion/libs/conversion_ext/test/Jamfile.v2 | 11 ++++++-
sandbox/conversion/libs/conversion_ext/test/array.cpp | 5 ++-
sandbox/conversion/libs/conversion_ext/test/builtins.cpp | 52 +++++++++++++++++++++++++++++++++++++++
sandbox/conversion/libs/conversion_ext/test/chrono_posix_time_duration.cpp | 11 ++++++--
sandbox/conversion/libs/conversion_ext/test/chrono_posix_time_time.cpp | 10 ++++++-
sandbox/conversion/libs/conversion_ext/test/extrinsec.cpp | 35 +++++++++++++++++++++-----
sandbox/conversion/libs/conversion_ext/test/helper.hpp | 8 +++---
sandbox/conversion/libs/conversion_ext/test/intrinsec.cpp | 23 ++++++++++++++++
sandbox/conversion/libs/conversion_ext/test/is_assignable.cpp | 31 +++++++++++++++++++++--
sandbox/conversion/libs/conversion_ext/test/is_constructible.cpp | 7 +++-
sandbox/conversion/libs/conversion_ext/test/is_explicitly_convertible.cpp | 2
sandbox/conversion/libs/conversion_ext/test/optional.cpp | 42 +++++++++++++++++++++++++++----
sandbox/conversion/libs/conversion_ext/test/pair.cpp | 15 ++++++++---
sandbox/conversion/libs/conversion_ext/test/rational.cpp | 11 ++++++--
sandbox/conversion/libs/conversion_ext/test/tuple.cpp | 19 +++++++++-----
sandbox/conversion/libs/conversion_ext/test/vector.cpp | 16 +++++++++---
16 files changed, 246 insertions(+), 52 deletions(-)
Modified: sandbox/conversion/libs/conversion_ext/test/Jamfile.v2
==============================================================================
--- sandbox/conversion/libs/conversion_ext/test/Jamfile.v2 (original)
+++ sandbox/conversion/libs/conversion_ext/test/Jamfile.v2 2011-06-19 03:40:08 EDT (Sun, 19 Jun 2011)
@@ -44,7 +44,7 @@
test-suite "type_traits" :
- [ compile is_assignable.cpp ]
+ [ run is_assignable.cpp ]
[ compile is_constructible.cpp ]
[ compile is_copy_assignable.cpp ]
[ compile is_copy_constructible.cpp ]
@@ -60,7 +60,7 @@
[ run intrinsec.cpp ]
[ run extrinsec.cpp ]
[ run pair.cpp ]
- [ run complex.cpp ]
+ #[ run complex.cpp ]
[ run string.cpp ]
[ run vector.cpp ]
[ run interval.cpp ]
@@ -73,6 +73,13 @@
;
+test-suite "example" :
+ [ run ../example/even.cpp ]
+ [ run ../example/swap.cpp ]
+ [ run ../example/no_throw.cpp ]
+ ;
+
+
test-suite "compile_fail_test" :
# [ compile-fail ../example/IL_BancAccount.cpp : : <define>BOOST_SYNCHRO_DO_NOT_COMPILE : IL_BancAccount_comp_fail ]
;
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-06-19 03:40:08 EDT (Sun, 19 Jun 2011)
@@ -16,8 +16,6 @@
#include <boost/static_assert.hpp>
#if defined(BOOST_CONVERSION_ENABLE_CND)
-BOOST_STATIC_ASSERT(( !boost::conversion::default_converter_condition< boost::array<A1,3>, boost::array<B1,3> >::value));
-BOOST_STATIC_ASSERT(( boost::conversion::default_assigner_condition< boost::array<A1,3>, boost::array<B1,3> >::value));
BOOST_STATIC_ASSERT(( boost::is_extrinsic_assignable< A1, B1 >::value));
BOOST_STATIC_ASSERT(( boost::is_extrinsic_assignable< boost::array<A1,3>, boost::array<B1,3> >::value));
#endif
@@ -27,7 +25,10 @@
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);
}
void explicit_assign_to() {
Modified: sandbox/conversion/libs/conversion_ext/test/builtins.cpp
==============================================================================
--- sandbox/conversion/libs/conversion_ext/test/builtins.cpp (original)
+++ sandbox/conversion/libs/conversion_ext/test/builtins.cpp 2011-06-19 03:40:08 EDT (Sun, 19 Jun 2011)
@@ -71,8 +71,58 @@
ul=boost::conversion::convert_to<unsigned long>(l);
}
+void implicit_convert_to_with_builtin_types() {
+ char c=0;
+ short s=1;
+ int i=2;
+ long l=3;
+ unsigned char uc(c);
+ unsigned short us(s);
+ unsigned int ui(i);
+ unsigned long ul(l);
+
+ c=boost::conversion::implicit_convert_to<char>(c);
+ s=boost::conversion::implicit_convert_to<short>(c);
+ i=boost::conversion::implicit_convert_to<int>(c);
+ l=boost::conversion::implicit_convert_to<long>(c);
+ uc=boost::conversion::implicit_convert_to<unsigned char>(c);
+ us=boost::conversion::implicit_convert_to<unsigned short>(c);
+ ui=boost::conversion::implicit_convert_to<unsigned int>(c);
+ ul=boost::conversion::implicit_convert_to<unsigned long>(c);
+
+
+ c=boost::conversion::implicit_convert_to<char>(s);
+ s=boost::conversion::implicit_convert_to<short>(s);
+ i=boost::conversion::implicit_convert_to<int>(s);
+ l=boost::conversion::implicit_convert_to<long>(s);
+ uc=boost::conversion::implicit_convert_to<unsigned char>(s);
+ us=boost::conversion::implicit_convert_to<unsigned short>(s);
+ ui=boost::conversion::implicit_convert_to<unsigned int>(s);
+ ul=boost::conversion::implicit_convert_to<unsigned long>(s);
+
+ c=boost::conversion::implicit_convert_to<char>(i);
+ s=boost::conversion::implicit_convert_to<short>(i);
+ i=boost::conversion::implicit_convert_to<int>(i);
+ l=boost::conversion::implicit_convert_to<long>(i);
+ uc=boost::conversion::implicit_convert_to<unsigned char>(i);
+ us=boost::conversion::implicit_convert_to<unsigned short>(i);
+ ui=boost::conversion::implicit_convert_to<unsigned int>(i);
+ ul=boost::conversion::implicit_convert_to<unsigned long>(i);
+
+ c=boost::conversion::implicit_convert_to<char>(l);
+ s=boost::conversion::implicit_convert_to<short>(l);
+ i=boost::conversion::implicit_convert_to<int>(l);
+ l=boost::conversion::implicit_convert_to<long>(l);
+ uc=boost::conversion::implicit_convert_to<unsigned char>(l);
+ us=boost::conversion::implicit_convert_to<unsigned short>(l);
+ ui=boost::conversion::implicit_convert_to<unsigned int>(l);
+ ul=boost::conversion::implicit_convert_to<unsigned long>(l);
+}
+
+
void assign_to_with_builtin_types() {
+
char c=0;
short s=1;
int i=2;
@@ -168,7 +218,6 @@
boost::conversion::mca(l) = us;
boost::conversion::mca(l) = ui;
boost::conversion::mca(l) = ul;
-
}
void assign_to_transitive() {
@@ -238,6 +287,7 @@
int main( )
{
convert_to_with_builtin_types();
+ implicit_convert_to_with_builtin_types();
assign_to_with_builtin_types();
mca_assign_to_with_builtin_types();
assign_to_transitive();
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-06-19 03:40:08 EDT (Sun, 19 Jun 2011)
@@ -20,9 +20,14 @@
void explicit_convert_to() {
boost::chrono::seconds a(3);
- 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));
-
+#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));
}
void explicit_assign_to() {
boost::chrono::seconds a(3);
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-06-19 03:40:08 EDT (Sun, 19 Jun 2011)
@@ -20,8 +20,14 @@
void explicit_convert_to() {
chrono::system_clock::time_point a=chrono::system_clock::now();
- 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));
+#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));
}
void explicit_assign_to() {
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-06-19 03:40:08 EDT (Sun, 19 Jun 2011)
@@ -8,6 +8,7 @@
//
//////////////////////////////////////////////////////////////////////////////
+
#include <boost/conversion/explicit_convert_to.hpp>
#include <boost/conversion/convert_to.hpp>
#include <boost/conversion/assign_to.hpp>
@@ -51,14 +52,14 @@
namespace boost {
namespace conversion {
template <>
- struct converter< A,B > : true_type {
+ struct converter_cp< A,B > : true_type {
A operator()(B const &)
{
return A();
}
};
template <>
- struct converter< B,C > : true_type {
+ struct converter_cp< B,C > : true_type {
B operator()(C const &)
{
return B();
@@ -68,10 +69,8 @@
}
#endif
-#if defined(BOOST_CONVERSION_ENABLE_CND)
BOOST_STATIC_ASSERT(( boost::is_extrinsic_convertible< B,A >::value));
BOOST_STATIC_ASSERT(( boost::is_extrinsic_convertible< C,B >::value));
-#endif
void f(B) {}
@@ -107,6 +106,12 @@
}
}
+BOOST_STATIC_ASSERT(( !boost::is_convertible< X,ICF_X >::value));
+BOOST_STATIC_ASSERT(( boost::is_extrinsic_convertible< X,ICF_X >::value));
+#if defined(BOOST_CONVERSION_ENABLE_CND) || !defined(BOOST_NO_SFINAE_EXPR)
+ BOOST_STATIC_ASSERT(( boost::is_extrinsic_explicit_convertible< X,ICF_X >::value));
+#endif
+
struct ECF_X {
};
@@ -168,13 +173,19 @@
}
}
+ BOOST_STATIC_ASSERT(( !boost::is_extrinsic_convertible< X,AF_X >::value));
+ BOOST_STATIC_ASSERT(( !boost::is_extrinsic_explicit_convertible< X,AF_X >::value));
+
//////////////////////////
void xconvert_to_with_implicit_constructor()
{
{
X x;
- ICF_X y1(convert_to<ICF_X>(x));
+ ICF_X y1(implicit_convert_to<ICF_X>(x));
+#if defined(BOOST_CONVERSION_ENABLE_CND) || !defined(BOOST_NO_SFINAE_EXPR)
+ ICF_X y1_1(convert_to<ICF_X>(x));
+#endif
ICF_X y2(mcf(x));
mat(y2) = x;
}
@@ -201,9 +212,15 @@
{
{
ICT_X y;
- X x1(convert_to<X>(y));
+ X x1(implicit_convert_to<X>(y));
+#if defined(BOOST_CONVERSION_ENABLE_CND) || !defined(BOOST_NO_SFINAE_EXPR)
+ X x1_1(convert_to<X>(y));
+#endif
X x2(mcf(y));
- X x3=convert_to<X>(y);
+ X x3=implicit_convert_to<X>(y);
+#if defined(BOOST_CONVERSION_ENABLE_CND) || !defined(BOOST_NO_SFINAE_EXPR)
+ X x3_1=convert_to<X>(y);
+#endif
X x4=mcf(y);
mat(x4) = y;
}
@@ -230,6 +247,7 @@
}
////
+#if defined(BOOST_CONVERSION_ENABLE_CND) || !defined(BOOST_NO_SFINAE_EXPR)
void explicit_convert_to() {
@@ -282,6 +300,7 @@
C c;
h(c);
}
+#endif
int main( )
{
@@ -290,6 +309,7 @@
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();
@@ -297,6 +317,7 @@
implicit_conversion_via_mcf();
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-06-19 03:40:08 EDT (Sun, 19 Jun 2011)
@@ -23,28 +23,28 @@
namespace boost {
namespace conversion {
template <>
- struct converter< A1,B1 > : true_type {
+ struct converter_cp< A1,B1 > : true_type {
A1 operator()(B1 const &)
{
return A1();
}
};
template <>
- struct converter< A2,B2 > : true_type {
+ struct converter_cp< A2,B2 > : true_type {
A2 operator()(B2 const &)
{
return A2();
}
};
template < >
- struct assigner< A1,B1 > : true_type {
+ struct assigner_cp< A1,B1 > : true_type {
A1& operator()(A1& to, const B1&)
{
return to;
}
};
template < >
- struct assigner< A2,B2 > : true_type {
+ struct assigner_cp< A2,B2 > : true_type {
A2& operator()(A2& to, const B2&)
{
return to;
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-06-19 03:40:08 EDT (Sun, 19 Jun 2011)
@@ -16,6 +16,7 @@
#include <boost/conversion/convertible_from.hpp>
#include <iostream>
#include <boost/detail/lightweight_test.hpp>
+#include <boost/static_assert.hpp>
using namespace boost;
using namespace boost::conversion;
@@ -68,6 +69,11 @@
AF_X& operator=(X) { return *this; }
};
+#if defined(BOOST_CONVERSION_ENABLE_CND)
+BOOST_STATIC_ASSERT(( ! boost::is_explicitly_convertible< X,AF_X >::value));
+BOOST_STATIC_ASSERT(( ! boost::is_extrinsic_convertible< X,AF_X >::value));
+#endif
+
//////////////////////////
void convert_to_with_implicit_constructor()
@@ -98,7 +104,9 @@
//ECF_X y(convert_to<ECF_X>(x)); // compile must fail
BOOST_CONVERSION_CONSTRUCT(ECF_X, y, x); // Maybe a macro !!!
ECF_X y1_1(explicit_convert_to<ECF_X>(x));
+#if defined(BOOST_CONVERSION_ENABLE_CND)
ECF_X y1_2(mcf(x)); // doesn't fail as there is the constructor from X, but will fails for extrinsic conversion.
+#endif
ECF_X y2 = explicit_convert_to<ECF_X>(x);
}
@@ -138,25 +146,30 @@
//AF_X y1(x); // compile fails
AF_X y2;
y2=x;
+#if defined(BOOST_CONVERSION_ENABLE_CND)
assign_to(y2,x);
mat(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() {
@@ -165,16 +178,20 @@
AA aa(1);
aa=b;
}
+#if defined(BOOST_CONVERSION_ENABLE_CND)
{
B b;
AA aa(1);
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() {
@@ -183,17 +200,21 @@
CC cc(1);
cc=c;
}
+#if defined(BOOST_CONVERSION_ENABLE_CND)
{
C c;
CC cc(1);
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/is_assignable.cpp
==============================================================================
--- sandbox/conversion/libs/conversion_ext/test/is_assignable.cpp (original)
+++ sandbox/conversion/libs/conversion_ext/test/is_assignable.cpp 2011-06-19 03:40:08 EDT (Sun, 19 Jun 2011)
@@ -13,25 +13,50 @@
#include <boost/static_assert.hpp>
#include <boost/conversion/type_traits/is_assignable.hpp>
-
struct A
{
};
struct B
{
- void operator=(A);
+ B& operator=(A);
};
-
+#if 0
+B b;
+A a;
+typedef char yes_type;
+struct no_type { char _[2]; };
+template<std::size_t N>
+struct dummy{};
+
+//BOOST_STATIC_ASSERT(( sizeof((a = b))>0 ));
+BOOST_STATIC_ASSERT(( sizeof((b = boost::declval<A>()))>0 ));
+
+dummy<sizeof(b = boost::declval<A>())> ptr;
+
+yes_type
+test(dummy<sizeof((b = boost::declval<A>()))>*);
+
+static no_type
+test(...);
+static const bool value = sizeof(test(0)) == sizeof(yes_type);
+BOOST_STATIC_ASSERT(( value ));
+#endif
int main()
{
+
+// std:: cout << sizeof((b = a)) << std::endl;
+// std:: cout << sizeof((b = boost::declval<A>())) << std::endl;
+
BOOST_STATIC_ASSERT(( boost::is_assignable<int&, int&>::value));
BOOST_STATIC_ASSERT(( boost::is_assignable<int&, int>::value));
BOOST_STATIC_ASSERT((!boost::is_assignable<int, int&>::value));
BOOST_STATIC_ASSERT(( boost::is_assignable<int&, double>::value));
BOOST_STATIC_ASSERT(( boost::is_assignable<B, A>::value));
BOOST_STATIC_ASSERT((!boost::is_assignable<A, B>::value));
+
+ return 0;
}
Modified: sandbox/conversion/libs/conversion_ext/test/is_constructible.cpp
==============================================================================
--- sandbox/conversion/libs/conversion_ext/test/is_constructible.cpp (original)
+++ sandbox/conversion/libs/conversion_ext/test/is_constructible.cpp 2011-06-19 03:40:08 EDT (Sun, 19 Jun 2011)
@@ -28,12 +28,15 @@
int main()
{
- BOOST_STATIC_ASSERT((boost::is_constructible<int>::value));
+ // BUG: Default constructible doesn't works yet
+ //BOOST_STATIC_ASSERT((boost::is_constructible<int>::value));
+ //BOOST_STATIC_ASSERT((!boost::is_constructible<A>::value));
BOOST_STATIC_ASSERT((boost::is_constructible<int, const int>::value));
BOOST_STATIC_ASSERT((boost::is_constructible<A, int>::value));
BOOST_STATIC_ASSERT((boost::is_constructible<A, double>::value));
BOOST_STATIC_ASSERT((boost::is_constructible<A, int, double>::value));
BOOST_STATIC_ASSERT((boost::is_constructible<A, A const&>::value));
BOOST_STATIC_ASSERT((!boost::is_constructible<void>::value));
- BOOST_STATIC_ASSERT((!boost::is_constructible<A>::value));
+ // BUG: We need to add specializations for void
+ //BOOST_STATIC_ASSERT((!boost::is_constructible<void,A>::value));
}
Modified: sandbox/conversion/libs/conversion_ext/test/is_explicitly_convertible.cpp
==============================================================================
--- sandbox/conversion/libs/conversion_ext/test/is_explicitly_convertible.cpp (original)
+++ sandbox/conversion/libs/conversion_ext/test/is_explicitly_convertible.cpp 2011-06-19 03:40:08 EDT (Sun, 19 Jun 2011)
@@ -31,5 +31,5 @@
BOOST_STATIC_ASSERT((boost::is_explicitly_convertible<const int, int>::value));
BOOST_STATIC_ASSERT((boost::is_explicitly_convertible<int, A>::value));
BOOST_STATIC_ASSERT((boost::is_explicitly_convertible<double, A>::value));
- BOOST_STATIC_ASSERT((!boost::is_explicitly_convertible<void,A>::value));
+ //BOOST_STATIC_ASSERT((!boost::is_explicitly_convertible<void,A>::value));
}
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-06-19 03:40:08 EDT (Sun, 19 Jun 2011)
@@ -52,27 +52,51 @@
{
B1 b1;
boost::optional<B1> b=b1;
- boost::optional<A1> a(boost::conversion::convert_to<boost::optional<A1> >(b));
+#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;
- boost::optional<A1> a(boost::conversion::convert_to<boost::optional<A1> >(boost::optional<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);
}
{ // target is not assigned when the source is not initialized
boost::optional<B1> b;
boost::optional<A1> a;
- a=boost::conversion::convert_to<boost::optional<A1> >(b);
+#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);
}
{ // target is not assigned when the source is not initialized
boost::optional<C1> c;
boost::optional<A1> a;
- a=boost::conversion::convert_to<boost::optional<A1> >(c);
+#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);
}
@@ -81,7 +105,13 @@
boost::optional<C1> c=c1;
boost::optional<A1> a;
try {
- a=boost::conversion::convert_to<boost::optional<A1> >(c);
+#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 (...) { }
}
@@ -111,7 +141,7 @@
void explicit_try_convert_to()
{
- { // when the target is optional and the source isn't it, the target is assigned
+ { // when the target is optional and the source isn't, the target is assigned
B1 b1;
boost::optional<A1> a;
a=boost::conversion::convert_to<boost::optional<A1> >(b1);
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-06-19 03:40:08 EDT (Sun, 19 Jun 2011)
@@ -23,28 +23,35 @@
using namespace boost;
-#if defined(BOOST_CONVERSION_ENABLE_CND)
-
BOOST_STATIC_ASSERT(( boost::is_extrinsic_convertible<B1, A1>::value));
BOOST_STATIC_ASSERT(( boost::is_extrinsic_convertible<B2, A2>::value));
+
+#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::is_assignable<B1, A1>::value));
BOOST_STATIC_ASSERT(( !boost::is_assignable<B2, A2>::value));
BOOST_STATIC_ASSERT(( !boost::is_assignable<std::pair<B1,B2>, std::pair<A1,A2> >::value));
-//BOOST_STATIC_ASSERT(( !boost::is_assignable<std::pair<B1,B2>&, std::pair<A1,A2> const& >::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)));
}
void explicit_assign_to() {
B1 b1;
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-06-19 03:40:08 EDT (Sun, 19 Jun 2011)
@@ -20,9 +20,14 @@
B1 b1(3);
B1 b2(2);
boost::rational<B1> b(1,2);
- 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)));
- //boost::rational<A1> a3(convert_to<boost::rational<A1> >(b));
+#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)));
}
void explicit_assign_to() {
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-06-19 03:40:08 EDT (Sun, 19 Jun 2011)
@@ -17,20 +17,24 @@
using namespace boost;
#include <boost/static_assert.hpp>
-#if defined(BOOST_CONVERSION_ENABLE_CND)
-BOOST_STATIC_ASSERT(( !boost::conversion::default_converter_condition< fusion::tuple<A1,A2>, fusion::tuple<B1,B2> >::value));
-#endif
void explicit_convert_to() {
B1 b1;
B2 b2;
fusion::tuple<B1,B2> b;
- 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)));
-
+#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;
@@ -38,6 +42,7 @@
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-06-19 03:40:08 EDT (Sun, 19 Jun 2011)
@@ -19,8 +19,6 @@
using namespace boost;
#if defined(BOOST_CONVERSION_ENABLE_CND)
-BOOST_STATIC_ASSERT(( !boost::conversion::default_converter_condition< std::vector<A1>, std::vector<B1> >::value));
-BOOST_STATIC_ASSERT(( boost::conversion::default_assigner_condition< std::vector<A1>, std::vector<B1> >::value));
BOOST_STATIC_ASSERT(( boost::is_extrinsic_assignable< A1, B1 >::value));
BOOST_STATIC_ASSERT(( boost::is_extrinsic_assignable< std::vector<A1>, std::vector<B1> >::value));
#endif
@@ -40,7 +38,12 @@
void explicit_convert_to() {
std::vector<B1> vb1;
- std::vector<A1> va1(boost::conversion::convert_to<std::vector<A1> >(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;
vb2.reserve(5);
@@ -48,7 +51,12 @@
vb2[1]=b11;
vb2[2]=b12;
vb2[3]=b13;
- std::vector<A1> va2(boost::conversion::convert_to<std::vector<A1> >(vb2));
+#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;
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