Merge lexical_cast library from trunk:

* multiple optimizations and bugfixes for boost::iterator_range (refs #6786, refs #6430, refs #6663)
* documentation update
* new Unicode characters support updated
* much more tests, removed incorrect tests

[SVN r78059]

test/Jamfile.v2

@@ -12,6 +12,7 @@ project
     : requirements
         <library>/boost/test//boost_unit_test_framework
         <link>static 
+        <toolset>gcc-4.8:<define>BOOST_STL_SUPPORTS_NEW_UNICODE_LOCALES
     ;
 
 # Thanks to Steven Watanabe for helping with <nowchar> feature 

test/lexical_cast_containers_test.cpp

@@ -14,6 +14,8 @@
 
 void testing_boost_containers_basic_string();
 void testing_boost_containers_string_std_string();
+void testing_boost_containers_string_widening();
+
 
 using namespace boost;
 
@@ -23,6 +25,7 @@ boost::unit_test::test_suite *init_unit_test_suite(int, char *[])
         BOOST_TEST_SUITE("Testing boost::lexical_cast with boost::container::string");
     suite->add(BOOST_TEST_CASE(testing_boost_containers_basic_string));
     suite->add(BOOST_TEST_CASE(testing_boost_containers_string_std_string));
+    suite->add(BOOST_TEST_CASE(testing_boost_containers_string_widening));
 
     return suite;
 }
@@ -58,3 +61,23 @@ void testing_boost_containers_string_std_string()
 #endif
 
 }
+
+void testing_boost_containers_string_widening()
+{
+    const char char_array[] = "Test string";
+
+#ifndef BOOST_LCAST_NO_WCHAR_T
+    const wchar_t wchar_array[] = L"Test string";
+    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)
+    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)
+    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_iterator_range_test.cpp

