Release 1.48.0

[SVN r75495]

doc/lexical_cast.qbk

@@ -159,22 +159,9 @@ 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,9 +17,8 @@
 //        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, 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
+//        Alexander Nasonov, Antony Polukhin and other Boosters
+// when:  November 2000, March 2003, June 2005, June 2006, March 2011
 
 #include <climits>
 #include <cstddef>
@@ -47,10 +46,8 @@
 #include <boost/static_assert.hpp>
 #include <boost/detail/lcast_precision.hpp>
 #include <boost/detail/workaround.hpp>
-#include <boost/container/container_fwd.hpp>
-#ifndef BOOST_NO_CWCHAR
-#   include <cwchar>
-#endif
+#include <cwchar>
+
 
 #ifndef BOOST_NO_STD_LOCALE
 #   include <locale>
@@ -148,12 +145,6 @@ namespace boost
     {
         typedef CharT type;
     };
-
-    template<class CharT, class Traits, class Alloc>
-    struct stream_char< ::boost::container::basic_string<CharT,Traits,Alloc> >
-    {
-        typedef CharT type;
-    };
 #endif
 
 #ifndef BOOST_LCAST_NO_WCHAR_T
@@ -268,24 +259,6 @@ namespace boost
             typedef Traits type;
         };
 
-        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>
@@ -294,15 +267,6 @@ 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;
-        };
 #endif
     }
 
@@ -586,12 +550,11 @@ namespace boost
             --end;
             value = 0;
 
-            if (begin > end || *end < czero || *end >= czero + 10)
+            if ( *end < czero || *end >= czero + 10 || begin > end)
                 return false;
             value = *end - czero;
             --end;
             T multiplier = 1;
-            bool multiplier_overflowed = false;
 
 #ifndef BOOST_LEXICAL_CAST_ASSUME_C_LOCALE
             std::locale loc;
