Release 1.49.0

[SVN r77094]

doc/lexical_cast.qbk

@@ -159,9 +159,22 @@ Read a good C++ book, study `std::sentry` and [@boost:libs/io/doc/ios_state.html
 the rules of `scanf` for conversions. And in the C99 standard for unsigned input value minus sign is optional, so 
 if a negative number is read, no errors will arise and the result will be the two's complement.
 
+[pre
+]
+
+* [*Question:]    Why `boost::lexical_cast<int>(L'A');` outputs 65 and `boost::lexical_cast<wchar_t>(L"65");` does not throw?
+  * [*Answer:]      If you are using an old version of Visual Studio or compile code with /Zc:wchar_t- flag, 
+`boost::lexical_cast` sees single `wchar_t` character as `unsigned short`. It is not a `boost::lexical_cast` mistake, but a 
+limitation of compiler options that you use.
+
 [endsect]
 
 [section Changes]
+* [*boost 1.49.0 :]
+  
+    * Restored work with typedefed wchar_t (compilation flag /Zc:wchar_t- for Visual Studio). 
+    * Better performance and less memory usage for `boost::container::basic_string` conversions.
+    
 * [*boost 1.48.0 :]
   
     * Added code to work with Inf and NaN on any platform.    

include/boost/lexical_cast.hpp

@@ -17,8 +17,35 @@
 //        enhanced with contributions from Terje Slettebo,
 //        with additional fixes and suggestions from Gennaro Prota,
 //        Beman Dawes, Dave Abrahams, Daryle Walker, Peter Dimov,
-//        Alexander Nasonov, Antony Polukhin and other Boosters
-// when:  November 2000, March 2003, June 2005, June 2006, March 2011
+//        Alexander Nasonov, Antony Polukhin, Justin Viiret, Michael Hofmann,
+//        Cheng Yang, Matthew Bradbury, David W. Birdsall and other Boosters
+// when:  November 2000, March 2003, June 2005, June 2006, March 2011 - 2012
+
+#include <boost/config.hpp>
+#if defined(BOOST_NO_STRINGSTREAM) || defined(BOOST_NO_STD_WSTRING)
+#define BOOST_LCAST_NO_WCHAR_T
+#endif
+
+#if (defined(__MINGW32__) || defined(__MINGW64__)) && (__GNUC__ == 4) \
+ && ((__GNUC_MINOR__ == 4) || (__GNUC_MINOR__ == 5)) && defined(__STRICT_ANSI__) \
+ && !defined(BOOST_LCAST_NO_WCHAR_T)
+
+// workaround for a mingw bug
+// http://sourceforge.net/tracker/index.php?func=detail&aid=2373234&group_id=2435&atid=102435
+#include <_mingw.h>
+#if (__GNUC_MINOR__ == 4)
+extern "C" {
+_CRTIMP int __cdecl swprintf(wchar_t * __restrict__ , const wchar_t * __restrict__ , ...);
+_CRTIMP int __cdecl vswprintf(wchar_t * __restrict__ , const wchar_t * __restrict__ , ...);
+}
+#endif
+#if (__GNUC_MINOR__ == 5)
+extern "C" {
+_CRTIMP int __cdecl swprintf(wchar_t * __restrict__ , const wchar_t * __restrict__ , ...);
+_CRTIMP int __cdecl vswprintf(wchar_t * __restrict__ , const wchar_t * __restrict__ , va_list);
+}
+#endif
+#endif
 
 #include <climits>
 #include <cstddef>
@@ -29,7 +56,6 @@
 #include <typeinfo>
 #include <exception>
 #include <cmath>
-#include <boost/config.hpp>
 #include <boost/limits.hpp>
 #include <boost/mpl/if.hpp>
 #include <boost/throw_exception.hpp>
@@ -46,8 +72,12 @@
 #include <boost/static_assert.hpp>
 #include <boost/detail/lcast_precision.hpp>
 #include <boost/detail/workaround.hpp>
-#include <cwchar>
-
+#if !defined(__SUNPRO_CC)
+#include <boost/container/container_fwd.hpp>
+#endif // !defined(__SUNPRO_CC)
+#ifndef BOOST_NO_CWCHAR
+#   include <cwchar>
+#endif
 
 #ifndef BOOST_NO_STD_LOCALE
 #   include <locale>
@@ -64,10 +94,6 @@
 #include <sstream>
 #endif
 
-#if defined(BOOST_NO_STRINGSTREAM) || defined(BOOST_NO_STD_WSTRING)
-#define BOOST_LCAST_NO_WCHAR_T
-#endif
-
 #ifdef BOOST_NO_TYPEID
 #define BOOST_LCAST_THROW_BAD_CAST(S, T) throw_exception(bad_lexical_cast())
 #else
@@ -145,6 +171,14 @@ namespace boost
     {
         typedef CharT type;
     };
+
+#if !defined(__SUNPRO_CC)
+    template<class CharT, class Traits, class Alloc>
+    struct stream_char< ::boost::container::basic_string<CharT,Traits,Alloc> >
+    {
+        typedef CharT type;
+    };
+#endif // !defined(__SUNPRO_CC)
 #endif
 
 #ifndef BOOST_LCAST_NO_WCHAR_T
@@ -259,6 +293,25 @@ namespace boost
             typedef Traits type;
         };
 