@@ -43,7 +43,7 @@ inline std::basic_istream<CharT>& operator >> (std::basic_istream<CharT>& istr,
 
 
 template <class RngT>
-void do_test_iterator_range(const RngT& rng)
+void do_test_iterator_range_impl(const RngT& rng)
 {
     BOOST_CHECK_EQUAL(lexical_cast<int>(rng), 1);
     BOOST_CHECK_EQUAL(lexical_cast<unsigned int>(rng), 1u);
@@ -51,11 +51,13 @@ void do_test_iterator_range(const RngT& rng)
     BOOST_CHECK_EQUAL(lexical_cast<unsigned short>(rng), 1u);
     BOOST_CHECK_EQUAL(lexical_cast<long int>(rng), 1);
     BOOST_CHECK_EQUAL(lexical_cast<unsigned long int>(rng), 1u);
+
+#ifdef BOOST_STL_SUPPORTS_NEW_UNICODE_LOCALES
     BOOST_CHECK_EQUAL(lexical_cast<float>(rng), 1.0f);
     BOOST_CHECK_EQUAL(lexical_cast<double>(rng), 1.0);
     BOOST_CHECK_EQUAL(lexical_cast<long double>(rng), 1.0L);
     BOOST_CHECK_EQUAL(lexical_cast<class_with_user_defined_sream_operators>(rng), 1);
-
+#endif
 #if defined(BOOST_HAS_LONG_LONG)
     BOOST_CHECK_EQUAL(lexical_cast<boost::ulong_long_type>(rng), 1u);
     BOOST_CHECK_EQUAL(lexical_cast<boost::long_long_type>(rng), 1);
@@ -63,115 +65,139 @@ void do_test_iterator_range(const RngT& rng)
     BOOST_CHECK_EQUAL(lexical_cast<unsigned __int64>(rng), 1u);
     BOOST_CHECK_EQUAL(lexical_cast<__int64>(rng), 1);
 #endif
+}
+
+template <class CharT>
+void test_it_range_using_any_chars(CharT* one, CharT* eleven)
+{
+    typedef CharT test_char_type;
+
+    // Zero terminated
+    iterator_range<test_char_type*> rng1(one, one + 1);
+    do_test_iterator_range_impl(rng1);
+
+    iterator_range<const test_char_type*> crng1(one, one + 1);
+    do_test_iterator_range_impl(crng1);
+
+    // Non zero terminated
+    iterator_range<test_char_type*> rng2(eleven, eleven + 1);
+    do_test_iterator_range_impl(rng2);
+
+    iterator_range<const test_char_type*> crng2(eleven, eleven + 1);
+    do_test_iterator_range_impl(crng2);
+}
+
+template <class CharT>
+void test_it_range_using_char(CharT* one, CharT* eleven)
+{
+    typedef CharT test_char_type;
+
+    iterator_range<test_char_type*> rng1(one, one + 1);
+    BOOST_CHECK_EQUAL(lexical_cast<std::string>(rng1), "1");
+
+    iterator_range<const test_char_type*> crng1(one, one + 1);
+    BOOST_CHECK_EQUAL(lexical_cast<std::string>(crng1), "1");
+
+    iterator_range<test_char_type*> rng2(eleven, eleven + 1);
+    BOOST_CHECK_EQUAL(lexical_cast<std::string>(rng2), "1");
+
+    iterator_range<const test_char_type*> crng2(eleven, eleven + 1);
+    BOOST_CHECK_EQUAL(lexical_cast<std::string>(crng2), "1");
+
+    BOOST_CHECK_EQUAL(lexical_cast<float>(rng1), 1.0f);
+    BOOST_CHECK_EQUAL(lexical_cast<double>(rng1), 1.0);
+    BOOST_CHECK_EQUAL(lexical_cast<long double>(rng1), 1.0L);
+    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);
+    BOOST_CHECK_EQUAL(lexical_cast<long double>(crng2), 1.0L);
+    BOOST_CHECK_EQUAL(lexical_cast<class_with_user_defined_sream_operators>(crng2), 1);
 
 #ifndef BOOST_LCAST_NO_WCHAR_T
-    BOOST_CHECK(lexical_cast<std::wstring>(rng) == L"1");
+    BOOST_CHECK(lexical_cast<std::wstring>(rng1) == L"1");
+    BOOST_CHECK(lexical_cast<std::wstring>(crng1) == L"1");
+    BOOST_CHECK(lexical_cast<std::wstring>(rng2) == L"1");
+    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)
+    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");
+    BOOST_CHECK(lexical_cast<my_char16_string>(rng2) == u"1");
+    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)
+    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");
+    BOOST_CHECK(lexical_cast<my_char32_string>(rng2) == U"1");
+    BOOST_CHECK(lexical_cast<my_char32_string>(crng2) == U"1");
 #endif
 }
 
 void test_char_iterator_ranges() 
 {
     typedef char test_char_type;
-
-    // Zero terminated
     test_char_type data1[] = "1";
-    iterator_range<test_char_type*> rng1(data1, data1 + 1);
-    do_test_iterator_range(rng1);
-    BOOST_CHECK_EQUAL(lexical_cast<std::string>(rng1), "1");
-
-    const test_char_type cdata1[] = "1";
-    iterator_range<const test_char_type*> crng1(cdata1, cdata1 + 1);
-    do_test_iterator_range(crng1);
-    BOOST_CHECK_EQUAL(lexical_cast<std::string>(crng1), "1");
-
-    // Non zero terminated
     test_char_type data2[] = "11";
-    iterator_range<test_char_type*> rng2(data2, data2 + 1);
-    do_test_iterator_range(rng2);
-    BOOST_CHECK_EQUAL(lexical_cast<std::string>(rng2), "1");
-
-    const test_char_type cdata2[] = "11";
-    iterator_range<const test_char_type*> crng2(cdata2, cdata2 + 1);
-    do_test_iterator_range(crng2);
-    BOOST_CHECK_EQUAL(lexical_cast<std::string>(crng2), "1");
+    test_it_range_using_any_chars(data1, data2);
+    test_it_range_using_char(data1, data2);
 }
 
