Release 1.54.0

[SVN r84923]

doc/lexical_cast.qbk

@@ -3,7 +3,7 @@
     [version 1.0]
     [copyright 2000-2005 Kevlin Henney]
     [copyright 2006-2010 Alexander Nasonov]
-    [copyright 2011-2012 Antony Polukhin]
+    [copyright 2011-2013 Antony Polukhin]
     [category String and text processing]
     [category Miscellaneous]
     [license
@@ -94,8 +94,12 @@ Library features defined in [@boost:boost/lexical_cast.hpp boost/lexical_cast.hp
     namespace boost
     {
         class bad_lexical_cast;
+        
         template<typename Target, typename Source>
           Target lexical_cast(const Source& arg);
+
+        template <typename Target>
+          Target lexical_cast(const AnyCharacterType* chars, std::size_t count);
     }
 ``
 
@@ -119,15 +123,14 @@ The requirements on the argument and result types for both functions are:
 * Target is CopyConstructible [20.1.3].
 * Target is DefaultConstructible, meaning that it is possible to default-initialize an object of that type [8.5, 20.1.4].
 
-The character type of the underlying stream is assumed to be `char` unless either the `Source` or the `Target` requires wide-character streaming, in which case the underlying stream uses `wchar_t`, `char16_t` or `char32_t`. Wide-character streaming is currently detected for:
+The character type of the underlying stream is assumed to be `char` unless either the `Source` or the `Target` requires wide-character streaming, in which case the underlying stream uses `wchar_t`. Following types also can use `char16_t` or `char32_t` for wide-character streaming:
 
-* Single character: `wchar_t`, `char16_t`, `char32_t`
-* Arrays of characters: `wchar_t *`, `char16_t *`, `char32_t *`, `const wchar_t *`, `const char16_t *`, `const char32_t *`
+* Single character: `char16_t`, `char32_t`
+* Arrays of characters: `char16_t *`, `char32_t *`, `const char16_t *`, `const char32_t *`
 * Strings: `std::basic_string`, `boost::containers::basic_string`
 * `boost::iterator_range<WideCharPtr>`, where `WideCharPtr` is a pointer to wide-character or pointer to const wide-character
 * `boost::array<CharT, N>` and `std::array<CharT, N>`, `boost::array<const CharT, N>` and `std::array<const CharT, N>` 
 
-
 [important Many compilers and runtime libraries fail to make conversions using new Unicode characters. Make sure that the following code compiles and outputs nonzero values, before using new types:
 ``
     std::cout
@@ -235,7 +238,7 @@ It breaks my `operator>>` that works only in presence of this flag. Can you remo
   * [*Answer:]      May be in a future version. There is no requirement in
 __proposallong__ to reset the flag but
 remember that __proposalshort__ is not yet accepted by the committee. By the way, it's a great opportunity to
-make your `operator>>` conform to the standard.
+make your `operator>>` more general.
 Read a good C++ book, study `std::sentry` and [@boost:libs/io/doc/ios_state.html `ios_state_saver`].
 
 [pre
@@ -273,6 +276,16 @@ limitation of compiler options that you use.
 
 [section Changes]
 
+* [*boost 1.54.0 :]
+
+    * Added code to convert `boost::int128_type` and `boost::uint128_type` types (requires GCC 4.7 or higher).
+    * Conversions to pointers will now fail to compile, instead of throwing at runtime.
+    * Restored ability to get pointers to `lexical_cast` function (was broken in 1.53.0).
+
+* [*boost 1.53.0 :]
+
+    * Much better input and output streams detection for user defined types.
+
 * [*boost 1.52.0 :]
 
     * Restored compilation on MSVC-2003 (was broken in 1.51.0).
@@ -873,6 +886,132 @@ Do not use this results to compare compilers, because tests were taken on differ
 ]
 [endsect]
 
+[section Microsoft Visual C++ version 11.0]
+[table:id Performance Table ( Microsoft Visual C++ version 11.0)
+[[From->To] [lexical_cast] [std::stringstream with construction] [std::stringstream without construction][scanf/printf]]
+  [[ string->char ][ !!! *<1* !!! ][ 43 ][ 17 ][ 7 ]]
+  [[ string->signed char ][ !!! *<1* !!! ][ 43 ][ 17 ][ 8 ]]
+  [[ string->unsigned char ][ !!! *<1* !!! ][ 42 ][ 17 ][ 8 ]]
+  [[ string->int ][ !!! *8* !!! ][ 71 ][ 49 ][ 10 ]]
+  [[ string->short ][ !!! *8* !!! ][ 72 ][ 47 ][ 10 ]]
+  [[ string->long int ][ !!! *8* !!! ][ 71 ][ 47 ][ 10 ]]
+  [[ string->long long ][ !!! *8* !!! ][ 71 ][ 47 ][ 10 ]]
+  [[ string->unsigned int ][ !!! *8* !!! ][ 72 ][ 46 ][ 10 ]]
+  [[ string->unsigned short ][ !!! *8* !!! ][ 71 ][ 47 ][ 10 ]]
+  [[ string->unsigned long int ][ !!! *8* !!! ][ 70 ][ 45 ][ 10 ]]
+  [[ string->unsigned long long ][ !!! *8* !!! ][ 70 ][ 46 ][ 10 ]]
+  [[ string->float ][ !!! *14* !!! ][ 586 ][ 559 ][ 37 ]]
+  [[ string->double ][ 601 ][ 618 ][ 592 ][ !!! *37* !!! ]]
+  [[ string->long double ][ 629 ][ 645 ][ 618 ][ !!! *37* !!! ]]
+  [[ string->array<char, 50> ][ !!! *<1* !!! ][ 52 ][ 28 ][ 11 ]]
+  [[ string->string ][ !!! *1* !!! ][ 59 ][ 34 ][ --- ]]
+  [[ string->container::string ][ !!! *2* !!! ][ 54 ][ 31 ][ --- ]]
+  [[ string->char ][ !!! *2* !!! ][ 50 ][ 24 ][ 9 ]]
+  [[ string->signed char ][ !!! *2* !!! ][ 50 ][ 24 ][ 13 ]]
+  [[ string->unsigned char ][ !!! *2* !!! ][ 50 ][ 24 ][ 13 ]]
+  [[ int->string ][ !!! *9* !!! ][ 86 ][ 59 ][ 13 ]]
+  [[ short->string ][ !!! *9* !!! ][ 86 ][ 59 ][ 13 ]]
+  [[ long int->string ][ !!! *9* !!! ][ 87 ][ 59 ][ 13 ]]
+  [[ long long->string ][ !!! *9* !!! ][ 88 ][ 62 ][ 13 ]]
+  [[ unsigned int->string ][ !!! *9* !!! ][ 87 ][ 60 ][ 13 ]]
+  [[ unsigned short->string ][ !!! *9* !!! ][ 91 ][ 63 ][ 13 ]]
+  [[ unsigned long int->string ][ !!! *9* !!! ][ 91 ][ 62 ][ 13 ]]
+  [[ unsigned long long->string ][ !!! *9* !!! ][ 88 ][ 60 ][ 13 ]]
+  [[ float->string ][ 73 ][ 167 ][ 137 ][ !!! *56* !!! ]]
+  [[ double->string ][ 77 ][ 176 ][ 144 ][ !!! *64* !!! ]]
+  [[ long double->string ][ 79 ][ 175 ][ 143 ][ !!! *63* !!! ]]
+  [[ char*->char ][ !!! *<1* !!! ][ 43 ][ 17 ][ 7 ]]
+  [[ char*->signed char ][ !!! *<1* !!! ][ 43 ][ 17 ][ 8 ]]
+  [[ char*->unsigned char ][ !!! *<1* !!! ][ 44 ][ 17 ][ 8 ]]
+  [[ char*->int ][ !!! *8* !!! ][ 70 ][ 47 ][ 10 ]]
+  [[ char*->short ][ !!! *8* !!! ][ 72 ][ 48 ][ 10 ]]
+  [[ char*->long int ][ !!! *8* !!! ][ 72 ][ 47 ][ 10 ]]
+  [[ char*->long long ][ !!! *8* !!! ][ 71 ][ 47 ][ 10 ]]
+  [[ char*->unsigned int ][ !!! *8* !!! ][ 72 ][ 46 ][ 10 ]]
+  [[ char*->unsigned short ][ !!! *8* !!! ][ 72 ][ 47 ][ 10 ]]
+  [[ char*->unsigned long int ][ !!! *8* !!! ][ 70 ][ 46 ][ 10 ]]
+  [[ char*->unsigned long long ][ !!! *8* !!! ][ 70 ][ 45 ][ 10 ]]
+  [[ char*->float ][ !!! *14* !!! ][ 586 ][ 560 ][ 37 ]]
+  [[ char*->double ][ 598 ][ 617 ][ 597 ][ !!! *40* !!! ]]
+  [[ char*->long double ][ 635 ][ 653 ][ 622 ][ !!! *37* !!! ]]
+  [[ char*->array<char, 50> ][ !!! *1* !!! ][ 53 ][ 28 ][ 11 ]]
+  [[ char*->string ][ !!! *1* !!! ][ 59 ][ 35 ][ --- ]]
+  [[ char*->container::string ][ !!! *3* !!! ][ 54 ][ 30 ][ --- ]]
+  [[ unsigned char*->char ][ !!! *<1* !!! ][ 41 ][ 17 ][ 7 ]]
+  [[ unsigned char*->signed char ][ !!! *<1* !!! ][ 42 ][ 17 ][ 8 ]]
+  [[ unsigned char*->unsigned char ][ !!! *<1* !!! ][ 41 ][ 17 ][ 8 ]]
+  [[ unsigned char*->int ][ !!! *8* !!! ][ 72 ][ 47 ][ 10 ]]
+  [[ unsigned char*->short ][ !!! *8* !!! ][ 72 ][ 47 ][ 10 ]]
+  [[ unsigned char*->long int ][ !!! *8* !!! ][ 72 ][ 47 ][ 10 ]]
+  [[ unsigned char*->long long ][ !!! *8* !!! ][ 72 ][ 47 ][ 11 ]]
+  [[ unsigned char*->unsigned int ][ !!! *8* !!! ][ 70 ][ 46 ][ 10 ]]
+  [[ unsigned char*->unsigned short ][ !!! *8* !!! ][ 72 ][ 48 ][ 10 ]]
+  [[ unsigned char*->unsigned long int ][ !!! *8* !!! ][ 71 ][ 46 ][ 10 ]]
+  [[ unsigned char*->unsigned long long ][ !!! *8* !!! ][ 70 ][ 45 ][ 11 ]]
+  [[ unsigned char*->float ][ !!! *14* !!! ][ 589 ][ 564 ][ 38 ]]
+  [[ unsigned char*->double ][ 601 ][ 615 ][ 588 ][ !!! *37* !!! ]]
+  [[ unsigned char*->long double ][ 628 ][ 644 ][ 620 ][ !!! *38* !!! ]]
+  [[ unsigned char*->array<char, 50> ][ !!! *1* !!! ][ 54 ][ 28 ][ 11 ]]
+  [[ unsigned char*->string ][ !!! *2* !!! ][ 59 ][ 36 ][ --- ]]
+  [[ unsigned char*->container::string ][ !!! *3* !!! ][ 54 ][ 30 ][ --- ]]
+  [[ signed char*->char ][ !!! *<1* !!! ][ 41 ][ 17 ][ 7 ]]
+  [[ signed char*->signed char ][ !!! *<1* !!! ][ 43 ][ 17 ][ 8 ]]
+  [[ signed char*->unsigned char ][ !!! *<1* !!! ][ 42 ][ 17 ][ 8 ]]
+  [[ signed char*->int ][ !!! *8* !!! ][ 71 ][ 47 ][ 10 ]]
+  [[ signed char*->short ][ !!! *8* !!! ][ 72 ][ 48 ][ 10 ]]
+  [[ signed char*->long int ][ !!! *8* !!! ][ 71 ][ 47 ][ 10 ]]
+  [[ signed char*->long long ][ !!! *8* !!! ][ 72 ][ 47 ][ 10 ]]
+  [[ signed char*->unsigned int ][ !!! *8* !!! ][ 70 ][ 46 ][ 10 ]]
+  [[ signed char*->unsigned short ][ !!! *8* !!! ][ 72 ][ 47 ][ 10 ]]
+  [[ signed char*->unsigned long int ][ !!! *8* !!! ][ 70 ][ 46 ][ 10 ]]
+  [[ signed char*->unsigned long long ][ !!! *8* !!! ][ 70 ][ 46 ][ 11 ]]
+  [[ signed char*->float ][ !!! *14* !!! ][ 586 ][ 562 ][ 37 ]]
+  [[ signed char*->double ][ 603 ][ 615 ][ 589 ][ !!! *37* !!! ]]
+  [[ signed char*->long double ][ 630 ][ 644 ][ 623 ][ !!! *40* !!! ]]
+  [[ signed char*->array<char, 50> ][ !!! *1* !!! ][ 54 ][ 28 ][ 11 ]]
+  [[ signed char*->string ][ !!! *2* !!! ][ 59 ][ 36 ][ --- ]]
+  [[ signed char*->container::string ][ !!! *3* !!! ][ 54 ][ 30 ][ --- ]]
+  [[ iterator_range<char*>->char ][ !!! *<1* !!! ][ 74 ][ 46 ][ 7 ]]
+  [[ iterator_range<char*>->signed char ][ !!! *<1* !!! ][ 75 ][ 46 ][ 8 ]]
+  [[ iterator_range<char*>->unsigned char ][ !!! *<1* !!! ][ 74 ][ 46 ][ 8 ]]
+  [[ iterator_range<char*>->int ][ !!! *8* !!! ][ 98 ][ 70 ][ 10 ]]
+  [[ iterator_range<char*>->short ][ !!! *8* !!! ][ 103 ][ 72 ][ 10 ]]
+  [[ iterator_range<char*>->long int ][ !!! *8* !!! ][ 111 ][ 71 ][ 10 ]]
+  [[ iterator_range<char*>->long long ][ !!! *8* !!! ][ 98 ][ 70 ][ 10 ]]
+  [[ iterator_range<char*>->unsigned int ][ !!! *7* !!! ][ 103 ][ 76 ][ 10 ]]
+  [[ iterator_range<char*>->unsigned short ][ !!! *8* !!! ][ 104 ][ 75 ][ 10 ]]
+  [[ iterator_range<char*>->unsigned long int ][ !!! *7* !!! ][ 104 ][ 71 ][ 10 ]]
+  [[ iterator_range<char*>->unsigned long long ][ !!! *8* !!! ][ 99 ][ 71 ][ 11 ]]
+  [[ iterator_range<char*>->float ][ !!! *13* !!! ][ 123 ][ 93 ][ 37 ]]
+  [[ iterator_range<char*>->double ][ 603 ][ 111 ][ 82 ][ !!! *38* !!! ]]
+  [[ iterator_range<char*>->long double ][ 629 ][ 116 ][ 83 ][ !!! *38* !!! ]]
+  [[ iterator_range<char*>->array<char, 50> ][ !!! *<1* !!! ][ 82 ][ 52 ][ 11 ]]
+  [[ iterator_range<char*>->string ][ !!! *2* !!! ][ 83 ][ 56 ][ --- ]]
+  [[ iterator_range<char*>->container::string ][ !!! *2* !!! ][ 81 ][ 53 ][ --- ]]
+  [[ array<char, 50>->char ][ !!! *<1* !!! ][ 41 ][ 17 ][ 7 ]]
+  [[ array<char, 50>->signed char ][ !!! *<1* !!! ][ 41 ][ 17 ][ 8 ]]
+  [[ array<char, 50>->unsigned char ][ !!! *<1* !!! ][ 41 ][ 17 ][ 8 ]]
+  [[ array<char, 50>->int ][ !!! *8* !!! ][ 73 ][ 46 ][ 10 ]]
+  [[ array<char, 50>->short ][ !!! *8* !!! ][ 73 ][ 47 ][ 10 ]]
+  [[ array<char, 50>->long int ][ !!! *8* !!! ][ 75 ][ 48 ][ 10 ]]
+  [[ array<char, 50>->long long ][ !!! *8* !!! ][ 73 ][ 48 ][ 11 ]]
+  [[ array<char, 50>->unsigned int ][ !!! *8* !!! ][ 73 ][ 47 ][ 10 ]]
+  [[ array<char, 50>->unsigned short ][ !!! *8* !!! ][ 74 ][ 50 ][ 10 ]]
+  [[ array<char, 50>->unsigned long int ][ !!! *8* !!! ][ 71 ][ 46 ][ 10 ]]
+  [[ array<char, 50>->unsigned long long ][ !!! *8* !!! ][ 70 ][ 47 ][ 11 ]]
+  [[ array<char, 50>->float ][ !!! *14* !!! ][ 586 ][ 567 ][ 37 ]]
+  [[ array<char, 50>->double ][ 599 ][ 624 ][ 590 ][ !!! *37* !!! ]]
+  [[ array<char, 50>->long double ][ 632 ][ 643 ][ 618 ][ !!! *37* !!! ]]
+  [[ array<char, 50>->array<char, 50> ][ !!! *1* !!! ][ 52 ][ 28 ][ 11 ]]
+  [[ array<char, 50>->string ][ !!! *2* !!! ][ 59 ][ 34 ][ --- ]]
+  [[ array<char, 50>->container::string ][ !!! *3* !!! ][ 55 ][ 30 ][ --- ]]
+  [[ int->int ][ !!! *<1* !!! ][ 105 ][ 79 ][ --- ]]
+  [[ float->double ][ !!! *<1* !!! ][ 226 ][ 188 ][ --- ]]
+  [[ char->signed char ][ !!! *<1* !!! ][ 40 ][ 16 ][ --- ]]
+]
+[endsect]
+
+
 
 [/ END of section, generated by performance measuring program ]
 [endsect]

lexical_cast_test.cpp

@@ -36,6 +36,7 @@
 #include <boost/type_traits/integral_promotion.hpp>
 #include <string>
 #include <vector>
+#include <algorithm> // std::transform
 #include <memory>
 
 #if (defined(BOOST_HAS_LONG_LONG) || defined(BOOST_HAS_MS_INT64)) \
@@ -66,7 +67,6 @@ void test_conversion_to_bool();
 void test_conversion_with_nonconst_char();
 void test_conversion_to_string();
 void test_conversion_from_to_wchar_t_alias();
-void test_conversion_to_pointer();
 void test_conversion_from_wchar_t();
 void test_conversion_to_wchar_t();
 void test_conversion_from_wstring();
@@ -82,10 +82,10 @@ void test_wallocator();
 #endif
 void test_char_types_conversions();
 void operators_overload_test();
-#if !defined(BOOST_NO_CHAR16_T) && !defined(BOOST_NO_UNICODE_LITERALS)
+#if !defined(BOOST_NO_CXX11_CHAR16_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS)
 void test_char16_conversions();
 #endif
-#if !defined(BOOST_NO_CHAR32_T) && !defined(BOOST_NO_UNICODE_LITERALS)
+#if !defined(BOOST_NO_CXX11_CHAR32_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS)
 void test_char32_conversions();
 #endif
 void test_getting_pointer_to_function();
@@ -99,7 +99,6 @@ unit_test::test_suite *init_unit_test_suite(int, char *[])
     suite->add(BOOST_TEST_CASE(test_conversion_to_double));
     suite->add(BOOST_TEST_CASE(test_conversion_to_bool));
     suite->add(BOOST_TEST_CASE(test_conversion_from_to_wchar_t_alias));
-    suite->add(BOOST_TEST_CASE(test_conversion_to_pointer));
     suite->add(BOOST_TEST_CASE(test_conversion_to_string));
     suite->add(BOOST_TEST_CASE(test_conversion_with_nonconst_char));
 #ifndef BOOST_LCAST_NO_WCHAR_T
@@ -120,10 +119,10 @@ unit_test::test_suite *init_unit_test_suite(int, char *[])
 
     suite->add(BOOST_TEST_CASE(&test_char_types_conversions));
     suite->add(BOOST_TEST_CASE(&operators_overload_test));
-#if !defined(BOOST_NO_CHAR16_T) && !defined(BOOST_NO_UNICODE_LITERALS)
+#if !defined(BOOST_NO_CXX11_CHAR16_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS)
     suite->add(BOOST_TEST_CASE(&test_char16_conversions));
 #endif
-#if !defined(BOOST_NO_CHAR32_T) && !defined(BOOST_NO_UNICODE_LITERALS)
+#if !defined(BOOST_NO_CXX11_CHAR32_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS)
     suite->add(BOOST_TEST_CASE(&test_char32_conversions));
 #endif
     suite->add(BOOST_TEST_CASE(&test_getting_pointer_to_function));
@@ -243,9 +242,15 @@ void test_conversion_to_bool()
     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_THROW(lexical_cast<bool>(-123), bad_lexical_cast);
     BOOST_CHECK_EQUAL(false, lexical_cast<bool>(0.0));
+    BOOST_CHECK_THROW(lexical_cast<bool>(1234), bad_lexical_cast);
+#if !defined(_CRAYC)
+    // Looks like a bug in CRAY compiler (throws bad_lexical_cast)
+    // TODO: localize the bug and report it to developers.
     BOOST_CHECK_EQUAL(true, lexical_cast<bool>(true));
     BOOST_CHECK_EQUAL(false, lexical_cast<bool>(false));
+#endif
     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);
@@ -305,14 +310,6 @@ void test_conversion_from_to_wchar_t_alias()
     BOOST_CHECK_EQUAL(std::string("123"), lexical_cast<std::string>(123ul));
 }
 
-void test_conversion_to_pointer()
-{
-    BOOST_CHECK_THROW(lexical_cast<char *>("Test"), bad_lexical_cast);
-#ifndef BOOST_LCAST_NO_WCHAR_T
-    BOOST_CHECK_THROW(lexical_cast<wchar_t *>("Test"), bad_lexical_cast);
-#endif
-}
-
 void test_conversion_from_wchar_t()
 {
 #ifndef BOOST_LCAST_NO_WCHAR_T
@@ -585,7 +582,7 @@ void operators_overload_test()
 }
 
 
-#if !defined(BOOST_NO_CHAR16_T) && !defined(BOOST_NO_UNICODE_LITERALS)
+#if !defined(BOOST_NO_CXX11_CHAR16_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS)
 void test_char16_conversions()
 {
     BOOST_CHECK(u"100" == lexical_cast<std::u16string>(u"100"));
@@ -593,7 +590,7 @@ void test_char16_conversions()
 }
 #endif
 
-#if !defined(BOOST_NO_CHAR16_T) && !defined(BOOST_NO_UNICODE_LITERALS)
+#if !defined(BOOST_NO_CXX11_CHAR16_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS)
 void test_char32_conversions()
 {
     BOOST_CHECK(U"100" == lexical_cast<std::u32string>(U"100"));
@@ -601,17 +598,25 @@ void test_char32_conversions()
 }
 #endif
 
-template <class To, class From, class Func>
-To try_cast_by_ptr(const From& from, const Func& f) {
-    return f(from);
-};
-
 void test_getting_pointer_to_function()
 {
     // Just checking that &lexical_cast<To, From> is not ambiguous
-    BOOST_CHECK_EQUAL(100, try_cast_by_ptr<int>("100", &boost::lexical_cast<int, const char[4]>));
-    BOOST_CHECK_EQUAL(100, try_cast_by_ptr<int>("100", &boost::lexical_cast<int, std::string>));
-    BOOST_CHECK_EQUAL(std::string("100"), try_cast_by_ptr<std::string>(100, &boost::lexical_cast<std::string, int>));
+    typedef char char_arr[4];    
+    typedef int(*f1)(const char_arr&);
+    f1 p1 = &boost::lexical_cast<int, char_arr>;
+    BOOST_CHECK(p1);
+
+    typedef int(*f2)(const std::string&);
+    f2 p2 = &boost::lexical_cast<int, std::string>;
+    BOOST_CHECK(p2);
+
+    typedef std::string(*f3)(const int&);
+    f3 p3 = &boost::lexical_cast<std::string, int>;
+    BOOST_CHECK(p3);
+
+    std::vector<int> values;
+    std::vector<std::string> ret;
+    std::transform(values.begin(), values.end(), ret.begin(), boost::lexical_cast<std::string, int>);
 }
 
 

test/Jamfile.v2

@@ -12,7 +12,9 @@ project
     : requirements
         <library>/boost/test//boost_unit_test_framework
         <link>static
-        <toolset>gcc-4.8:<define>BOOST_STL_SUPPORTS_NEW_UNICODE_LOCALES
+        <toolset>gcc-4.7:<cxxflags>-ftrapv
+        <toolset>gcc-4.6:<cxxflags>-ftrapv
+        <toolset>clang:<cxxflags>-ftrapv
     ;
 
 # Thanks to Steven Watanabe for helping with <nowchar> feature
@@ -40,14 +42,20 @@ test-suite conversion
     [ run lexical_cast_typedefed_wchar_test_runtime.cpp : : : <toolset>msvc:<nowchar>on <toolset>msvc,<stdlib>stlport:<build>no ]
     [ run lexical_cast_no_locale_test.cpp : : : <define>BOOST_NO_STD_LOCALE <define>BOOST_LEXICAL_CAST_ASSUME_C_LOCALE ]
     [ run lexical_cast_no_exceptions_test.cpp : : : <define>BOOST_NO_EXCEPTIONS
-      <toolset>gcc-4.3:<cflags>-fno-exceptions
-      <toolset>gcc-4.4:<cflags>-fno-exceptions
-      <toolset>gcc-4.5:<cflags>-fno-exceptions
-      <toolset>gcc-4.6:<cflags>-fno-exceptions
-      <toolset>gcc-4.7:<cflags>-fno-exceptions
+      <toolset>gcc-4.3:<cxxflags>-fno-exceptions
+      <toolset>gcc-4.4:<cxxflags>-fno-exceptions
+      <toolset>gcc-4.5:<cxxflags>-fno-exceptions
+      <toolset>gcc-4.6:<cxxflags>-fno-exceptions
+      <toolset>gcc-4.7:<cxxflags>-fno-exceptions
+      <toolset>gcc-4.8:<cxxflags>-fno-exceptions
+      <toolset>clang:<cxxflags>-fno-exceptions
     ]
     [ run lexical_cast_iterator_range_test.cpp ]
     [ run lexical_cast_arrays_test.cpp ]
     [ run lexical_cast_integral_types_test.cpp ]
+    [ run lexical_cast_stream_detection_test.cpp ]
+    [ run lexical_cast_stream_traits_test.cpp ]
+    [ compile-fail lexical_cast_to_pointer_test.cpp ]
+    [ run lexical_cast_filesystem_test.cpp ../../filesystem/build//boost_filesystem/<link>static ]
   ;
 

test/lexical_cast_arrays_test.cpp

@@ -22,6 +22,14 @@ void testing_std_array_input_conversion();
 
 using namespace boost;
 
+#if !defined(BOOST_NO_CXX11_CHAR16_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS) && !defined(_LIBCPP_VERSION)
+#define BOOST_LC_RUNU16
+#endif
+
+#if !defined(BOOST_NO_CXX11_CHAR32_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS) && !defined(_LIBCPP_VERSION)
+#define BOOST_LC_RUNU32
+#endif
+
 boost::unit_test::test_suite *init_unit_test_suite(int, char *[])
 {
     unit_test::test_suite *suite =
@@ -50,25 +58,25 @@ static void testing_template_array_output_on_spec_value(T val)
 
     {
         arr_type res1 = lexical_cast<arr_type>(val);
-        BOOST_CHECK_EQUAL(res1.begin(), ethalon);
+        BOOST_CHECK_EQUAL(&res1[0], ethalon);
         const arr_type res2 = lexical_cast<arr_type>(val);
-        BOOST_CHECK_EQUAL(res2.begin(), ethalon);
+        BOOST_CHECK_EQUAL(&res2[0], ethalon);
         BOOST_CHECK_THROW(lexical_cast<short_arr_type>(val), boost::bad_lexical_cast);
     }
     
     {
         uarr_type res1 = lexical_cast<uarr_type>(val);
-        BOOST_CHECK_EQUAL(reinterpret_cast<char*>(res1.begin()), ethalon);
+        BOOST_CHECK_EQUAL(reinterpret_cast<char*>(&res1[0]), ethalon);
         const uarr_type res2 = lexical_cast<uarr_type>(val);
-        BOOST_CHECK_EQUAL(reinterpret_cast<const char*>(res2.begin()), ethalon);
+        BOOST_CHECK_EQUAL(reinterpret_cast<const char*>(&res2[0]), ethalon);
         BOOST_CHECK_THROW(lexical_cast<ushort_arr_type>(val), boost::bad_lexical_cast);
     }
     
     {
         sarr_type res1 = lexical_cast<sarr_type>(val);
-        BOOST_CHECK_EQUAL(reinterpret_cast<char*>(res1.begin()), ethalon);
+        BOOST_CHECK_EQUAL(reinterpret_cast<char*>(&res1[0]), ethalon);
         const sarr_type res2 = lexical_cast<sarr_type>(val);
-        BOOST_CHECK_EQUAL(reinterpret_cast<const char*>(res2.begin()), ethalon);
+        BOOST_CHECK_EQUAL(reinterpret_cast<const char*>(&res2[0]), ethalon);
         BOOST_CHECK_THROW(lexical_cast<sshort_arr_type>(val), boost::bad_lexical_cast);
     }
 
@@ -79,49 +87,49 @@ static void testing_template_array_output_on_spec_value(T val)
 
     {
         warr_type res = lexical_cast<warr_type>(val);
-        BOOST_CHECK(res.begin() == wethalon);
+        BOOST_CHECK(&res[0] == wethalon);
     }
 
     {
         const warr_type res = lexical_cast<warr_type>(val);
-        BOOST_CHECK(res.begin() == wethalon);
+        BOOST_CHECK(&res[0] == wethalon);
     }
     
     BOOST_CHECK_THROW(lexical_cast<wshort_arr_type>(val), boost::bad_lexical_cast);
 
 #endif
 
-#if !defined(BOOST_NO_CHAR16_T) && !defined(BOOST_NO_UNICODE_LITERALS)
+#ifdef BOOST_LC_RUNU16
     typedef ArrayT<char16_t, 300> u16arr_type;
     typedef ArrayT<char16_t, 3> u16short_arr_type;
     std::u16string u16ethalon(u"100");
 
     {
         u16arr_type res = lexical_cast<u16arr_type>(val);
-        BOOST_CHECK(res.begin() == u16ethalon);
+        BOOST_CHECK(&res[0] == u16ethalon);
     }
 
     {
         const u16arr_type res = lexical_cast<u16arr_type>(val);
-        BOOST_CHECK(res.begin() == u16ethalon);
+        BOOST_CHECK(&res[0] == u16ethalon);
     }
     
     BOOST_CHECK_THROW(lexical_cast<u16short_arr_type>(val), boost::bad_lexical_cast);
 #endif
 
-#if !defined(BOOST_NO_CHAR32_T) && !defined(BOOST_NO_UNICODE_LITERALS)
+#ifdef BOOST_LC_RUNU32
     typedef ArrayT<char32_t, 300> u32arr_type;
     typedef ArrayT<char32_t, 3> u32short_arr_type;
     std::u32string u32ethalon(U"100");
 
     {
         u32arr_type res = lexical_cast<u32arr_type>(val);
-        BOOST_CHECK(res.begin() == u32ethalon);
+        BOOST_CHECK(&res[0] == u32ethalon);
     }
 
     {
         const u32arr_type res = lexical_cast<u32arr_type>(val);
-        BOOST_CHECK(res.begin() == u32ethalon);
+        BOOST_CHECK(&res[0] == u32ethalon);
     }
     
     BOOST_CHECK_THROW(lexical_cast<u32short_arr_type>(val), boost::bad_lexical_cast);
@@ -145,25 +153,25 @@ static void testing_template_array_output_on_char_value()
 
     {
         arr_type res1 = lexical_cast<arr_type>(val);
-        BOOST_CHECK_EQUAL(res1.begin(), ethalon);
+        BOOST_CHECK_EQUAL(&res1[0], ethalon);
         const arr_type res2 = lexical_cast<arr_type>(val);
-        BOOST_CHECK_EQUAL(res2.begin(), ethalon);
+        BOOST_CHECK_EQUAL(&res2[0], ethalon);
         BOOST_CHECK_THROW(lexical_cast<short_arr_type>(val), boost::bad_lexical_cast);
     }
     
     {
         uarr_type res1 = lexical_cast<uarr_type>(val);
-        BOOST_CHECK_EQUAL(reinterpret_cast<char*>(res1.begin()), ethalon);
+        BOOST_CHECK_EQUAL(reinterpret_cast<char*>(&res1[0]), ethalon);
         const uarr_type res2 = lexical_cast<uarr_type>(val);
-        BOOST_CHECK_EQUAL(reinterpret_cast<const char*>(res2.begin()), ethalon);
+        BOOST_CHECK_EQUAL(reinterpret_cast<const char*>(&res2[0]), ethalon);
         BOOST_CHECK_THROW(lexical_cast<ushort_arr_type>(val), boost::bad_lexical_cast);
     }
     
     {
         sarr_type res1 = lexical_cast<sarr_type>(val);
-        BOOST_CHECK_EQUAL(reinterpret_cast<char*>(res1.begin()), ethalon);
+        BOOST_CHECK_EQUAL(reinterpret_cast<char*>(&res1[0]), ethalon);
         const sarr_type res2 = lexical_cast<sarr_type>(val);
-        BOOST_CHECK_EQUAL(reinterpret_cast<const char*>(res2.begin()), ethalon);
+        BOOST_CHECK_EQUAL(reinterpret_cast<const char*>(&res2[0]), ethalon);
         BOOST_CHECK_THROW(lexical_cast<sshort_arr_type>(val), boost::bad_lexical_cast);
     }
 
@@ -174,23 +182,23 @@ static void testing_template_array_output_on_char_value()
 
     {
         warr_type res = lexical_cast<warr_type>(val);
-        BOOST_CHECK(res.begin() == wethalon);
+        BOOST_CHECK(&res[0] == wethalon);
         warr_type res3 = lexical_cast<warr_type>(wethalon);
-        BOOST_CHECK(res3.begin() == wethalon);
+        BOOST_CHECK(&res3[0] == wethalon);
     }
 
     {
         const warr_type res = lexical_cast<warr_type>(val);
-        BOOST_CHECK(res.begin() == wethalon);
+        BOOST_CHECK(&res[0] == wethalon);
         const warr_type res3 = lexical_cast<warr_type>(wethalon);
-        BOOST_CHECK(res3.begin() == wethalon);
+        BOOST_CHECK(&res3[0] == wethalon);
     }
     
     BOOST_CHECK_THROW(lexical_cast<wshort_arr_type>(val), boost::bad_lexical_cast);
 
 #endif
 
-#if !defined(BOOST_NO_CHAR16_T) && !defined(BOOST_NO_UNICODE_LITERALS)
+#ifdef BOOST_LC_RUNU16
     typedef ArrayT<char16_t, 300> u16arr_type;
     typedef ArrayT<char16_t, 3> u16short_arr_type;
     std::u16string u16ethalon(u"100");
@@ -198,26 +206,26 @@ static void testing_template_array_output_on_char_value()
     {
 #ifdef BOOST_STL_SUPPORTS_NEW_UNICODE_LOCALES
         u16arr_type res = lexical_cast<u16arr_type>(val);
-        BOOST_CHECK(res.begin() == u16ethalon);  
+        BOOST_CHECK(&res[0] == u16ethalon);  
 #endif
 
         u16arr_type res3 = lexical_cast<u16arr_type>(u16ethalon);
-        BOOST_CHECK(res3.begin() == u16ethalon);
+        BOOST_CHECK(&res3[0] == u16ethalon);
     }
 
     {
 #ifdef BOOST_STL_SUPPORTS_NEW_UNICODE_LOCALES
         const u16arr_type res = lexical_cast<u16arr_type>(val);
-        BOOST_CHECK(res.begin() == u16ethalon);
+        BOOST_CHECK(&res[0] == u16ethalon);
 #endif
         const u16arr_type res3 = lexical_cast<u16arr_type>(u16ethalon);
-        BOOST_CHECK(res3.begin() == u16ethalon);
+        BOOST_CHECK(&res3[0] == u16ethalon);
     }
     
     BOOST_CHECK_THROW(lexical_cast<u16short_arr_type>(val), boost::bad_lexical_cast);
 #endif
 
-#if !defined(BOOST_NO_CHAR32_T) && !defined(BOOST_NO_UNICODE_LITERALS)
+#ifdef BOOST_LC_RUNU32
     typedef ArrayT<char32_t, 300> u32arr_type;
     typedef ArrayT<char32_t, 3> u32short_arr_type;
     std::u32string u32ethalon(U"100");
@@ -225,19 +233,19 @@ static void testing_template_array_output_on_char_value()
     {
 #ifdef BOOST_STL_SUPPORTS_NEW_UNICODE_LOCALES
         u32arr_type res = lexical_cast<u32arr_type>(val);
-        BOOST_CHECK(res.begin() == u32ethalon);
+        BOOST_CHECK(&res[0] == u32ethalon);
 #endif
         u32arr_type res3 = lexical_cast<u32arr_type>(u32ethalon);
-        BOOST_CHECK(res3.begin() == u32ethalon);
+        BOOST_CHECK(&res3[0] == u32ethalon);
     }
 
     {
 #ifdef BOOST_STL_SUPPORTS_NEW_UNICODE_LOCALES
         const u32arr_type res = lexical_cast<u32arr_type>(val);
-        BOOST_CHECK(res.begin() == u32ethalon);
+        BOOST_CHECK(&res[0] == u32ethalon);
 #endif
         const u32arr_type res3 = lexical_cast<u32arr_type>(u32ethalon);
-        BOOST_CHECK(res3.begin() == u32ethalon);
+        BOOST_CHECK(&res3[0] == u32ethalon);
     }
     
     BOOST_CHECK_THROW(lexical_cast<u32short_arr_type>(val), boost::bad_lexical_cast);
@@ -256,7 +264,7 @@ void testing_boost_array_output_conversion()
 
 void testing_std_array_output_conversion()
 {
-#if !defined(BOOST_NO_CXX11_HDR_ARRAY) && defined(BOOST_HAS_TR1_ARRAY)
+#ifndef BOOST_NO_CXX11_HDR_ARRAY
     testing_template_array_output_on_char_value<std::array>();
     testing_template_array_output_on_spec_value<std::array>(100);
     testing_template_array_output_on_spec_value<std::array>(static_cast<short>(100));
@@ -328,7 +336,7 @@ static void testing_generic_array_input_conversion()
     }
 #endif
 
-#if !defined(BOOST_NO_CHAR16_T) && !defined(BOOST_NO_UNICODE_LITERALS)
+#ifdef BOOST_LC_RUNU16
     {
         const ArrayT<const char16_t, 4> var_zero_terminated_const_var_const_char = {{ u'1', u'0', u'0', u'\0'}}; 
         BOOST_CHECK(lexical_cast<std::u16string>(var_zero_terminated_const_var_const_char) == u"100");
@@ -339,7 +347,7 @@ static void testing_generic_array_input_conversion()
     }
 #endif
 
-#if !defined(BOOST_NO_CHAR32_T) && !defined(BOOST_NO_UNICODE_LITERALS)
+#ifdef BOOST_LC_RUNU32
     {
         const ArrayT<const char32_t, 4> var_zero_terminated_const_var_const_char = {{ U'1', U'0', U'0', U'\0'}}; 
         BOOST_CHECK(lexical_cast<std::u32string>(var_zero_terminated_const_var_const_char) == U"100");
@@ -358,7 +366,7 @@ void testing_boost_array_input_conversion()
 
 void testing_std_array_input_conversion()
 {
-#if !defined(BOOST_NO_CXX11_HDR_ARRAY) && defined(BOOST_HAS_TR1_ARRAY)
+#ifndef BOOST_NO_CXX11_HDR_ARRAY
     testing_generic_array_input_conversion<std::array>();
 #endif
 

test/lexical_cast_containers_test.cpp

@@ -71,12 +71,12 @@ void testing_boost_containers_string_widening()
     BOOST_CHECK(boost::lexical_cast<boost::container::wstring>(char_array) == wchar_array);
 #endif
 
-#if !defined(BOOST_NO_CHAR16_T) && !defined(BOOST_NO_UNICODE_LITERALS) && defined(BOOST_STL_SUPPORTS_NEW_UNICODE_LOCALES)
+#if !defined(BOOST_NO_CXX11_CHAR16_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS) && defined(BOOST_STL_SUPPORTS_NEW_UNICODE_LOCALES)
     const char16_t char16_array[] = u"Test string";
     BOOST_CHECK(boost::lexical_cast<boost::container::basic_string<char16_t> >(char_array) == char16_array);
 #endif
 
-#if !defined(BOOST_NO_CHAR32_T) && !defined(BOOST_NO_UNICODE_LITERALS) && defined(BOOST_STL_SUPPORTS_NEW_UNICODE_LOCALES)
+#if !defined(BOOST_NO_CXX11_CHAR32_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS) && defined(BOOST_STL_SUPPORTS_NEW_UNICODE_LOCALES)
     const char32_t char32_array[] = U"Test string";
     BOOST_CHECK(boost::lexical_cast<boost::container::basic_string<char32_t> >(char_array) == char32_array);
 #endif

test/lexical_cast_empty_input_test.cpp

@@ -32,7 +32,9 @@ void do_test_on_empty_input(T& 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);
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
     BOOST_CHECK_THROW(lexical_cast<long double>(v), bad_lexical_cast);
+#endif
     BOOST_CHECK_THROW(lexical_cast<unsigned int>(v), bad_lexical_cast);
     BOOST_CHECK_THROW(lexical_cast<unsigned short>(v), bad_lexical_cast);
 #if defined(BOOST_HAS_LONG_LONG)
@@ -84,12 +86,12 @@ void test_empty_string()
 #endif
 
 // Currently, no compiler and STL library fully support char16_t and char32_t
-//#ifndef BOOST_NO_CHAR16_T
+//#ifndef BOOST_NO_CXX11_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
+//#ifndef BOOST_NO_CXX11_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);

test/lexical_cast_filesystem_test.cpp

@@ -0,0 +1,46 @@
+//  Unit test for boost::lexical_cast.
+//
+//  See http://www.boost.org for most recent version, including documentation.
+//
+//  Copyright Antony Polukhin, 2013.
+//
+//  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).
+//
+// Test lexical_cast usage with long filesystem::path. Bug 7704.
+
+#include <boost/config.hpp>
+
+#include <boost/test/unit_test.hpp>
+#include <boost/lexical_cast.hpp>
+#include <boost/filesystem/path.hpp>
+
+using namespace boost;
+
+void test_filesystem();
+
+unit_test::test_suite *init_unit_test_suite(int, char *[])
+{
+    unit_test::test_suite *suite =
+        BOOST_TEST_SUITE("lexical_cast unit test");
+    suite->add(BOOST_TEST_CASE(&test_filesystem));
+
+    return suite;
+}
+
+void test_filesystem()
+{
+    boost::filesystem::path p;
+    std::string s1 = "aaaaaaaaaaaaaaaaaaaaaaa";
+    p = boost::lexical_cast<boost::filesystem::path>(s1);
+    BOOST_CHECK(!p.empty());
+    BOOST_CHECK_EQUAL(p, s1);
+    p.clear();
+
+    const char ab[] = "aaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb";
+    p = boost::lexical_cast<boost::filesystem::path>(ab);
+    BOOST_CHECK(!p.empty());
+    BOOST_CHECK_EQUAL(p, ab);
+}
+

test/lexical_cast_float_types_test.cpp

@@ -264,8 +264,11 @@ void test_converion_to_float_types()
     BOOST_CHECK_THROW(lexical_cast<test_t>("."), bad_lexical_cast);
 
     BOOST_CHECK_THROW(lexical_cast<test_t>("-B"), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<test_t>("0xB"), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<test_t>("0x0"), bad_lexical_cast);
+
+    // Following two tests are not valid for C++11 compilers    
+    //BOOST_CHECK_THROW(lexical_cast<test_t>("0xB"), bad_lexical_cast);
+    //BOOST_CHECK_THROW(lexical_cast<test_t>("0x0"), bad_lexical_cast);
+
     BOOST_CHECK_THROW(lexical_cast<test_t>("--1.0"), bad_lexical_cast);
     BOOST_CHECK_THROW(lexical_cast<test_t>("1.0e--1"), bad_lexical_cast);
     BOOST_CHECK_THROW(lexical_cast<test_t>("1.0.0"), bad_lexical_cast);
@@ -505,7 +508,11 @@ void test_conversion_from_to_double()
 }
 void test_conversion_from_to_long_double()
 {
+// We do not run tests on compilers with bugs
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
     test_conversion_from_to_float<long double>();
+#endif
+    BOOST_CHECK(true);
 }
 
 

test/lexical_cast_inf_nan_test.cpp

@@ -186,7 +186,11 @@ void test_inf_nan_double()
 
 void test_inf_nan_long_double()
 {
+// We do not run tests on compilers with bugs
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
     test_inf_nan_templated<long double >();
+#endif
+    BOOST_CHECK(true);
 }
 
 unit_test::test_suite *init_unit_test_suite(int, char *[])

test/lexical_cast_integral_types_test.cpp

@@ -34,6 +34,7 @@
 #include <boost/test/floating_point_comparison.hpp>
 
 #include <boost/type_traits/integral_promotion.hpp>
+#include <boost/type_traits/make_unsigned.hpp>
 #include <string>
 #include <vector>
 #include <memory>
@@ -47,6 +48,10 @@
 #define BOOST_LCAST_NO_WCHAR_T
 #endif
 
+#if (defined(BOOST_LCAST_HAS_INT128) && !defined(__GNUC__)) || GCC_VERSION > 40700
+#define BOOST_LCAST_HAS_INT128
+#endif
+
 // Test all 65536 values if true:
 bool const lcast_test_small_integral_types_completely = false;
 
@@ -56,6 +61,8 @@ int const lcast_integral_test_counter=500;
 
 using namespace boost;
 
+
+
 void test_conversion_from_to_short();
 void test_conversion_from_to_ushort();
 void test_conversion_from_to_int();
@@ -68,6 +75,11 @@ void test_conversion_from_to_uintmax_t();
 void test_conversion_from_to_longlong();
 void test_conversion_from_to_ulonglong();
 #endif
+#ifdef BOOST_LCAST_HAS_INT128
+void test_conversion_from_to_int128();
+void test_conversion_from_to_uint128();
+#endif
+void test_integral_conversions_on_min_max();
 
 
 unit_test::test_suite *init_unit_test_suite(int, char *[])
@@ -87,6 +99,11 @@ unit_test::test_suite *init_unit_test_suite(int, char *[])
     suite->add(BOOST_TEST_CASE(&test_conversion_from_to_longlong));
     suite->add(BOOST_TEST_CASE(&test_conversion_from_to_ulonglong));
 #endif
+#ifdef BOOST_LCAST_HAS_INT128
+    suite->add(BOOST_TEST_CASE(&test_conversion_from_to_int128));
+    suite->add(BOOST_TEST_CASE(&test_conversion_from_to_uint128));
+#endif
+    suite->add(BOOST_TEST_CASE(&test_integral_conversions_on_min_max));
 
     return suite;
 }
@@ -230,7 +247,7 @@ void test_conversion_from_integral_to_string(CharT)
 
         // Test values around 100, 1000, 10000, ...
         T ten_power = 100;
-        for(int e = 2; e <= limits::digits10; ++e, ten_power *= 10)
+        for(int e = 2; e < limits::digits10; ++e, ten_power *= 10)
         {
             // ten_power + 100 probably never overflows
             for(t = ten_power - 100; t != ten_power + 100; ++t)
@@ -327,7 +344,7 @@ void test_conversion_from_string_to_integral(CharT)
 
         // Test values around 100, 1000, 10000, ...
         T ten_power = 100;
-        for(int e = 2; e <= limits::digits10; ++e, ten_power *= 10)
+        for(int e = 2; e < limits::digits10; ++e, ten_power *= 10)
         {
             // ten_power + 100 probably never overflows
             for(t = ten_power - 100; t != ten_power + 100; ++t)
@@ -370,7 +387,7 @@ struct restore_oldloc
 };
 
 template<class T>
-void test_conversion_from_to_integral()
+void test_conversion_from_to_integral_minimal()
 {
     char const zero = '0';
     signed char const szero = '0';
@@ -386,12 +403,12 @@ void test_conversion_from_to_integral()
     test_conversion_from_integral_to_char<T>(wzero);
     test_conversion_from_char_to_integral<T>(wzero);
 #endif
-#if !defined(BOOST_NO_CHAR16_T) && !defined(BOOST_NO_UNICODE_LITERALS)
+#if !defined(BOOST_NO_CXX11_CHAR16_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS) && !defined(_LIBCPP_VERSION)
     char16_t const u16zero = u'0';
     test_conversion_from_integral_to_char<T>(u16zero);
     test_conversion_from_char_to_integral<T>(u16zero);
 #endif
-#if !defined(BOOST_NO_CHAR32_T) && !defined(BOOST_NO_UNICODE_LITERALS)
+#if !defined(BOOST_NO_CXX11_CHAR32_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS) && !defined(_LIBCPP_VERSION)
     char32_t const u32zero = u'0';
     test_conversion_from_integral_to_char<T>(u32zero);
     test_conversion_from_char_to_integral<T>(u32zero);
@@ -436,7 +453,12 @@ void test_conversion_from_to_integral()
         must_owerflow_str += '0';
         must_owerflow_negative_str += '0';
     }
+}
 
+template<class T>
+void test_conversion_from_to_integral()
+{
+    test_conversion_from_to_integral_minimal<T>();
     typedef std::numpunct<char> numpunct;
 
     restore_oldloc guard;
@@ -535,5 +557,56 @@ void test_conversion_from_to_ulonglong()
 #endif
 
 
+#ifdef BOOST_LCAST_HAS_INT128
+void test_conversion_from_to_int128()
+{
+    test_conversion_from_to_integral_minimal<boost::int128_type>();
+}
+
+void test_conversion_from_to_uint128()
+{
+    test_conversion_from_to_integral_minimal<boost::uint128_type>();
+}
+#endif
+
+template <typename SignedT>
+void test_integral_conversions_on_min_max_impl()
+{
+    typedef SignedT signed_t;
+    typedef BOOST_DEDUCED_TYPENAME boost::make_unsigned<signed_t>::type unsigned_t;
+    
+    typedef std::numeric_limits<signed_t> s_limits;
+    typedef std::numeric_limits<unsigned_t> uns_limits;
+
+    BOOST_CHECK_EQUAL(lexical_cast<unsigned_t>((uns_limits::max)()), (uns_limits::max)());
+    BOOST_CHECK_EQUAL(lexical_cast<unsigned_t>((uns_limits::min)()), (uns_limits::min)());
+
+    BOOST_CHECK_EQUAL(lexical_cast<signed_t>((s_limits::max)()), (s_limits::max)());
+    BOOST_CHECK_EQUAL(lexical_cast<signed_t>((uns_limits::min)()), static_cast<signed_t>((uns_limits::min)()));
+
+    BOOST_CHECK_EQUAL(lexical_cast<unsigned_t>((s_limits::max)()), static_cast<unsigned_t>((s_limits::max)()));
+    BOOST_CHECK_EQUAL(lexical_cast<unsigned_t>((s_limits::min)()), static_cast<unsigned_t>((s_limits::min)()));
+}
+
+void test_integral_conversions_on_min_max()
+{
+    test_integral_conversions_on_min_max_impl<int>();
+    test_integral_conversions_on_min_max_impl<short>();
+
+#ifdef _MSC_VER
+    test_integral_conversions_on_min_max_impl<long int>();
+
+#if defined(BOOST_HAS_LONG_LONG)
+    test_integral_conversions_on_min_max_impl<boost::long_long_type>();
+#elif defined(BOOST_HAS_MS_INT64)
+    test_integral_conversions_on_min_max_impl<__int64>();
+#endif
+
+#ifdef BOOST_LCAST_HAS_INT128
+    test_integral_conversions_on_min_max_impl<boost::int128_type>();
+#endif
+#endif
+
+}
 
 

test/lexical_cast_iterator_range_test.cpp

@@ -27,6 +27,15 @@ using namespace boost;
 #define BOOST_LCAST_NO_WCHAR_T
 #endif
 
+
+#if !defined(BOOST_NO_CXX11_CHAR16_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS) && !defined(_LIBCPP_VERSION)
+#define BOOST_LC_RUNU16
+#endif
+
+#if !defined(BOOST_NO_CXX11_CHAR32_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS) && !defined(_LIBCPP_VERSION)
+#define BOOST_LC_RUNU32
+#endif
+
 struct class_with_user_defined_sream_operators {
     int i;
 
@@ -63,8 +72,10 @@ void do_test_iterator_range_impl(const RngT& rng)
     BOOST_CHECK_EQUAL(lexical_cast<float>(rng.begin(), rng.size()), 1.0f);
     BOOST_CHECK_EQUAL(lexical_cast<double>(rng), 1.0);
     BOOST_CHECK_EQUAL(lexical_cast<double>(rng.begin(), rng.size()), 1.0);
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
     BOOST_CHECK_EQUAL(lexical_cast<long double>(rng), 1.0L);
     BOOST_CHECK_EQUAL(lexical_cast<long double>(rng.begin(), rng.size()), 1.0L);
+#endif
     BOOST_CHECK_EQUAL(lexical_cast<class_with_user_defined_sream_operators>(rng), 1);
 #endif
 #if defined(BOOST_HAS_LONG_LONG)
@@ -119,12 +130,16 @@ void test_it_range_using_char(CharT* one, CharT* eleven)
 
     BOOST_CHECK_EQUAL(lexical_cast<float>(rng1), 1.0f);
     BOOST_CHECK_EQUAL(lexical_cast<double>(rng1), 1.0);
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
     BOOST_CHECK_EQUAL(lexical_cast<long double>(rng1), 1.0L);
+#endif
     BOOST_CHECK_EQUAL(lexical_cast<class_with_user_defined_sream_operators>(rng1), 1);
 
     BOOST_CHECK_EQUAL(lexical_cast<float>(crng2), 1.0f);
     BOOST_CHECK_EQUAL(lexical_cast<double>(crng2), 1.0);
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
     BOOST_CHECK_EQUAL(lexical_cast<long double>(crng2), 1.0L);
+#endif
     BOOST_CHECK_EQUAL(lexical_cast<class_with_user_defined_sream_operators>(crng2), 1);
 
 #ifndef BOOST_LCAST_NO_WCHAR_T
@@ -134,7 +149,7 @@ void test_it_range_using_char(CharT* one, CharT* eleven)
     BOOST_CHECK(lexical_cast<std::wstring>(crng2) == L"1");
 #endif
 
-#if !defined(BOOST_NO_CHAR16_T) && !defined(BOOST_NO_UNICODE_LITERALS) && defined(BOOST_STL_SUPPORTS_NEW_UNICODE_LOCALES)
+#if defined(BOOST_LC_RUNU16) && defined(BOOST_STL_SUPPORTS_NEW_UNICODE_LOCALES)
     typedef std::basic_string<char16_t> my_char16_string;
     BOOST_CHECK(lexical_cast<my_char16_string>(rng1) == u"1");
     BOOST_CHECK(lexical_cast<my_char16_string>(crng1) == u"1");
@@ -142,7 +157,7 @@ void test_it_range_using_char(CharT* one, CharT* eleven)
     BOOST_CHECK(lexical_cast<my_char16_string>(crng2) == u"1");
 #endif
 
-#if !defined(BOOST_NO_CHAR32_T) && !defined(BOOST_NO_UNICODE_LITERALS) && defined(BOOST_STL_SUPPORTS_NEW_UNICODE_LOCALES)
+#if defined(BOOST_LC_RUNU32) && defined(BOOST_STL_SUPPORTS_NEW_UNICODE_LOCALES)
     typedef std::basic_string<char32_t> my_char32_string;
     BOOST_CHECK(lexical_cast<my_char32_string>(rng1) == U"1");
     BOOST_CHECK(lexical_cast<my_char32_string>(crng1) == U"1");
@@ -194,7 +209,7 @@ void test_wchar_iterator_ranges()
 
 void test_char16_iterator_ranges()
 {
-#if !defined(BOOST_NO_CHAR16_T) && !defined(BOOST_NO_UNICODE_LITERALS)
+#if defined(BOOST_LC_RUNU16)
     typedef char16_t test_char_type;
     test_char_type data1[] = u"1";
     test_char_type data2[] = u"11";
@@ -206,7 +221,7 @@ void test_char16_iterator_ranges()
 
 void test_char32_iterator_ranges()
 {
-#if !defined(BOOST_NO_CHAR32_T) && !defined(BOOST_NO_UNICODE_LITERALS)
+#if defined(BOOST_LC_RUNU32)
     typedef char32_t test_char_type;
     test_char_type data1[] = U"1";
     test_char_type data2[] = U"11";

test/lexical_cast_loopback_test.cpp

@@ -86,7 +86,11 @@ void test_round_conversion_double()
 
 void test_round_conversion_long_double()
 {
+// We do not run tests on compilers with bugs
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
     test_round_conversion<long double>();
     test_msvc_magic_values<long double>();
+#endif
+    BOOST_CHECK(true);
 }
 

test/lexical_cast_no_locale_test.cpp

@@ -37,7 +37,9 @@ void do_test_on_empty_input(T& 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);
+#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
     BOOST_CHECK_THROW(lexical_cast<long double>(v), bad_lexical_cast);
+#endif
     BOOST_CHECK_THROW(lexical_cast<unsigned int>(v), bad_lexical_cast);
     BOOST_CHECK_THROW(lexical_cast<unsigned short>(v), bad_lexical_cast);
 #if defined(BOOST_HAS_LONG_LONG)

test/lexical_cast_stream_detection_test.cpp

@@ -0,0 +1,307 @@
+//  Unit test for boost::lexical_cast.
+//
+//  See http://www.boost.org for most recent version, including documentation.
+//
+//  Copyright Antony Polukhin, 2011-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>
+#include <boost/test/unit_test.hpp>
+
+#include <boost/lexical_cast.hpp>
+
+#include <iostream>
+
+
+///////////////////////// char streamable classes ///////////////////////////////////////////
+
+struct streamable_easy { enum ENU {value = 0}; };
+std::ostream& operator << (std::ostream& ostr, const streamable_easy&) {
+    return ostr << streamable_easy::value;
+}
+std::istream& operator >> (std::istream& istr, const streamable_easy&) {
+    int i; istr >> i; BOOST_CHECK_EQUAL(i, streamable_easy::value);
+    return istr;
+}
+
+struct streamable_medium { enum ENU {value = 1}; };
+template <class CharT>
+typename boost::enable_if<boost::is_same<CharT, char>, std::basic_ostream<CharT>&>::type 
+operator << (std::basic_ostream<CharT>& ostr, const streamable_medium&) {
+    return ostr << streamable_medium::value;
+}
+template <class CharT>
+typename boost::enable_if<boost::is_same<CharT, char>, std::basic_istream<CharT>&>::type 
+operator >> (std::basic_istream<CharT>& istr, const streamable_medium&) {
+    int i; istr >> i; BOOST_CHECK_EQUAL(i, streamable_medium::value);
+    return istr;
+}
+
+struct streamable_hard { enum ENU {value = 2}; };
+template <class CharT, class TraitsT>
+typename boost::enable_if<boost::is_same<CharT, char>, std::basic_ostream<CharT, TraitsT>&>::type 
+operator << (std::basic_ostream<CharT, TraitsT>& ostr, const streamable_hard&) {
+    return ostr << streamable_hard::value;
+}
+template <class CharT, class TraitsT>
+typename boost::enable_if<boost::is_same<CharT, char>, std::basic_istream<CharT, TraitsT>&>::type 
+operator >> (std::basic_istream<CharT, TraitsT>& istr, const streamable_hard&) {
+    int i; istr >> i; BOOST_CHECK_EQUAL(i, streamable_hard::value);
+    return istr;
+}
+
+struct streamable_hard2 { enum ENU {value = 3}; };
+template <class TraitsT>
+std::basic_ostream<char, TraitsT>& operator << (std::basic_ostream<char, TraitsT>& ostr, const streamable_hard2&) {
+    return ostr << streamable_hard2::value;
+}
+template <class TraitsT>
+std::basic_istream<char, TraitsT>& operator >> (std::basic_istream<char, TraitsT>& istr, const streamable_hard2&) {
+    int i; istr >> i; BOOST_CHECK_EQUAL(i, streamable_hard2::value);
+    return istr;
+}
+
+
+///////////////////////// wchar_t streamable classes ///////////////////////////////////////////
+
+struct wstreamable_easy { enum ENU {value = 4}; };
+std::wostream& operator << (std::wostream& ostr, const wstreamable_easy&) {
+    return ostr << wstreamable_easy::value;
+}
+std::wistream& operator >> (std::wistream& istr, const wstreamable_easy&) {
+    int i; istr >> i; BOOST_CHECK_EQUAL(i, wstreamable_easy::value);
+    return istr;
+}
+
+struct wstreamable_medium { enum ENU {value = 5}; };
+template <class CharT>
+typename boost::enable_if<boost::is_same<CharT, wchar_t>, std::basic_ostream<CharT>& >::type 
+operator << (std::basic_ostream<CharT>& ostr, const wstreamable_medium&) {
+    return ostr << wstreamable_medium::value;
+}
+template <class CharT>
+typename boost::enable_if<boost::is_same<CharT, wchar_t>, std::basic_istream<CharT>& >::type 
+operator >> (std::basic_istream<CharT>& istr, const wstreamable_medium&) {
+    int i; istr >> i; BOOST_CHECK_EQUAL(i, wstreamable_medium::value);
+    return istr;
+}
+
+struct wstreamable_hard { enum ENU {value = 6}; };
+template <class CharT, class TraitsT>
+typename boost::enable_if<boost::is_same<CharT, wchar_t>, std::basic_ostream<CharT, TraitsT>&>::type 
+operator << (std::basic_ostream<CharT, TraitsT>& ostr, const wstreamable_hard&) {
+    return ostr << wstreamable_hard::value;
+}
+template <class CharT, class TraitsT>
+typename boost::enable_if<boost::is_same<CharT, wchar_t>, std::basic_istream<CharT, TraitsT>&>::type 
+operator >> (std::basic_istream<CharT, TraitsT>& istr, const wstreamable_hard&) {
+    int i; istr >> i; BOOST_CHECK_EQUAL(i, wstreamable_hard::value);
+    return istr;
+}
+
+struct wstreamable_hard2 { enum ENU {value = 7}; };
+template <class TraitsT>
+std::basic_ostream<wchar_t, TraitsT>& operator << (std::basic_ostream<wchar_t, TraitsT>& ostr, const wstreamable_hard2&) {
+    return ostr << wstreamable_hard2::value;
+}
+template <class TraitsT>
+std::basic_istream<wchar_t, TraitsT>& operator >> (std::basic_istream<wchar_t, TraitsT>& istr, const wstreamable_hard2&) {
+    int i; istr >> i; BOOST_CHECK_EQUAL(i, wstreamable_hard2::value);
+    return istr;
+}
+
+///////////////////////// char and wchar_t streamable classes ///////////////////////////////////////////
+
+
+struct bistreamable_easy { enum ENU {value = 8}; };
+std::ostream& operator << (std::ostream& ostr, const bistreamable_easy&) {
+    return ostr << bistreamable_easy::value;
+}
+std::istream& operator >> (std::istream& istr, const bistreamable_easy&) {
+    int i; istr >> i; BOOST_CHECK_EQUAL(i, bistreamable_easy::value);
+    return istr;
+}
+
+std::wostream& operator << (std::wostream& ostr, const bistreamable_easy&) {
+    return ostr << bistreamable_easy::value + 100;
+}
+std::wistream& operator >> (std::wistream& istr, const bistreamable_easy&) {
+    int i; istr >> i; BOOST_CHECK_EQUAL(i, bistreamable_easy::value + 100);
+    return istr;
+}
+
+struct bistreamable_medium { enum ENU {value = 9}; };
+template <class CharT>
+std::basic_ostream<CharT>& operator << (std::basic_ostream<CharT>& ostr, const bistreamable_medium&) {
+    return ostr << bistreamable_medium::value + (sizeof(CharT) == 1 ? 0 : 100);
+}
+template <class CharT>
+std::basic_istream<CharT>& operator >> (std::basic_istream<CharT>& istr, const bistreamable_medium&) {
+    int i; istr >> i; BOOST_CHECK_EQUAL(i, bistreamable_medium::value + (sizeof(CharT) == 1 ? 0 : 100));
+    return istr;
+}
+
+struct bistreamable_hard { enum ENU {value = 10}; };
+template <class CharT, class TraitsT>
+std::basic_ostream<CharT, TraitsT>& operator << (std::basic_ostream<CharT, TraitsT>& ostr, const bistreamable_hard&) {
+    return ostr << bistreamable_hard::value + (sizeof(CharT) == 1 ? 0 : 100);
+}
+template <class CharT, class TraitsT>
+std::basic_istream<CharT, TraitsT>& operator >> (std::basic_istream<CharT, TraitsT>& istr, const bistreamable_hard&) {
+    int i; istr >> i; BOOST_CHECK_EQUAL(i, bistreamable_hard::value + (sizeof(CharT) == 1 ? 0 : 100));
+    return istr;
+}
+
+struct bistreamable_hard2 { enum ENU {value = 11}; };
+template <class TraitsT>
+std::basic_ostream<char, TraitsT>& operator << (std::basic_ostream<char, TraitsT>& ostr, const bistreamable_hard2&) {
+    return ostr << bistreamable_hard2::value;
+}
+template <class TraitsT>
+std::basic_istream<char, TraitsT>& operator >> (std::basic_istream<char, TraitsT>& istr, const bistreamable_hard2&) {
+    int i; istr >> i; BOOST_CHECK_EQUAL(i, bistreamable_hard2::value);
+    return istr;
+}
+
+template <class TraitsT>
+std::basic_ostream<wchar_t, TraitsT>& operator << (std::basic_ostream<wchar_t, TraitsT>& ostr, const bistreamable_hard2&) {
+    return ostr << bistreamable_hard2::value + 100;
+}
+template <class TraitsT>
+std::basic_istream<wchar_t, TraitsT>& operator >> (std::basic_istream<wchar_t, TraitsT>& istr, const bistreamable_hard2&) {
+    int i; istr >> i; BOOST_CHECK_EQUAL(i, bistreamable_hard2::value + 100);
+    return istr;
+}
+
+
+void test_ostream_character_detection();
+void test_istream_character_detection();
+void test_mixed_stream_character_detection();
+
+boost::unit_test::test_suite *init_unit_test_suite(int, char *[])
+{
+    boost::unit_test::test_suite *suite = 
+        BOOST_TEST_SUITE("lexical_cast stream character detection");
+    suite->add(BOOST_TEST_CASE(&test_ostream_character_detection));
+    suite->add(BOOST_TEST_CASE(&test_istream_character_detection));
+    suite->add(BOOST_TEST_CASE(&test_mixed_stream_character_detection));
+    
+    return suite;
+}
+
+template <class T>
+static void test_ostr_impl() {
+    T streamable;
+    BOOST_CHECK_EQUAL(T::value,  boost::lexical_cast<int>(streamable));
+    BOOST_CHECK_EQUAL(boost::lexical_cast<std::string>(T::value),  boost::lexical_cast<std::string>(streamable));
+}
+
+template <class T>
+static void test_wostr_impl() {
+    T streamable;
+    BOOST_CHECK_EQUAL(T::value,  boost::lexical_cast<int>(streamable));
+    // BOOST_CHECK_EQUAL(boost::lexical_cast<std::string>(T::value), boost::lexical_cast<std::string>(streamable)); // Shall not compile???
+    BOOST_CHECK(boost::lexical_cast<std::wstring>(T::value) == boost::lexical_cast<std::wstring>(streamable));
+}
+
+template <class T>
+static void test_bistr_impl() {
+    T streamable;
+
+    BOOST_CHECK_EQUAL(T::value,  boost::lexical_cast<int>(streamable));
+    BOOST_CHECK_EQUAL(boost::lexical_cast<std::string>(T::value),  boost::lexical_cast<std::string>(streamable));
+
+    BOOST_CHECK(boost::lexical_cast<std::wstring>(T::value + 100) == boost::lexical_cast<std::wstring>(streamable));
+}
+
+void test_ostream_character_detection() {
+    test_ostr_impl<streamable_easy>();
+    test_ostr_impl<streamable_medium>();
+    test_ostr_impl<streamable_hard>();
+    test_ostr_impl<streamable_hard2>();
+    
+    test_wostr_impl<wstreamable_easy>();
+    test_wostr_impl<wstreamable_medium>();
+    test_wostr_impl<wstreamable_hard>();
+    test_wostr_impl<wstreamable_hard2>();
+    
+    test_bistr_impl<bistreamable_easy>();
+    test_bistr_impl<bistreamable_medium>();
+    test_bistr_impl<bistreamable_hard>();
+    test_bistr_impl<bistreamable_hard2>();
+}
+
+
+template <class T>
+static void test_istr_impl() {
+    boost::lexical_cast<T>(T::value);
+    boost::lexical_cast<T>(boost::lexical_cast<std::string>(T::value));
+}
+
+template <class T>
+static void test_wistr_impl() {
+    boost::lexical_cast<T>(T::value);
+    //boost::lexical_cast<T>(boost::lexical_cast<std::string>(T::value)); // Shall not compile???
+    boost::lexical_cast<T>(boost::lexical_cast<std::wstring>(T::value));
+}
+
+template <class T>
+static void test_bistr_instr_impl() {
+    boost::lexical_cast<T>(T::value);
+    boost::lexical_cast<T>(boost::lexical_cast<std::string>(T::value));
+    boost::lexical_cast<T>(boost::lexical_cast<std::wstring>(T::value + 100));
+}
+
+void test_istream_character_detection() {
+    test_istr_impl<streamable_easy>();
+    test_istr_impl<streamable_medium>();
+    test_istr_impl<streamable_hard>();
+    test_istr_impl<streamable_hard2>();
+    
+    test_wistr_impl<wstreamable_easy>();
+    test_wistr_impl<wstreamable_medium>();
+    test_wistr_impl<wstreamable_hard>();
+    test_wistr_impl<wstreamable_hard2>();
+    
+    test_bistr_instr_impl<bistreamable_easy>();
+    test_bistr_instr_impl<bistreamable_medium>();
+    test_bistr_instr_impl<bistreamable_hard>();
+    test_bistr_instr_impl<bistreamable_hard2>();
+}
+
+
+
+
+
+
+struct wistreamble_ostreamable { enum ENU {value = 200}; };
+std::ostream& operator << (std::ostream& ostr, const wistreamble_ostreamable&) {
+    return ostr << wistreamble_ostreamable::value;
+}
+std::wistream& operator >> (std::wistream& istr, const wistreamble_ostreamable&) {
+    int i; istr >> i; BOOST_CHECK_EQUAL(i, wistreamble_ostreamable::value);
+    return istr;
+}
+
+struct istreamble_wostreamable { enum ENU {value = 201}; };
+std::wostream& operator << (std::wostream& ostr, const istreamble_wostreamable&) {
+    return ostr << istreamble_wostreamable::value;
+}
+std::istream& operator >> (std::istream& istr, const istreamble_wostreamable&) {
+    int i; istr >> i; BOOST_CHECK_EQUAL(i, istreamble_wostreamable::value);
+    return istr;
+}
+
+void test_mixed_stream_character_detection() {
+    //boost::lexical_cast<std::wstring>(std::string("qwe")); // TODO: ALLOW IT AS EXTENSION!
+    
+    boost::lexical_cast<wistreamble_ostreamable>(wistreamble_ostreamable::value);
+    BOOST_CHECK_EQUAL(boost::lexical_cast<int>(wistreamble_ostreamable()), wistreamble_ostreamable::value);
+    
+    boost::lexical_cast<istreamble_wostreamable>(istreamble_wostreamable::value);
+    BOOST_CHECK_EQUAL(boost::lexical_cast<int>(istreamble_wostreamable()), istreamble_wostreamable::value);
+}

test/lexical_cast_stream_traits_test.cpp

@@ -0,0 +1,158 @@
+//  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>
+
+#include <boost/lexical_cast.hpp>
+
+#include <boost/test/unit_test.hpp>
+
+template <class T>
+static void test_optimized_types_to_string_const()
+{
+    namespace de = boost::detail;
+    typedef de::lexical_cast_stream_traits<T, std::string> trait_1;
+    BOOST_CHECK(!trait_1::is_source_input_not_optimized_t::value);
+    BOOST_CHECK((boost::is_same<BOOST_DEDUCED_TYPENAME trait_1::src_char_t, char>::value));
+    BOOST_CHECK((boost::is_same<BOOST_DEDUCED_TYPENAME trait_1::target_char_t, char>::value));
+    BOOST_CHECK((boost::is_same<BOOST_DEDUCED_TYPENAME trait_1::char_type, char>::value));
+    BOOST_CHECK(!trait_1::is_string_widening_required_t::value);
+    BOOST_CHECK(!trait_1::is_source_input_not_optimized_t::value);
+        
+    typedef de::lexical_cast_stream_traits<const T, std::string> trait_2;
+    BOOST_CHECK(!trait_2::is_source_input_not_optimized_t::value);
+    BOOST_CHECK((boost::is_same<BOOST_DEDUCED_TYPENAME trait_2::src_char_t, char>::value));
+    BOOST_CHECK((boost::is_same<BOOST_DEDUCED_TYPENAME trait_2::target_char_t, char>::value));
+    BOOST_CHECK((boost::is_same<BOOST_DEDUCED_TYPENAME trait_2::char_type, char>::value));
+    BOOST_CHECK(!trait_2::is_string_widening_required_t::value);
+    BOOST_CHECK(!trait_2::is_source_input_not_optimized_t::value);
+
+    typedef de::lexical_cast_stream_traits<T, std::wstring> trait_3;
+    BOOST_CHECK(!trait_3::is_source_input_not_optimized_t::value);
+    BOOST_CHECK((boost::is_same<BOOST_DEDUCED_TYPENAME trait_3::src_char_t, char>::value));
+    BOOST_CHECK((boost::is_same<BOOST_DEDUCED_TYPENAME trait_3::target_char_t, wchar_t>::value));
+    BOOST_CHECK((boost::is_same<BOOST_DEDUCED_TYPENAME trait_3::char_type, wchar_t>::value));
+
+    BOOST_CHECK((boost::detail::is_char_or_wchar<BOOST_DEDUCED_TYPENAME trait_3::no_cv_src>::value != trait_3::is_string_widening_required_t::value));
+
+    BOOST_CHECK(!trait_3::is_source_input_not_optimized_t::value);
+}    
+
+
+template <class T>
+static void test_optimized_types_to_string()
+{
+    test_optimized_types_to_string_const<T>();
+
+    namespace de = boost::detail;
+    typedef de::lexical_cast_stream_traits<std::string, T> trait_4;
+    BOOST_CHECK(!trait_4::is_source_input_not_optimized_t::value);
+    BOOST_CHECK((boost::is_same<BOOST_DEDUCED_TYPENAME trait_4::src_char_t, char>::value));
+    BOOST_CHECK((boost::is_same<BOOST_DEDUCED_TYPENAME trait_4::target_char_t, char>::value));
+    BOOST_CHECK((boost::is_same<BOOST_DEDUCED_TYPENAME trait_4::char_type, char>::value));
+    BOOST_CHECK(!trait_4::is_string_widening_required_t::value);
+    BOOST_CHECK(!trait_4::is_source_input_not_optimized_t::value);
+        
+    typedef de::lexical_cast_stream_traits<const std::string, T> trait_5;
+    BOOST_CHECK(!trait_5::is_source_input_not_optimized_t::value);
+    BOOST_CHECK((boost::is_same<BOOST_DEDUCED_TYPENAME trait_5::src_char_t, char>::value));
+    BOOST_CHECK((boost::is_same<BOOST_DEDUCED_TYPENAME trait_5::target_char_t, char>::value));
+    BOOST_CHECK((boost::is_same<BOOST_DEDUCED_TYPENAME trait_5::char_type, char>::value));
+    BOOST_CHECK(!trait_5::is_string_widening_required_t::value);
+    BOOST_CHECK(!trait_5::is_source_input_not_optimized_t::value);
+
+    typedef de::lexical_cast_stream_traits<const std::wstring, T> trait_6;
+    BOOST_CHECK(!trait_6::is_source_input_not_optimized_t::value);
+    BOOST_CHECK((boost::is_same<BOOST_DEDUCED_TYPENAME trait_6::src_char_t, wchar_t>::value));
+    BOOST_CHECK((boost::is_same<BOOST_DEDUCED_TYPENAME trait_6::target_char_t, char>::value));
+    BOOST_CHECK((boost::is_same<BOOST_DEDUCED_TYPENAME trait_6::char_type, wchar_t>::value));
+    BOOST_CHECK(!trait_6::is_string_widening_required_t::value);
+}
+
+void test_metafunctions()
+{
+    test_optimized_types_to_string<bool>();
+    test_optimized_types_to_string<char>();
+    test_optimized_types_to_string<unsigned char>();
+    test_optimized_types_to_string<signed char>();
+    test_optimized_types_to_string<short>();
+    test_optimized_types_to_string<unsigned short>();
+    test_optimized_types_to_string<int>();
+    test_optimized_types_to_string<unsigned int>();
+    test_optimized_types_to_string<long>();
+    test_optimized_types_to_string<unsigned long>();
+
+#if defined(BOOST_HAS_LONG_LONG)
+    test_optimized_types_to_string<boost::ulong_long_type>();
+    test_optimized_types_to_string<boost::long_long_type>();
+#elif defined(BOOST_HAS_MS_INT64)
+    test_optimized_types_to_string<unsigned __int64>();
+    test_optimized_types_to_string<__int64>();
+#endif
+
+#if !defined(BOOST_NO_SWPRINTF) && !defined(__MINGW32__)
+    test_optimized_types_to_string<float>();
+#endif
+    
+    test_optimized_types_to_string<std::string>();
+    test_optimized_types_to_string<char*>();
+    //test_optimized_types_to_string<char[5]>();
+    //test_optimized_types_to_string<char[1]>();
+    test_optimized_types_to_string<unsigned char*>();
+    //test_optimized_types_to_string<unsigned char[5]>();
+    //test_optimized_types_to_string<unsigned char[1]>();
+    test_optimized_types_to_string<signed char*>();
+    //test_optimized_types_to_string<signed char[5]>();
+    //test_optimized_types_to_string<signed char[1]>();
+    test_optimized_types_to_string<boost::array<char, 1> >();
+    test_optimized_types_to_string<boost::array<char, 5> >();
+    test_optimized_types_to_string<boost::array<unsigned char, 1> >();
+    test_optimized_types_to_string<boost::array<unsigned char, 5> >();
+    test_optimized_types_to_string<boost::array<signed char, 1> >();
+    test_optimized_types_to_string<boost::array<signed char, 5> >();
+    test_optimized_types_to_string<boost::iterator_range<char*> >();
+    test_optimized_types_to_string<boost::iterator_range<unsigned char*> >();
+    test_optimized_types_to_string<boost::iterator_range<signed char*> >();
+
+    test_optimized_types_to_string_const<boost::array<const char, 1> >();
+    test_optimized_types_to_string_const<boost::array<const char, 5> >();
+    test_optimized_types_to_string_const<boost::array<const unsigned char, 1> >();
+    test_optimized_types_to_string_const<boost::array<const unsigned char, 5> >();
+    test_optimized_types_to_string_const<boost::array<const signed char, 1> >();
+    test_optimized_types_to_string_const<boost::array<const signed char, 5> >();
+    test_optimized_types_to_string_const<boost::iterator_range<const char*> >();
+    test_optimized_types_to_string_const<boost::iterator_range<const unsigned char*> >();
+    test_optimized_types_to_string_const<boost::iterator_range<const signed char*> >();
+
+#ifndef BOOST_NO_CXX11_HDR_ARRAY
+    test_optimized_types_to_string<std::array<char, 1> >();
+    test_optimized_types_to_string<std::array<char, 5> >();
+    test_optimized_types_to_string<std::array<unsigned char, 1> >();
+    test_optimized_types_to_string<std::array<unsigned char, 5> >();
+    test_optimized_types_to_string<std::array<signed char, 1> >();
+    test_optimized_types_to_string<std::array<signed char, 5> >();
+    
+    test_optimized_types_to_string_const<std::array<const char, 1> >();
+    test_optimized_types_to_string_const<std::array<const char, 5> >();
+    test_optimized_types_to_string_const<std::array<const unsigned char, 1> >();
+    test_optimized_types_to_string_const<std::array<const unsigned char, 5> >();
+    test_optimized_types_to_string_const<std::array<const signed char, 1> >();
+    test_optimized_types_to_string_const<std::array<const signed char, 5> >();
+#endif
+}
+
+boost::unit_test::test_suite *init_unit_test_suite(int, char *[])
+{
+    boost::unit_test::test_suite *suite =
+        BOOST_TEST_SUITE("lexical_cast traits tests");
+    suite->add(BOOST_TEST_CASE(&test_metafunctions));
+    return suite;
+}
+

test/lexical_cast_to_pointer_test.cpp

@@ -0,0 +1,21 @@
+//  //  Unit test for boost::lexical_cast.
+//
+//  See http://www.boost.org for most recent version, including documentation.
+//
+//  Copyright Antony Polukhin, 2013.
+//
+//  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/type.hpp>
+
+#define BOOST_INCLUDE_MAIN
+#include <boost/test/test_tools.hpp>
+
+int test_main(int, char*[])
+{
+    boost::lexical_cast<char*>("Hello");
+    return 0;
+}

test/lexical_cast_vc8_bug_test.cpp

@@ -34,7 +34,7 @@ void test_too_long_number(CharT zero)
     o << (limits::max)() << zero;
     s = o.str();
     BOOST_CHECK_THROW(lexical_cast<T>(s), bad_lexical_cast);
-    s[s.size()-1] += 9; // '0' -> '9'
+    s[s.size()-1] += static_cast<CharT>(9); // '0' -> '9'
     BOOST_CHECK_THROW(lexical_cast<T>(s), bad_lexical_cast);
 
     if(limits::is_signed)
@@ -43,7 +43,7 @@ void test_too_long_number(CharT zero)
         o << (limits::min)() << zero;
         s = o.str();
         BOOST_CHECK_THROW(lexical_cast<T>(s), bad_lexical_cast);
-        s[s.size()-1] += 9; // '0' -> '9'
+        s[s.size()-1] += static_cast<CharT>(9); // '0' -> '9'
         BOOST_CHECK_THROW(lexical_cast<T>(s), bad_lexical_cast);
     }
 }

test/lexical_cast_wchars_test.cpp

@@ -58,7 +58,7 @@ void test_char_types_conversions_wchar_t()
 
 void test_char_types_conversions_char16_t()
 {
-#if !defined(BOOST_NO_CHAR16_T) && !defined(BOOST_NO_UNICODE_LITERALS) && defined(BOOST_STL_SUPPORTS_NEW_UNICODE_LOCALES)
+#if !defined(BOOST_NO_CXX11_CHAR16_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS) && defined(BOOST_STL_SUPPORTS_NEW_UNICODE_LOCALES)
     test_impl(u"Test array of chars");
 #endif
 
@@ -67,7 +67,7 @@ void test_char_types_conversions_char16_t()
 
 void test_char_types_conversions_char32_t()
 {
-#if !defined(BOOST_NO_CHAR32_T) && !defined(BOOST_NO_UNICODE_LITERALS) && defined(BOOST_STL_SUPPORTS_NEW_UNICODE_LOCALES)
+#if !defined(BOOST_NO_CXX11_CHAR32_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS) && defined(BOOST_STL_SUPPORTS_NEW_UNICODE_LOCALES)
     test_impl(U"Test array of chars");
 #endif