+#if !defined(__SUNPRO_CC)
+        template<class CharT, class Traits, class Alloc, class Source>
+        struct deduce_char_traits< CharT
+                                 , ::boost::container::basic_string<CharT,Traits,Alloc>
+                                 , Source
+                                 >
+        {
+            typedef Traits type;
+        };
+
+        template<class CharT, class Target, class Traits, class Alloc>
+        struct deduce_char_traits< CharT
+                                 , Target
+                                 , ::boost::container::basic_string<CharT,Traits,Alloc>
+                                 >
+        {
+            typedef Traits type;
+        };
+
         template<class CharT, class Traits, class Alloc1, class Alloc2>
         struct deduce_char_traits< CharT
                                  , std::basic_string<CharT,Traits,Alloc1>
@@ -267,6 +320,34 @@ namespace boost
         {
             typedef Traits type;
         };
+
+        template<class CharT, class Traits, class Alloc1, class Alloc2>
+        struct deduce_char_traits< CharT
+                                 , ::boost::container::basic_string<CharT,Traits,Alloc1>
+                                 , ::boost::container::basic_string<CharT,Traits,Alloc2>
+                                 >
+        {
+            typedef Traits type;
+        };
+
+        template<class CharT, class Traits, class Alloc1, class Alloc2>
+        struct deduce_char_traits< CharT
+                                 , ::boost::container::basic_string<CharT,Traits,Alloc1>
+                                 , std::basic_string<CharT,Traits,Alloc2>
+                                 >
+        {
+            typedef Traits type;
+        };
+
+        template<class CharT, class Traits, class Alloc1, class Alloc2>
+        struct deduce_char_traits< CharT
+                                 , std::basic_string<CharT,Traits,Alloc1>
+                                 , ::boost::container::basic_string<CharT,Traits,Alloc2>
+                                 >
+        {
+            typedef Traits type;
+        };
+#endif // !defined(__SUNPRO_CC)
 #endif
     }
 
@@ -550,11 +631,12 @@ namespace boost
             --end;
             value = 0;
 
-            if ( *end < czero || *end >= czero + 10 || begin > end)
+            if (begin > end || *end < czero || *end >= czero + 10)
                 return false;
             value = *end - czero;
             --end;
             T multiplier = 1;
+            bool multiplier_overflowed = false;
 
 #ifndef BOOST_LEXICAL_CAST_ASSUME_C_LOCALE
             std::locale loc;
@@ -577,12 +659,17 @@ namespace boost
                     for(;end>=begin; --end)
                     {
                         if (remained) {
-                            T const new_sub_value = multiplier * 10 * (*end - czero);
+                            T const multiplier_10 = multiplier * 10;
+                            if (multiplier_10 / 10 != multiplier) multiplier_overflowed = true;
+
+                            T const dig_value = *end - czero;
+                            T const new_sub_value = multiplier_10 * dig_value;
 
                             if (*end < czero || *end >= czero + 10
                                     /* detecting overflow */
-                                    || new_sub_value/10 != multiplier * (*end - czero)
+                                    || (dig_value && new_sub_value / dig_value != multiplier_10)
                                     || static_cast<T>((std::numeric_limits<T>::max)()-new_sub_value) < value
+                                    || (multiplier_overflowed && dig_value)
                                     )
                                 return false;
 
@@ -620,12 +707,17 @@ namespace boost
             {
                 while ( begin <= end )
                 {
-                    T const new_sub_value = multiplier * 10 * (*end - czero);
+                    T const multiplier_10 = multiplier * 10;
+                    if (multiplier_10 / 10 != multiplier) multiplier_overflowed = true;
+
+                    T const dig_value = *end - czero;
+                    T const new_sub_value = multiplier_10 * dig_value;
 
                     if (*end < czero || *end >= czero + 10
                             /* detecting overflow */
-                            || new_sub_value/10 != multiplier * (*end - czero)
+                            || (dig_value && new_sub_value / dig_value != multiplier_10)
                             || static_cast<T>((std::numeric_limits<T>::max)()-new_sub_value) < value
+                            || (multiplier_overflowed && dig_value)
                             )
                         return false;
 
@@ -648,8 +740,9 @@ namespace boost
             , const CharT opening_brace, const CharT closing_brace)
         {
             using namespace std;
-            const wchar_t minus = lcast_char_constants<wchar_t>::minus;
-            const wchar_t plus = lcast_char_constants<wchar_t>::plus;
+            if (begin == end) return false;
+            const CharT minus = lcast_char_constants<CharT>::minus;
+            const CharT plus = lcast_char_constants<CharT>::plus;
             const int inifinity_size = 8;
 
             bool has_minus = false;
@@ -707,6 +800,26 @@ namespace boost
                                , L'(', L')');
         }
 #endif
+#ifndef BOOST_NO_CHAR16_T
+        template <class T>
+        bool parse_inf_nan(const char16_t* begin, const char16_t* end, T& value)
+        {
+            return parse_inf_nan_impl(begin, end, value
+                               , u"NAN", u"nan"
+                               , u"INFINITY", u"infinity"
+                               , u'(', u')');
+        }
+#endif
+#ifndef BOOST_NO_CHAR32_T
+        template <class T>
+        bool parse_inf_nan(const char32_t* begin, const char32_t* end, T& value)
+        {
+            return parse_inf_nan_impl(begin, end, value
+                               , U"NAN", U"nan"
+                               , U"INFINITY", U"infinity"
+                               , U'(', U')');
+        }
+#endif
 
         template <class CharT, class T>
         bool parse_inf_nan(const CharT* begin, const CharT* end, T& value)
@@ -827,7 +940,7 @@ namespace boost
             CharT const thousands_sep = grouping_size ? np.thousands_sep() : 0;
             CharT const decimal_point = np.decimal_point();
             bool found_grouping = false;
-            unsigned int last_grouping_pos = grouping_size - 1;
+            std::string::size_type last_grouping_pos = grouping_size - 1;
 #else
             CharT const decimal_point = lcast_char_constants<CharT>::c_decimal_separator;
 #endif
@@ -1147,7 +1260,7 @@ namespace boost
                 bool const result = !(stream << input).fail();
                 start = stringbuffer.pbase();
                 finish = stringbuffer.pptr();
-                return result && (start != finish);
+                return result;
             }
 
             template <class T>
@@ -1257,6 +1370,15 @@ namespace boost
                 return true;
             }
 