+
+
 void test_unsigned_char_iterator_ranges() 
 {
     typedef unsigned char test_char_type;
-
-    // Zero terminated
     test_char_type data1[] = "1";
-    iterator_range<test_char_type*> rng1(data1, data1 + 1);
-    do_test_iterator_range(rng1);
-    BOOST_CHECK_EQUAL(lexical_cast<std::string>(rng1), "1");
-
-    const test_char_type cdata1[] = "1";
-    iterator_range<const test_char_type*> crng1(cdata1, cdata1 + 1);
-    do_test_iterator_range(crng1);
-    BOOST_CHECK_EQUAL(lexical_cast<std::string>(crng1), "1");
-
-    // Non zero terminated
     test_char_type data2[] = "11";
-    iterator_range<test_char_type*> rng2(data2, data2 + 1);
-    do_test_iterator_range(rng2);
-    BOOST_CHECK_EQUAL(lexical_cast<std::string>(rng2), "1");
-
-    const test_char_type cdata2[] = "11";
-    iterator_range<const test_char_type*> crng2(cdata2, cdata2 + 1);
-    do_test_iterator_range(crng2);
-    BOOST_CHECK_EQUAL(lexical_cast<std::string>(crng2), "1");
+    test_it_range_using_any_chars(data1, data2);
+    test_it_range_using_char(data1, data2);
 }
 
 void test_signed_char_iterator_ranges() 
 {
     typedef signed char test_char_type;
-
-    // Zero terminated
     test_char_type data1[] = "1";
-    iterator_range<test_char_type*> rng1(data1, data1 + 1);
-    do_test_iterator_range(rng1);
-    BOOST_CHECK_EQUAL(lexical_cast<std::string>(rng1), "1");
-
-    const test_char_type cdata1[] = "1";
-    iterator_range<const test_char_type*> crng1(cdata1, cdata1 + 1);
-    do_test_iterator_range(crng1);
-    BOOST_CHECK_EQUAL(lexical_cast<std::string>(crng1), "1");
-
-    // Non zero terminated
     test_char_type data2[] = "11";
-    iterator_range<test_char_type*> rng2(data2, data2 + 1);
-    do_test_iterator_range(rng2);
-    BOOST_CHECK_EQUAL(lexical_cast<std::string>(rng2), "1");
-
-    const test_char_type cdata2[] = "11";
-    iterator_range<const test_char_type*> crng2(cdata2, cdata2 + 1);
-    do_test_iterator_range(crng2);
-    BOOST_CHECK_EQUAL(lexical_cast<std::string>(crng2), "1");
+    test_it_range_using_any_chars(data1, data2);
+    test_it_range_using_char(data1, data2);
 }
 
-void test_wide_char_iterator_ranges() 
+void test_wchar_iterator_ranges() 
 {
 #ifndef BOOST_LCAST_NO_WCHAR_T
     typedef wchar_t test_char_type;
-
-    // Zero terminated
     test_char_type data1[] = L"1";
-    iterator_range<test_char_type*> rng1(data1, data1 + 1);
-    do_test_iterator_range(rng1);
-
-    const test_char_type cdata1[] = L"1";
-    iterator_range<const test_char_type*> crng1(cdata1, cdata1 + 1);
-    do_test_iterator_range(crng1);
-
-    // Non zero terminated
     test_char_type data2[] = L"11";
-    iterator_range<test_char_type*> rng2(data2, data2 + 1);
-    do_test_iterator_range(rng2);
+    test_it_range_using_any_chars(data1, data2);
+#endif
 
-    const test_char_type cdata2[] = L"11";
-    iterator_range<const test_char_type*> crng2(cdata2, cdata2 + 1);
-    do_test_iterator_range(crng2);
+    BOOST_CHECK(true);
+}
+
+void test_char16_iterator_ranges() 
+{
+#if !defined(BOOST_NO_CHAR16_T) && !defined(BOOST_NO_UNICODE_LITERALS)
+    typedef char16_t test_char_type;
+    test_char_type data1[] = u"1";
+    test_char_type data2[] = u"11";
+    test_it_range_using_any_chars(data1, data2);
+#endif
+
+    BOOST_CHECK(true);
+}
+
+void test_char32_iterator_ranges() 
+{
+#if !defined(BOOST_NO_CHAR32_T) && !defined(BOOST_NO_UNICODE_LITERALS)
+    typedef char32_t test_char_type;
+    test_char_type data1[] = U"1";
+    test_char_type data2[] = U"11";
+    test_it_range_using_any_chars(data1, data2);
 #endif
 
     BOOST_CHECK(true);
@@ -183,7 +209,9 @@ unit_test::test_suite *init_unit_test_suite(int, char *[])
     suite->add(BOOST_TEST_CASE(&test_char_iterator_ranges));
     suite->add(BOOST_TEST_CASE(&test_unsigned_char_iterator_ranges));
     suite->add(BOOST_TEST_CASE(&test_signed_char_iterator_ranges));
-    suite->add(BOOST_TEST_CASE(&test_wide_char_iterator_ranges));
+    suite->add(BOOST_TEST_CASE(&test_wchar_iterator_ranges));
+    suite->add(BOOST_TEST_CASE(&test_char16_iterator_ranges));
+    suite->add(BOOST_TEST_CASE(&test_char32_iterator_ranges));
 
     return suite;
 }

