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

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);
-*/