+#if !defined(__SUNPRO_CC)
+            template<class Alloc>
+            bool operator<<(::boost::container::basic_string<CharT,Traits,Alloc> const& str)
+            {
+                start = const_cast<CharT*>(str.data());
+                finish = start + str.length();
+                return true;
+            }
+#endif // !defined(__SUNPRO_CC)
             bool operator<<(bool value)
             {
                 CharT const czero = lcast_char_constants<CharT>::zero;
@@ -1310,9 +1432,11 @@ namespace boost
 
 /************************************ HELPER FUNCTIONS FOR OPERATORS >> ( ... ) ********************************/
         private:
+
             template <typename Type>
             bool shr_unsigned(Type& output)
             {
+                if (start == finish) return false;
                 CharT const minus = lcast_char_constants<CharT>::minus;
                 CharT const plus = lcast_char_constants<CharT>::plus;
                 bool has_minus = false;
@@ -1347,6 +1471,7 @@ namespace boost
             template <typename Type>
             bool shr_signed(Type& output)
             {
+                if (start == finish) return false;
                 CharT const minus = lcast_char_constants<CharT>::minus;
                 CharT const plus = lcast_char_constants<CharT>::plus;
                 typedef BOOST_DEDUCED_TYPENAME make_unsigned<Type>::type utype;
@@ -1436,7 +1561,7 @@ namespace boost
             }
 
 /************************************ OPERATORS >> ( ... ) ********************************/
-        public:
+            public:
             bool operator>>(unsigned short& output)             { return shr_unsigned(output); }
             bool operator>>(unsigned int& output)               { return shr_unsigned(output); }
             bool operator>>(unsigned long int& output)          { return shr_unsigned(output); }
@@ -1449,11 +1574,19 @@ namespace boost
 #elif defined(BOOST_HAS_MS_INT64)
             bool operator>>(unsigned __int64& output)           { return shr_unsigned(output); }
             bool operator>>(__int64& output)                    { return shr_signed(output); }
-
 #endif
-            bool operator>>(CharT& output)                      { return shr_xchar(output); }
+            bool operator>>(char& output)                       { return shr_xchar(output); }
             bool operator>>(unsigned char& output)              { return shr_xchar(output); }
             bool operator>>(signed char& output)                { return shr_xchar(output); }
+#if !defined(BOOST_LCAST_NO_WCHAR_T) && !defined(BOOST_NO_INTRINSIC_WCHAR_T)
+            bool operator>>(wchar_t& output)                    { return shr_xchar(output); }
+#endif
+#ifndef BOOST_NO_CHAR16_T
+            bool operator>>(char16_t& output)                   { return shr_xchar(output); }
+#endif
+#ifndef BOOST_NO_CHAR32_T
+            bool operator>>(char32_t& output)                   { return shr_xchar(output); }
+#endif
 #ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
             bool operator>>(std::string& str)                   { str.assign(start, finish); return true; }
 #   ifndef BOOST_LCAST_NO_WCHAR_T
@@ -1462,6 +1595,10 @@ namespace boost
 #else
             template<class Alloc>
             bool operator>>(std::basic_string<CharT,Traits,Alloc>& str) { str.assign(start, finish); return true; }
+#if !defined(__SUNPRO_CC)
+            template<class Alloc>
+            bool operator>>(::boost::container::basic_string<CharT,Traits,Alloc>& str) { str.assign(start, finish); return true; }
+#endif // !defined(__SUNPRO_CC)
 #endif
             /*
              * case "-0" || "0" || "+0" :   output = false; return true;
@@ -1597,7 +1734,13 @@ namespace boost
         {
             BOOST_STATIC_CONSTANT(bool, value = true );
         };
-
+#if !defined(__SUNPRO_CC)
+        template<typename CharT, typename Traits, typename Alloc>
+        struct is_stdstring< ::boost::container::basic_string<CharT, Traits, Alloc> >
+        {
+            BOOST_STATIC_CONSTANT(bool, value = true );
+        };
+#endif // !defined(__SUNPRO_CC)
         template<typename T>
         struct is_char_or_wchar
         {
@@ -1697,6 +1840,19 @@ namespace boost
         {
             BOOST_STATIC_CONSTANT(bool, value = true );
         };
+#if !defined(__SUNPRO_CC)
+        template<typename CharT, typename Traits, typename Alloc>
+        struct is_char_array_to_stdstring< ::boost::container::basic_string<CharT, Traits, Alloc>, CharT* >
+        {
+            BOOST_STATIC_CONSTANT(bool, value = true );
+        };
+
+        template<typename CharT, typename Traits, typename Alloc>
+        struct is_char_array_to_stdstring< ::boost::container::basic_string<CharT, Traits, Alloc>, const CharT* >
+        {
+            BOOST_STATIC_CONSTANT(bool, value = true );
+        };
+#endif // !defined(__SUNPRO_CC)
 
 #if (defined _MSC_VER)
 # pragma warning( push )
@@ -1725,6 +1881,24 @@ namespace boost
                     deduce_char_traits<char_type,Target,Source>::type traits;
 
                 typedef BOOST_DEDUCED_TYPENAME remove_pointer<src >::type removed_ptr_t;
+
+                // is_char_types_match variable value can be computed via
+                // sizeof(char_type) == sizeof(removed_ptr_t). But when
+                // removed_ptr_t is an incomplete type or void*, compilers
+                // produce warnings or errors.
+                const bool is_char_types_match =
+                (::boost::type_traits::ice_or<
+                    ::boost::type_traits::ice_and<
+                        ::boost::type_traits::ice_eq<sizeof(char_type), sizeof(char) >::value,
+                        ::boost::type_traits::ice_or<
+                            ::boost::is_same<char, removed_ptr_t>::value,
+                            ::boost::is_same<unsigned char, removed_ptr_t>::value,
+                            ::boost::is_same<signed char, removed_ptr_t>::value
+                        >::value
+                    >::value,
+                    is_same<char_type, removed_ptr_t>::value
+                >::value);
+
                 const bool requires_stringbuf =
                         !(
                              ::boost::type_traits::ice_or<
@@ -1733,10 +1907,7 @@ namespace boost
                                  ::boost::type_traits::ice_and<
                                      is_pointer<src >::value,
                                      is_char_or_wchar<removed_ptr_t >::value,
-                                     ::boost::type_traits::ice_eq<
-                                        sizeof(char_type),
-                                        sizeof(removed_ptr_t)
-                                     >::value
+                                     is_char_types_match
                                  >::value
                              >::value
                         );
@@ -2014,7 +2185,7 @@ namespace boost
 
 // Copyright Kevlin Henney, 2000-2005.
 // Copyright Alexander Nasonov, 2006-2010.
-// Copyright Antony Polukhin, 2011.
+// Copyright Antony Polukhin, 2011-2012.
 //
 // Distributed under the Boost Software License, Version 1.0. (See
 // accompanying file LICENSE_1_0.txt or copy at

lexical_cast_test.cpp

@@ -110,7 +110,7 @@ void test_char32_conversions();
 
 unit_test::test_suite *init_unit_test_suite(int, char *[])
 {
-    unit_test_framework::test_suite *suite =
+    unit_test::test_suite *suite =
         BOOST_TEST_SUITE("lexical_cast unit test");
     suite->add(BOOST_TEST_CASE(test_conversion_to_char));
     suite->add(BOOST_TEST_CASE(test_conversion_to_int));
@@ -796,6 +796,17 @@ void test_conversion_from_to_integral()
     BOOST_CHECK_THROW(lexical_cast<T>("+-9"), bad_lexical_cast);
     // test_conversion_from_to_integral_for_locale
 
+    // Overflow test case from David W. Birdsall
+    std::string must_owerflow_str = "160000000000000000000";
+    std::string must_owerflow_negative_str = "-160000000000000000000";
+    for (int i = 0; i < 15; ++i) {
+        BOOST_CHECK_THROW(lexical_cast<T>(must_owerflow_str), bad_lexical_cast);
+        BOOST_CHECK_THROW(lexical_cast<T>(must_owerflow_negative_str), bad_lexical_cast);
+
+        must_owerflow_str += '0';
+        must_owerflow_negative_str += '0';
+    }
+
     typedef std::numpunct<char> numpunct;
 
     restore_oldloc guard;

test/Jamfile.v2

@@ -14,7 +14,12 @@
 
 # bring in rules for testing
 import testing ;
+import feature ;
 
+feature.feature nowchar : on :
+ composite optional propagated link-incompatible ;
+feature.compose <nowchar>on : <cxxflags>/Zc:wchar_t- ; 
+ 
 test-suite conversion
   : [ run implicit_cast.cpp ]
     [ compile-fail implicit_cast_fail.cpp ]
@@ -28,7 +33,10 @@ test-suite conversion
     [ run lexical_cast_wchars_test.cpp ../../test/build//boost_unit_test_framework/<link>static ]
     [ run lexical_cast_float_types_test.cpp ../../test/build//boost_unit_test_framework/<link>static ]
     [ run lexical_cast_inf_nan_test.cpp ../../test/build//boost_unit_test_framework/<link>static ]
+    [ run lexical_cast_containers_test.cpp ../../test/build//boost_unit_test_framework/<link>static ]
     [ run lexical_cast_empty_input_test.cpp ../../test/build//boost_unit_test_framework/<link>static ]
+    [ run lexical_cast_pointers_test.cpp ../../test/build//boost_unit_test_framework/<link>static ]
+    [ compile lexical_cast_typedefed_wchar_test.cpp : <toolset>msvc:<nowchar>on ]
+    [ run lexical_cast_typedefed_wchar_test_runtime.cpp ../../test/build//boost_unit_test_framework/<link>static : : : <toolset>msvc:<nowchar>on ]
   ;
-
       

test/lexical_cast_abstract_test.cpp

@@ -28,7 +28,7 @@ void test_abstract();
 
 unit_test::test_suite *init_unit_test_suite(int, char *[])
 {
-    unit_test_framework::test_suite *suite =
+    unit_test::test_suite *suite =
         BOOST_TEST_SUITE("lexical_cast unit test");
     suite->add(BOOST_TEST_CASE(&test_abstract));
 

test/lexical_cast_containers_test.cpp

@@ -0,0 +1,38 @@
+//  Testing boost::lexical_cast with boost::container::string.
+//
+//  See http://www.boost.org for most recent version, including documentation.
+//
+//  Copyright Antony Polukhin, 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).
+
+#include <boost/lexical_cast.hpp>
+#include <boost/test/unit_test.hpp>
+#include <boost/container/string.hpp>
+
+void testing_boost_containers_basic_string();
+
+using namespace boost;
+
+boost::unit_test::test_suite *init_unit_test_suite(int, char *[])
+{
+    unit_test::test_suite *suite =
+        BOOST_TEST_SUITE("Testing boost::lexical_cast with boost::container::string");
+    suite->add(BOOST_TEST_CASE(testing_boost_containers_basic_string));
+
+    return suite;
+}
+
+void testing_boost_containers_basic_string()
+{       
+    BOOST_CHECK("100" == lexical_cast<boost::container::string>("100"));
+    BOOST_CHECK(L"100" == lexical_cast<boost::container::wstring>(L"100"));
+
+    BOOST_CHECK("100" == lexical_cast<boost::container::string>(100));
+    boost::container::string str("1000");
+    BOOST_CHECK(1000 == lexical_cast<int>(str));
+}
+
+

test/lexical_cast_empty_input_test.cpp

@@ -22,37 +22,130 @@
 
 using namespace boost;
 
-void test_empty_iterator_range()
+#if defined(BOOST_NO_STRINGSTREAM) || defined(BOOST_NO_STD_WSTRING)
+#define BOOST_LCAST_NO_WCHAR_T
+#endif
+
+template <class T>
+void do_test_on_empty_input(T& v)
 {
-		boost::iterator_range<const char*> v;
     BOOST_CHECK_THROW(lexical_cast<int>(v), bad_lexical_cast);
     BOOST_CHECK_THROW(lexical_cast<float>(v), bad_lexical_cast);
     BOOST_CHECK_THROW(lexical_cast<double>(v), bad_lexical_cast);
     BOOST_CHECK_THROW(lexical_cast<long double>(v), bad_lexical_cast);
     BOOST_CHECK_THROW(lexical_cast<unsigned int>(v), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<std::string>(v), bad_lexical_cast);
     BOOST_CHECK_THROW(lexical_cast<unsigned short>(v), bad_lexical_cast);
+#if defined(BOOST_HAS_LONG_LONG)
+    BOOST_CHECK_THROW(lexical_cast<boost::ulong_long_type>(v), bad_lexical_cast);
+    BOOST_CHECK_THROW(lexical_cast<boost::long_long_type>(v), bad_lexical_cast);
+#elif defined(BOOST_HAS_MS_INT64)
+    BOOST_CHECK_THROW(lexical_cast<unsigned __int64>(v), bad_lexical_cast);
+    BOOST_CHECK_THROW(lexical_cast<__int64>(v), bad_lexical_cast);
+#endif
+}
+
+void test_empty_iterator_range()
+{
+
+    boost::iterator_range<char*> v;
+    do_test_on_empty_input(v);
+    BOOST_CHECK_EQUAL(lexical_cast<std::string>(v), std::string());
     BOOST_CHECK_THROW(lexical_cast<char>(v), bad_lexical_cast);
+    BOOST_CHECK_THROW(lexical_cast<unsigned char>(v), bad_lexical_cast);
+    BOOST_CHECK_THROW(lexical_cast<signed char>(v), bad_lexical_cast);
+
+    boost::iterator_range<const char*> cv;
+    do_test_on_empty_input(cv);
+    BOOST_CHECK_EQUAL(lexical_cast<std::string>(cv), std::string());
+    BOOST_CHECK_THROW(lexical_cast<char>(cv), bad_lexical_cast);
+    BOOST_CHECK_THROW(lexical_cast<unsigned char>(cv), bad_lexical_cast);
+    BOOST_CHECK_THROW(lexical_cast<signed char>(cv), bad_lexical_cast);
+
+    const boost::iterator_range<const char*> ccv;
+    do_test_on_empty_input(ccv);
+    BOOST_CHECK_EQUAL(lexical_cast<std::string>(ccv), std::string());
+    BOOST_CHECK_THROW(lexical_cast<char>(ccv), bad_lexical_cast);
+    BOOST_CHECK_THROW(lexical_cast<unsigned char>(ccv), bad_lexical_cast);
+    BOOST_CHECK_THROW(lexical_cast<signed char>(ccv), bad_lexical_cast);
 }
 
 void test_empty_string()
 {
-    BOOST_CHECK_THROW(lexical_cast<int>(std::string()), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<float>(std::string()), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<double>(std::string()), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<long double>(std::string()), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<unsigned int>(std::string()), bad_lexical_cast);
-    BOOST_CHECK_EQUAL(lexical_cast<std::string>(std::string()), std::string());
-    BOOST_CHECK_THROW(lexical_cast<unsigned short>(std::string()), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<char>(std::string()), bad_lexical_cast);
+    std::string v;
+    do_test_on_empty_input(v);
+    BOOST_CHECK_THROW(lexical_cast<char>(v), bad_lexical_cast);
+    BOOST_CHECK_THROW(lexical_cast<unsigned char>(v), bad_lexical_cast);
+    BOOST_CHECK_THROW(lexical_cast<signed char>(v), bad_lexical_cast);
+
+#ifndef BOOST_LCAST_NO_WCHAR_T
+    std::wstring vw;
+    do_test_on_empty_input(vw);
+    BOOST_CHECK_THROW(lexical_cast<wchar_t>(vw), bad_lexical_cast);
+#endif
+
+// Currently, no compiler and STL library fully support char16_t and char32_t
+//#ifndef BOOST_NO_CHAR16_T
+//    std::basic_string<char16_t> v16w;
+//    do_test_on_empty_input(v16w);
+//    BOOST_CHECK_THROW(lexical_cast<char16_t>(v16w), bad_lexical_cast);
+//#endif
+//#ifndef BOOST_NO_CHAR32_T
+//    std::basic_string<char32_t> v32w;
+//    do_test_on_empty_input(v32w);
+//    BOOST_CHECK_THROW(lexical_cast<char32_t>(v32w), bad_lexical_cast);
+//#endif
+}
+
+struct Escape
+{
+    Escape(const std::string& s)
+        : str_(s)
+    {}
+
+    std::string str_;
+};
+
+inline std::ostream& operator<< (std::ostream& o, const Escape& rhs)
+{
+    return o << rhs.str_;
+}
+
+void test_empty_user_class()
+{
+    Escape v("");
+    do_test_on_empty_input(v);
+    BOOST_CHECK_THROW(lexical_cast<char>(v), bad_lexical_cast);
+    BOOST_CHECK_THROW(lexical_cast<unsigned char>(v), bad_lexical_cast);
+    BOOST_CHECK_THROW(lexical_cast<signed char>(v), bad_lexical_cast);
+}
+
+namespace std {
+inline std::ostream & operator<<(std::ostream & out, const std::vector<long> & v)
+{
+    std::ostream_iterator<long> it(out);
+    std::copy(v.begin(), v.end(), it);
+    assert(out);
+    return out;
+}
+}
+
+void test_empty_vector()
+{
+    std::vector<long> v;
+    do_test_on_empty_input(v);
+    BOOST_CHECK_THROW(lexical_cast<char>(v), bad_lexical_cast);
+    BOOST_CHECK_THROW(lexical_cast<unsigned char>(v), bad_lexical_cast);
+    BOOST_CHECK_THROW(lexical_cast<signed char>(v), bad_lexical_cast);
 }
 
 unit_test::test_suite *init_unit_test_suite(int, char *[])
 {
-    unit_test_framework::test_suite *suite =
+    unit_test::test_suite *suite =
         BOOST_TEST_SUITE("lexical_cast. Empty input unit test");
     suite->add(BOOST_TEST_CASE(&test_empty_iterator_range));
     suite->add(BOOST_TEST_CASE(&test_empty_string));
+    suite->add(BOOST_TEST_CASE(&test_empty_user_class));
+    suite->add(BOOST_TEST_CASE(&test_empty_vector));
 
     return suite;
 }

test/lexical_cast_float_types_test.cpp

@@ -31,7 +31,7 @@ using namespace boost;
 
 unit_test::test_suite *init_unit_test_suite(int, char *[])
 {
-    unit_test_framework::test_suite *suite =
+    unit_test::test_suite *suite =
         BOOST_TEST_SUITE("lexical_cast float types unit test");
     suite->add(BOOST_TEST_CASE(&test_conversion_from_to_float));
     suite->add(BOOST_TEST_CASE(&test_conversion_from_to_double));

test/lexical_cast_inf_nan_test.cpp

@@ -170,7 +170,7 @@ void test_inf_nan_long_double()
 
 unit_test::test_suite *init_unit_test_suite(int, char *[])
 {
-    unit_test_framework::test_suite *suite =
+    unit_test::test_suite *suite =
         BOOST_TEST_SUITE("lexical_cast inf anf nan parsing unit test");
     suite->add(BOOST_TEST_CASE(&test_inf_nan_float));
     suite->add(BOOST_TEST_CASE(&test_inf_nan_double));

test/lexical_cast_loopback_test.cpp

@@ -30,7 +30,7 @@ void test_round_conversion_long_double();
 
 unit_test::test_suite *init_unit_test_suite(int, char *[])
 {
-    unit_test_framework::test_suite *suite =
+    unit_test::test_suite *suite =
         BOOST_TEST_SUITE("lexical_cast unit test");
     suite->add(BOOST_TEST_CASE(&test_round_conversion_float));
     suite->add(BOOST_TEST_CASE(&test_round_conversion_double));

test/lexical_cast_noncopyable_test.cpp

@@ -28,7 +28,7 @@ void test_noncopyable();
 
 unit_test::test_suite *init_unit_test_suite(int, char *[])
 {
-    unit_test_framework::test_suite *suite =
+    unit_test::test_suite *suite =
         BOOST_TEST_SUITE("lexical_cast unit test");
     suite->add(BOOST_TEST_CASE(&test_noncopyable));
 

test/lexical_cast_pointers_test.cpp

@@ -0,0 +1,96 @@
+//  Unit test for boost::lexical_cast.
+//
+//  See http://www.boost.org for most recent version, including documentation.
+//
+//  Copyright Antony Polukhin, 2012.
+//
+//  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).
+
+#include <boost/config.hpp>
+
+#if defined(__INTEL_COMPILER)
+#pragma warning(disable: 193 383 488 981 1418 1419)
+#elif defined(BOOST_MSVC)
+#pragma warning(disable: 4097 4100 4121 4127 4146 4244 4245 4511 4512 4701 4800)
+#endif
+
+#include <boost/lexical_cast.hpp>
+#include <boost/test/unit_test.hpp>
+
+using namespace boost;
+
+#if defined(BOOST_NO_STRINGSTREAM)
+            typedef std::strstream ss_t;
+#else
+            typedef std::stringstream ss_t;
+#endif
+
+void test_void_pointers_conversions()
+{
+    void *p_to_null = NULL;
+    const void *cp_to_data = "Some data";
+    char nonconst_data[5];
+    void *p_to_data = nonconst_data;
+    ss_t ss;
+
+    ss << p_to_null;
+    BOOST_CHECK_EQUAL(boost::lexical_cast<std::string>(p_to_null), ss.str());
+    ss.str(std::string());
+
+    ss << cp_to_data;
+    BOOST_CHECK_EQUAL(boost::lexical_cast<std::string>(cp_to_data), ss.str());
+    ss.str(std::string());
+
+    ss << p_to_data;
+    BOOST_CHECK_EQUAL(boost::lexical_cast<std::string>(p_to_data), ss.str());
+    ss.str(std::string());
+}
+
+struct incomplete_type;
+
+void test_incomplete_type_pointers_conversions()
+{
+    incomplete_type *p_to_null = NULL;
+    const incomplete_type *cp_to_data = NULL;
+    char nonconst_data[5];
+    incomplete_type *p_to_data = reinterpret_cast<incomplete_type*>(nonconst_data);
+    ss_t ss;
+
+    ss << p_to_null;
+    BOOST_CHECK_EQUAL(boost::lexical_cast<std::string>(p_to_null), ss.str());
+    ss.str(std::string());
+
+    ss << cp_to_data;
+    BOOST_CHECK_EQUAL(boost::lexical_cast<std::string>(cp_to_data), ss.str());
+    ss.str(std::string());
+
+    ss << p_to_data;
+    BOOST_CHECK_EQUAL(boost::lexical_cast<std::string>(p_to_data), ss.str());
+    ss.str(std::string());
+}
+
+struct ble;
+typedef struct ble *meh;
+std::ostream& operator <<(std::ostream &o, meh) {
+  o << "yay";
+  return o;
+}
+
+void test_inomplete_type_with_overloaded_ostream_op() {
+    meh heh = NULL;
+    ss_t ss;
+    ss << heh;
+    BOOST_CHECK_EQUAL(boost::lexical_cast<std::string>(heh), ss.str());
+}
+
+unit_test::test_suite *init_unit_test_suite(int, char *[])
+{
+    unit_test::test_suite *suite =
+        BOOST_TEST_SUITE("lexical_cast pinters test");
+    suite->add(BOOST_TEST_CASE(&test_void_pointers_conversions));
+    suite->add(BOOST_TEST_CASE(&test_incomplete_type_pointers_conversions));
+    suite->add(BOOST_TEST_CASE(&test_inomplete_type_with_overloaded_ostream_op));
+    return suite;
+}

test/lexical_cast_typedefed_wchar_test.cpp

@@ -0,0 +1,25 @@
+//  Unit test for boost::lexical_cast.
+//
+//  See http://www.boost.org for most recent version, including documentation.
+//
+//  Copyright Antony Polukhin, 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).
+
+#include <boost/config.hpp>
+
+#include <boost/static_assert.hpp>
+#include <boost/lexical_cast.hpp>
+
+int main()
+{
+#ifdef BOOST_MSVC
+    BOOST_STATIC_ASSERT((boost::is_same<wchar_t, unsigned short>::value));
+#endif
+
+    return ::boost::lexical_cast<int>(L"1000") == 1000;
+}
+
+

test/lexical_cast_typedefed_wchar_test_runtime.cpp

@@ -0,0 +1,48 @@
+//  Unit test for boost::lexical_cast.
+//
+//  See http://www.boost.org for most recent version, including documentation.
+//
+//  Copyright Antony Polukhin, 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).
+
+#include <boost/config.hpp>
+
+#if defined(__INTEL_COMPILER)
+#pragma warning(disable: 193 383 488 981 1418 1419)
+#elif defined(BOOST_MSVC)
+#pragma warning(disable: 4097 4100 4121 4127 4146 4244 4245 4511 4512 4701 4800)
+#endif
+
+#include <boost/lexical_cast.hpp>
+
+#include <boost/test/unit_test.hpp>
+using namespace boost;
+
+void test_typedefed_wchar_t_runtime()
+{
+#ifndef BOOST_LCAST_NO_WCHAR_T
+#ifdef BOOST_MSVC
+    BOOST_STATIC_ASSERT((boost::is_same<wchar_t, unsigned short>::value));
+
+
+    BOOST_CHECK_EQUAL(boost::lexical_cast<int>(L'A'), 65);
+    BOOST_CHECK_EQUAL(boost::lexical_cast<int>(L'B'), 66);
+    
+    BOOST_CHECK_EQUAL(boost::lexical_cast<wchar_t>(L"65"), 65);
+    BOOST_CHECK_EQUAL(boost::lexical_cast<wchar_t>(L"66"), 66);
+#endif
+#endif
+    BOOST_CHECK(1);
+}
+
+unit_test::test_suite *init_unit_test_suite(int, char *[])
+{
+    unit_test::test_suite *suite =
+        BOOST_TEST_SUITE("lexical_cast typedefed wchar_t runtime test");
+    suite->add(BOOST_TEST_CASE(&test_typedefed_wchar_t_runtime));
+
+    return suite;
+}

test/lexical_cast_vc8_bug_test.cpp

@@ -60,7 +60,7 @@ void test_vc8_bug()
 
 unit_test::test_suite *init_unit_test_suite(int, char *[])
 {
-    unit_test_framework::test_suite *suite =
+    unit_test::test_suite *suite =
         BOOST_TEST_SUITE("lexical_cast vc8 bug unit test");
     suite->add(BOOST_TEST_CASE(test_vc8_bug));
     return suite;

test/lexical_cast_wchars_test.cpp

@@ -48,7 +48,7 @@ void test_char_types_conversions()
 
 unit_test::test_suite *init_unit_test_suite(int, char *[])
 {
-    unit_test_framework::test_suite *suite =
+    unit_test::test_suite *suite =
         BOOST_TEST_SUITE("lexical_cast char<->wchar_t unit test");
     suite->add(BOOST_TEST_CASE(&test_char_types_conversions));