@@ -614,17 +577,12 @@ namespace boost
                     for(;end>=begin; --end)
                     {
                         if (remained) {
-                            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;
+                            T const new_sub_value = multiplier * 10 * (*end - czero);
 
                             if (*end < czero || *end >= czero + 10
                                     /* detecting overflow */
-                                    || (dig_value && new_sub_value / dig_value != multiplier_10)
+                                    || new_sub_value/10 != multiplier * (*end - czero)
                                     || static_cast<T>((std::numeric_limits<T>::max)()-new_sub_value) < value
-                                    || (multiplier_overflowed && dig_value)
                                     )
                                 return false;
 
@@ -662,17 +620,12 @@ namespace boost
             {
                 while ( begin <= end )
                 {
-                    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;
+                    T const new_sub_value = multiplier * 10 * (*end - czero);
 
                     if (*end < czero || *end >= czero + 10
                             /* detecting overflow */
-                            || (dig_value && new_sub_value / dig_value != multiplier_10)
+                            || new_sub_value/10 != multiplier * (*end - czero)
                             || static_cast<T>((std::numeric_limits<T>::max)()-new_sub_value) < value
-                            || (multiplier_overflowed && dig_value)
                             )
                         return false;
 
@@ -695,9 +648,8 @@ namespace boost
             , const CharT opening_brace, const CharT closing_brace)
         {
             using namespace std;
-            if (begin == end) return false;
-            const CharT minus = lcast_char_constants<CharT>::minus;
-            const CharT plus = lcast_char_constants<CharT>::plus;
+            const wchar_t minus = lcast_char_constants<wchar_t>::minus;
+            const wchar_t plus = lcast_char_constants<wchar_t>::plus;
             const int inifinity_size = 8;
 
             bool has_minus = false;
@@ -755,26 +707,6 @@ 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)
@@ -895,7 +827,7 @@ namespace boost
             CharT const thousands_sep = grouping_size ? np.thousands_sep() : 0;
             CharT const decimal_point = np.decimal_point();
             bool found_grouping = false;
-            std::string::size_type last_grouping_pos = grouping_size - 1;
+            unsigned int last_grouping_pos = grouping_size - 1;
 #else
             CharT const decimal_point = lcast_char_constants<CharT>::c_decimal_separator;
 #endif
@@ -1215,7 +1147,7 @@ namespace boost
                 bool const result = !(stream << input).fail();
                 start = stringbuffer.pbase();
                 finish = stringbuffer.pptr();
-                return result;
+                return result && (start != finish);
             }
 
             template <class T>
@@ -1325,14 +1257,6 @@ namespace boost
                 return true;
             }
 
-            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;
-            }
-
             bool operator<<(bool value)
             {
                 CharT const czero = lcast_char_constants<CharT>::zero;
@@ -1386,11 +1310,9 @@ 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;
@@ -1425,7 +1347,6 @@ 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;
@@ -1515,7 +1436,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); }
@@ -1528,19 +1449,11 @@ 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>>(char& output)                       { return shr_xchar(output); }
+            bool operator>>(CharT& 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
@@ -1549,9 +1462,6 @@ namespace boost
 #else
             template<class Alloc>
             bool operator>>(std::basic_string<CharT,Traits,Alloc>& str) { str.assign(start, finish); return true; }
-
-            template<class Alloc>
-            bool operator>>(::boost::container::basic_string<CharT,Traits,Alloc>& str) { str.assign(start, finish); return true; }
 #endif
             /*
              * case "-0" || "0" || "+0" :   output = false; return true;
@@ -1688,12 +1598,6 @@ namespace boost
             BOOST_STATIC_CONSTANT(bool, value = true );
         };
 
-        template<typename CharT, typename Traits, typename Alloc>
-        struct is_stdstring< ::boost::container::basic_string<CharT, Traits, Alloc> >
-        {
-            BOOST_STATIC_CONSTANT(bool, value = true );
-        };
-
         template<typename T>
         struct is_char_or_wchar
         {
@@ -1794,18 +1698,6 @@ namespace boost
             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>, 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 );
-        };
-
 #if (defined _MSC_VER)
 # pragma warning( push )
 # pragma warning( disable : 4701 ) // possible use of ... before initialization
@@ -1833,24 +1725,6 @@ 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<
@@ -1859,7 +1733,10 @@ namespace boost
                                  ::boost::type_traits::ice_and<
                                      is_pointer<src >::value,
                                      is_char_or_wchar<removed_ptr_t >::value,
-                                     is_char_types_match
+                                     ::boost::type_traits::ice_eq<
+                                        sizeof(char_type),
+                                        sizeof(removed_ptr_t)
+                                     >::value
                                  >::value
                              >::value
                         );
@@ -2137,7 +2014,7 @@ namespace boost
 
 // Copyright Kevlin Henney, 2000-2005.
 // Copyright Alexander Nasonov, 2006-2010.
-// Copyright Antony Polukhin, 2011-2012.
+// Copyright Antony Polukhin, 2011.
 //
 // 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::test_suite *suite =
+    unit_test_framework::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,17 +796,6 @@ 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,12 +14,7 @@
 
 # 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 ]
@@ -33,10 +28,7 @@ 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::test_suite *suite =
+    unit_test_framework::test_suite *suite =
         BOOST_TEST_SUITE("lexical_cast unit test");
     suite->add(BOOST_TEST_CASE(&test_abstract));
 

test/lexical_cast_containers_test.cpp

@@ -1,38 +0,0 @@
-//  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,130 +22,37 @@
 
 using namespace boost;
 
-#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)
+void test_empty_iterator_range()
 {
+		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()
 {
-    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);
+    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);
 }
 
 unit_test::test_suite *init_unit_test_suite(int, char *[])
 {
-    unit_test::test_suite *suite =
+    unit_test_framework::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::test_suite *suite =
+    unit_test_framework::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::test_suite *suite =
+    unit_test_framework::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::test_suite *suite =
+    unit_test_framework::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::test_suite *suite =
+    unit_test_framework::test_suite *suite =
         BOOST_TEST_SUITE("lexical_cast unit test");
     suite->add(BOOST_TEST_CASE(&test_noncopyable));
 

test/lexical_cast_pointers_test.cpp

@@ -1,96 +0,0 @@
-//  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

@@ -1,25 +0,0 @@
-//  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

@@ -1,48 +0,0 @@
-//  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::test_suite *suite =
+    unit_test_framework::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::test_suite *suite =
+    unit_test_framework::test_suite *suite =
         BOOST_TEST_SUITE("lexical_cast char<->wchar_t unit test");
     suite->add(BOOST_TEST_CASE(&test_char_types_conversions));