[Boost-commit] svn:boost r72952 - sandbox/coerce/libs/coerce/test

Subject: [Boost-commit] svn:boost r72952 - sandbox/coerce/libs/coerce/test
From: vexocide_at_[hidden]
Date: 2011-07-07 05:43:44

Author: vexocide
Date: 2011-07-07 05:43:42 EDT (Thu, 07 Jul 2011)
New Revision: 72952
URL: http://svn.boost.org/trac/boost/changeset/72952

Log:
More tests
Added:
   sandbox/coerce/libs/coerce/test/char.cpp   (contents, props changed)
   sandbox/coerce/libs/coerce/test/default.cpp   (contents, props changed)
   sandbox/coerce/libs/coerce/test/wchar_t.cpp   (contents, props changed)
Text files modified: 
   sandbox/coerce/libs/coerce/test/Jamfile.v2   |     9 ++++                                    
   sandbox/coerce/libs/coerce/test/bool.cpp     |    75 ++++++++++++++++++++++++++++++++++++++- 
   sandbox/coerce/libs/coerce/test/integral.cpp |    73 ++++++++++++++++++++++++++++++++++++++  
   3 files changed, 154 insertions(+), 3 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-07 05:43:42 EDT (Thu, 07 Jul 2011)
@@ -13,6 +13,12 @@
 unit-test bool :
     bool.cpp ;
 
+unit-test char :
+    char.cpp ;
+
+unit-test default_ :
+    default.cpp ;
+
 unit-test integral :
     integral.cpp ;
 
@@ -24,3 +30,6 @@
 
 unit-test qi :
     qi.cpp ;
+
+unit-test wchar_t :
+    wchar_t.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-07 05:43:42 EDT (Thu, 07 Jul 2011)
@@ -4,7 +4,7 @@
 // (See accompanying file ../../../LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
 
-#define BOOST_TEST_MODULE bool_
+#define BOOST_TEST_MODULE bool
 
 #include <boost/coerce.hpp>
 #include <boost/test/unit_test.hpp>
@@ -19,11 +19,80 @@
 BOOST_AUTO_TEST_CASE(target) {
     using namespace boost;
 
+    BOOST_CHECK_THROW(coerce::as<bool>(""), coerce::bad_cast);
+
     BOOST_CHECK_EQUAL(coerce::as<bool>("true"), true);
     BOOST_CHECK_EQUAL(coerce::as<bool>("false"), false);
 
-    BOOST_CHECK_THROW(coerce::as<bool>(""), coerce::bad_cast);
-
     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");
+*/

Added: sandbox/coerce/libs/coerce/test/char.cpp
==============================================================================
--- (empty file)
+++ sandbox/coerce/libs/coerce/test/char.cpp	2011-07-07 05:43:42 EDT (Thu, 07 Jul 2011)
@@ -0,0 +1,56 @@
+//              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 char
+
+#include <boost/coerce.hpp>
+#include <boost/test/unit_test.hpp>
+
+BOOST_AUTO_TEST_CASE(source) {
+    using namespace boost;
+
+    BOOST_CHECK_EQUAL(coerce::as<std::string>('\0'), std::string("\0", 1));
+    BOOST_CHECK_EQUAL(coerce::as<std::string>(' '), " ");
+    BOOST_CHECK_EQUAL(coerce::as<std::string>('\x23'), "\x23");
+    BOOST_CHECK_EQUAL(coerce::as<std::string>('A'), "A");
+}
+
+BOOST_AUTO_TEST_CASE(target) {
+    using namespace boost;
+
+    BOOST_CHECK_THROW(coerce::as<char>(""), coerce::bad_cast);
+
+    BOOST_CHECK_EQUAL(coerce::as<char>("\0"), '\0');
+    BOOST_CHECK_EQUAL(coerce::as<char>(" "), ' ');
+    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);
+
+    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/default.cpp
==============================================================================
--- (empty file)
+++ sandbox/coerce/libs/coerce/test/default.cpp	2011-07-07 05:43:42 EDT (Thu, 07 Jul 2011)
@@ -0,0 +1,17 @@
+//              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 default
+
+#include <boost/coerce.hpp>
+#include <boost/test/unit_test.hpp>
+
+BOOST_AUTO_TEST_CASE(default_) {
+    using namespace boost;
+
+    BOOST_CHECK_EQUAL(coerce::as_default<int>("XXX"), 0);
+    BOOST_CHECK_EQUAL(coerce::as_default<int>("XXX", 23), 23);
+}

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-07 05:43:42 EDT (Thu, 07 Jul 2011)
@@ -69,6 +69,11 @@
             BOOST_CHECK_EQUAL(coerce::as<T>("-23"), static_cast<T>(-23));
         }
 
+        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"), coerce::bad_cast);
+        BOOST_CHECK_THROW(coerce::as<T>("--23"), coerce::bad_cast);
+
         BOOST_CHECK_EQUAL(coerce::as<T>("00023"), static_cast<T>(23));
         if (std::numeric_limits<T>::is_signed) {
             BOOST_CHECK_EQUAL(coerce::as<T>("+00023"), static_cast<T>(23));
@@ -79,6 +84,10 @@
         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(
@@ -107,3 +116,67 @@
 
     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);
+*/

Added: sandbox/coerce/libs/coerce/test/wchar_t.cpp
==============================================================================
--- (empty file)
+++ sandbox/coerce/libs/coerce/test/wchar_t.cpp	2011-07-07 05:43:42 EDT (Thu, 07 Jul 2011)
@@ -0,0 +1,62 @@
+//              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 wchar_t
+
+#include <boost/coerce.hpp>
+#include <boost/config.hpp>
+#include <boost/test/unit_test.hpp>
+
+BOOST_AUTO_TEST_CASE(source) {
+    using namespace boost;
+
+#ifndef BOOST_NO_INTRINSIC_WCHAR_T
+    BOOST_CHECK_EQUAL(coerce::as<std::string>(L'\0'), std::string("\0", 1));
+    BOOST_CHECK_EQUAL(coerce::as<std::string>(L' '), " ");
+    BOOST_CHECK_EQUAL(coerce::as<std::string>(L'\x23'), "\x23");
+    BOOST_CHECK_EQUAL(coerce::as<std::string>(L'A'), "A");
+#endif
+}
+
+BOOST_AUTO_TEST_CASE(target) {
+    using namespace boost;
+
+#ifndef BOOST_NO_INTRINSIC_WCHAR_T
+    BOOST_CHECK_THROW(coerce::as<wchar_t>(""), coerce::bad_cast);
+
+    BOOST_CHECK_EQUAL(coerce::as<wchar_t>("\0"), L'\0');
+    BOOST_CHECK_EQUAL(coerce::as<wchar_t>(" "), L' ');
+    BOOST_CHECK_EQUAL(coerce::as<wchar_t>("\x23"), L'\x23');
+    BOOST_CHECK_EQUAL(coerce::as<wchar_t>("A"), L'A');
+
+    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);
+*/