test/lexical_cast_wchars_test.cpp

@@ -2,7 +2,7 @@
 //
 //  See http://www.boost.org for most recent version, including documentation.
 //
-//  Copyright Antony Polukhin, 2011.
+//  Copyright Antony Polukhin, 2011-2012.
 //
 //  Distributed under the Boost
 //  Software License, Version 1.0. (See accompanying file
@@ -17,40 +17,70 @@
 #endif
 
 #include <boost/lexical_cast.hpp>
-
-#include <boost/cstdint.hpp>
 #include <boost/test/unit_test.hpp>
-#include <boost/test/floating_point_comparison.hpp>
 
 using namespace boost;
 
-void test_char_types_conversions()
+#if defined(BOOST_NO_STRINGSTREAM) || defined(BOOST_NO_STD_WSTRING)
+#define BOOST_LCAST_NO_WCHAR_T
+#endif
+
+template <class CharT>
+void test_impl(const CharT* wc_arr)
 {
-#ifndef BOOST_LCAST_NO_WCHAR_T
+    typedef CharT                       wide_char;
+    typedef std::basic_string<CharT>    wide_string;
     const char c_arr[]            = "Test array of chars";
     const unsigned char uc_arr[]  = "Test array of chars";
     const signed char sc_arr[]    = "Test array of chars";
-    const wchar_t wc_arr[]        =L"Test array of chars";
 
     // Following tests depend on realization of std::locale
     // and pass for popular compilers and STL realizations
-    BOOST_CHECK(boost::lexical_cast<wchar_t>(c_arr[0]) == wc_arr[0]);
-    BOOST_CHECK(boost::lexical_cast<std::wstring>(c_arr) == std::wstring(wc_arr));
+    BOOST_CHECK(boost::lexical_cast<wide_char>(c_arr[0]) == wc_arr[0]);
+    BOOST_CHECK(boost::lexical_cast<wide_string>(c_arr) == wide_string(wc_arr));
 
-    BOOST_CHECK(boost::lexical_cast<std::wstring>(sc_arr) == std::wstring(wc_arr) );
-    BOOST_CHECK(boost::lexical_cast<std::wstring>(uc_arr) == std::wstring(wc_arr) );
+    BOOST_CHECK(boost::lexical_cast<wide_string>(sc_arr) == wide_string(wc_arr) );
+    BOOST_CHECK(boost::lexical_cast<wide_string>(uc_arr) == wide_string(wc_arr) );
 
-    BOOST_CHECK_EQUAL(boost::lexical_cast<wchar_t>(uc_arr[0]), wc_arr[0]);
-    BOOST_CHECK_EQUAL(boost::lexical_cast<wchar_t>(sc_arr[0]), wc_arr[0]);
+    BOOST_CHECK_EQUAL(boost::lexical_cast<wide_char>(uc_arr[0]), wc_arr[0]);
+    BOOST_CHECK_EQUAL(boost::lexical_cast<wide_char>(sc_arr[0]), wc_arr[0]);
+}
+
+
+void test_char_types_conversions_wchar_t()
+{
+#ifndef BOOST_LCAST_NO_WCHAR_T
+    test_impl(L"Test array of chars");
 #endif
-    BOOST_CHECK(1);
+
+    BOOST_CHECK(true);
+}
+
+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)
+    test_impl(u"Test array of chars");
+#endif
+
+    BOOST_CHECK(true);
+}
+
+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)
+    test_impl(U"Test array of chars");
+#endif
+
+    BOOST_CHECK(true);
 }
 
 unit_test::test_suite *init_unit_test_suite(int, char *[])
 {
     unit_test::test_suite *suite =
-        BOOST_TEST_SUITE("lexical_cast char<->wchar_t unit test");
-    suite->add(BOOST_TEST_CASE(&test_char_types_conversions));
+        BOOST_TEST_SUITE("lexical_cast char => wide characters unit test (widening test)");
+    suite->add(BOOST_TEST_CASE(&test_char_types_conversions_wchar_t));
+    suite->add(BOOST_TEST_CASE(&test_char_types_conversions_char16_t));
+    suite->add(BOOST_TEST_CASE(&test_char_types_conversions_char32_t));
 
     return suite;
 }