Release 1.55.0

[SVN r86621]
Merge lexical_casts documentation and tests to release branch (refs #9046 )
2026-08-07 14:04:20 +02:00 · 2013-11-11 19:45:21 +00:00 · 2013-09-25 13:27:07 +00:00 · 2013-09-24 14:21:53 +00:00 · 2013-09-23 11:59:06 +00:00 · 2013-09-22 16:06:45 +00:00
16 changed files with 321 additions and 134 deletions
@@ -10,6 +10,13 @@
    <meta name="ProgId" content="FrontPage.Editor.Document">

    <title>Header boost/cast.hpp Documentation</title>
+    <style>
+       .copyright
+        {
+            color: #666666;
+            font-size: small;
+        }
+    </style>
  </head>

  <body bgcolor="#FFFFFF" text="#000000">
@@ -131,10 +138,9 @@ void f( Fruit * fruit ) {
                    -->June 23, 2005<!--webbot bot="Timestamp" endspan i-checksum="30348"
                    --></p>

-    <p>&copy; Copyright boost.org 1999. Permission to copy, use, modify, sell
-    and distribute this document is granted provided this copyright notice
-    appears in all copies. This document is provided "as is" without express
-    or implied warranty, and with no claim as to its suitability for any
-    purpose.</p>
+    <p class="copyright">&copy; Copyright boost.org 1999. 
+    Distributed under the Boost Software License, Version 1.0. (See accompanying
+    file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt">http://www.boost.org/LICENSE_1_0.txt</a>)
+    </p>
  </body>
-</html>
+</html>
@@ -38,54 +38,22 @@ For a good discussion of the options and issues involved in string-based formatt
 [endsect]

 [section Examples]
-The following example treats command line arguments as a sequence of numeric data:
-``
-    int main(int argc, char * argv[])
-    {
-        using boost::lexical_cast;
-        using boost::bad_lexical_cast;

-        std::vector<short> args;
+[import ../example/args_to_numbers.cpp]

-        while(*++argv)
-        {
-            try
-            {
-                args.push_back(lexical_cast<short>(*argv));
-            }
-            catch(bad_lexical_cast &)
-            {
-                args.push_back(0);
-            }
-        }
-        ...
-    }
-``
-The following example uses numeric data in a string expression:
-``
-    void log_message(const std::string &);
+[section Strings to numbers conversion] [lexical_cast_args_example] [endsect]
+
+[import ../example/small_examples.cpp]
+[section Numbers to strings conversion] [lexical_cast_log_errno] [endsect]
+[section Converting to string without dynamic memory allocation] [lexical_cast_fixed_buffer] [endsect]
+[section Converting part of the string] [lexical_cast_substring_conversion] [endsect]
+
+[import ../example/generic_stringize.cpp]
+[section Generic programming (Boost.Fusion)] [lexical_cast_stringize] [endsect]
+
+[import ../example/variant_to_long_double.cpp]
+[section Generic programming (Boost.Variant)] [lexical_cast_variant_to_long_double] [endsect]

-    void log_errno(int yoko)
-    {
-        log_message("Error " + boost::lexical_cast<std::string>(yoko) + ": " + strerror(yoko));
-    }
-``
-Following example converts some number and puts it to file:
-``
-    int i;
-    FILE* file;
-    ...
-    typedef boost::array<char, 50> buf_t; // You can use std::array if your compiler supports it
-    buf_t buffer = boost::lexical_cast<buf_t>(i); // No dynamic memory allocation
-    puts(buffer.begin(), file);
-``
-Following example takes part of the string and converts it to `int`:
-``
-int convert_strings_part(const std::string& s, std::size_t pos, std::size_t n) 
-{
-    return boost::lexical_cast<int>(s.data() + pos, n);
-}
-``
 [endsect]

 [section Synopsis]
@@ -156,56 +124,6 @@ Exception used to indicate runtime lexical_cast failure.

 [endsect]

-[/ Commenting out bad advise (this will break the ability to get correct function pointers via &lexical_cast<Target, Source>)
-[section Tuning classes for fast lexical conversions]
-Because of `boost::lexical_cast` optimizations for `boost::iterator_range<character_type*>`, it is possibile to make very fast lexical conversions for non zero terminated strings, substrings and user-defined classes.
-
-Consider the following example:
-``
-    class example_class {
-        char non_zero_terminated_data[10];
-        std::size_t data_length;
-
-    public:
-        example_class();
-        void fill_data();
-
-        const char* data() const {
-            return non_zero_terminated_data;
-        }
-
-        std::size_t size() const {
-            return data_length;
-        }
-    };
-
-    inline std::ostream& operator << (std::ostream& ostr, const example_class& rhs) {
-        return ostr << boost::make_iterator_range(rhs.data(), rhs.data() + rhs.size());
-    }
-``
-
-This is a good generic solution for most use cases.
-But we can make it even faster for some performance critical applications. During conversion, we loose speed at:
-
- * `std::ostream` construction     (it makes some heap allocations)
- * `operator <<`                   (it copyies one by one all the symbols to an instance of `std::ostream`)
- * `std::ostream` destruction      (it makes some heap deallocations)
-
-We can avoid all of this, by specifieng an overload for `boost::lexical_cast`:
-``
-namespace boost {
-    template <class OutT>
-    OutT lexical_cast(const example_class& rhs) {
-        return boost::lexical_cast<OutT>(
-            boost::make_iterator_range(rhs.data(), rhs.data() + rhs.size())
-        );
-    }
-}
-``
-Now `boost::lexical_cast<some_type>(example_class_instance)` conversions won't copy data and construct heavy STL stream objects. See [link boost_lexical_cast.performance Performance] section for info on `boost::iterator_range` conversion performance.
-[endsect]
-]
-
 [section Frequently Asked Questions]

 * [*Question:]    Why does `lexical_cast<int8_t>("127")` throw `bad_lexical_cast`?
@@ -276,6 +194,11 @@ limitation of compiler options that you use.

 [section Changes]

+* [*boost 1.54.0 :]
+
+    * Fix some issues with `boost::int128_type` and `boost::uint128_type` conversions. Notify user at compile time 
+      if the `std::numeric_limits` are not specialized for 128bit types and `boost::lexical_cast` can not make conversions.
+
 * [*boost 1.54.0 :]

    * Added code to convert `boost::int128_type` and `boost::uint128_type` types (requires GCC 4.7 or higher).
@@ -0,0 +1,35 @@
+// Copyright 2013 Antony Polukhin
+
+// Distributed under the Boost Software License, Version 1.0.
+// (See the accompanying file LICENSE_1_0.txt
+// or a copy at <http://www.boost.org/LICENSE_1_0.txt>.)
+
+//[lexical_cast_args_example
+//`The following example treats command line arguments as a sequence of numeric data
+
+#include <boost/lexical_cast.hpp>
+#include <vector>
+
+int main(int /*argc*/, char * argv[])
+{
+    using boost::lexical_cast;
+    using boost::bad_lexical_cast;
+
+    std::vector<short> args;
+
+    while (*++argv)
+    {
+        try
+        {
+            args.push_back(lexical_cast<short>(*argv));
+        }
+        catch(const bad_lexical_cast &)
+        {
+            args.push_back(0);
+        }
+    }
+
+    // ...
+}
+
+//] [/lexical_cast_args_example]
@@ -0,0 +1,61 @@
+// Copyright 2013 Antony Polukhin
+
+// Distributed under the Boost Software License, Version 1.0.
+// (See the accompanying file LICENSE_1_0.txt
+// or a copy at <http://www.boost.org/LICENSE_1_0.txt>.)
+
+
+//[lexical_cast_stringize
+/*`
+    In this example we'll make a `stringize` method that accepts a sequence, converts
+    each element of the sequence into string and appends that string to the result.
+
+    Example is based on the example from the [@http://www.packtpub.com/boost-cplusplus-application-development-cookbook/book Boost C++ Application Development Cookbook]
+    by Antony Polukhin, ISBN 9781849514880.
+
+    Step 1: Making a functor that converts any type to a string and remembers result:
+*/
+
+#include <boost/lexical_cast.hpp>
+
+struct stringize_functor {
+private:
+    std::string& result;
+
+public:
+    explicit stringize_functor(std::string& res)
+        : result(res)
+    {}
+
+    template <class T>
+    void operator()(const T& v) const {
+        result += boost::lexical_cast<std::string>(v);
+    }
+};
+
+//` Step 2: Applying `stringize_functor` to each element in sequence:
+#include <boost/fusion/include/for_each.hpp>
+template <class Sequence>
+std::string stringize(const Sequence& seq) {
+    std::string result;
+    boost::fusion::for_each(seq, stringize_functor(result));
+    return result;
+}
+
+//` Step 3: Using the `stringize` with different types:
+#include <cassert>
+#include <boost/fusion/adapted/boost_tuple.hpp>
+#include <boost/fusion/adapted/std_pair.hpp>
+
+int main() {
+    boost::tuple<char, int, char, int> decim('-', 10, 'e', 5);
+    assert(stringize(decim) == "-10e5");
+
+    std::pair<short, std::string> value_and_type(270, "Kelvin");
+    assert(stringize(value_and_type) == "270Kelvin");
+}
+
+//] [/lexical_cast_stringize]
+
+
+
@@ -0,0 +1,52 @@
+// Copyright 2013 Antony Polukhin
+
+// Distributed under the Boost Software License, Version 1.0.
+// (See the accompanying file LICENSE_1_0.txt
+// or a copy at <http://www.boost.org/LICENSE_1_0.txt>.)
+
+#include <boost/lexical_cast.hpp>
+#include <string>
+#include <cstdio>
+
+//[lexical_cast_log_errno
+//`The following example uses numeric data in a string expression: 
+
+void log_message(const std::string &);
+
+void log_errno(int yoko)
+{
+    log_message("Error " + boost::lexical_cast<std::string>(yoko) + ": " + strerror(yoko));
+}
+
+//] [/lexical_cast_log_errno]
+
+
+//[lexical_cast_fixed_buffer
+//`The following example converts some number and puts it to file:
+
+void number_to_file(int number, FILE* file)
+{
+    typedef boost::array<char, 50> buf_t; // You can use std::array if your compiler supports it
+    buf_t buffer = boost::lexical_cast<buf_t>(number); // No dynamic memory allocation
+    fputs(buffer.begin(), file);
+}
+
+//] [/lexical_cast_fixed_buffer]
+
+//[lexical_cast_substring_conversion
+//`The following example takes part of the string and converts it to `int`:
+
+int convert_strings_part(const std::string& s, std::size_t pos, std::size_t n)
+{
+    return boost::lexical_cast<int>(s.data() + pos, n);
+}
+
+//] [/lexical_cast_substring_conversion]
+
+void log_message(const std::string &) {}
+
+int main()
+{
+    return 0;
+}
+
@@ -0,0 +1,39 @@
+// Copyright 2013 Antony Polukhin
+
+// Distributed under the Boost Software License, Version 1.0.
+// (See the accompanying file LICENSE_1_0.txt
+// or a copy at <http://www.boost.org/LICENSE_1_0.txt>.)
+
+
+//[lexical_cast_variant_to_long_double
+/*`
+    In this example we'll make a `to_long_double` method that converts value of the Boost.Variant to `long double`.
+*/
+
+#include <boost/lexical_cast.hpp>
+#include <boost/variant.hpp>
+#include <cassert>
+
+struct to_long_double_functor: boost::static_visitor<long double> {
+    template <class T>
+    long double operator()(const T& v) const {
+        // Lexical cast has many optimizations including optimizations for situations that usually 
+        // occur in generic programming, like std::string to std::string or arithmetic type to arithmetic type conversion. 
+        return boost::lexical_cast<long double>(v);
+    }
+};
+
+// Throws `boost::bad_lexical_cast` if value of the variant is not convertible to `long double`
+template <class Variant>
+long double to_long_double(const Variant& v) {
+    return boost::apply_visitor(to_long_double_functor(), v);
+}
+
+int main() {
+    boost::variant<char, int, std::string> v1('0'), v2("10.0001"), v3(1);
+
+    long double sum = to_long_double(v1) + to_long_double(v2) + to_long_double(v3);
+    assert(sum > 11 && sum < 11.1);
+}
+
+//] [/lexical_cast_variant_to_long_double]
@@ -69,11 +69,6 @@
    throw_exception(bad_lexical_cast(typeid(Source), typeid(Target)))
 #endif

-#if (defined(BOOST_LCAST_HAS_INT128) && !defined(__GNUC__)) || GCC_VERSION > 40700
-#define BOOST_LCAST_HAS_INT128
-#endif
-
-
 namespace boost
 {
    // exception used to indicate runtime lexical_cast failure
@@ -316,7 +311,7 @@ namespace boost {
        > {};
 #endif

-#ifdef BOOST_LCAST_HAS_INT128
+#ifdef BOOST_HAS_INT128
        template <> struct stream_char_common< boost::int128_type >: public boost::mpl::identity< char > {};
        template <> struct stream_char_common< boost::uint128_type >: public boost::mpl::identity< char > {};
 #endif
@@ -613,7 +608,7 @@ namespace boost {
        BOOST_LCAST_DEF(unsigned __int64)
        BOOST_LCAST_DEF(         __int64)
 #endif
-#ifdef BOOST_LCAST_HAS_INT128
+#ifdef BOOST_HAS_INT128
        BOOST_LCAST_DEF(boost::int128_type)
        BOOST_LCAST_DEF(boost::uint128_type)
 #endif
@@ -879,6 +874,15 @@ namespace boost {
        {
 #ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
            BOOST_STATIC_ASSERT(!std::numeric_limits<T>::is_signed);
+
+            // GCC when used with flag -std=c++0x may not have std::numeric_limits
+            // specializations for __int128 and unsigned __int128 types.
+            // Try compilation with -std=gnu++0x or -std=gnu++11.
+            //
+            // http://gcc.gnu.org/bugzilla/show_bug.cgi?id=40856
+            BOOST_STATIC_ASSERT_MSG(std::numeric_limits<T>::is_specialized,
+                "std::numeric_limits are not specialized for integral type passed to boost::lexical_cast"
+            );
 #endif
            CharT const czero = lcast_char_constants<CharT>::zero;
            --end;
@@ -1612,6 +1616,11 @@ namespace boost {
                // does not support such conversions. Try updating it.
                BOOST_STATIC_ASSERT((boost::is_same<char, CharT>::value));
 #endif
+
+#ifndef BOOST_NO_EXCEPTIONS
+                out_stream.exceptions(std::ios::badbit);
+                try {
+#endif
                bool const result = !(out_stream << input).fail();
                const buffer_t* const p = static_cast<buffer_t*>(
                    static_cast<std::basic_streambuf<CharT, Traits>*>(out_stream.rdbuf())
@@ -1619,6 +1628,11 @@ namespace boost {
                start = p->pbase();
                finish = p->pptr();
                return result;
+#ifndef BOOST_NO_EXCEPTIONS
+                } catch (const ::std::ios_base::failure& /*f*/) {
+                    return false;
+                }
+#endif
            }

            template <class T>
@@ -1827,7 +1841,7 @@ namespace boost {
            bool operator<<(         __int64 n)         { return shl_signed(n); }
 #endif

-#ifdef BOOST_LCAST_HAS_INT128
+#ifdef BOOST_HAS_INT128
        bool operator<<(const boost::uint128_type& n)   { start = lcast_put_unsigned<Traits>(n, finish); return true; }
        bool operator<<(const boost::int128_type& n)    { return shl_signed(n); }
 #endif
@@ -1992,6 +2006,10 @@ namespace boost {
 #endif // BOOST_NO_STD_LOCALE
 #endif // BOOST_NO_STRINGSTREAM

+#ifndef BOOST_NO_EXCEPTIONS
+                stream.exceptions(std::ios::badbit);
+                try {
+#endif
                stream.unsetf(std::ios::skipws);
                lcast_set_precision(stream, static_cast<InputStreamable*>(0));

@@ -2006,6 +2024,12 @@ namespace boost {
 #else
                Traits::eof();
 #endif
+
+#ifndef BOOST_NO_EXCEPTIONS
+                } catch (const ::std::ios_base::failure& /*f*/) {
+                    return false;
+                }
+#endif
            }

            template<class T>
@@ -2039,7 +2063,7 @@ namespace boost {
            bool operator>>(__int64& output)                    { return shr_signed(output); }
 #endif

-#ifdef BOOST_LCAST_HAS_INT128
+#ifdef BOOST_HAS_INT128
            bool operator>>(boost::uint128_type& output)        { return shr_unsigned(output); }
            bool operator>>(boost::int128_type& output)         { return shr_signed(output); }
 #endif
@@ -2553,7 +2577,7 @@ namespace boost {
        );
    }
 #endif
-#ifndef BOOST_NO_CHAR16_T
+#ifndef BOOST_NO_CXX11_CHAR16_T
    template <typename Target>
    inline Target lexical_cast(const char16_t* chars, std::size_t count)
    {
@@ -2562,7 +2586,7 @@ namespace boost {
        );
    }
 #endif
-#ifndef BOOST_NO_CHAR32_T
+#ifndef BOOST_NO_CXX11_CHAR32_T
    template <typename Target>
    inline Target lexical_cast(const char32_t* chars, std::size_t count)
    {
@@ -2719,7 +2743,6 @@ namespace boost {

 #undef BOOST_LCAST_THROW_BAD_CAST
 #undef BOOST_LCAST_NO_WCHAR_T
-#undef BOOST_LCAST_HAS_INT128

 #endif // BOOST_LEXICAL_CAST_INCLUDED

@@ -6,6 +6,13 @@
 <meta name="GENERATOR" content="Microsoft FrontPage 5.0">
 <meta name="ProgId" content="FrontPage.Editor.Document">
 <title>Boost Conversion Library</title>
+<style>
+   .copyright
+    {
+        color: #666666;
+        font-size: small;
+    }
+</style>
 </head>

 <body bgcolor="#FFFFFF" text="#000000">
@@ -32,7 +39,11 @@ supplied by several headers:</p>
 <p>Revised <!--webbot bot="Timestamp" S-Type="EDITED"
 S-Format="%d %B, %Y" startspan -->June 23, 2005<!--webbot bot="Timestamp" endspan i-checksum="30348" -->
 </p>
-
+<p class="copyright">
+    Copyright 2001 Beman Dawes.
+    Distributed under the Boost Software License, Version 1.0. (See accompanying
+    file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt">http://www.boost.org/LICENSE_1_0.txt</a>)
+</p>
 </body>

-</html>
+</html>
@@ -48,7 +48,7 @@ int test_main( int , char * [] )
    long large_negative_value = LONG_MIN;
    signed char c = 0;

-    c = large_value;  // see if compiler generates warning
+    c = static_cast<signed char>(large_value);

    c = numeric_cast<signed char>( small_value );
    BOOST_CHECK( c == 1 );
@@ -1,5 +1,5 @@
 # Copyright (C) 2001-2003 Douglas Gregor
-# Copyright (C) 2011-2012 Antony Polukhin
+# Copyright (C) 2011-2013 Antony Polukhin
 #
 # 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)
@@ -15,6 +15,11 @@ project
        <toolset>gcc-4.7:<cxxflags>-ftrapv
        <toolset>gcc-4.6:<cxxflags>-ftrapv
        <toolset>clang:<cxxflags>-ftrapv
+        # default to all warnings on:
+        <warnings>all
+        # set warnings as errors for those compilers we know we get warning free:
+        <toolset>gcc:<cxxflags>-Wextra
+        <toolset>gcc:<cxxflags>-Wno-uninitialized
    ;

 # Thanks to Steven Watanabe for helping with <nowchar> feature
@@ -35,7 +40,7 @@ test-suite conversion
    [ run lexical_cast_wchars_test.cpp ]
    [ run lexical_cast_float_types_test.cpp ]
    [ run lexical_cast_inf_nan_test.cpp ]
-    [ run lexical_cast_containers_test.cpp ]
+    [ run lexical_cast_containers_test.cpp : : : <toolset>gcc:<cxxflags>-Wno-long-long <toolset>clang:<cxxflags>-Wno-long-long ]
    [ run lexical_cast_empty_input_test.cpp ]
    [ run lexical_cast_pointers_test.cpp ]
    [ compile lexical_cast_typedefed_wchar_test.cpp : <toolset>msvc:<nowchar>on ]
@@ -59,3 +64,10 @@ test-suite conversion
    [ run lexical_cast_filesystem_test.cpp ../../filesystem/build//boost_filesystem/<link>static ]
  ;

+# Assuring that examples compile and run. Adding sources from `example` directory to the `conversion` test suite. 
+for local p in [ glob ../example/*.cpp ]
+{
+    conversion += [ run $(p) ] ;
+}
+
+
@@ -19,6 +19,8 @@ struct foo
 int test_main(int, char*[])
 {
    foo x = implicit_cast<foo>("foobar");
-    (void)x;  // warning suppression.
+    (void)x;            // warning suppression.
+    BOOST_CHECK(false); // suppressing warning about 'boost::unit_test::{anonymous}::unit_test_log' defined but not used
    return 0;
 }
+
@@ -222,7 +222,8 @@ static void testing_template_array_output_on_char_value()
        BOOST_CHECK(&res3[0] == u16ethalon);
    }
    
-    BOOST_CHECK_THROW(lexical_cast<u16short_arr_type>(val), boost::bad_lexical_cast);
+    // Some compillers may throw std::bad_alloc here
+    BOOST_CHECK_THROW(lexical_cast<u16short_arr_type>(val), std::exception); 
 #endif

 #ifdef BOOST_LC_RUNU32
@@ -248,7 +249,8 @@ static void testing_template_array_output_on_char_value()
        BOOST_CHECK(&res3[0] == u32ethalon);
    }
    
-    BOOST_CHECK_THROW(lexical_cast<u32short_arr_type>(val), boost::bad_lexical_cast);
+    // Some compillers may throw std::bad_alloc here
+    BOOST_CHECK_THROW(lexical_cast<u32short_arr_type>(val), std::exception);
 #endif
 }

@@ -297,12 +297,16 @@ void test_float_typess_for_overflows()
    BOOST_CHECK_CLOSE_FRACTION(maxvalue, lexical_cast<test_t>(maxvalue), (std::numeric_limits<test_t>::epsilon()));
    BOOST_CHECK_CLOSE_FRACTION(maxvalue, lexical_cast<test_t>(s_max_value), (std::numeric_limits<test_t>::epsilon()));

+#ifndef _LIBCPP_VERSION
+    // libc++ had a bug in implementation of stream conversions for values that must be represented as infinity. 
+    // http://llvm.org/bugs/show_bug.cgi?id=15723#c4
    BOOST_CHECK_THROW(lexical_cast<test_t>(s_max_value+"1"), bad_lexical_cast);
    BOOST_CHECK_THROW(lexical_cast<test_t>(s_max_value+"9"), bad_lexical_cast);

-    // VC9 can fail the fllowing tests on floats and doubles when using stingstream...
+    // VC9 can fail the following tests on floats and doubles when using stingstream...
    BOOST_CHECK_THROW(lexical_cast<test_t>("1"+s_max_value), bad_lexical_cast);
    BOOST_CHECK_THROW(lexical_cast<test_t>("9"+s_max_value), bad_lexical_cast);
+#endif

    if ( is_same<test_t,float>::value )
    {
@@ -48,10 +48,6 @@
 #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;

@@ -75,7 +71,7 @@ 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
+#ifdef BOOST_HAS_INT128
 void test_conversion_from_to_int128();
 void test_conversion_from_to_uint128();
 #endif
@@ -99,7 +95,7 @@ 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
+#ifdef BOOST_HAS_INT128
    suite->add(BOOST_TEST_CASE(&test_conversion_from_to_int128));
    suite->add(BOOST_TEST_CASE(&test_conversion_from_to_uint128));
 #endif
@@ -444,8 +440,8 @@ void test_conversion_from_to_integral_minimal()
    // 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";
+    std::string must_owerflow_str =             (sizeof(T) < 16 ?  "160000000000000000000" :  "1600000000000000000000000000000000000000");
+    std::string must_owerflow_negative_str =    (sizeof(T) < 16 ? "-160000000000000000000" : "-1600000000000000000000000000000000000000");
    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);
@@ -557,15 +553,34 @@ void test_conversion_from_to_ulonglong()
 #endif


-#ifdef BOOST_LCAST_HAS_INT128
+#ifdef BOOST_HAS_INT128
+
+template <bool Specialized, class T>
+struct test_if_specialized {
+    static void test() {}
+};
+
+template <class T>
+struct test_if_specialized<true, T> {
+    static void test() {
+        test_conversion_from_to_integral_minimal<T>();
+    }
+};
+
 void test_conversion_from_to_int128()
 {
-    test_conversion_from_to_integral_minimal<boost::int128_type>();
+    test_if_specialized<
+        std::numeric_limits<boost::int128_type>::is_specialized, 
+        boost::int128_type
+    >::test();
 }

 void test_conversion_from_to_uint128()
 {
-    test_conversion_from_to_integral_minimal<boost::uint128_type>();
+    test_if_specialized<
+        std::numeric_limits<boost::int128_type>::is_specialized, 
+        boost::uint128_type
+    >::test();
 }
 #endif

@@ -602,7 +617,7 @@ void test_integral_conversions_on_min_max()
    test_integral_conversions_on_min_max_impl<__int64>();
 #endif

-#ifdef BOOST_LCAST_HAS_INT128
+#ifdef BOOST_HAS_INT128
    test_integral_conversions_on_min_max_impl<boost::int128_type>();
 #endif
 #endif
@@ -17,5 +17,7 @@
 int test_main(int, char*[])
 {
    boost::lexical_cast<char*>("Hello");
+    BOOST_CHECK(false); // suppressing warning about 'boost::unit_test::{anonymous}::unit_test_log' defined but not used
    return 0;
 }
+