Subject: [Boost-commit] svn:boost r72979 - sandbox/coerce/libs/coerce/test
From: vexocide_at_[hidden]
Date: 2011-07-09 08:37:28
Author: vexocide
Date: 2011-07-09 08:37:27 EDT (Sat, 09 Jul 2011)
New Revision: 72979
URL: http://svn.boost.org/trac/boost/changeset/72979
Log:
Yet more tests
Added:
sandbox/coerce/libs/coerce/test/floating_point.cpp (contents, props changed)
Text files modified:
sandbox/coerce/libs/coerce/test/Jamfile.v2 | 5 +
sandbox/coerce/libs/coerce/test/bool.cpp | 69 ------------------------
sandbox/coerce/libs/coerce/test/char.cpp | 25 --------
sandbox/coerce/libs/coerce/test/integral.cpp | 115 +++++++++------------------------------
sandbox/coerce/libs/coerce/test/wchar_t.cpp | 25 --------
5 files changed, 32 insertions(+), 207 deletions(-)
Modified: sandbox/coerce/libs/coerce/test/Jamfile.v2
==============================================================================
--- sandbox/coerce/libs/coerce/test/Jamfile.v2 (original)
+++ sandbox/coerce/libs/coerce/test/Jamfile.v2 2011-07-09 08:37:27 EDT (Sat, 09 Jul 2011)
@@ -16,9 +16,12 @@
unit-test char :
char.cpp ;
-unit-test default_ :
+unit-test "default" :
default.cpp ;
+unit-test floating_point :
+ floating_point.cpp ;
+
unit-test integral :
integral.cpp ;
Modified: sandbox/coerce/libs/coerce/test/bool.cpp
==============================================================================
--- sandbox/coerce/libs/coerce/test/bool.cpp (original)
+++ sandbox/coerce/libs/coerce/test/bool.cpp 2011-07-09 08:37:27 EDT (Sat, 09 Jul 2011)
@@ -27,72 +27,3 @@
BOOST_CHECK_THROW(coerce::as<bool>("trueX"), coerce::bad_cast);
BOOST_CHECK_THROW(coerce::as<bool>("XXX"), coerce::bad_cast);
}
-
-/* lexical_cast
-
- BOOST_CHECK_EQUAL(true, lexical_cast<bool>('1'));
- BOOST_CHECK_EQUAL(false, lexical_cast<bool>('0'));
- BOOST_CHECK_THROW(lexical_cast<bool>('A'), bad_lexical_cast);
- BOOST_CHECK_EQUAL(true, lexical_cast<bool>(1));
- BOOST_CHECK_EQUAL(false, lexical_cast<bool>(0));
- BOOST_CHECK_THROW(lexical_cast<bool>(123), bad_lexical_cast);
- BOOST_CHECK_EQUAL(true, lexical_cast<bool>(1.0));
- BOOST_CHECK_EQUAL(false, lexical_cast<bool>(0.0));
- BOOST_CHECK_EQUAL(true, lexical_cast<bool>(true));
- BOOST_CHECK_EQUAL(false, lexical_cast<bool>(false));
- BOOST_CHECK_EQUAL(true, lexical_cast<bool>("1"));
- BOOST_CHECK_EQUAL(false, lexical_cast<bool>("0"));
- BOOST_CHECK_THROW(lexical_cast<bool>(""), bad_lexical_cast);
- BOOST_CHECK_THROW(lexical_cast<bool>("Test"), bad_lexical_cast);
- BOOST_CHECK_EQUAL(true, lexical_cast<bool>("1"));
- BOOST_CHECK_EQUAL(false, lexical_cast<bool>("0"));
- BOOST_CHECK_EQUAL(true, lexical_cast<bool>(std::string("1")));
- BOOST_CHECK_EQUAL(false, lexical_cast<bool>(std::string("0")));
-
- BOOST_CHECK_THROW(lexical_cast<bool>(1.0001L), bad_lexical_cast);
- BOOST_CHECK_THROW(lexical_cast<bool>(2), bad_lexical_cast);
- BOOST_CHECK_THROW(lexical_cast<bool>(2u), bad_lexical_cast);
- BOOST_CHECK_THROW(lexical_cast<bool>(-1), bad_lexical_cast);
- BOOST_CHECK_THROW(lexical_cast<bool>(-2), bad_lexical_cast);
-
-
- BOOST_CHECK_THROW(
- lexical_cast<bool>(std::string("")), bad_lexical_cast);
- BOOST_CHECK_THROW(
- lexical_cast<bool>(std::string("Test")), bad_lexical_cast);
-
- BOOST_CHECK(lexical_cast<bool>("+1") == true );
- BOOST_CHECK(lexical_cast<bool>("+0") == false );
- BOOST_CHECK(lexical_cast<bool>("-0") == false );
- BOOST_CHECK_THROW(lexical_cast<bool>("--0"), bad_lexical_cast);
- BOOST_CHECK_THROW(lexical_cast<bool>("-+-0"), bad_lexical_cast);
-*/
-
-/* convert
-
- convert<bool>::result bool_res1 = convert<bool>::from("1", false);
- convert<bool>::result bool_res2 = convert<bool>::from("true", false);
- convert<bool>::result bool_res3 = convert<bool>::from("yes", false);
- convert<bool>::result bool_res4 = convert<bool>::from(L"1", false);
- convert<bool>::result bool_res5 = convert<bool>::from(L"true", false);
- convert<bool>::result bool_res6 = convert<bool>::from(L"yes", false);
- convert<bool>::result bool_res7 = convert<bool>::from("junk", true);
-
- BOOST_ASSERT( bool_res1 && bool_res1.value() == true);
- BOOST_ASSERT( bool_res2 && bool_res2.value() == true);
- BOOST_ASSERT( bool_res3 && bool_res3.value() == true);
- BOOST_ASSERT( bool_res4 && bool_res4.value() == true);
- BOOST_ASSERT( bool_res5 && bool_res5.value() == true);
- BOOST_ASSERT( bool_res6 && bool_res6.value() == true);
- BOOST_ASSERT(!bool_res7 && bool_res7.value() == true);
-
- string bool_str1 = convert<string>::from(true, "failed");
- string bool_str2 = convert<string>::from(false, "failed");
- string bool_str3 = convert<string>::from(1, "failed");
- string bool_str4 = convert<string>::from(0, "failed");
-
- BOOST_ASSERT(bool_str1 == "1");
- BOOST_ASSERT(bool_str2 == "0");
- BOOST_ASSERT(bool_str3 == "1");
- BOOST_ASSERT(bool_str4 == "0");
-*/
Modified: sandbox/coerce/libs/coerce/test/char.cpp
==============================================================================
--- sandbox/coerce/libs/coerce/test/char.cpp (original)
+++ sandbox/coerce/libs/coerce/test/char.cpp 2011-07-09 08:37:27 EDT (Sat, 09 Jul 2011)
@@ -28,29 +28,8 @@
BOOST_CHECK_EQUAL(coerce::as<char>("\x17"), '\x17');
BOOST_CHECK_EQUAL(coerce::as<char>("A"), 'A');
- BOOST_CHECK_THROW(coerce::as<char>(L"\u2345"), coerce::bad_cast);
+ // http://cdn.svcs.c2.uclick.com/c2/c88fd5f0c8e9012d63f600163e41dd5b
+ BOOST_CHECK_THROW(coerce::as<char>(L"\u2603"), coerce::bad_cast);
BOOST_CHECK_THROW(coerce::as<char>("XXX"), coerce::bad_cast);
}
-
-/* lexical_cast
-
- BOOST_CHECK_EQUAL('A', lexical_cast<char>('A'));
- BOOST_CHECK_EQUAL(' ', lexical_cast<char>(' '));
- BOOST_CHECK_EQUAL('1', lexical_cast<char>(1));
- BOOST_CHECK_EQUAL('0', lexical_cast<char>(0));
- BOOST_CHECK_THROW(lexical_cast<char>(123), bad_lexical_cast);
- BOOST_CHECK_EQUAL('1', lexical_cast<char>(1.0));
- BOOST_CHECK_EQUAL('1', lexical_cast<char>(true));
- BOOST_CHECK_EQUAL('0', lexical_cast<char>(false));
- BOOST_CHECK_EQUAL('A', lexical_cast<char>("A"));
- BOOST_CHECK_EQUAL(' ', lexical_cast<char>(" "));
- BOOST_CHECK_THROW(lexical_cast<char>(""), bad_lexical_cast);
- BOOST_CHECK_THROW(lexical_cast<char>("Test"), bad_lexical_cast);
- BOOST_CHECK_EQUAL('A', lexical_cast<char>(std::string("A")));
- BOOST_CHECK_EQUAL(' ', lexical_cast<char>(std::string(" ")));
- BOOST_CHECK_THROW(
- lexical_cast<char>(std::string("")), bad_lexical_cast);
- BOOST_CHECK_THROW(
- lexical_cast<char>(std::string("Test")), bad_lexical_cast);
-*/
Added: sandbox/coerce/libs/coerce/test/floating_point.cpp
==============================================================================
--- (empty file)
+++ sandbox/coerce/libs/coerce/test/floating_point.cpp 2011-07-09 08:37:27 EDT (Sat, 09 Jul 2011)
@@ -0,0 +1,135 @@
+// Copyright Jeroen Habraken 2011.
+//
+// Distributed under 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)
+
+#define BOOST_TEST_MODULE floating_point
+
+#include <boost/coerce.hpp>
+#include <boost/limits.hpp>
+#include <boost/math/special_functions/fpclassify.hpp>
+#include <boost/mpl/for_each.hpp>
+#include <boost/mpl/vector.hpp>
+#include <boost/test/floating_point_comparison.hpp>
+#include <boost/test/unit_test.hpp>
+
+struct source_test {
+ template <typename T>
+ void
+ operator()(T) {
+ using namespace boost;
+ BOOST_CHECK_EQUAL(coerce::as<std::string>(static_cast<T>(0)), "0.0");
+
+ BOOST_CHECK_EQUAL(coerce::as<std::string>(static_cast<T>(23)), "23.0");
+ BOOST_CHECK_EQUAL(
+ coerce::as<std::string>(static_cast<T>(-23)), "-23.0");
+
+ BOOST_CHECK_EQUAL(
+ coerce::as<std::string>(static_cast<T>(1.01828183L)), "1.01828183");
+
+ BOOST_CHECK_EQUAL(
+ coerce::as<std::string>(static_cast<T>(1.0e23L)), "1.0e23");
+ BOOST_CHECK_EQUAL(
+ coerce::as<std::string>(static_cast<T>(1.0e-23L)), "1.0e-23");
+
+ BOOST_CHECK_EQUAL(
+ coerce::as<std::string>(std::numeric_limits<T>::quiet_NaN()),
+ "nan");
+ BOOST_CHECK_EQUAL(
+ coerce::as<std::string>(-std::numeric_limits<T>::quiet_NaN()),
+ "-nan");
+
+ BOOST_CHECK_EQUAL(
+ coerce::as<std::string>(std::numeric_limits<T>::infinity()), "inf");
+ BOOST_CHECK_EQUAL(
+ coerce::as<std::string>(-std::numeric_limits<T>::infinity()),
+ "-inf");
+ }
+};
+
+BOOST_AUTO_TEST_CASE(source) {
+ source_test test;
+
+ typedef boost::mpl::vector<
+ float
+ , double
+ , long double
+ > integral_types;
+
+ boost::mpl::for_each<integral_types>(test);
+}
+
+struct target_test {
+ template <typename T>
+ void
+ operator()(T) {
+ using namespace boost;
+
+ BOOST_CHECK_EQUAL(coerce::as<T>(".0"), 0);
+ BOOST_CHECK_EQUAL(coerce::as<T>("0."), 0);
+ BOOST_CHECK_EQUAL(coerce::as<T>("0.0"), 0);
+
+ BOOST_CHECK_EQUAL(coerce::as<T>("23.0"), 23);
+ BOOST_CHECK_EQUAL(coerce::as<T>("+23.0"), 23);
+ BOOST_CHECK_EQUAL(coerce::as<T>("-23.0"), -23);
+
+ BOOST_CHECK_CLOSE_FRACTION(
+ coerce::as<T>("1.01828183"),
+ static_cast<T>(1.01828183L),
+ std::numeric_limits<double>::epsilon());
+
+ BOOST_CHECK_CLOSE_FRACTION(
+ coerce::as<T>("1.0e23"),
+ static_cast<T>(1.0e23L),
+ std::numeric_limits<double>::epsilon());
+ BOOST_CHECK_CLOSE_FRACTION(
+ coerce::as<T>("1.0E23"),
+ static_cast<T>(1.0e23L),
+ std::numeric_limits<double>::epsilon());
+ BOOST_CHECK_CLOSE_FRACTION(
+ coerce::as<T>("1.0e+23"),
+ static_cast<T>(1.0e23L),
+ std::numeric_limits<double>::epsilon());
+ BOOST_CHECK_CLOSE_FRACTION(
+ coerce::as<T>("1.0e-23"),
+ static_cast<T>(1.0e-23L),
+ std::numeric_limits<double>::epsilon());
+
+ if (std::numeric_limits<T>::max() > 1.0e2603L) {
+ BOOST_CHECK_CLOSE_FRACTION(
+ coerce::as<T>("1.0e2603"),
+ static_cast<T>(1.0e2603L),
+ std::numeric_limits<double>::epsilon());
+ BOOST_CHECK_CLOSE_FRACTION(
+ coerce::as<T>("1.0e+2603"),
+ static_cast<T>(1.0e2603L),
+ std::numeric_limits<double>::epsilon());
+ BOOST_CHECK_CLOSE_FRACTION(
+ coerce::as<T>("1.0e-2603"),
+ static_cast<T>(1.0e-2603L),
+ std::numeric_limits<double>::epsilon());
+ }
+
+ BOOST_CHECK_EQUAL(math::fpclassify(coerce::as<T>("NaN")), FP_NAN);
+ BOOST_CHECK_EQUAL(math::fpclassify(coerce::as<T>("-NaN")), FP_NAN);
+
+ BOOST_CHECK_EQUAL(math::fpclassify(coerce::as<T>("Inf")), FP_INFINITE);
+ BOOST_CHECK_EQUAL(
+ math::fpclassify(coerce::as<T>("Infinity")), FP_INFINITE);
+ BOOST_CHECK_EQUAL(
+ math::fpclassify(coerce::as<T>("-Inf")), FP_INFINITE);
+ }
+};
+
+BOOST_AUTO_TEST_CASE(target) {
+ target_test test;
+
+ typedef boost::mpl::vector<
+ float
+ , double
+ , long double
+ > integral_types;
+
+ boost::mpl::for_each<integral_types>(test);
+}
Modified: sandbox/coerce/libs/coerce/test/integral.cpp
==============================================================================
--- sandbox/coerce/libs/coerce/test/integral.cpp (original)
+++ sandbox/coerce/libs/coerce/test/integral.cpp 2011-07-09 08:37:27 EDT (Sat, 09 Jul 2011)
@@ -32,16 +32,16 @@
source_test test;
typedef boost::mpl::vector<
+ short
+ , unsigned short
+ , int
+ , unsigned int
+ , long
+ , unsigned long
#ifdef BOOST_HAS_LONG_LONG
- boost::long_long_type,
- boost::ulong_long_type,
+ , boost::long_long_type
+ , boost::ulong_long_type
#endif
- short,
- unsigned short,
- int,
- unsigned int,
- long,
- unsigned long
> integral_types;
boost::mpl::for_each<integral_types>(test);
@@ -65,7 +65,7 @@
BOOST_CHECK_EQUAL(coerce::as<T>("23"), static_cast<T>(23));
if (std::numeric_limits<T>::is_signed) {
- BOOST_CHECK_EQUAL(coerce::as<T>("23"), static_cast<T>(23));
+ BOOST_CHECK_EQUAL(coerce::as<T>("+23"), static_cast<T>(23));
BOOST_CHECK_EQUAL(coerce::as<T>("-23"), static_cast<T>(-23));
}
@@ -84,14 +84,12 @@
BOOST_CHECK_THROW(coerce::as<T>("23 "), coerce::bad_cast);
BOOST_CHECK_THROW(coerce::as<T>(" 23 "), coerce::bad_cast);
- BOOST_CHECK_THROW(coerce::as<T>("23.0"), coerce::bad_cast);
- BOOST_CHECK_THROW(coerce::as<T>("+23.0"), coerce::bad_cast);
- BOOST_CHECK_THROW(coerce::as<T>("-23.0"), coerce::bad_cast);
-
- BOOST_CHECK_THROW(
- coerce::as<T>("18446744073709551616"), coerce::bad_cast);
- BOOST_CHECK_THROW(
- coerce::as<T>("-9223372036854775809"), coerce::bad_cast);
+ if (std::numeric_limits<T>::is_integer) {
+ BOOST_CHECK_THROW(
+ coerce::as<T>("18446744073709551616"), coerce::bad_cast);
+ BOOST_CHECK_THROW(
+ coerce::as<T>("-9223372036854775809"), coerce::bad_cast);
+ }
BOOST_CHECK_THROW(coerce::as<T>("23X"), coerce::bad_cast);
BOOST_CHECK_THROW(coerce::as<T>("XXX"), coerce::bad_cast);
@@ -102,81 +100,20 @@
target_test test;
typedef boost::mpl::vector<
+ short
+ , unsigned short
+ , int
+ , unsigned int
+ , long
+ , unsigned long
#ifdef BOOST_HAS_LONG_LONG
- boost::long_long_type,
- boost::ulong_long_type,
+ , boost::long_long_type
+ , boost::ulong_long_type
#endif
- short,
- unsigned short,
- int,
- unsigned int,
- long,
- unsigned long
+ , float
+ , double
+ , long double
> integral_types;
boost::mpl::for_each<integral_types>(test);
}
-
-/* lexical_cast
-
- BOOST_CHECK_EQUAL(1, lexical_cast<int>('1'));
- BOOST_CHECK_EQUAL(0, lexical_cast<int>('0'));
- BOOST_CHECK_THROW(lexical_cast<int>('A'), bad_lexical_cast);
- BOOST_CHECK_EQUAL(1, lexical_cast<int>(1));
- BOOST_CHECK_EQUAL(1, lexical_cast<int>(1.0));
-
- BOOST_CHECK_EQUAL(
- (std::numeric_limits<int>::max)(),
- lexical_cast<int>((std::numeric_limits<int>::max)()));
-
- BOOST_CHECK_EQUAL(
- (std::numeric_limits<int>::min)(),
- lexical_cast<int>((std::numeric_limits<int>::min)()));
-
- BOOST_CHECK_THROW(lexical_cast<int>(1.23), bad_lexical_cast);
-
- BOOST_CHECK_THROW(lexical_cast<int>(1e20), bad_lexical_cast);
- BOOST_CHECK_EQUAL(1, lexical_cast<int>(true));
- BOOST_CHECK_EQUAL(0, lexical_cast<int>(false));
- BOOST_CHECK_EQUAL(123, lexical_cast<int>("123"));
- BOOST_CHECK_THROW(
- lexical_cast<int>(" 123"), bad_lexical_cast);
- BOOST_CHECK_THROW(lexical_cast<int>(""), bad_lexical_cast);
- BOOST_CHECK_THROW(lexical_cast<int>("Test"), bad_lexical_cast);
- BOOST_CHECK_EQUAL(123, lexical_cast<int>("123"));
- BOOST_CHECK_EQUAL(123, lexical_cast<int>(std::string("123")));
- BOOST_CHECK_THROW(
- lexical_cast<int>(std::string(" 123")), bad_lexical_cast);
- BOOST_CHECK_THROW(
- lexical_cast<int>(std::string("")), bad_lexical_cast);
- BOOST_CHECK_THROW(
- lexical_cast<int>(std::string("Test")), bad_lexical_cast);
-
- BOOST_CHECK(lexical_cast<T>("-1") == static_cast<T>(-1));
- BOOST_CHECK(lexical_cast<T>("-9") == static_cast<T>(-9));
- BOOST_CHECK(lexical_cast<T>(-1) == static_cast<T>(-1));
- BOOST_CHECK(lexical_cast<T>(-9) == static_cast<T>(-9));
-
- BOOST_CHECK_THROW(lexical_cast<T>("-1.0"), bad_lexical_cast);
- BOOST_CHECK_THROW(lexical_cast<T>("-9.0"), bad_lexical_cast);
- BOOST_CHECK(lexical_cast<T>(-1.0) == static_cast<T>(-1));
- BOOST_CHECK(lexical_cast<T>(-9.0) == static_cast<T>(-9));
-
- BOOST_CHECK(lexical_cast<T>(static_cast<T>(1)) == static_cast<T>(1));
- BOOST_CHECK(lexical_cast<T>(static_cast<T>(9)) == static_cast<T>(9));
- BOOST_CHECK_THROW(lexical_cast<T>(1.1f), bad_lexical_cast);
- BOOST_CHECK_THROW(lexical_cast<T>(1.1), bad_lexical_cast);
- BOOST_CHECK_THROW(lexical_cast<T>(1.1L), bad_lexical_cast);
- BOOST_CHECK_THROW(lexical_cast<T>(1.0001f), bad_lexical_cast);
- BOOST_CHECK_THROW(lexical_cast<T>(1.0001), bad_lexical_cast);
- BOOST_CHECK_THROW(lexical_cast<T>(1.0001L), bad_lexical_cast);
-
- BOOST_CHECK(lexical_cast<T>("+1") == static_cast<T>(1) );
- BOOST_CHECK(lexical_cast<T>("+9") == static_cast<T>(9) );
- BOOST_CHECK(lexical_cast<T>("+10") == static_cast<T>(10) );
- BOOST_CHECK(lexical_cast<T>("+90") == static_cast<T>(90) );
- BOOST_CHECK_THROW(lexical_cast<T>("++1"), bad_lexical_cast);
- BOOST_CHECK_THROW(lexical_cast<T>("-+9"), bad_lexical_cast);
- BOOST_CHECK_THROW(lexical_cast<T>("--1"), bad_lexical_cast);
- BOOST_CHECK_THROW(lexical_cast<T>("+-9"), bad_lexical_cast);
-*/
Modified: sandbox/coerce/libs/coerce/test/wchar_t.cpp
==============================================================================
--- sandbox/coerce/libs/coerce/test/wchar_t.cpp (original)
+++ sandbox/coerce/libs/coerce/test/wchar_t.cpp 2011-07-09 08:37:27 EDT (Sat, 09 Jul 2011)
@@ -35,28 +35,3 @@
BOOST_CHECK_THROW(coerce::as<wchar_t>("XXX"), coerce::bad_cast);
#endif
}
-
-/* lexical_cast
-
- BOOST_CHECK_EQUAL(L'1', lexical_cast<wchar_t>(1));
- BOOST_CHECK_EQUAL(L'0', lexical_cast<wchar_t>(0));
- BOOST_CHECK_EQUAL(L'1', lexical_cast<wchar_t>('1'));
- BOOST_CHECK_EQUAL(L'0', lexical_cast<wchar_t>('0'));
- BOOST_CHECK_THROW(lexical_cast<wchar_t>(123), bad_lexical_cast);
- BOOST_CHECK_EQUAL(L'1', lexical_cast<wchar_t>(1.0));
- BOOST_CHECK_EQUAL(L'0', lexical_cast<wchar_t>(0.0));
- BOOST_CHECK_EQUAL(L'1', lexical_cast<wchar_t>(true));
- BOOST_CHECK_EQUAL(L'0', lexical_cast<wchar_t>(false));
- BOOST_CHECK_EQUAL(L'A', lexical_cast<wchar_t>(L'A'));
- BOOST_CHECK_EQUAL(L' ', lexical_cast<wchar_t>(L' '));
- BOOST_CHECK_EQUAL(L'A', lexical_cast<wchar_t>(L"A"));
- BOOST_CHECK_EQUAL(L' ', lexical_cast<wchar_t>(L" "));
- BOOST_CHECK_THROW(lexical_cast<wchar_t>(L""), bad_lexical_cast);
- BOOST_CHECK_THROW(lexical_cast<wchar_t>(L"Test"), bad_lexical_cast);
- BOOST_CHECK_EQUAL(L'A', lexical_cast<wchar_t>(std::wstring(L"A")));
- BOOST_CHECK_EQUAL(L' ', lexical_cast<wchar_t>(std::wstring(L" ")));
- BOOST_CHECK_THROW(
- lexical_cast<wchar_t>(std::wstring(L"")), bad_lexical_cast);
- BOOST_CHECK_THROW(
- lexical_cast<wchar_t>(std::wstring(L"Test")), bad_lexical_cast);
-*/