diff --git a/CMakeLists.txt b/CMakeLists.txt
index 17103a3..3a46e67 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -14,15 +14,12 @@ target_include_directories(boost_lexical_cast INTERFACE include)
 
 target_link_libraries(boost_lexical_cast
   INTERFACE
-    Boost::array
-    Boost::assert
     Boost::config
     Boost::container
     Boost::core
     Boost::integer
     Boost::numeric_conversion
     Boost::range
-    Boost::static_assert
     Boost::throw_exception
     Boost::type_traits
 )
diff --git a/doc/lexical_cast.qbk b/doc/lexical_cast.qbk
index 5e26ff3..221b0a4 100644
--- a/doc/lexical_cast.qbk
+++ b/doc/lexical_cast.qbk
@@ -235,6 +235,10 @@ limitation of compiler options that you use.
 
 [section Changes]
 
+* [*boost 1.84.0 :]
+
+    * Dropped support of C++98 and C++03.
+
 * [*boost 1.56.0 :]
 
     * Added `boost::conversion::try_lexical_convert` functions.
diff --git a/example/generic_stringize.cpp b/example/generic_stringize.cpp
index c8c8737..dfe4eef 100644
--- a/example/generic_stringize.cpp
+++ b/example/generic_stringize.cpp
@@ -47,11 +47,11 @@ std::string stringize(const Sequence& seq) {
 }
 
 //` Step 3: Using the `stringize` with different types:
-#include <boost/fusion/adapted/boost_tuple.hpp>
+#include <boost/fusion/adapted/std_tuple.hpp>
 #include <boost/fusion/adapted/std_pair.hpp>
 
 int main() {
-    boost::tuple<char, int, char, int> decim('-', 10, 'e', 5);
+    std::tuple<char, int, char, int> decim('-', 10, 'e', 5);
     if (stringize(decim) != "-10e5") {
         return 1;
     }
diff --git a/example/small_examples.cpp b/example/small_examples.cpp
index 33d32d4..13aba4b 100644
--- a/example/small_examples.cpp
+++ b/example/small_examples.cpp
@@ -5,6 +5,8 @@
 // or a copy at <http://www.boost.org/LICENSE_1_0.txt>.)
 
 #include <boost/lexical_cast.hpp>
+
+#include <array>
 #include <string>
 #include <cstdio>
 
@@ -30,9 +32,9 @@ void log_errno(int yoko)
 
 void number_to_file(int number, std::FILE* file)
 {
-    typedef boost::array<char, 50> buf_t; // You can use std::array if your compiler supports it
+    using buf_t = std::array<char, 50>;
     buf_t buffer = boost::lexical_cast<buf_t>(number); // No dynamic memory allocation
-    std::fputs(buffer.begin(), file);
+    std::fputs(buffer.data(), file);
 }
 
 //] [/lexical_cast_fixed_buffer]
diff --git a/include/boost/detail/basic_pointerbuf.hpp b/include/boost/detail/basic_pointerbuf.hpp
index a92a489..424dcac 100644
--- a/include/boost/detail/basic_pointerbuf.hpp
+++ b/include/boost/detail/basic_pointerbuf.hpp
@@ -42,13 +42,8 @@ public:
    basic_pointerbuf() : base_type() { this_type::setbuf(0, 0); }
    const charT* getnext() { return this->gptr(); }
 
-#ifndef BOOST_NO_USING_TEMPLATE
     using base_type::pptr;
     using base_type::pbase;
-#else
-    charT* pptr() const { return base_type::pptr(); }
-    charT* pbase() const { return base_type::pbase(); }
-#endif
 
 protected:
    // VC mistakenly assumes that `setbuf` and other functions are not referenced.
diff --git a/include/boost/detail/lcast_precision.hpp b/include/boost/detail/lcast_precision.hpp
index 84bf122..dadf9c9 100644
--- a/include/boost/detail/lcast_precision.hpp
+++ b/include/boost/detail/lcast_precision.hpp
@@ -21,23 +21,10 @@
 #include <boost/type_traits/is_abstract.hpp>
 #endif
 
-#if defined(BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS) || \
-  (defined(BOOST_MSVC) && (BOOST_MSVC<1310))
-
-#define BOOST_LCAST_NO_COMPILE_TIME_PRECISION
-#endif
-
-#ifdef BOOST_LCAST_NO_COMPILE_TIME_PRECISION
-#include <boost/assert.hpp>
-#else
-#include <boost/static_assert.hpp>
-#endif
-
 namespace boost { namespace detail {
 
 class lcast_abstract_stub {};
 
-#ifndef BOOST_LCAST_NO_COMPILE_TIME_PRECISION
 // Calculate an argument to pass to std::ios_base::precision from
 // lexical_cast. See alternative implementation for broken standard
 // libraries in lcast_get_precision below. Keep them in sync, please.
@@ -47,7 +34,7 @@ struct lcast_precision
 #ifdef BOOST_NO_IS_ABSTRACT
     typedef std::numeric_limits<T> limits; // No fix for SF:1358600.
 #else
-    typedef BOOST_DEDUCED_TYPENAME boost::conditional<
+    typedef typename boost::conditional<
         boost::is_abstract<T>::value
       , std::numeric_limits<lcast_abstract_stub>
       , std::numeric_limits<T>
@@ -74,95 +61,31 @@ struct lcast_precision
 
     BOOST_STATIC_CONSTANT(unsigned int, precision_dec = limits::digits10 + 1U);
 
-    BOOST_STATIC_ASSERT(!is_specialized_dec ||
+    static_assert(!is_specialized_dec ||
             precision_dec <= streamsize_max + 0UL
-        );
+        , "");
 
     BOOST_STATIC_CONSTANT(unsigned long, precision_bin =
             2UL + limits::digits * 30103UL / 100000UL
         );
 
-    BOOST_STATIC_ASSERT(!is_specialized_bin ||
+    static_assert(!is_specialized_bin ||
             (limits::digits + 0UL < ULONG_MAX / 30103UL &&
             precision_bin > limits::digits10 + 0UL &&
             precision_bin <= streamsize_max + 0UL)
-        );
+        , "");
 
     BOOST_STATIC_CONSTANT(std::streamsize, value =
             is_specialized_bin ? precision_bin
                                : is_specialized_dec ? precision_dec : 6
         );
 };
-#endif
+
 
 template<class T>
 inline std::streamsize lcast_get_precision(T* = 0)
 {
-#ifndef BOOST_LCAST_NO_COMPILE_TIME_PRECISION
     return lcast_precision<T>::value;
-#else // Follow lcast_precision algorithm at run-time:
-
-#ifdef BOOST_NO_IS_ABSTRACT
-    typedef std::numeric_limits<T> limits; // No fix for SF:1358600.
-#else
-    typedef BOOST_DEDUCED_TYPENAME boost::conditional<
-        boost::is_abstract<T>::value
-      , std::numeric_limits<lcast_abstract_stub>
-      , std::numeric_limits<T>
-      >::type limits;
-#endif
-
-    bool const use_default_precision =
-        !limits::is_specialized || limits::is_exact;
-
-    if(!use_default_precision)
-    { // Includes all built-in floating-point types, float, double ...
-      // and UDT types for which digits (significand bits) is defined (not zero)
-
-        bool const is_specialized_bin =
-            limits::radix == 2 && limits::digits > 0;
-        bool const is_specialized_dec =
-            limits::radix == 10 && limits::digits10 > 0;
-        std::streamsize const streamsize_max =
-            (boost::integer_traits<std::streamsize>::max)();
-        (void)streamsize_max;
-
-        if(is_specialized_bin)
-        { // Floating-point types with
-          // limits::digits defined by the specialization.
-
-            unsigned long const digits = limits::digits;
-            unsigned long const precision = 2UL + digits * 30103UL / 100000UL;
-            // unsigned long is selected because it is at least 32-bits
-            // and thus ULONG_MAX / 30103UL is big enough for all types.
-            BOOST_ASSERT(
-                    digits < ULONG_MAX / 30103UL &&
-                    precision > limits::digits10 + 0UL &&
-                    precision <= streamsize_max + 0UL
-                );
-            return precision;
-        }
-        else if(is_specialized_dec)
-        {   // Decimal Floating-point type, most likely a User Defined Type
-            // rather than a real floating-point hardware type.
-            unsigned int const precision = limits::digits10 + 1U;
-            BOOST_ASSERT(precision <= streamsize_max + 0UL);
-            return precision;
-        }
-    }
-
-    // Integral type (for which precision has no effect)
-    // or type T for which limits is NOT specialized,
-    // so assume stream precision remains the default 6 decimal digits.
-    // Warning: if your User-defined Floating-point type T is NOT specialized,
-    // then you may lose accuracy by only using 6 decimal digits.
-    // To avoid this, you need to specialize T with either
-    // radix == 2 and digits == the number of significand bits,
-    // OR
-    // radix = 10 and digits10 == the number of decimal digits.
-
-    return 6;
-#endif
 }
 
 template<class T>
diff --git a/include/boost/lexical_cast.hpp b/include/boost/lexical_cast.hpp
index 2c8b773..f8adc4f 100644
--- a/include/boost/lexical_cast.hpp
+++ b/include/boost/lexical_cast.hpp
@@ -23,24 +23,6 @@
 #   pragma once
 #endif
 
-#include <boost/config/pragma_message.hpp>
-#if defined(BOOST_NO_CXX11_RVALUE_REFERENCES) || \
-    defined(BOOST_NO_CXX11_AUTO_DECLARATIONS) || \
-    defined(BOOST_NO_CXX11_CONSTEXPR) || \
-    defined(BOOST_NO_CXX11_NULLPTR) || \
-    defined(BOOST_NO_CXX11_NOEXCEPT) || \
-    defined(BOOST_NO_CXX11_DEFAULTED_FUNCTIONS) || \
-    defined(BOOST_NO_CXX11_FINAL) || \
-    defined(BOOST_NO_CXX11_ALIGNOF) || \
-    defined(BOOST_NO_CXX11_STATIC_ASSERT) || \
-    defined(BOOST_NO_CXX11_SMART_PTR) || \
-    defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST) || \
-    defined(BOOST_NO_CXX11_HDR_TYPE_TRAITS)
-
-BOOST_PRAGMA_MESSAGE("C++03 support is deprecated in Boost.LexicalCast 1.82 and will be removed in Boost.LexicalCast 1.84.")
-
-#endif
-
 #if defined(BOOST_NO_STRINGSTREAM) || defined(BOOST_NO_STD_WSTRING)
 #define BOOST_LCAST_NO_WCHAR_T
 #endif
@@ -96,7 +78,6 @@ namespace boost
         );
     }
 #endif
-#ifndef BOOST_NO_CXX11_CHAR16_T
     template <typename Target>
     inline Target lexical_cast(const char16_t* chars, std::size_t count)
     {
@@ -104,8 +85,6 @@ namespace boost
             ::boost::iterator_range<const char16_t*>(chars, chars + count)
         );
     }
-#endif
-#ifndef BOOST_NO_CXX11_CHAR32_T
     template <typename Target>
     inline Target lexical_cast(const char32_t* chars, std::size_t count)
     {
@@ -113,7 +92,6 @@ namespace boost
             ::boost::iterator_range<const char32_t*>(chars, chars + count)
         );
     }
-#endif
 
 } // namespace boost
 
diff --git a/include/boost/lexical_cast/bad_lexical_cast.hpp b/include/boost/lexical_cast/bad_lexical_cast.hpp
index 07ae40c..3854f5f 100644
--- a/include/boost/lexical_cast/bad_lexical_cast.hpp
+++ b/include/boost/lexical_cast/bad_lexical_cast.hpp
@@ -37,29 +37,23 @@ namespace boost
 #else
         public std::bad_cast
 #endif
-
-#if defined(BOOST_BORLANDC) && BOOST_WORKAROUND( BOOST_BORLANDC, < 0x560 )
-        // under bcc32 5.5.1 bad_cast doesn't derive from exception
-        , public std::exception
-#endif
-
     {
     public:
-        bad_lexical_cast() BOOST_NOEXCEPT
+        bad_lexical_cast() noexcept
 #ifndef BOOST_NO_TYPEID
            : source(&typeid(void)), target(&typeid(void))
 #endif
         {}
 
-        const char *what() const BOOST_NOEXCEPT_OR_NOTHROW BOOST_OVERRIDE {
+        const char *what() const noexcept override {
             return "bad lexical cast: "
                    "source type value could not be interpreted as target";
         }
 
-        ~bad_lexical_cast() BOOST_NOEXCEPT_OR_NOTHROW BOOST_OVERRIDE = default;
+        ~bad_lexical_cast() override = default;
 
-        bad_lexical_cast(const bad_lexical_cast&) BOOST_NOEXCEPT_OR_NOTHROW = default;
-        bad_lexical_cast& operator=(const bad_lexical_cast&) BOOST_NOEXCEPT_OR_NOTHROW = default;
+        bad_lexical_cast(const bad_lexical_cast&) = default;
+        bad_lexical_cast& operator=(const bad_lexical_cast&) = default;
 
 #ifndef BOOST_NO_TYPEID
     private:
@@ -71,15 +65,15 @@ namespace boost
     public:
         bad_lexical_cast(
                 const type_info_t &source_type_arg,
-                const type_info_t &target_type_arg) BOOST_NOEXCEPT
+                const type_info_t &target_type_arg) noexcept
             : source(&source_type_arg), target(&target_type_arg)
         {}
 
-        const type_info_t &source_type() const BOOST_NOEXCEPT {
+        const type_info_t &source_type() const noexcept {
             return *source;
         }
 
-        const type_info_t &target_type() const BOOST_NOEXCEPT {
+        const type_info_t &target_type() const noexcept {
             return *target;
         }
 
diff --git a/include/boost/lexical_cast/detail/converter_lexical.hpp b/include/boost/lexical_cast/detail/converter_lexical.hpp
index 39b2bbf..7ba548d 100644
--- a/include/boost/lexical_cast/detail/converter_lexical.hpp
+++ b/include/boost/lexical_cast/detail/converter_lexical.hpp
@@ -37,17 +37,13 @@
 #include <boost/type_traits/is_float.hpp>
 #include <boost/type_traits/has_left_shift.hpp>
 #include <boost/type_traits/has_right_shift.hpp>
-#include <boost/static_assert.hpp>
 #include <boost/detail/lcast_precision.hpp>
 
 #include <boost/lexical_cast/detail/widest_char.hpp>
 #include <boost/lexical_cast/detail/is_character.hpp>
 
-#ifndef BOOST_NO_CXX11_HDR_ARRAY
 #include <array>
-#endif
 
-#include <boost/array.hpp>
 #include <boost/range/iterator_range_core.hpp>
 #include <boost/container/container_fwd.hpp>
 
@@ -55,6 +51,10 @@
 
 namespace boost {
 
+    // Forward declaration
+    template<class T, std::size_t N>
+    class array;
+
     namespace detail // normalize_single_byte_char<Char>
     {
         // Converts signed/unsigned char to char
@@ -190,7 +190,7 @@ namespace boost {
         template < class Char >
         struct deduce_source_char_impl
         {
-            typedef BOOST_DEDUCED_TYPENAME boost::detail::normalize_single_byte_char< Char >::type type;
+            typedef typename boost::detail::normalize_single_byte_char< Char >::type type;
         };
 
         template < class T >
@@ -199,15 +199,15 @@ namespace boost {
             typedef boost::has_left_shift< std::basic_ostream< char >, T > result_t;
 
 #if defined(BOOST_LCAST_NO_WCHAR_T)
-            BOOST_STATIC_ASSERT_MSG((result_t::value),
+            static_assert(result_t::value,
                 "Source type is not std::ostream`able and std::wostream`s are not supported by your STL implementation");
             typedef char type;
 #else
-            typedef BOOST_DEDUCED_TYPENAME boost::conditional<
+            typedef typename boost::conditional<
                 result_t::value, char, wchar_t
             >::type type;
 
-            BOOST_STATIC_ASSERT_MSG((result_t::value || boost::has_left_shift< std::basic_ostream< type >, T >::value),
+            static_assert(result_t::value || boost::has_left_shift< std::basic_ostream< type >, T >::value,
                 "Source type is neither std::ostream`able nor std::wostream`able");
 #endif
         };
@@ -223,7 +223,7 @@ namespace boost {
         template < class Char >
         struct deduce_target_char_impl
         {
-            typedef BOOST_DEDUCED_TYPENAME normalize_single_byte_char< Char >::type type;
+            typedef typename normalize_single_byte_char< Char >::type type;
         };
 
         template < class T >
@@ -232,15 +232,15 @@ namespace boost {
             typedef boost::has_right_shift<std::basic_istream<char>, T > result_t;
 
 #if defined(BOOST_LCAST_NO_WCHAR_T)
-            BOOST_STATIC_ASSERT_MSG((result_t::value),
+            static_assert(result_t::value,
                 "Target type is not std::istream`able and std::wistream`s are not supported by your STL implementation");
             typedef char type;
 #else
-            typedef BOOST_DEDUCED_TYPENAME boost::conditional<
+            typedef typename boost::conditional<
                 result_t::value, char, wchar_t
             >::type type;
 
-            BOOST_STATIC_ASSERT_MSG((result_t::value || boost::has_right_shift<std::basic_istream<wchar_t>, T >::value),
+            static_assert(result_t::value || boost::has_right_shift<std::basic_istream<wchar_t>, T >::value,
                 "Target type is neither std::istream`able nor std::wistream`able");
 #endif
         };
@@ -266,8 +266,8 @@ namespace boost {
         template < class T >
         struct deduce_target_char
         {
-            typedef BOOST_DEDUCED_TYPENAME stream_char_common< T >::type stage1_type;
-            typedef BOOST_DEDUCED_TYPENAME deduce_target_char_impl< stage1_type >::type stage2_type;
+            typedef typename stream_char_common< T >::type stage1_type;
+            typedef typename deduce_target_char_impl< stage1_type >::type stage2_type;
 
             typedef stage2_type type;
         };
@@ -275,8 +275,8 @@ namespace boost {
         template < class T >
         struct deduce_source_char
         {
-            typedef BOOST_DEDUCED_TYPENAME stream_char_common< T >::type stage1_type;
-            typedef BOOST_DEDUCED_TYPENAME deduce_source_char_impl< stage1_type >::type stage2_type;
+            typedef typename stream_char_common< T >::type stage1_type;
+            typedef typename deduce_source_char_impl< stage1_type >::type stage2_type;
 
             typedef stage2_type type;
         };
@@ -349,7 +349,7 @@ namespace boost {
         // When is_specialized is false, the whole expression is 0.
         template <class Source>
         struct lcast_src_length<
-                    Source, BOOST_DEDUCED_TYPENAME boost::enable_if<boost::is_integral<Source> >::type
+                    Source, typename boost::enable_if<boost::is_integral<Source> >::type
                 >
         {
 #ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
@@ -360,7 +360,7 @@ namespace boost {
               );
 #else
             BOOST_STATIC_CONSTANT(std::size_t, value = 156);
-            BOOST_STATIC_ASSERT(sizeof(Source) * CHAR_BIT <= 256);
+            static_assert(sizeof(Source) * CHAR_BIT <= 256, "");
 #endif
         };
 
@@ -376,15 +376,15 @@ namespace boost {
         // sign + leading digit + decimal point + "e" + exponent sign == 5
         template<class Source>
         struct lcast_src_length<
-                Source, BOOST_DEDUCED_TYPENAME boost::enable_if<boost::is_float<Source> >::type
+                Source, typename boost::enable_if<boost::is_float<Source> >::type
             >
         {
 
 #ifndef BOOST_LCAST_NO_COMPILE_TIME_PRECISION
-            BOOST_STATIC_ASSERT(
+            static_assert(
                     std::numeric_limits<Source>::max_exponent10 <=  999999L &&
                     std::numeric_limits<Source>::min_exponent10 >= -999999L
-                );
+                , "");
 
             BOOST_STATIC_CONSTANT(std::size_t, value =
                     5 + lcast_precision<Source>::value + 6
@@ -399,32 +399,32 @@ namespace boost {
     {
         template <class Source, class Target>
         struct lexical_cast_stream_traits {
-            typedef BOOST_DEDUCED_TYPENAME boost::detail::array_to_pointer_decay<Source>::type src;
-            typedef BOOST_DEDUCED_TYPENAME boost::remove_cv<src>::type            no_cv_src;
+            typedef typename boost::detail::array_to_pointer_decay<Source>::type src;
+            typedef typename boost::remove_cv<src>::type            no_cv_src;
 
             typedef boost::detail::deduce_source_char<no_cv_src>                           deduce_src_char_metafunc;
-            typedef BOOST_DEDUCED_TYPENAME deduce_src_char_metafunc::type           src_char_t;
-            typedef BOOST_DEDUCED_TYPENAME boost::detail::deduce_target_char<Target>::type target_char_t;
+            typedef typename deduce_src_char_metafunc::type           src_char_t;
+            typedef typename boost::detail::deduce_target_char<Target>::type target_char_t;
 
-            typedef BOOST_DEDUCED_TYPENAME boost::detail::widest_char<
+            typedef typename boost::detail::widest_char<
                 target_char_t, src_char_t
             >::type char_type;
 
 #if !defined(BOOST_NO_CXX11_CHAR16_T) && defined(BOOST_NO_CXX11_UNICODE_LITERALS)
-            BOOST_STATIC_ASSERT_MSG(( !boost::is_same<char16_t, src_char_t>::value
-                                        && !boost::is_same<char16_t, target_char_t>::value),
+            static_assert(!boost::is_same<char16_t, src_char_t>::value
+                                        && !boost::is_same<char16_t, target_char_t>::value,
                 "Your compiler does not have full support for char16_t" );
 #endif
 #if !defined(BOOST_NO_CXX11_CHAR32_T) && defined(BOOST_NO_CXX11_UNICODE_LITERALS)
-            BOOST_STATIC_ASSERT_MSG(( !boost::is_same<char32_t, src_char_t>::value
-                                        && !boost::is_same<char32_t, target_char_t>::value),
+            static_assert(!boost::is_same<char32_t, src_char_t>::value
+                                        && !boost::is_same<char32_t, target_char_t>::value,
                 "Your compiler does not have full support for char32_t" );
 #endif
 
-            typedef BOOST_DEDUCED_TYPENAME boost::conditional<
+            typedef typename boost::conditional<
                 boost::detail::extract_char_traits<char_type, Target>::value,
-                BOOST_DEDUCED_TYPENAME boost::detail::extract_char_traits<char_type, Target>,
-                BOOST_DEDUCED_TYPENAME boost::detail::extract_char_traits<char_type, no_cv_src>
+                typename boost::detail::extract_char_traits<char_type, Target>,
+                typename boost::detail::extract_char_traits<char_type, no_cv_src>
             >::type::trait_t traits;
 
             typedef boost::integral_constant<
@@ -438,7 +438,7 @@ namespace boost {
               bool,
                 !(boost::is_integral<no_cv_src>::value ||
                   boost::detail::is_character<
-                    BOOST_DEDUCED_TYPENAME deduce_src_char_metafunc::stage1_type          // if we did not get character type at stage1
+                    typename deduce_src_char_metafunc::stage1_type          // if we did not get character type at stage1
                   >::value                                                           // then we have no optimization for that type
                  )
                 > is_source_input_not_optimized_t;
@@ -461,15 +461,15 @@ namespace boost {
             typedef lexical_cast_stream_traits<Source, Target>  stream_trait;
 
             typedef detail::lexical_istream_limited_src<
-                BOOST_DEDUCED_TYPENAME stream_trait::char_type,
-                BOOST_DEDUCED_TYPENAME stream_trait::traits,
+                typename stream_trait::char_type,
+                typename stream_trait::traits,
                 stream_trait::requires_stringbuf,
                 stream_trait::len_t::value + 1
             > i_interpreter_type;
 
             typedef detail::lexical_ostream_limited_src<
-                BOOST_DEDUCED_TYPENAME stream_trait::char_type,
-                BOOST_DEDUCED_TYPENAME stream_trait::traits
+                typename stream_trait::char_type,
+                typename stream_trait::traits
             > o_interpreter_type;
 
             static inline bool try_convert(const Source& arg, Target& result) {
diff --git a/include/boost/lexical_cast/detail/converter_lexical_streams.hpp b/include/boost/lexical_cast/detail/converter_lexical_streams.hpp
index 04383bf..430e373 100644
--- a/include/boost/lexical_cast/detail/converter_lexical_streams.hpp
+++ b/include/boost/lexical_cast/detail/converter_lexical_streams.hpp
@@ -35,7 +35,6 @@
 #include <boost/limits.hpp>
 #include <boost/type_traits/conditional.hpp>
 #include <boost/type_traits/is_pointer.hpp>
-#include <boost/static_assert.hpp>
 #include <boost/detail/lcast_precision.hpp>
 #include <boost/detail/workaround.hpp>
 #include <boost/core/snprintf.hpp>
@@ -65,11 +64,8 @@
 
 #include <istream>
 
-#ifndef BOOST_NO_CXX11_HDR_ARRAY
 #include <array>
-#endif
 
-#include <boost/array.hpp>
 #include <boost/type_traits/make_unsigned.hpp>
 #include <boost/type_traits/is_integral.hpp>
 #include <boost/type_traits/is_float.hpp>
@@ -84,6 +80,10 @@
 
 namespace boost {
 
+    // Forward declaration
+    template<class T, std::size_t N>
+    class array;
+
     namespace detail // basic_unlockedbuf
     {
         // acts as a stream buffer which wraps around a pair of pointers
@@ -92,7 +92,7 @@ namespace boost {
         class basic_unlockedbuf : public basic_pointerbuf<CharT, BufferType> {
         public:
            typedef basic_pointerbuf<CharT, BufferType> base_type;
-           typedef BOOST_DEDUCED_TYPENAME base_type::streamsize streamsize;
+           typedef typename base_type::streamsize streamsize;
 
 #ifndef BOOST_NO_USING_TEMPLATE
             using base_type::pptr;
@@ -138,15 +138,15 @@ namespace boost {
                 , std::size_t CharacterBufferSize
                 >
         class lexical_istream_limited_src: boost::noncopyable {
-            typedef BOOST_DEDUCED_TYPENAME boost::conditional<
+            typedef typename boost::conditional<
                 RequiresStringbuffer,
-                BOOST_DEDUCED_TYPENAME out_stream_helper_trait<CharT, Traits>::out_stream_t,
+                typename out_stream_helper_trait<CharT, Traits>::out_stream_t,
                 do_not_construct_out_stream_t
             >::type deduced_out_stream_t;
 
-            typedef BOOST_DEDUCED_TYPENAME boost::conditional<
+            typedef typename boost::conditional<
                 RequiresStringbuffer,
-                BOOST_DEDUCED_TYPENAME out_stream_helper_trait<CharT, Traits>::stringbuffer_t,
+                typename out_stream_helper_trait<CharT, Traits>::stringbuffer_t,
                 do_not_construct_out_buffer_t
             >::type deduced_out_buffer_t;
 
@@ -160,24 +160,24 @@ namespace boost {
             const CharT*  finish;
 
         public:
-            lexical_istream_limited_src() BOOST_NOEXCEPT
+            lexical_istream_limited_src() noexcept
               : out_buffer()
               , out_stream(&out_buffer)
               , start(buffer)
               , finish(buffer + CharacterBufferSize)
             {}
 
-            const CharT* cbegin() const BOOST_NOEXCEPT {
+            const CharT* cbegin() const noexcept {
                 return start;
             }
 
-            const CharT* cend() const BOOST_NOEXCEPT {
+            const CharT* cend() const noexcept {
                 return finish;
             }
 
         private:
 /************************************ HELPER FUNCTIONS FOR OPERATORS << ( ... ) ********************************/
-            bool shl_char(CharT ch) BOOST_NOEXCEPT {
+            bool shl_char(CharT ch) noexcept {
                 Traits::assign(buffer[0], ch);
                 finish = start + 1;
                 return true;
@@ -186,7 +186,7 @@ namespace boost {
 #ifndef BOOST_LCAST_NO_WCHAR_T
             template <class T>
             bool shl_char(T ch) {
-                BOOST_STATIC_ASSERT_MSG(( sizeof(T) <= sizeof(CharT)) ,
+                static_assert(sizeof(T) <= sizeof(CharT),
                     "boost::lexical_cast does not support narrowing of char types."
                     "Use boost::locale instead" );
 #ifndef BOOST_LEXICAL_CAST_ASSUME_C_LOCALE
@@ -201,7 +201,7 @@ namespace boost {
             }
 #endif
 
-            bool shl_char_array(CharT const* str_value) BOOST_NOEXCEPT {
+            bool shl_char_array(CharT const* str_value) noexcept {
                 start = str_value;
                 finish = start + Traits::length(str_value);
                 return true;
@@ -209,13 +209,13 @@ namespace boost {
 
             template <class T>
             bool shl_char_array(T const* str_value) {
-                BOOST_STATIC_ASSERT_MSG(( sizeof(T) <= sizeof(CharT)),
+                static_assert(sizeof(T) <= sizeof(CharT),
                     "boost::lexical_cast does not support narrowing of char types."
                     "Use boost::locale instead" );
                 return shl_input_streamable(str_value);
             }
 
-            bool shl_char_array_limited(CharT const* str, std::size_t max_size) BOOST_NOEXCEPT {
+            bool shl_char_array_limited(CharT const* str, std::size_t max_size) noexcept {
                 start = str;
                 finish = std::find(start, start + max_size, Traits::to_char_type(0));
                 return true;
@@ -226,7 +226,7 @@ namespace boost {
 #if defined(BOOST_NO_STRINGSTREAM) || defined(BOOST_NO_STD_LOCALE)
                 // If you have compilation error at this point, than your STL library
                 // does not support such conversions. Try updating it.
-                BOOST_STATIC_ASSERT((boost::is_same<char, CharT>::value));
+                static_assert(boost::is_same<char, CharT>::value, "");
 #endif
 
 #ifndef BOOST_NO_EXCEPTIONS
@@ -258,7 +258,7 @@ namespace boost {
             template <class T>
             inline bool shl_signed(const T n) {
                 CharT* tmp_finish = buffer + CharacterBufferSize;
-                typedef BOOST_DEDUCED_TYPENAME boost::make_unsigned<T>::type utype;
+                typedef typename boost::make_unsigned<T>::type utype;
                 CharT* tmp_start = lcast_put_unsigned<Traits, utype, CharT>(lcast_to_unsigned(n), tmp_finish).convert();
                 if (n < 0) {
                     --tmp_start;
@@ -343,20 +343,20 @@ namespace boost {
 /************************************ OPERATORS << ( ... ) ********************************/
         public:
             template<class Alloc>
-            bool operator<<(std::basic_string<CharT,Traits,Alloc> const& str) BOOST_NOEXCEPT {
+            bool operator<<(std::basic_string<CharT,Traits,Alloc> const& str) noexcept {
                 start = str.data();
                 finish = start + str.length();
                 return true;
             }
 
             template<class Alloc>
-            bool operator<<(boost::container::basic_string<CharT,Traits,Alloc> const& str) BOOST_NOEXCEPT {
+            bool operator<<(boost::container::basic_string<CharT,Traits,Alloc> const& str) noexcept {
                 start = str.data();
                 finish = start + str.length();
                 return true;
             }
 
-            bool operator<<(bool value) BOOST_NOEXCEPT {
+            bool operator<<(bool value) noexcept {
                 CharT const czero = lcast_char_constants<CharT>::zero;
                 Traits::assign(buffer[0], Traits::to_char_type(czero + value));
                 finish = start + 1;
@@ -364,25 +364,25 @@ namespace boost {
             }
 
             template <class C>
-            BOOST_DEDUCED_TYPENAME boost::disable_if<boost::is_const<C>, bool>::type
-            operator<<(const iterator_range<C*>& rng) BOOST_NOEXCEPT {
+            typename boost::disable_if<boost::is_const<C>, bool>::type
+            operator<<(const iterator_range<C*>& rng) noexcept {
                 return (*this) << iterator_range<const C*>(rng.begin(), rng.end());
             }
 
-            bool operator<<(const iterator_range<const CharT*>& rng) BOOST_NOEXCEPT {
+            bool operator<<(const iterator_range<const CharT*>& rng) noexcept {
                 start = rng.begin();
                 finish = rng.end();
                 return true;
             }
 
-            bool operator<<(const iterator_range<const signed char*>& rng) BOOST_NOEXCEPT {
+            bool operator<<(const iterator_range<const signed char*>& rng) noexcept {
                 return (*this) << iterator_range<const char*>(
                     reinterpret_cast<const char*>(rng.begin()),
                     reinterpret_cast<const char*>(rng.end())
                 );
             }
 
-            bool operator<<(const iterator_range<const unsigned char*>& rng) BOOST_NOEXCEPT {
+            bool operator<<(const iterator_range<const unsigned char*>& rng) noexcept {
                 return (*this) << iterator_range<const char*>(
                     reinterpret_cast<const char*>(rng.begin()),
                     reinterpret_cast<const char*>(rng.end())
@@ -446,36 +446,36 @@ namespace boost {
 
             // Adding constness to characters. Constness does not change layout
             template <class C, std::size_t N>
-            BOOST_DEDUCED_TYPENAME boost::disable_if<boost::is_const<C>, bool>::type
-            operator<<(boost::array<C, N> const& input) BOOST_NOEXCEPT {
-                BOOST_STATIC_ASSERT_MSG(
-                    (sizeof(boost::array<const C, N>) == sizeof(boost::array<C, N>)),
+            typename boost::disable_if<boost::is_const<C>, bool>::type
+            operator<<(boost::array<C, N> const& input) noexcept {
+                static_assert(
+                    sizeof(boost::array<const C, N>) == sizeof(boost::array<C, N>),
                     "boost::array<C, N> and boost::array<const C, N> must have exactly the same layout."
                 );
                 return ((*this) << reinterpret_cast<boost::array<const C, N> const& >(input));
             }
 
             template <std::size_t N>
-            bool operator<<(boost::array<const CharT, N> const& input) BOOST_NOEXCEPT {
+            bool operator<<(boost::array<const CharT, N> const& input) noexcept {
                 return shl_char_array_limited(input.data(), N);
             }
 
             template <std::size_t N>
-            bool operator<<(boost::array<const unsigned char, N> const& input) BOOST_NOEXCEPT {
+            bool operator<<(boost::array<const unsigned char, N> const& input) noexcept {
                 return ((*this) << reinterpret_cast<boost::array<const char, N> const& >(input));
             }
 
             template <std::size_t N>
-            bool operator<<(boost::array<const signed char, N> const& input) BOOST_NOEXCEPT {
+            bool operator<<(boost::array<const signed char, N> const& input) noexcept {
                 return ((*this) << reinterpret_cast<boost::array<const char, N> const& >(input));
             }
 
 #ifndef BOOST_NO_CXX11_HDR_ARRAY
             // Making a Boost.Array from std::array
             template <class C, std::size_t N>
-            bool operator<<(std::array<C, N> const& input) BOOST_NOEXCEPT {
-                BOOST_STATIC_ASSERT_MSG(
-                    (sizeof(std::array<C, N>) == sizeof(boost::array<C, N>)),
+            bool operator<<(std::array<C, N> const& input) noexcept {
+                static_assert(
+                    sizeof(std::array<C, N>) == sizeof(boost::array<C, N>),
                     "std::array and boost::array must have exactly the same layout. "
                     "Bug in implementation of std::array or boost::array."
                 );
@@ -494,7 +494,7 @@ namespace boost {
             const CharT* const  finish;
 
         public:
-            lexical_ostream_limited_src(const CharT* begin, const CharT* end) BOOST_NOEXCEPT
+            lexical_ostream_limited_src(const CharT* begin, const CharT* end) noexcept
               : start(begin)
               , finish(end)
             {}
@@ -527,7 +527,7 @@ namespace boost {
                 if (start == finish) return false;
                 CharT const minus = lcast_char_constants<CharT>::minus;
                 CharT const plus = lcast_char_constants<CharT>::plus;
-                typedef BOOST_DEDUCED_TYPENAME make_unsigned<Type>::type utype;
+                typedef typename make_unsigned<Type>::type utype;
                 utype out_tmp = 0;
                 bool const has_minus = Traits::eq(minus, *start);
 
@@ -552,13 +552,13 @@ namespace boost {
             template<typename InputStreamable>
             bool shr_using_base_class(InputStreamable& output)
             {
-                BOOST_STATIC_ASSERT_MSG(
-                    (!boost::is_pointer<InputStreamable>::value),
+                static_assert(
+                    !boost::is_pointer<InputStreamable>::value,
                     "boost::lexical_cast can not convert to pointers"
                 );
 
 #if defined(BOOST_NO_STRINGSTREAM) || defined(BOOST_NO_STD_LOCALE)
-                BOOST_STATIC_ASSERT_MSG((boost::is_same<char, CharT>::value),
+                static_assert(boost::is_same<char, CharT>::value,
                     "boost::lexical_cast can not convert, because your STL library does not "
                     "support such conversions. Try updating it."
                 );
@@ -567,7 +567,7 @@ namespace boost {
 #if defined(BOOST_NO_STRINGSTREAM)
                 std::istrstream stream(start, static_cast<std::istrstream::streamsize>(finish - start));
 #else
-                typedef BOOST_DEDUCED_TYPENAME out_stream_helper_trait<CharT, Traits>::buffer_t buffer_t;
+                typedef typename out_stream_helper_trait<CharT, Traits>::buffer_t buffer_t;
                 buffer_t buf;
                 // Usually `istream` and `basic_istream` do not modify
                 // content of buffer; `buffer_t` assures that this is true
@@ -597,8 +597,8 @@ namespace boost {
             }
 
             template<class T>
-            inline bool shr_xchar(T& output) BOOST_NOEXCEPT {
-                BOOST_STATIC_ASSERT_MSG(( sizeof(CharT) == sizeof(T) ),
+            inline bool shr_xchar(T& output) noexcept {
+                static_assert(sizeof(CharT) == sizeof(T),
                     "boost::lexical_cast does not support narrowing of character types."
                     "Use boost::locale instead" );
                 bool const ok = (finish - start == 1);
@@ -611,7 +611,7 @@ namespace boost {
             }
 
             template <std::size_t N, class ArrayT>
-            bool shr_std_array(ArrayT& output) BOOST_NOEXCEPT {
+            bool shr_std_array(ArrayT& output) noexcept {
                 using namespace std;
                 const std::size_t size = static_cast<std::size_t>(finish - start);
                 if (size > N - 1) { // `-1` because we need to store \0 at the end
@@ -667,32 +667,30 @@ namespace boost {
             }
 
             template <std::size_t N>
-            bool operator>>(boost::array<CharT, N>& output) BOOST_NOEXCEPT {
+            bool operator>>(std::array<CharT, N>& output) noexcept {
                 return shr_std_array<N>(output);
             }
 
             template <std::size_t N>
-            bool operator>>(boost::array<unsigned char, N>& output) BOOST_NOEXCEPT {
-                return ((*this) >> reinterpret_cast<boost::array<char, N>& >(output));
+            bool operator>>(std::array<unsigned char, N>& output) noexcept {
+                return ((*this) >> reinterpret_cast<std::array<char, N>& >(output));
             }
 
             template <std::size_t N>
-            bool operator>>(boost::array<signed char, N>& output) BOOST_NOEXCEPT {
-                return ((*this) >> reinterpret_cast<boost::array<char, N>& >(output));
+            bool operator>>(std::array<signed char, N>& output) noexcept {
+                return ((*this) >> reinterpret_cast<std::array<char, N>& >(output));
             }
 
-#ifndef BOOST_NO_CXX11_HDR_ARRAY
             template <class C, std::size_t N>
-            bool operator>>(std::array<C, N>& output) BOOST_NOEXCEPT {
-                BOOST_STATIC_ASSERT_MSG(
-                    (sizeof(std::array<C, N>) == sizeof(boost::array<C, N>)),
+            bool operator>>(boost::array<C, N>& output) noexcept {
+                static_assert(
+                    sizeof(std::array<C, N>) == sizeof(boost::array<C, N>),
                     "std::array<C, N> and boost::array<C, N> must have exactly the same layout."
                 );
-                return ((*this) >> reinterpret_cast<boost::array<C, N>& >(output));
+                return ((*this) >> reinterpret_cast<std::array<C, N>& >(output));
             }
-#endif
 
-            bool operator>>(bool& output) BOOST_NOEXCEPT {
+            bool operator>>(bool& output) noexcept {
                 output = false; // Suppress warning about uninitalized variable
 
                 if (start == finish) return false;
diff --git a/include/boost/lexical_cast/detail/converter_numeric.hpp b/include/boost/lexical_cast/detail/converter_numeric.hpp
index 853e254..a2c992d 100644
--- a/include/boost/lexical_cast/detail/converter_numeric.hpp
+++ b/include/boost/lexical_cast/detail/converter_numeric.hpp
@@ -43,11 +43,11 @@ struct detect_precision_loss
 {
     typedef Source source_type;
     typedef boost::numeric::Trunc<Source> Rounder;
-    typedef BOOST_DEDUCED_TYPENAME conditional<
+    typedef typename conditional<
         boost::is_arithmetic<Source>::value, Source, Source const&
     >::type argument_type ;
 
-    static inline source_type nearbyint(argument_type s, bool& is_ok) BOOST_NOEXCEPT {
+    static inline source_type nearbyint(argument_type s, bool& is_ok) noexcept {
         const source_type near_int = Rounder::nearbyint(s);
         if (near_int && is_ok) {
             const source_type orig_div_round = s / near_int;
@@ -66,24 +66,24 @@ template <typename Base, class Source>
 struct fake_precision_loss: public Base
 {
     typedef Source source_type ;
-    typedef BOOST_DEDUCED_TYPENAME conditional<
+    typedef typename conditional<
         boost::is_arithmetic<Source>::value, Source, Source const&
     >::type argument_type ;
 
-    static inline source_type nearbyint(argument_type s, bool& /*is_ok*/) BOOST_NOEXCEPT {
+    static inline source_type nearbyint(argument_type s, bool& /*is_ok*/) noexcept {
         return s;
     }
 };
 
 struct nothrow_overflow_handler
 {
-    inline bool operator() ( boost::numeric::range_check_result r ) const BOOST_NOEXCEPT {
+    inline bool operator() ( boost::numeric::range_check_result r ) const noexcept {
         return (r == boost::numeric::cInRange);
     }
 };
 
 template <typename Target, typename Source>
-inline bool noexcept_numeric_convert(const Source& arg, Target& result) BOOST_NOEXCEPT {
+inline bool noexcept_numeric_convert(const Source& arg, Target& result) noexcept {
     typedef boost::numeric::converter<
             Target,
             Source,
@@ -92,7 +92,7 @@ inline bool noexcept_numeric_convert(const Source& arg, Target& result) BOOST_NO
             detect_precision_loss<Source >
     > converter_orig_t;
 
-    typedef BOOST_DEDUCED_TYPENAME boost::conditional<
+    typedef typename boost::conditional<
         boost::is_base_of< detect_precision_loss<Source >, converter_orig_t >::value,
         converter_orig_t,
         fake_precision_loss<converter_orig_t, Source>
@@ -109,7 +109,7 @@ inline bool noexcept_numeric_convert(const Source& arg, Target& result) BOOST_NO
 template <typename Target, typename Source>
 struct lexical_cast_dynamic_num_not_ignoring_minus
 {
-    static inline bool try_convert(const Source &arg, Target& result) BOOST_NOEXCEPT {
+    static inline bool try_convert(const Source &arg, Target& result) noexcept {
         return noexcept_numeric_convert<Target, Source >(arg, result);
     }
 };
@@ -117,13 +117,13 @@ struct lexical_cast_dynamic_num_not_ignoring_minus
 template <typename Target, typename Source>
 struct lexical_cast_dynamic_num_ignoring_minus
 {
-    static inline bool try_convert(const Source &arg, Target& result) BOOST_NOEXCEPT {
-        typedef BOOST_DEDUCED_TYPENAME boost::conditional<
+    static inline bool try_convert(const Source &arg, Target& result) noexcept {
+        typedef typename boost::conditional<
                 boost::is_float<Source>::value,
                 boost::type_identity<Source>,
                 boost::make_unsigned<Source>
         >::type usource_lazy_t;
-        typedef BOOST_DEDUCED_TYPENAME usource_lazy_t::type usource_t;
+        typedef typename usource_lazy_t::type usource_t;
 
         if (arg < 0) {
             const bool res = noexcept_numeric_convert<Target, usource_t>(0u - arg, result);
@@ -156,10 +156,10 @@ struct lexical_cast_dynamic_num_ignoring_minus
 template <typename Target, typename Source>
 struct dynamic_num_converter_impl
 {
-    typedef BOOST_DEDUCED_TYPENAME boost::remove_volatile<Source>::type source_type;
+    typedef typename boost::remove_volatile<Source>::type source_type;
 
-    static inline bool try_convert(source_type arg, Target& result) BOOST_NOEXCEPT {
-        typedef BOOST_DEDUCED_TYPENAME boost::conditional<
+    static inline bool try_convert(source_type arg, Target& result) noexcept {
+        typedef typename boost::conditional<
             boost::is_unsigned<Target>::value &&
             (boost::is_signed<source_type>::value || boost::is_float<source_type>::value) &&
             !(boost::is_same<source_type, bool>::value) &&
diff --git a/include/boost/lexical_cast/detail/inf_nan.hpp b/include/boost/lexical_cast/detail/inf_nan.hpp
index ef53e52..a9f92b2 100644
--- a/include/boost/lexical_cast/detail/inf_nan.hpp
+++ b/include/boost/lexical_cast/detail/inf_nan.hpp
@@ -39,7 +39,7 @@ namespace boost {
     namespace detail
     {
         template <class CharT>
-        bool lc_iequal(const CharT* val, const CharT* lcase, const CharT* ucase, unsigned int len) BOOST_NOEXCEPT {
+        bool lc_iequal(const CharT* val, const CharT* lcase, const CharT* ucase, unsigned int len) noexcept {
             for( unsigned int i=0; i < len; ++i ) {
                 if ( val[i] != lcase[i] && val[i] != ucase[i] ) return false;
             }
@@ -52,7 +52,7 @@ namespace boost {
         inline bool parse_inf_nan_impl(const CharT* begin, const CharT* end, T& value
             , const CharT* lc_NAN, const CharT* lc_nan
             , const CharT* lc_INFINITY, const CharT* lc_infinity
-            , const CharT opening_brace, const CharT closing_brace) BOOST_NOEXCEPT
+            , const CharT opening_brace, const CharT closing_brace) noexcept
         {
             if (begin == end) return false;
             const CharT minus = lcast_char_constants<CharT>::minus;
@@ -102,7 +102,7 @@ namespace boost {
         template <class CharT, class T>
         bool put_inf_nan_impl(CharT* begin, CharT*& end, const T& value
                          , const CharT* lc_nan
-                         , const CharT* lc_infinity) BOOST_NOEXCEPT
+                         , const CharT* lc_infinity) noexcept
         {
             const CharT minus = lcast_char_constants<CharT>::minus;
             if (boost::core::isnan(value)) {
@@ -131,7 +131,7 @@ namespace boost {
 
 #ifndef BOOST_LCAST_NO_WCHAR_T
         template <class T>
-        bool parse_inf_nan(const wchar_t* begin, const wchar_t* end, T& value) BOOST_NOEXCEPT {
+        bool parse_inf_nan(const wchar_t* begin, const wchar_t* end, T& value) noexcept {
             return parse_inf_nan_impl(begin, end, value
                                , L"NAN", L"nan"
                                , L"INFINITY", L"infinity"
@@ -139,14 +139,14 @@ namespace boost {
         }
 
         template <class T>
-        bool put_inf_nan(wchar_t* begin, wchar_t*& end, const T& value) BOOST_NOEXCEPT {
+        bool put_inf_nan(wchar_t* begin, wchar_t*& end, const T& value) noexcept {
             return put_inf_nan_impl(begin, end, value, L"nan", L"infinity");
         }
 
 #endif
 #if !defined(BOOST_NO_CXX11_CHAR16_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS)
         template <class T>
-        bool parse_inf_nan(const char16_t* begin, const char16_t* end, T& value) BOOST_NOEXCEPT {
+        bool parse_inf_nan(const char16_t* begin, const char16_t* end, T& value) noexcept {
             return parse_inf_nan_impl(begin, end, value
                                , u"NAN", u"nan"
                                , u"INFINITY", u"infinity"
@@ -154,13 +154,13 @@ namespace boost {
         }
 
         template <class T>
-        bool put_inf_nan(char16_t* begin, char16_t*& end, const T& value) BOOST_NOEXCEPT {
+        bool put_inf_nan(char16_t* begin, char16_t*& end, const T& value) noexcept {
             return put_inf_nan_impl(begin, end, value, u"nan", u"infinity");
         }
 #endif
 #if !defined(BOOST_NO_CXX11_CHAR32_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS)
         template <class T>
-        bool parse_inf_nan(const char32_t* begin, const char32_t* end, T& value) BOOST_NOEXCEPT {
+        bool parse_inf_nan(const char32_t* begin, const char32_t* end, T& value) noexcept {
             return parse_inf_nan_impl(begin, end, value
                                , U"NAN", U"nan"
                                , U"INFINITY", U"infinity"
@@ -168,13 +168,13 @@ namespace boost {
         }
 
         template <class T>
-        bool put_inf_nan(char32_t* begin, char32_t*& end, const T& value) BOOST_NOEXCEPT {
+        bool put_inf_nan(char32_t* begin, char32_t*& end, const T& value) noexcept {
             return put_inf_nan_impl(begin, end, value, U"nan", U"infinity");
         }
 #endif
 
         template <class CharT, class T>
-        bool parse_inf_nan(const CharT* begin, const CharT* end, T& value) BOOST_NOEXCEPT {
+        bool parse_inf_nan(const CharT* begin, const CharT* end, T& value) noexcept {
             return parse_inf_nan_impl(begin, end, value
                                , "NAN", "nan"
                                , "INFINITY", "infinity"
@@ -182,7 +182,7 @@ namespace boost {
         }
 
         template <class CharT, class T>
-        bool put_inf_nan(CharT* begin, CharT*& end, const T& value) BOOST_NOEXCEPT {
+        bool put_inf_nan(CharT* begin, CharT*& end, const T& value) noexcept {
             return put_inf_nan_impl(begin, end, value, "nan", "infinity");
         }
     }
diff --git a/include/boost/lexical_cast/detail/is_character.hpp b/include/boost/lexical_cast/detail/is_character.hpp
index 176dd3d..c0e4929 100644
--- a/include/boost/lexical_cast/detail/is_character.hpp
+++ b/include/boost/lexical_cast/detail/is_character.hpp
@@ -34,7 +34,7 @@ namespace boost {
         template < typename T >
         struct is_character
         {
-            typedef BOOST_DEDUCED_TYPENAME boost::integral_constant<
+            typedef typename boost::integral_constant<
                 bool,
                 boost::is_same< T, char >::value ||
                     #if !defined(BOOST_NO_STRINGSTREAM) && !defined(BOOST_NO_STD_WSTRING)
diff --git a/include/boost/lexical_cast/detail/lcast_unsigned_converters.hpp b/include/boost/lexical_cast/detail/lcast_unsigned_converters.hpp
index e4a581e..cfb0c2e 100644
--- a/include/boost/lexical_cast/detail/lcast_unsigned_converters.hpp
+++ b/include/boost/lexical_cast/detail/lcast_unsigned_converters.hpp
@@ -30,7 +30,6 @@
 #include <cstdio>
 #include <boost/limits.hpp>
 #include <boost/type_traits/conditional.hpp>
-#include <boost/static_assert.hpp>
 #include <boost/detail/workaround.hpp>
 
 
@@ -58,8 +57,8 @@ namespace boost
     {
         template<class T>
         inline
-        BOOST_DEDUCED_TYPENAME boost::make_unsigned<T>::type lcast_to_unsigned(const T value) BOOST_NOEXCEPT {
-            typedef BOOST_DEDUCED_TYPENAME boost::make_unsigned<T>::type result_type;
+        typename boost::make_unsigned<T>::type lcast_to_unsigned(const T value) noexcept {
+            typedef typename boost::make_unsigned<T>::type result_type;
             return value < 0
                 ? static_cast<result_type>(0u - static_cast<result_type>(value))
                 : static_cast<result_type>(value);
@@ -70,8 +69,8 @@ namespace boost
     {
         template <class Traits, class T, class CharT>
         class lcast_put_unsigned: boost::noncopyable {
-            typedef BOOST_DEDUCED_TYPENAME Traits::int_type int_type;
-            BOOST_DEDUCED_TYPENAME boost::conditional<
+            typedef typename Traits::int_type int_type;
+            typename boost::conditional<
                     (sizeof(unsigned) > sizeof(T))
                     , unsigned
                     , T
@@ -81,12 +80,12 @@ namespace boost
             int_type const  m_zero;
 
         public:
-            lcast_put_unsigned(const T n_param, CharT* finish) BOOST_NOEXCEPT
+            lcast_put_unsigned(const T n_param, CharT* finish) noexcept
                 : m_value(n_param), m_finish(finish)
                 , m_czero(lcast_char_constants<CharT>::zero), m_zero(Traits::to_int_type(m_czero))
             {
 #ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
-                BOOST_STATIC_ASSERT(!std::numeric_limits<T>::is_signed);
+                static_assert(!std::numeric_limits<T>::is_signed, "");
 #endif
             }
 
@@ -108,7 +107,7 @@ namespace boost
 
 #ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
                 // Check that ulimited group is unreachable:
-                BOOST_STATIC_ASSERT(std::numeric_limits<T>::digits10 < CHAR_MAX);
+                static_assert(std::numeric_limits<T>::digits10 < CHAR_MAX, "");
 #endif
                 CharT const thousands_sep = np.thousands_sep();
                 std::string::size_type group = 0; // current group number
@@ -138,7 +137,7 @@ namespace boost
             }
 
         private:
-            inline bool main_convert_iteration() BOOST_NOEXCEPT {
+            inline bool main_convert_iteration() noexcept {
                 --m_finish;
                 int_type const digit = static_cast<int_type>(m_value % 10U);
                 Traits::assign(*m_finish, Traits::to_char_type(m_zero + digit));
@@ -146,7 +145,7 @@ namespace boost
                 return !!m_value; // suppressing warnings
             }
 
-            inline CharT* main_convert_loop() BOOST_NOEXCEPT {
+            inline CharT* main_convert_loop() noexcept {
                 while (main_convert_iteration());
                 return m_finish;
             }
@@ -164,18 +163,18 @@ namespace boost
             const CharT* m_end;
 
         public:
-            lcast_ret_unsigned(T& value, const CharT* const begin, const CharT* end) BOOST_NOEXCEPT
+            lcast_ret_unsigned(T& value, const CharT* const begin, const CharT* end) noexcept
                 : m_multiplier_overflowed(false), m_multiplier(1), m_value(value), m_begin(begin), m_end(end)
             {
 #ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
-                BOOST_STATIC_ASSERT(!std::numeric_limits<T>::is_signed);
+                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,
+                static_assert(std::numeric_limits<T>::is_specialized,
                     "std::numeric_limits are not specialized for integral type passed to boost::lexical_cast"
                 );
 #endif
@@ -252,7 +251,7 @@ namespace boost
         private:
             // Iteration that does not care about grouping/separators and assumes that all
             // input characters are digits
-            inline bool main_convert_iteration() BOOST_NOEXCEPT {
+            inline bool main_convert_iteration() noexcept {
                 CharT const czero = lcast_char_constants<CharT>::zero;
                 T const maxv = (std::numeric_limits<T>::max)();
 
@@ -277,7 +276,7 @@ namespace boost
                 return true;
             }
 
-            bool main_convert_loop() BOOST_NOEXCEPT {
+            bool main_convert_loop() noexcept {
                 for ( ; m_end >= m_begin; --m_end) {
                     if (!main_convert_iteration()) {
                         return false;
diff --git a/include/boost/lexical_cast/detail/widest_char.hpp b/include/boost/lexical_cast/detail/widest_char.hpp
index ca1e39d..f7a36fa 100644
--- a/include/boost/lexical_cast/detail/widest_char.hpp
+++ b/include/boost/lexical_cast/detail/widest_char.hpp
@@ -30,7 +30,7 @@ namespace boost { namespace detail {
 
     template <typename TargetChar, typename SourceChar>
     struct widest_char {
-        typedef BOOST_DEDUCED_TYPENAME boost::conditional<
+        typedef typename boost::conditional<
             (sizeof(TargetChar) > sizeof(SourceChar))
             , TargetChar
             , SourceChar
diff --git a/include/boost/lexical_cast/lexical_cast_old.hpp b/include/boost/lexical_cast/lexical_cast_old.hpp
index b7b7358..28248d9 100644
--- a/include/boost/lexical_cast/lexical_cast_old.hpp
+++ b/include/boost/lexical_cast/lexical_cast_old.hpp
@@ -34,7 +34,6 @@
 #include <cstdio>
 #include <boost/limits.hpp>
 #include <boost/type_traits/is_pointer.hpp>
-#include <boost/static_assert.hpp>
 #include <boost/detail/lcast_precision.hpp>
 #include <boost/detail/workaround.hpp>
 
@@ -154,8 +153,8 @@ namespace boost {
     Target lexical_cast(Source arg)
     {
         typedef typename detail::widest_char<
-            BOOST_DEDUCED_TYPENAME detail::stream_char<Target>::type
-          , BOOST_DEDUCED_TYPENAME detail::stream_char<Source>::type
+            typename detail::stream_char<Target>::type
+          , typename detail::stream_char<Source>::type
         >::type char_type;
 
         typedef std::char_traits<char_type> traits;
diff --git a/include/boost/lexical_cast/try_lexical_convert.hpp b/include/boost/lexical_cast/try_lexical_convert.hpp
index d326f12..3c0d36d 100644
--- a/include/boost/lexical_cast/try_lexical_convert.hpp
+++ b/include/boost/lexical_cast/try_lexical_convert.hpp
@@ -164,7 +164,7 @@ namespace boost {
         template <typename Target, typename Source>
         inline bool try_lexical_convert(const Source& arg, Target& result)
         {
-            typedef BOOST_DEDUCED_TYPENAME boost::detail::array_to_pointer_decay<Source>::type src;
+            typedef typename boost::detail::array_to_pointer_decay<Source>::type src;
 
             typedef boost::integral_constant<
                 bool,
@@ -186,7 +186,7 @@ namespace boost {
 
             // We do evaluate second `if_` lazily to avoid unnecessary instantiations
             // of `shall_we_copy_with_dynamic_check_t` and improve compilation times.
-            typedef BOOST_DEDUCED_TYPENAME boost::conditional<
+            typedef typename boost::conditional<
                 shall_we_copy_t::value,
                 boost::type_identity<boost::detail::copy_converter_impl<Target, src > >,
                 boost::conditional<
@@ -196,7 +196,7 @@ namespace boost {
                 >
             >::type caster_type_lazy;
 
-            typedef BOOST_DEDUCED_TYPENAME caster_type_lazy::type caster_type;
+            typedef typename caster_type_lazy::type caster_type;
 
             return caster_type::try_convert(arg, result);
         }
@@ -204,7 +204,7 @@ namespace boost {
         template <typename Target, typename CharacterT>
         inline bool try_lexical_convert(const CharacterT* chars, std::size_t count, Target& result)
         {
-            BOOST_STATIC_ASSERT_MSG(
+            static_assert(
                 boost::detail::is_character<CharacterT>::value,
                 "This overload of try_lexical_convert is meant to be used only with arrays of characters."
             );
diff --git a/meta/libraries.json b/meta/libraries.json
index 7d73efc..150c515 100644
--- a/meta/libraries.json
+++ b/meta/libraries.json
@@ -12,5 +12,5 @@
     "maintainers": [
         "Antony Polukhin <antoshkka -at- gmail.com>"
     ],
-    "cxxstd": "03"
+    "cxxstd": "11"
 }
diff --git a/test/Jamfile.v2 b/test/Jamfile.v2
index 71b163e..d24373d 100644
--- a/test/Jamfile.v2
+++ b/test/Jamfile.v2
@@ -8,9 +8,11 @@
 import testing ;
 import feature ;
 
+import ../../config/checks/config : requires ;
+
 project
     : requirements
-        <library>/boost/test//boost_unit_test_framework
+        [ requires cxx11_rvalue_references ]
         <link>static
         <toolset>gcc-4.7:<cxxflags>-ftrapv
         <toolset>gcc-4.6:<cxxflags>-ftrapv
@@ -64,9 +66,6 @@ test-suite conversion
     [ compile-fail to_pointer_test.cpp ]
     [ run filesystem_test.cpp ../../filesystem/build//boost_filesystem/<link>static ]
     [ run try_lexical_convert.cpp ]
-    [ run no_comp_time_prcision.cpp : : :
-        <toolset>msvc:<cxxflags>/wd4127 # conditional expression is constant
-    ]
   ;
 
 # Assuring that examples compile and run. Adding sources from `example` directory to the `conversion` test suite.
diff --git a/test/abstract_test.cpp b/test/abstract_test.cpp
index ff1b2bb..3922ef1 100644
--- a/test/abstract_test.cpp
+++ b/test/abstract_test.cpp
@@ -3,6 +3,7 @@
 //  See http://www.boost.org for most recent version, including documentation.
 //
 //  Copyright Sergey Shandar 2005, Alexander Nasonov, 2007.
+//  Copyright Antony Polukhin, 2023.
 //
 //  Distributed under the Boost
 //  Software License, Version 1.0. (See accompanying file
@@ -11,29 +12,9 @@
 // Test abstract class. Bug 1358600:
 // http://sf.net/tracker/?func=detail&aid=1358600&group_id=7586&atid=107586
 
-#include <boost/config.hpp>
-
-#if defined(__INTEL_COMPILER)
-#pragma warning(disable: 193 383 488 981 1418 1419)
-#elif defined(BOOST_MSVC)
-#pragma warning(disable: 4097 4100 4121 4127 4146 4244 4245 4511 4512 4701 4800)
-#endif
-
 #include <boost/lexical_cast.hpp>
-#include <boost/test/unit_test.hpp>
 
-using namespace boost;
-
-void test_abstract();
-
-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_abstract));
-
-    return suite;
-}
+#include <boost/core/lightweight_test.hpp>
 
 class A
 {
@@ -57,6 +38,12 @@ std::ostream &operator<<(std::ostream &O, const A &a)
 void test_abstract()
 {
     const A &a = B();
-    BOOST_CHECK(boost::lexical_cast<std::string>(a) == "B");
+    BOOST_TEST(boost::lexical_cast<std::string>(a) == "B");
+}
+
+int main()
+{
+    test_abstract();
+    return boost::report_errors();
 }
 
diff --git a/test/arrays_test.cpp b/test/arrays_test.cpp
index 41a207c..0f6e374 100644
--- a/test/arrays_test.cpp
+++ b/test/arrays_test.cpp
@@ -10,16 +10,10 @@
 
 #include <boost/lexical_cast.hpp>
 
-#include <boost/test/unit_test.hpp>
+#include <boost/core/lightweight_test.hpp>
 
 #include <boost/array.hpp>
 
-void testing_boost_array_output_conversion();
-void testing_std_array_output_conversion();
-
-void testing_boost_array_input_conversion();
-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) && !defined(BOOST_MSVC)
@@ -30,19 +24,6 @@ using namespace boost;
 #define BOOST_LC_RUNU32
 #endif
 
-boost::unit_test::test_suite *init_unit_test_suite(int, char *[])
-{
-    unit_test::test_suite *suite =
-        BOOST_TEST_SUITE("Testing boost::lexical_cast with boost::array and std::array");
-
-    suite->add(BOOST_TEST_CASE(testing_boost_array_output_conversion));
-    suite->add(BOOST_TEST_CASE(testing_std_array_output_conversion));
-    suite->add(BOOST_TEST_CASE(testing_boost_array_input_conversion));
-    suite->add(BOOST_TEST_CASE(testing_std_array_input_conversion));
-
-    return suite;
-}
-
 template <template <class, std::size_t> class ArrayT, class T>
 static void testing_template_array_output_on_spec_value(T val)
 {
@@ -58,26 +39,26 @@ static void testing_template_array_output_on_spec_value(T val)
 
     {
         arr_type res1 = lexical_cast<arr_type>(val);
-        BOOST_CHECK_EQUAL(&res1[0], ethalon);
+        BOOST_TEST_EQ(&res1[0], ethalon);
         const arr_type res2 = lexical_cast<arr_type>(val);
-        BOOST_CHECK_EQUAL(&res2[0], ethalon);
-        BOOST_CHECK_THROW(lexical_cast<short_arr_type>(val), boost::bad_lexical_cast);
+        BOOST_TEST_EQ(&res2[0], ethalon);
+        BOOST_TEST_THROWS(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[0]), ethalon);
+        BOOST_TEST_EQ(reinterpret_cast<char*>(&res1[0]), ethalon);
         const uarr_type res2 = lexical_cast<uarr_type>(val);
-        BOOST_CHECK_EQUAL(reinterpret_cast<const char*>(&res2[0]), ethalon);
-        BOOST_CHECK_THROW(lexical_cast<ushort_arr_type>(val), boost::bad_lexical_cast);
+        BOOST_TEST_EQ(reinterpret_cast<const char*>(&res2[0]), ethalon);
+        BOOST_TEST_THROWS(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[0]), ethalon);
+        BOOST_TEST_EQ(reinterpret_cast<char*>(&res1[0]), ethalon);
         const sarr_type res2 = lexical_cast<sarr_type>(val);
-        BOOST_CHECK_EQUAL(reinterpret_cast<const char*>(&res2[0]), ethalon);
-        BOOST_CHECK_THROW(lexical_cast<sshort_arr_type>(val), boost::bad_lexical_cast);
+        BOOST_TEST_EQ(reinterpret_cast<const char*>(&res2[0]), ethalon);
+        BOOST_TEST_THROWS(lexical_cast<sshort_arr_type>(val), boost::bad_lexical_cast);
     }
 
 #if !defined(BOOST_NO_STRINGSTREAM) && !defined(BOOST_NO_STD_WSTRING)
@@ -87,15 +68,15 @@ static void testing_template_array_output_on_spec_value(T val)
 
     {
         warr_type res = lexical_cast<warr_type>(val);
-        BOOST_CHECK(&res[0] == wethalon);
+        BOOST_TEST(&res[0] == wethalon);
     }
 
     {
         const warr_type res = lexical_cast<warr_type>(val);
-        BOOST_CHECK(&res[0] == wethalon);
+        BOOST_TEST(&res[0] == wethalon);
     }
 
-    BOOST_CHECK_THROW(lexical_cast<wshort_arr_type>(val), boost::bad_lexical_cast);
+    BOOST_TEST_THROWS(lexical_cast<wshort_arr_type>(val), boost::bad_lexical_cast);
 
 #endif
 
@@ -106,15 +87,15 @@ static void testing_template_array_output_on_spec_value(T val)
 
     {
         u16arr_type res = lexical_cast<u16arr_type>(val);
-        BOOST_CHECK(&res[0] == u16ethalon);
+        BOOST_TEST(&res[0] == u16ethalon);
     }
 
     {
         const u16arr_type res = lexical_cast<u16arr_type>(val);
-        BOOST_CHECK(&res[0] == u16ethalon);
+        BOOST_TEST(&res[0] == u16ethalon);
     }
 
-    BOOST_CHECK_THROW(lexical_cast<u16short_arr_type>(val), boost::bad_lexical_cast);
+    BOOST_TEST_THROWS(lexical_cast<u16short_arr_type>(val), boost::bad_lexical_cast);
 #endif
 
 #ifdef BOOST_LC_RUNU32
@@ -124,15 +105,15 @@ static void testing_template_array_output_on_spec_value(T val)
 
     {
         u32arr_type res = lexical_cast<u32arr_type>(val);
-        BOOST_CHECK(&res[0] == u32ethalon);
+        BOOST_TEST(&res[0] == u32ethalon);
     }
 
     {
         const u32arr_type res = lexical_cast<u32arr_type>(val);
-        BOOST_CHECK(&res[0] == u32ethalon);
+        BOOST_TEST(&res[0] == u32ethalon);
     }
 
-    BOOST_CHECK_THROW(lexical_cast<u32short_arr_type>(val), boost::bad_lexical_cast);
+    BOOST_TEST_THROWS(lexical_cast<u32short_arr_type>(val), boost::bad_lexical_cast);
 #endif
 }
 
@@ -153,26 +134,26 @@ static void testing_template_array_output_on_char_value()
 
     {
         arr_type res1 = lexical_cast<arr_type>(val);
-        BOOST_CHECK_EQUAL(&res1[0], ethalon);
+        BOOST_TEST_EQ(&res1[0], ethalon);
         const arr_type res2 = lexical_cast<arr_type>(val);
-        BOOST_CHECK_EQUAL(&res2[0], ethalon);
-        BOOST_CHECK_THROW(lexical_cast<short_arr_type>(val), boost::bad_lexical_cast);
+        BOOST_TEST_EQ(&res2[0], ethalon);
+        BOOST_TEST_THROWS(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[0]), ethalon);
+        BOOST_TEST_EQ(reinterpret_cast<char*>(&res1[0]), ethalon);
         const uarr_type res2 = lexical_cast<uarr_type>(val);
-        BOOST_CHECK_EQUAL(reinterpret_cast<const char*>(&res2[0]), ethalon);
-        BOOST_CHECK_THROW(lexical_cast<ushort_arr_type>(val), boost::bad_lexical_cast);
+        BOOST_TEST_EQ(reinterpret_cast<const char*>(&res2[0]), ethalon);
+        BOOST_TEST_THROWS(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[0]), ethalon);
+        BOOST_TEST_EQ(reinterpret_cast<char*>(&res1[0]), ethalon);
         const sarr_type res2 = lexical_cast<sarr_type>(val);
-        BOOST_CHECK_EQUAL(reinterpret_cast<const char*>(&res2[0]), ethalon);
-        BOOST_CHECK_THROW(lexical_cast<sshort_arr_type>(val), boost::bad_lexical_cast);
+        BOOST_TEST_EQ(reinterpret_cast<const char*>(&res2[0]), ethalon);
+        BOOST_TEST_THROWS(lexical_cast<sshort_arr_type>(val), boost::bad_lexical_cast);
     }
 
 #if !defined(BOOST_NO_STRINGSTREAM) && !defined(BOOST_NO_STD_WSTRING)
@@ -182,19 +163,19 @@ static void testing_template_array_output_on_char_value()
 
     {
         warr_type res = lexical_cast<warr_type>(val);
-        BOOST_CHECK(&res[0] == wethalon);
+        BOOST_TEST(&res[0] == wethalon);
         warr_type res3 = lexical_cast<warr_type>(wethalon);
-        BOOST_CHECK(&res3[0] == wethalon);
+        BOOST_TEST(&res3[0] == wethalon);
     }
 
     {
         const warr_type res = lexical_cast<warr_type>(val);
-        BOOST_CHECK(&res[0] == wethalon);
+        BOOST_TEST(&res[0] == wethalon);
         const warr_type res3 = lexical_cast<warr_type>(wethalon);
-        BOOST_CHECK(&res3[0] == wethalon);
+        BOOST_TEST(&res3[0] == wethalon);
     }
 
-    BOOST_CHECK_THROW(lexical_cast<wshort_arr_type>(val), boost::bad_lexical_cast);
+    BOOST_TEST_THROWS(lexical_cast<wshort_arr_type>(val), boost::bad_lexical_cast);
 
 #endif
 
@@ -206,24 +187,24 @@ 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[0] == u16ethalon);
+        BOOST_TEST(&res[0] == u16ethalon);
 #endif
 
         u16arr_type res3 = lexical_cast<u16arr_type>(u16ethalon);
-        BOOST_CHECK(&res3[0] == u16ethalon);
+        BOOST_TEST(&res3[0] == u16ethalon);
     }
 
     {
 #ifdef BOOST_STL_SUPPORTS_NEW_UNICODE_LOCALES
         const u16arr_type res = lexical_cast<u16arr_type>(val);
-        BOOST_CHECK(&res[0] == u16ethalon);
+        BOOST_TEST(&res[0] == u16ethalon);
 #endif
         const u16arr_type res3 = lexical_cast<u16arr_type>(u16ethalon);
-        BOOST_CHECK(&res3[0] == u16ethalon);
+        BOOST_TEST(&res3[0] == u16ethalon);
     }
 
     // Some compillers may throw std::bad_alloc here
-    BOOST_CHECK_THROW(lexical_cast<u16short_arr_type>(val), std::exception);
+    BOOST_TEST_THROWS(lexical_cast<u16short_arr_type>(val), std::exception);
 #endif
 
 #ifdef BOOST_LC_RUNU32
@@ -234,23 +215,23 @@ 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[0] == u32ethalon);
+        BOOST_TEST(&res[0] == u32ethalon);
 #endif
         u32arr_type res3 = lexical_cast<u32arr_type>(u32ethalon);
-        BOOST_CHECK(&res3[0] == u32ethalon);
+        BOOST_TEST(&res3[0] == u32ethalon);
     }
 
     {
 #ifdef BOOST_STL_SUPPORTS_NEW_UNICODE_LOCALES
         const u32arr_type res = lexical_cast<u32arr_type>(val);
-        BOOST_CHECK(&res[0] == u32ethalon);
+        BOOST_TEST(&res[0] == u32ethalon);
 #endif
         const u32arr_type res3 = lexical_cast<u32arr_type>(u32ethalon);
-        BOOST_CHECK(&res3[0] == u32ethalon);
+        BOOST_TEST(&res3[0] == u32ethalon);
     }
 
     // Some compillers may throw std::bad_alloc here
-    BOOST_CHECK_THROW(lexical_cast<u32short_arr_type>(val), std::exception);
+    BOOST_TEST_THROWS(lexical_cast<u32short_arr_type>(val), std::exception);
 #endif
 }
 
@@ -274,7 +255,7 @@ void testing_std_array_output_conversion()
     testing_template_array_output_on_spec_value<std::array>(static_cast<unsigned int>(100));
 #endif
 
-    BOOST_CHECK(true);
+    BOOST_TEST(true);
 }
 
 template <template <class, std::size_t> class ArrayT>
@@ -282,81 +263,81 @@ static void testing_generic_array_input_conversion()
 {
     {
         ArrayT<char, 4> var_zero_terminated = {{ '1', '0', '0', '\0'}};
-        BOOST_CHECK_EQUAL(lexical_cast<std::string>(var_zero_terminated), "100");
-        BOOST_CHECK_EQUAL(lexical_cast<int>(var_zero_terminated), 100);
+        BOOST_TEST_EQ(lexical_cast<std::string>(var_zero_terminated), "100");
+        BOOST_TEST_EQ(lexical_cast<int>(var_zero_terminated), 100);
 
         ArrayT<char, 3> var_none_terminated = {{ '1', '0', '0'}};
-        BOOST_CHECK_EQUAL(lexical_cast<std::string>(var_none_terminated), "100");
-        BOOST_CHECK_EQUAL(lexical_cast<short>(var_none_terminated), static_cast<short>(100));
+        BOOST_TEST_EQ(lexical_cast<std::string>(var_none_terminated), "100");
+        BOOST_TEST_EQ(lexical_cast<short>(var_none_terminated), static_cast<short>(100));
 
         ArrayT<const char, 4> var_zero_terminated_const_char = {{ '1', '0', '0', '\0'}};
-        BOOST_CHECK_EQUAL(lexical_cast<std::string>(var_zero_terminated_const_char), "100");
+        BOOST_TEST_EQ(lexical_cast<std::string>(var_zero_terminated_const_char), "100");
 
         ArrayT<const char, 3> var_none_terminated_const_char = {{ '1', '0', '0'}};
-        BOOST_CHECK_EQUAL(lexical_cast<std::string>(var_none_terminated_const_char), "100");
+        BOOST_TEST_EQ(lexical_cast<std::string>(var_none_terminated_const_char), "100");
 
         const ArrayT<char, 4> var_zero_terminated_const_var = {{ '1', '0', '0', '\0'}};
-        BOOST_CHECK_EQUAL(lexical_cast<std::string>(var_zero_terminated_const_var), "100");
+        BOOST_TEST_EQ(lexical_cast<std::string>(var_zero_terminated_const_var), "100");
 
         const ArrayT<char, 3> var_none_terminated_const_var = {{ '1', '0', '0'}};
-        BOOST_CHECK_EQUAL(lexical_cast<std::string>(var_none_terminated_const_var), "100");
+        BOOST_TEST_EQ(lexical_cast<std::string>(var_none_terminated_const_var), "100");
 
         const ArrayT<const char, 4> var_zero_terminated_const_var_const_char = {{ '1', '0', '0', '\0'}};
-        BOOST_CHECK_EQUAL(lexical_cast<std::string>(var_zero_terminated_const_var_const_char), "100");
+        BOOST_TEST_EQ(lexical_cast<std::string>(var_zero_terminated_const_var_const_char), "100");
 
         const ArrayT<const char, 3> var_none_terminated_const_var_const_char = {{ '1', '0', '0'}};
-        BOOST_CHECK_EQUAL(lexical_cast<std::string>(var_none_terminated_const_var_const_char), "100");
-        BOOST_CHECK_EQUAL(lexical_cast<int>(var_none_terminated_const_var_const_char), 100);
+        BOOST_TEST_EQ(lexical_cast<std::string>(var_none_terminated_const_var_const_char), "100");
+        BOOST_TEST_EQ(lexical_cast<int>(var_none_terminated_const_var_const_char), 100);
     }
 
     {
         const ArrayT<const unsigned char, 4> var_zero_terminated_const_var_const_char = {{ '1', '0', '0', '\0'}};
-        BOOST_CHECK_EQUAL(lexical_cast<std::string>(var_zero_terminated_const_var_const_char), "100");
+        BOOST_TEST_EQ(lexical_cast<std::string>(var_zero_terminated_const_var_const_char), "100");
 
         const ArrayT<const unsigned char, 3> var_none_terminated_const_var_const_char = {{ '1', '0', '0'}};
-        BOOST_CHECK_EQUAL(lexical_cast<std::string>(var_none_terminated_const_var_const_char), "100");
+        BOOST_TEST_EQ(lexical_cast<std::string>(var_none_terminated_const_var_const_char), "100");
     }
 
     {
         const ArrayT<const signed char, 4> var_zero_terminated_const_var_const_char = {{ '1', '0', '0', '\0'}};
-        BOOST_CHECK_EQUAL(lexical_cast<std::string>(var_zero_terminated_const_var_const_char), "100");
+        BOOST_TEST_EQ(lexical_cast<std::string>(var_zero_terminated_const_var_const_char), "100");
 
         const ArrayT<const signed char, 3> var_none_terminated_const_var_const_char = {{ '1', '0', '0'}};
-        BOOST_CHECK_EQUAL(lexical_cast<std::string>(var_none_terminated_const_var_const_char), "100");
-        BOOST_CHECK_EQUAL(lexical_cast<unsigned int>(var_none_terminated_const_var_const_char), 100u);
+        BOOST_TEST_EQ(lexical_cast<std::string>(var_none_terminated_const_var_const_char), "100");
+        BOOST_TEST_EQ(lexical_cast<unsigned int>(var_none_terminated_const_var_const_char), 100u);
     }
 
 
 #if !defined(BOOST_NO_STRINGSTREAM) && !defined(BOOST_NO_STD_WSTRING)
     {
         const ArrayT<const wchar_t, 4> var_zero_terminated_const_var_const_char = {{ L'1', L'0', L'0', L'\0'}};
-        BOOST_CHECK(lexical_cast<std::wstring>(var_zero_terminated_const_var_const_char) == L"100");
+        BOOST_TEST(lexical_cast<std::wstring>(var_zero_terminated_const_var_const_char) == L"100");
 
         const ArrayT<const wchar_t, 3> var_none_terminated_const_var_const_char = {{ L'1', L'0', L'0'}};
-        BOOST_CHECK(lexical_cast<std::wstring>(var_none_terminated_const_var_const_char) == L"100");
-        BOOST_CHECK_EQUAL(lexical_cast<int>(var_none_terminated_const_var_const_char), 100);
+        BOOST_TEST(lexical_cast<std::wstring>(var_none_terminated_const_var_const_char) == L"100");
+        BOOST_TEST_EQ(lexical_cast<int>(var_none_terminated_const_var_const_char), 100);
     }
 #endif
 
 #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");
-        BOOST_CHECK_EQUAL(lexical_cast<unsigned short>(var_zero_terminated_const_var_const_char), static_cast<unsigned short>(100));
+        BOOST_TEST(lexical_cast<std::u16string>(var_zero_terminated_const_var_const_char) == u"100");
+        BOOST_TEST_EQ(lexical_cast<unsigned short>(var_zero_terminated_const_var_const_char), static_cast<unsigned short>(100));
 
         const ArrayT<const char16_t, 3> var_none_terminated_const_var_const_char = {{ u'1', u'0', u'0'}};
-        BOOST_CHECK(lexical_cast<std::u16string>(var_none_terminated_const_var_const_char) == u"100");
+        BOOST_TEST(lexical_cast<std::u16string>(var_none_terminated_const_var_const_char) == u"100");
     }
 #endif
 
 #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");
+        BOOST_TEST(lexical_cast<std::u32string>(var_zero_terminated_const_var_const_char) == U"100");
 
         const ArrayT<const char32_t, 3> var_none_terminated_const_var_const_char = {{ U'1', U'0', U'0'}};
-        BOOST_CHECK(lexical_cast<std::u32string>(var_none_terminated_const_var_const_char) == U"100");
-        BOOST_CHECK_EQUAL(lexical_cast<int>(var_none_terminated_const_var_const_char), 100);
+        BOOST_TEST(lexical_cast<std::u32string>(var_none_terminated_const_var_const_char) == U"100");
+        BOOST_TEST_EQ(lexical_cast<int>(var_none_terminated_const_var_const_char), 100);
     }
 #endif
 }
@@ -372,6 +353,16 @@ void testing_std_array_input_conversion()
     testing_generic_array_input_conversion<std::array>();
 #endif
 
-    BOOST_CHECK(true);
+    BOOST_TEST(true);
+}
+
+int main()
+{
+    testing_boost_array_output_conversion();
+    testing_std_array_output_conversion();
+    testing_boost_array_input_conversion();
+    testing_std_array_input_conversion();
+
+    return boost::report_errors();
 }
 
diff --git a/test/containers_test.cpp b/test/containers_test.cpp
index caba715..cd56bb0 100644
--- a/test/containers_test.cpp
+++ b/test/containers_test.cpp
@@ -9,35 +9,20 @@
 //  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt).
 
 #include <boost/lexical_cast.hpp>
-#include <boost/test/unit_test.hpp>
+
+#include <boost/core/lightweight_test.hpp>
 #include <boost/container/string.hpp>
 
-void testing_boost_containers_basic_string();
-void testing_boost_containers_string_std_string();
-void testing_boost_containers_string_widening();
-
-
 using namespace boost;
 
-boost::unit_test::test_suite *init_unit_test_suite(int, char *[])
-{
-    unit_test::test_suite *suite =
-        BOOST_TEST_SUITE("Testing boost::lexical_cast with boost::container::string");
-    suite->add(BOOST_TEST_CASE(testing_boost_containers_basic_string));
-    suite->add(BOOST_TEST_CASE(testing_boost_containers_string_std_string));
-    suite->add(BOOST_TEST_CASE(testing_boost_containers_string_widening));
-
-    return suite;
-}
-
 void testing_boost_containers_basic_string()
 {
-    BOOST_CHECK("100" == lexical_cast<boost::container::string>("100"));
-    BOOST_CHECK(L"100" == lexical_cast<boost::container::wstring>(L"100"));
+    BOOST_TEST("100" == lexical_cast<boost::container::string>("100"));
+    BOOST_TEST(L"100" == lexical_cast<boost::container::wstring>(L"100"));
 
-    BOOST_CHECK("100" == lexical_cast<boost::container::string>(100));
+    BOOST_TEST("100" == lexical_cast<boost::container::string>(100));
     boost::container::string str("1000");
-    BOOST_CHECK(1000 == lexical_cast<int>(str));
+    BOOST_TEST(1000 == lexical_cast<int>(str));
 }
 
 #if defined(BOOST_NO_STRINGSTREAM) || defined(BOOST_NO_STD_WSTRING)
@@ -48,15 +33,15 @@ void testing_boost_containers_string_std_string()
 {
     std::string std_str("std_str");
     boost::container::string boost_str("boost_str");
-    BOOST_CHECK(boost::lexical_cast<std::string>(boost_str) == "boost_str");
-    BOOST_CHECK(boost::lexical_cast<boost::container::string>(std_str) == "std_str");
+    BOOST_TEST(boost::lexical_cast<std::string>(boost_str) == "boost_str");
+    BOOST_TEST(boost::lexical_cast<boost::container::string>(std_str) == "std_str");
 
 #ifndef BOOST_LCAST_NO_WCHAR_T
     std::wstring std_wstr(L"std_wstr");
     boost::container::wstring boost_wstr(L"boost_wstr");
 
-    BOOST_CHECK(boost::lexical_cast<std::wstring>(boost_wstr) == L"boost_wstr");
-    BOOST_CHECK(boost::lexical_cast<boost::container::wstring>(std_wstr) == L"std_wstr");
+    BOOST_TEST(boost::lexical_cast<std::wstring>(boost_wstr) == L"boost_wstr");
+    BOOST_TEST(boost::lexical_cast<boost::container::wstring>(std_wstr) == L"std_wstr");
 
 #endif
 
@@ -68,16 +53,25 @@ void testing_boost_containers_string_widening()
 
 #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);
+    BOOST_TEST(boost::lexical_cast<boost::container::wstring>(char_array) == wchar_array);
 #endif
 
 #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);
+    BOOST_TEST(boost::lexical_cast<boost::container::basic_string<char16_t> >(char_array) == char16_array);
 #endif
 
 #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);
+    BOOST_TEST(boost::lexical_cast<boost::container::basic_string<char32_t> >(char_array) == char32_array);
 #endif
 }
+
+int main()
+{
+    testing_boost_containers_basic_string();
+    testing_boost_containers_string_std_string();
+    testing_boost_containers_string_widening();
+
+    return boost::report_errors();
+}
diff --git a/test/empty_input_test.cpp b/test/empty_input_test.cpp
index 36e3ab3..e8b2313 100644
--- a/test/empty_input_test.cpp
+++ b/test/empty_input_test.cpp
@@ -8,20 +8,15 @@
 //  Software License, Version 1.0. (See accompanying file
 //  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt).
 
-#include <boost/config.hpp>
-
-#if defined(__INTEL_COMPILER)
-#pragma warning(disable: 193 383 488 981 1418 1419)
-#elif defined(BOOST_MSVC)
-#pragma warning(disable: 4097 4100 4121 4127 4146 4244 4245 4511 4512 4701 4800)
-#endif
-
 #include <boost/lexical_cast.hpp>
-#include <boost/test/unit_test.hpp>
 #include <boost/range/iterator_range.hpp>
 
 #include "escape_struct.hpp"
 
+#include <boost/core/lightweight_test.hpp>
+
+#include <vector>
+
 using namespace boost;
 
 #if defined(BOOST_NO_STRINGSTREAM) || defined(BOOST_NO_STD_WSTRING)
@@ -31,20 +26,20 @@ using namespace boost;
 template <class T>
 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);
+    BOOST_TEST_THROWS(lexical_cast<int>(v), bad_lexical_cast);
+    BOOST_TEST_THROWS(lexical_cast<float>(v), bad_lexical_cast);
+    BOOST_TEST_THROWS(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);
+    BOOST_TEST_THROWS(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);
+    BOOST_TEST_THROWS(lexical_cast<unsigned int>(v), bad_lexical_cast);
+    BOOST_TEST_THROWS(lexical_cast<unsigned short>(v), bad_lexical_cast);
 #if defined(BOOST_HAS_LONG_LONG)
-    BOOST_CHECK_THROW(lexical_cast<boost::ulong_long_type>(v), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<boost::long_long_type>(v), bad_lexical_cast);
+    BOOST_TEST_THROWS(lexical_cast<boost::ulong_long_type>(v), bad_lexical_cast);
+    BOOST_TEST_THROWS(lexical_cast<boost::long_long_type>(v), bad_lexical_cast);
 #elif defined(BOOST_HAS_MS_INT64)
-    BOOST_CHECK_THROW(lexical_cast<unsigned __int64>(v), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<__int64>(v), bad_lexical_cast);
+    BOOST_TEST_THROWS(lexical_cast<unsigned __int64>(v), bad_lexical_cast);
+    BOOST_TEST_THROWS(lexical_cast<__int64>(v), bad_lexical_cast);
 #endif
 }
 
@@ -53,50 +48,50 @@ void test_empty_iterator_range()
 
     boost::iterator_range<char*> v;
     do_test_on_empty_input(v);
-    BOOST_CHECK_EQUAL(lexical_cast<std::string>(v), std::string());
-    BOOST_CHECK_THROW(lexical_cast<char>(v), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<unsigned char>(v), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<signed char>(v), bad_lexical_cast);
+    BOOST_TEST_EQ(lexical_cast<std::string>(v), std::string());
+    BOOST_TEST_THROWS(lexical_cast<char>(v), bad_lexical_cast);
+    BOOST_TEST_THROWS(lexical_cast<unsigned char>(v), bad_lexical_cast);
+    BOOST_TEST_THROWS(lexical_cast<signed char>(v), bad_lexical_cast);
 
     boost::iterator_range<const char*> cv;
     do_test_on_empty_input(cv);
-    BOOST_CHECK_EQUAL(lexical_cast<std::string>(cv), std::string());
-    BOOST_CHECK_THROW(lexical_cast<char>(cv), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<unsigned char>(cv), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<signed char>(cv), bad_lexical_cast);
+    BOOST_TEST_EQ(lexical_cast<std::string>(cv), std::string());
+    BOOST_TEST_THROWS(lexical_cast<char>(cv), bad_lexical_cast);
+    BOOST_TEST_THROWS(lexical_cast<unsigned char>(cv), bad_lexical_cast);
+    BOOST_TEST_THROWS(lexical_cast<signed char>(cv), bad_lexical_cast);
 
     const boost::iterator_range<const char*> ccv;
     do_test_on_empty_input(ccv);
-    BOOST_CHECK_EQUAL(lexical_cast<std::string>(ccv), std::string());
-    BOOST_CHECK_THROW(lexical_cast<char>(ccv), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<unsigned char>(ccv), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<signed char>(ccv), bad_lexical_cast);
+    BOOST_TEST_EQ(lexical_cast<std::string>(ccv), std::string());
+    BOOST_TEST_THROWS(lexical_cast<char>(ccv), bad_lexical_cast);
+    BOOST_TEST_THROWS(lexical_cast<unsigned char>(ccv), bad_lexical_cast);
+    BOOST_TEST_THROWS(lexical_cast<signed char>(ccv), bad_lexical_cast);
 }
 
 void test_empty_string()
 {
     std::string v;
     do_test_on_empty_input(v);
-    BOOST_CHECK_THROW(lexical_cast<char>(v), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<unsigned char>(v), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<signed char>(v), bad_lexical_cast);
+    BOOST_TEST_THROWS(lexical_cast<char>(v), bad_lexical_cast);
+    BOOST_TEST_THROWS(lexical_cast<unsigned char>(v), bad_lexical_cast);
+    BOOST_TEST_THROWS(lexical_cast<signed char>(v), bad_lexical_cast);
 
 #ifndef BOOST_LCAST_NO_WCHAR_T
     std::wstring vw;
     do_test_on_empty_input(vw);
-    BOOST_CHECK_THROW(lexical_cast<wchar_t>(vw), bad_lexical_cast);
+    BOOST_TEST_THROWS(lexical_cast<wchar_t>(vw), bad_lexical_cast);
 #endif
 
 // Currently, no compiler and STL library fully support char16_t and char32_t
 //#ifndef BOOST_NO_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);
+//    BOOST_TEST_THROWS(lexical_cast<char16_t>(v16w), bad_lexical_cast);
 //#endif
 //#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);
+//    BOOST_TEST_THROWS(lexical_cast<char32_t>(v32w), bad_lexical_cast);
 //#endif
 }
 
@@ -104,9 +99,9 @@ void test_empty_user_class()
 {
     EscapeStruct v("");
     do_test_on_empty_input(v);
-    BOOST_CHECK_THROW(lexical_cast<char>(v), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<unsigned char>(v), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<signed char>(v), bad_lexical_cast);
+    BOOST_TEST_THROWS(lexical_cast<char>(v), bad_lexical_cast);
+    BOOST_TEST_THROWS(lexical_cast<unsigned char>(v), bad_lexical_cast);
+    BOOST_TEST_THROWS(lexical_cast<signed char>(v), bad_lexical_cast);
 }
 
 namespace std {
@@ -114,7 +109,7 @@ inline std::ostream & operator<<(std::ostream & out, const std::vector<long> & v
 {
     std::ostream_iterator<long> it(out);
     std::copy(v.begin(), v.end(), it);
-    BOOST_CHECK(out);
+    BOOST_TEST(out);
     return out;
 }
 }
@@ -123,9 +118,9 @@ void test_empty_vector()
 {
     std::vector<long> v;
     do_test_on_empty_input(v);
-    BOOST_CHECK_THROW(lexical_cast<char>(v), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<unsigned char>(v), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<signed char>(v), bad_lexical_cast);
+    BOOST_TEST_THROWS(lexical_cast<char>(v), bad_lexical_cast);
+    BOOST_TEST_THROWS(lexical_cast<unsigned char>(v), bad_lexical_cast);
+    BOOST_TEST_THROWS(lexical_cast<signed char>(v), bad_lexical_cast);
 }
 
 
@@ -138,18 +133,17 @@ struct my_string {
 void test_empty_zero_terminated_string()
 {
     my_string st;
-    BOOST_CHECK_EQUAL(boost::lexical_cast<std::string>(st), std::string());;
+    BOOST_TEST_EQ(boost::lexical_cast<std::string>(st), std::string());;
 }
 
-unit_test::test_suite *init_unit_test_suite(int, char *[])
+
+int main()
 {
-    unit_test::test_suite *suite =
-        BOOST_TEST_SUITE("lexical_cast. Empty input unit test");
-    suite->add(BOOST_TEST_CASE(&test_empty_iterator_range));
-    suite->add(BOOST_TEST_CASE(&test_empty_string));
-    suite->add(BOOST_TEST_CASE(&test_empty_user_class));
-    suite->add(BOOST_TEST_CASE(&test_empty_vector));
-    suite->add(BOOST_TEST_CASE(&test_empty_zero_terminated_string));
+    test_empty_iterator_range();
+    test_empty_string();
+    test_empty_user_class();
+    test_empty_vector();
+    test_empty_zero_terminated_string();
 
-    return suite;
+    return boost::report_errors();
 }
diff --git a/test/filesystem_test.cpp b/test/filesystem_test.cpp
index 7297fed..9ed1782 100644
--- a/test/filesystem_test.cpp
+++ b/test/filesystem_test.cpp
@@ -10,58 +10,51 @@
 //
 // 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/core/lightweight_test.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+filesystem 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);
+    BOOST_TEST(!p.empty());
+    BOOST_TEST_EQ(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);
+    BOOST_TEST(!p.empty());
+    BOOST_TEST_EQ(p, ab);
 
     // Tests for
     // https://github.com/boostorg/lexical_cast/issues/25
 
     const char quoted_path[] = "\"/home/my user\"";
     p = boost::lexical_cast<boost::filesystem::path>(quoted_path);
-    BOOST_CHECK(!p.empty());
+    BOOST_TEST(!p.empty());
     const char unquoted_path[] = "/home/my user";
-    BOOST_CHECK_EQUAL(p, boost::filesystem::path(unquoted_path));
+    BOOST_TEST_EQ(p, boost::filesystem::path(unquoted_path));
 
     // Converting back to std::string gives the initial string
-    BOOST_CHECK_EQUAL(boost::lexical_cast<std::string>(p), quoted_path);
+    BOOST_TEST_EQ(boost::lexical_cast<std::string>(p), quoted_path);
 
     try {
         // Without quotes the path will have only `/home/my` in it.
         // `user` remains in the stream, so an exception must be thrown.
         p = boost::lexical_cast<boost::filesystem::path>(unquoted_path);
-        BOOST_CHECK(false);
+        BOOST_TEST(false);
     } catch (const boost::bad_lexical_cast& ) {
         // Exception is expected
     }
 }
 
+int main()
+{
+    test_filesystem();
+
+    return boost::report_errors();
+}
+
diff --git a/test/float_types_test.cpp b/test/float_types_test.cpp
index c5417e3..9ecf7f1 100644
--- a/test/float_types_test.cpp
+++ b/test/float_types_test.cpp
@@ -8,19 +8,15 @@
 //  Software License, Version 1.0. (See accompanying file
 //  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt).
 
-#include <boost/config.hpp>
-
-#if defined(__INTEL_COMPILER)
-#pragma warning(disable: 193 383 488 981 1418 1419)
-#elif defined(BOOST_MSVC)
-#pragma warning(disable: 4097 4100 4121 4127 4146 4244 4245 4511 4512 4701 4800)
-#endif
-
 #include <boost/lexical_cast.hpp>
 
 #include <boost/cstdint.hpp>
-#include <boost/test/unit_test.hpp>
-#include <boost/test/tools/floating_point_comparison.hpp>
+#include <boost/core/lightweight_test.hpp>
+
+#ifndef BOOST_TEST_CLOSE_FRACTION
+// Naiive, but works for most tests in this file 
+#define BOOST_TEST_CLOSE_FRACTION(x, y, eps) BOOST_TEST(x - y + eps <= eps * 2)
+#endif
 
 #if (defined(__CYGWIN__) || defined(__FreeBSD__) || defined(__NetBSD__) \
    || (defined(__hppa) && !defined(__OpenBSD__)) || (defined(__NO_LONG_DOUBLE_MATH) && (DBL_MANT_DIG != LDBL_MANT_DIG))) \
@@ -28,27 +24,9 @@
 #  define BOOST_LEXICAL_CAST_NO_LONG_DOUBLE_MATH_FUNCTIONS
 #endif
 
-void test_conversion_from_to_float();
-void test_conversion_from_to_double();
-void test_conversion_from_to_long_double();
-void test_volatile_floats();
-
 using namespace boost;
 
 
-unit_test::test_suite *init_unit_test_suite(int, char *[])
-{
-    unit_test::test_suite *suite =
-        BOOST_TEST_SUITE("lexical_cast float types unit test");
-    suite->add(BOOST_TEST_CASE(&test_conversion_from_to_float));
-    suite->add(BOOST_TEST_CASE(&test_conversion_from_to_double));
-    suite->add(BOOST_TEST_CASE(&test_conversion_from_to_long_double));
-    suite->add(BOOST_TEST_CASE(&test_volatile_floats));
-
-    return suite;
-}
-
-
 // Replace "-,999" with "-999".
 template<class CharT>
 std::basic_string<CharT> to_str_gcc_workaround(std::basic_string<CharT> str)
@@ -87,25 +65,25 @@ void test_conversion_from_to_float_for_locale()
     numpunct const& np = BOOST_USE_FACET(numpunct, current_locale);
     if ( !np.grouping().empty() )
     {
-        BOOST_CHECK_THROW(
+        BOOST_TEST_THROWS(
                 lexical_cast<T>( std::string("100") + np.thousands_sep() + np.thousands_sep() + "0" )
                 , bad_lexical_cast);
-        BOOST_CHECK_THROW(lexical_cast<T>( std::string("100") + np.thousands_sep() ), bad_lexical_cast);
-        BOOST_CHECK_THROW(lexical_cast<T>( np.thousands_sep() + std::string("100") ), bad_lexical_cast);
-        BOOST_CHECK_THROW(lexical_cast<T>( std::string("1") + np.thousands_sep() + np.decimal_point() + "e10" ), bad_lexical_cast);
-        BOOST_CHECK_THROW(lexical_cast<T>( std::string("1e10") + np.thousands_sep() ), bad_lexical_cast);
-        BOOST_CHECK_THROW(lexical_cast<T>( std::string("1") + np.thousands_sep() + "e10" ), bad_lexical_cast);
+        BOOST_TEST_THROWS(lexical_cast<T>( std::string("100") + np.thousands_sep() ), bad_lexical_cast);
+        BOOST_TEST_THROWS(lexical_cast<T>( np.thousands_sep() + std::string("100") ), bad_lexical_cast);
+        BOOST_TEST_THROWS(lexical_cast<T>( std::string("1") + np.thousands_sep() + np.decimal_point() + "e10" ), bad_lexical_cast);
+        BOOST_TEST_THROWS(lexical_cast<T>( std::string("1e10") + np.thousands_sep() ), bad_lexical_cast);
+        BOOST_TEST_THROWS(lexical_cast<T>( std::string("1") + np.thousands_sep() + "e10" ), bad_lexical_cast);
 
-        BOOST_CHECK_CLOSE_FRACTION(lexical_cast<T>( to_str< char >(100000) ), 100000, (std::numeric_limits<T>::epsilon()) );
-        BOOST_CHECK_CLOSE_FRACTION(lexical_cast<T>( to_str< char >(10000000u) ), 10000000u, (std::numeric_limits<T>::epsilon()) );
-        BOOST_CHECK_CLOSE_FRACTION(lexical_cast<T>( to_str< char >(100) ), 100, (std::numeric_limits<T>::epsilon()) );
+        BOOST_TEST_CLOSE_FRACTION(lexical_cast<T>( to_str< char >(100000) ), 100000, (std::numeric_limits<T>::epsilon()) );
+        BOOST_TEST_CLOSE_FRACTION(lexical_cast<T>( to_str< char >(10000000u) ), 10000000u, (std::numeric_limits<T>::epsilon()) );
+        BOOST_TEST_CLOSE_FRACTION(lexical_cast<T>( to_str< char >(100) ), 100, (std::numeric_limits<T>::epsilon()) );
 #if !defined(BOOST_LCAST_NO_WCHAR_T) && !defined(BOOST_NO_INTRINSIC_WCHAR_T)
-        BOOST_CHECK_CLOSE_FRACTION(lexical_cast<T>( to_str< wchar_t >(100000) ), 100000, (std::numeric_limits<T>::epsilon()) );
-        BOOST_CHECK_CLOSE_FRACTION(lexical_cast<T>( to_str< wchar_t >(10000000u) ), 10000000u, (std::numeric_limits<T>::epsilon()) );
-        BOOST_CHECK_CLOSE_FRACTION(lexical_cast<T>( to_str< wchar_t >(100) ), 100, (std::numeric_limits<T>::epsilon()) );
+        BOOST_TEST_CLOSE_FRACTION(lexical_cast<T>( to_str< wchar_t >(100000) ), 100000, (std::numeric_limits<T>::epsilon()) );
+        BOOST_TEST_CLOSE_FRACTION(lexical_cast<T>( to_str< wchar_t >(10000000u) ), 10000000u, (std::numeric_limits<T>::epsilon()) );
+        BOOST_TEST_CLOSE_FRACTION(lexical_cast<T>( to_str< wchar_t >(100) ), 100, (std::numeric_limits<T>::epsilon()) );
 #endif
         // Exception must not be thrown, when we are using no separators at all
-        BOOST_CHECK_CLOSE_FRACTION( lexical_cast<T>("30000"), static_cast<T>(30000), (std::numeric_limits<T>::epsilon()) );
+        BOOST_TEST_CLOSE_FRACTION( lexical_cast<T>("30000"), static_cast<T>(30000), (std::numeric_limits<T>::epsilon()) );
     }
 }
 
@@ -119,16 +97,16 @@ void test_conversion_from_to_float_for_locale()
 #ifndef BOOST_LCAST_NO_WCHAR_T
 #define CHECK_CLOSE_ABS_DIFF(VAL,PREFIX)                                                          \
     converted_val = lexical_cast<test_t>(#VAL);                                                   \
-    BOOST_CHECK_CLOSE_FRACTION( (static_cast<bool>(VAL ## L)? VAL ## L : std::numeric_limits<test_t>::epsilon()), \
+    BOOST_TEST_CLOSE_FRACTION( (static_cast<bool>(VAL ## L)? VAL ## L : std::numeric_limits<test_t>::epsilon()), \
                        (converted_val ? converted_val : std::numeric_limits<test_t>::epsilon()),  \
                        std::numeric_limits<test_t>::epsilon()                                     \
                      );                                                                           \
-    BOOST_CHECK_EQUAL(converted_val, lexical_cast<test_t>(L## #VAL) );
+    BOOST_TEST_EQ(converted_val, lexical_cast<test_t>(L## #VAL) );
 
 #else
 #define CHECK_CLOSE_ABS_DIFF(VAL,TYPE)                                                            \
     converted_val = lexical_cast<test_t>(#VAL);                                                   \
-    BOOST_CHECK_CLOSE_FRACTION( (static_cast<bool>(VAL ## L)? VAL ## L : std::numeric_limits<test_t>::epsilon()), \
+    BOOST_TEST_CLOSE_FRACTION( (static_cast<bool>(VAL ## L)? VAL ## L : std::numeric_limits<test_t>::epsilon()), \
                        (converted_val ? converted_val : std::numeric_limits<test_t>::epsilon()),  \
                        std::numeric_limits<test_t>::epsilon()                                     \
                      );
@@ -140,30 +118,30 @@ void test_converion_to_float_types()
     typedef TestType test_t;
     test_t converted_val;
 
-    BOOST_CHECK_CLOSE_FRACTION(1.0, lexical_cast<test_t>('1'), (std::numeric_limits<test_t>::epsilon()));
-    BOOST_CHECK_EQUAL(0.0, lexical_cast<test_t>('0'));
+    BOOST_TEST_CLOSE_FRACTION(1.0, lexical_cast<test_t>('1'), (std::numeric_limits<test_t>::epsilon()));
+    BOOST_TEST_EQ(0.0, lexical_cast<test_t>('0'));
 
     unsigned char const uc_one = '1';
     unsigned char const uc_zero ='0';
-    BOOST_CHECK_CLOSE_FRACTION(1.0, lexical_cast<test_t>(uc_one), (std::numeric_limits<test_t>::epsilon()));
-    BOOST_CHECK_EQUAL(0.0, lexical_cast<test_t>(uc_zero));
+    BOOST_TEST_CLOSE_FRACTION(1.0, lexical_cast<test_t>(uc_one), (std::numeric_limits<test_t>::epsilon()));
+    BOOST_TEST_EQ(0.0, lexical_cast<test_t>(uc_zero));
 
     signed char const sc_one = '1';
     signed char const sc_zero ='0';
-    BOOST_CHECK_CLOSE_FRACTION(1.0, lexical_cast<test_t>(sc_one), (std::numeric_limits<test_t>::epsilon()));
-    BOOST_CHECK_EQUAL(0.0, lexical_cast<test_t>(sc_zero));
+    BOOST_TEST_CLOSE_FRACTION(1.0, lexical_cast<test_t>(sc_one), (std::numeric_limits<test_t>::epsilon()));
+    BOOST_TEST_EQ(0.0, lexical_cast<test_t>(sc_zero));
 
-    BOOST_CHECK_CLOSE_FRACTION(1e34L, lexical_cast<test_t>( "10000000000000000000000000000000000"), (std::numeric_limits<test_t>::epsilon()) );
+    BOOST_TEST_CLOSE_FRACTION(1e34L, lexical_cast<test_t>( "10000000000000000000000000000000000"), (std::numeric_limits<test_t>::epsilon() * 1e34L) );
 
 //    VC failes the next test
-//    BOOST_CHECK_CLOSE_FRACTION(1e-35L, lexical_cast<test_t>("0.00000000000000000000000000000000001"), (std::numeric_limits<test_t>::epsilon()) );
-    BOOST_CHECK_CLOSE_FRACTION(
+//    BOOST_TEST_CLOSE_FRACTION(1e-35L, lexical_cast<test_t>("0.00000000000000000000000000000000001"), (std::numeric_limits<test_t>::epsilon()) );
+    BOOST_TEST_CLOSE_FRACTION(
                                     0.1111111111111111111111111111111111111111111111111111111111111111111111111L
             , lexical_cast<test_t>("0.1111111111111111111111111111111111111111111111111111111111111111111111111")
             , (std::numeric_limits<test_t>::epsilon()) );
 
     CHECK_CLOSE_ABS_DIFF(1,test_t);
-    BOOST_CHECK_EQUAL(0,lexical_cast<test_t>("0"));
+    BOOST_TEST_EQ(0,lexical_cast<test_t>("0"));
     CHECK_CLOSE_ABS_DIFF(-1,test_t);
 
     CHECK_CLOSE_ABS_DIFF(1.0, test_t);
@@ -250,45 +228,45 @@ void test_converion_to_float_types()
     CHECK_CLOSE_ABS_DIFF(.34, test_t);
     CHECK_CLOSE_ABS_DIFF(.34e10, test_t);
 
-    BOOST_CHECK_THROW(lexical_cast<test_t>("-1.e"), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<test_t>("-1.E"), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<test_t>("1.e"), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<test_t>("1.E"), bad_lexical_cast);
+    BOOST_TEST_THROWS(lexical_cast<test_t>("-1.e"), bad_lexical_cast);
+    BOOST_TEST_THROWS(lexical_cast<test_t>("-1.E"), bad_lexical_cast);
+    BOOST_TEST_THROWS(lexical_cast<test_t>("1.e"), bad_lexical_cast);
+    BOOST_TEST_THROWS(lexical_cast<test_t>("1.E"), bad_lexical_cast);
 
-    BOOST_CHECK_THROW(lexical_cast<test_t>("1.0e"), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<test_t>("1.0E"), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<test_t>("10E"), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<test_t>("10e"), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<test_t>("1.0e-"), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<test_t>("1.0E-"), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<test_t>("10E-"), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<test_t>("10e-"), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<test_t>("e1"), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<test_t>("e-1"), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<test_t>("e-"), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<test_t>(".e"), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<test_t>(".11111111111111111111111111111111111111111111111111111111111111111111ee"), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<test_t>(".11111111111111111111111111111111111111111111111111111111111111111111e-"), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<test_t>("."), bad_lexical_cast);
+    BOOST_TEST_THROWS(lexical_cast<test_t>("1.0e"), bad_lexical_cast);
+    BOOST_TEST_THROWS(lexical_cast<test_t>("1.0E"), bad_lexical_cast);
+    BOOST_TEST_THROWS(lexical_cast<test_t>("10E"), bad_lexical_cast);
+    BOOST_TEST_THROWS(lexical_cast<test_t>("10e"), bad_lexical_cast);
+    BOOST_TEST_THROWS(lexical_cast<test_t>("1.0e-"), bad_lexical_cast);
+    BOOST_TEST_THROWS(lexical_cast<test_t>("1.0E-"), bad_lexical_cast);
+    BOOST_TEST_THROWS(lexical_cast<test_t>("10E-"), bad_lexical_cast);
+    BOOST_TEST_THROWS(lexical_cast<test_t>("10e-"), bad_lexical_cast);
+    BOOST_TEST_THROWS(lexical_cast<test_t>("e1"), bad_lexical_cast);
+    BOOST_TEST_THROWS(lexical_cast<test_t>("e-1"), bad_lexical_cast);
+    BOOST_TEST_THROWS(lexical_cast<test_t>("e-"), bad_lexical_cast);
+    BOOST_TEST_THROWS(lexical_cast<test_t>(".e"), bad_lexical_cast);
+    BOOST_TEST_THROWS(lexical_cast<test_t>(".11111111111111111111111111111111111111111111111111111111111111111111ee"), bad_lexical_cast);
+    BOOST_TEST_THROWS(lexical_cast<test_t>(".11111111111111111111111111111111111111111111111111111111111111111111e-"), bad_lexical_cast);
+    BOOST_TEST_THROWS(lexical_cast<test_t>("."), bad_lexical_cast);
 
-    BOOST_CHECK_THROW(lexical_cast<test_t>("-B"), bad_lexical_cast);
+    BOOST_TEST_THROWS(lexical_cast<test_t>("-B"), 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_TEST_THROWS(lexical_cast<test_t>("0xB"), bad_lexical_cast);
+    //BOOST_TEST_THROWS(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);
-    BOOST_CHECK_THROW(lexical_cast<test_t>("1e1e1"), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<test_t>("1.0e-1e-1"), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<test_t>(" 1.0"), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<test_t>("1.0 "), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<test_t>(""), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<test_t>("-"), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<test_t>('\0'), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<test_t>('-'), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<test_t>('.'), bad_lexical_cast);
+    BOOST_TEST_THROWS(lexical_cast<test_t>("--1.0"), bad_lexical_cast);
+    BOOST_TEST_THROWS(lexical_cast<test_t>("1.0e--1"), bad_lexical_cast);
+    BOOST_TEST_THROWS(lexical_cast<test_t>("1.0.0"), bad_lexical_cast);
+    BOOST_TEST_THROWS(lexical_cast<test_t>("1e1e1"), bad_lexical_cast);
+    BOOST_TEST_THROWS(lexical_cast<test_t>("1.0e-1e-1"), bad_lexical_cast);
+    BOOST_TEST_THROWS(lexical_cast<test_t>(" 1.0"), bad_lexical_cast);
+    BOOST_TEST_THROWS(lexical_cast<test_t>("1.0 "), bad_lexical_cast);
+    BOOST_TEST_THROWS(lexical_cast<test_t>(""), bad_lexical_cast);
+    BOOST_TEST_THROWS(lexical_cast<test_t>("-"), bad_lexical_cast);
+    BOOST_TEST_THROWS(lexical_cast<test_t>('\0'), bad_lexical_cast);
+    BOOST_TEST_THROWS(lexical_cast<test_t>('-'), bad_lexical_cast);
+    BOOST_TEST_THROWS(lexical_cast<test_t>('.'), bad_lexical_cast);
 }
 
 template <class T>
@@ -297,29 +275,29 @@ void test_float_typess_for_overflows()
     typedef T test_t;
     test_t minvalue = (std::numeric_limits<test_t>::min)();
     std::string s_min_value = lexical_cast<std::string>(minvalue);
-    BOOST_CHECK_CLOSE_FRACTION(minvalue, lexical_cast<test_t>(minvalue), (std::numeric_limits<test_t>::epsilon()));
-    BOOST_CHECK_CLOSE_FRACTION(minvalue, lexical_cast<test_t>(s_min_value), (std::numeric_limits<test_t>::epsilon() * 2));
+    BOOST_TEST_CLOSE_FRACTION(minvalue, lexical_cast<test_t>(minvalue), (std::numeric_limits<test_t>::epsilon()));
+    BOOST_TEST_CLOSE_FRACTION(minvalue, lexical_cast<test_t>(s_min_value), (std::numeric_limits<test_t>::epsilon() * 2));
 
     test_t maxvalue = (std::numeric_limits<test_t>::max)();
     std::string s_max_value = lexical_cast<std::string>(maxvalue);
-    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()));
+    BOOST_TEST_CLOSE_FRACTION(maxvalue, lexical_cast<test_t>(maxvalue), (std::numeric_limits<test_t>::epsilon()));
+    BOOST_TEST_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);
+    BOOST_TEST_THROWS(lexical_cast<test_t>(s_max_value+"1"), bad_lexical_cast);
+    BOOST_TEST_THROWS(lexical_cast<test_t>(s_max_value+"9"), bad_lexical_cast);
 
     // 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);
+    BOOST_TEST_THROWS(lexical_cast<test_t>("1"+s_max_value), bad_lexical_cast);
+    BOOST_TEST_THROWS(lexical_cast<test_t>("9"+s_max_value), bad_lexical_cast);
 #endif
 
     if ( is_same<test_t,float>::value )
     {
-        BOOST_CHECK_THROW(lexical_cast<test_t>( (std::numeric_limits<double>::max)() ), bad_lexical_cast);
-        BOOST_CHECK(
+        BOOST_TEST_THROWS(lexical_cast<test_t>( (std::numeric_limits<double>::max)() ), bad_lexical_cast);
+        BOOST_TEST(
                 (std::numeric_limits<double>::min)() - std::numeric_limits<test_t>::epsilon()
                 <= lexical_cast<test_t>( (std::numeric_limits<double>::min)() )
                 && lexical_cast<test_t>( (std::numeric_limits<double>::min)() )
@@ -329,8 +307,8 @@ void test_float_typess_for_overflows()
 
     if ( sizeof(test_t) < sizeof(long double) )
     {
-        BOOST_CHECK_THROW(lexical_cast<test_t>( (std::numeric_limits<long double>::max)() ), bad_lexical_cast);
-        BOOST_CHECK(
+        BOOST_TEST_THROWS(lexical_cast<test_t>( (std::numeric_limits<long double>::max)() ), bad_lexical_cast);
+        BOOST_TEST(
                 (std::numeric_limits<long double>::min)() - std::numeric_limits<test_t>::epsilon()
                 <= lexical_cast<test_t>( (std::numeric_limits<long double>::min)() )
                 && lexical_cast<test_t>( (std::numeric_limits<long double>::min)() )
@@ -345,7 +323,7 @@ void test_float_typess_for_overflows()
 #define TEST_TO_FROM_CAST_AROUND_TYPED(VAL,STRING_TYPE)                             \
     test_value = VAL + std::numeric_limits<test_t>::epsilon() * i ;                 \
     converted_val = lexical_cast<test_t>( lexical_cast<STRING_TYPE>(test_value) );  \
-    BOOST_CHECK_CLOSE_FRACTION(                                                     \
+    BOOST_TEST_CLOSE_FRACTION(                                                     \
             test_value,                                                             \
             converted_val,                                                          \
             std::numeric_limits<test_t>::epsilon() * 2                              \
@@ -407,39 +385,39 @@ void test_converion_from_to_float_types()
 template<class T, class CharT>
 void test_conversion_from_float_to_char(CharT zero)
 {
-    BOOST_CHECK(lexical_cast<CharT>(static_cast<T>(0)) == zero + 0);
-    BOOST_CHECK(lexical_cast<CharT>(static_cast<T>(1)) == zero + 1);
-    BOOST_CHECK(lexical_cast<CharT>(static_cast<T>(2)) == zero + 2);
-    BOOST_CHECK(lexical_cast<CharT>(static_cast<T>(3)) == zero + 3);
-    BOOST_CHECK(lexical_cast<CharT>(static_cast<T>(4)) == zero + 4);
-    BOOST_CHECK(lexical_cast<CharT>(static_cast<T>(5)) == zero + 5);
-    BOOST_CHECK(lexical_cast<CharT>(static_cast<T>(6)) == zero + 6);
-    BOOST_CHECK(lexical_cast<CharT>(static_cast<T>(7)) == zero + 7);
-    BOOST_CHECK(lexical_cast<CharT>(static_cast<T>(8)) == zero + 8);
-    BOOST_CHECK(lexical_cast<CharT>(static_cast<T>(9)) == zero + 9);
+    BOOST_TEST(lexical_cast<CharT>(static_cast<T>(0)) == zero + 0);
+    BOOST_TEST(lexical_cast<CharT>(static_cast<T>(1)) == zero + 1);
+    BOOST_TEST(lexical_cast<CharT>(static_cast<T>(2)) == zero + 2);
+    BOOST_TEST(lexical_cast<CharT>(static_cast<T>(3)) == zero + 3);
+    BOOST_TEST(lexical_cast<CharT>(static_cast<T>(4)) == zero + 4);
+    BOOST_TEST(lexical_cast<CharT>(static_cast<T>(5)) == zero + 5);
+    BOOST_TEST(lexical_cast<CharT>(static_cast<T>(6)) == zero + 6);
+    BOOST_TEST(lexical_cast<CharT>(static_cast<T>(7)) == zero + 7);
+    BOOST_TEST(lexical_cast<CharT>(static_cast<T>(8)) == zero + 8);
+    BOOST_TEST(lexical_cast<CharT>(static_cast<T>(9)) == zero + 9);
 
-    BOOST_CHECK_THROW(lexical_cast<CharT>(static_cast<T>(10)), bad_lexical_cast);
+    BOOST_TEST_THROWS(lexical_cast<CharT>(static_cast<T>(10)), bad_lexical_cast);
 
     T t = (std::numeric_limits<T>::max)();
-    BOOST_CHECK_THROW(lexical_cast<CharT>(t), bad_lexical_cast);
+    BOOST_TEST_THROWS(lexical_cast<CharT>(t), bad_lexical_cast);
 }
 
 template<class T, class CharT>
 void test_conversion_from_char_to_float(CharT zero)
 {
-    BOOST_CHECK_CLOSE_FRACTION(lexical_cast<T>( static_cast<CharT>(zero + 0)), static_cast<T>(0), (std::numeric_limits<T>::epsilon()) );
-    BOOST_CHECK_CLOSE_FRACTION(lexical_cast<T>( static_cast<CharT>(zero + 1)), static_cast<T>(1), (std::numeric_limits<T>::epsilon()) );
-    BOOST_CHECK_CLOSE_FRACTION(lexical_cast<T>( static_cast<CharT>(zero + 2)), static_cast<T>(2), (std::numeric_limits<T>::epsilon()) );
-    BOOST_CHECK_CLOSE_FRACTION(lexical_cast<T>( static_cast<CharT>(zero + 3)), static_cast<T>(3), (std::numeric_limits<T>::epsilon()) );
-    BOOST_CHECK_CLOSE_FRACTION(lexical_cast<T>( static_cast<CharT>(zero + 4)), static_cast<T>(4), (std::numeric_limits<T>::epsilon()) );
-    BOOST_CHECK_CLOSE_FRACTION(lexical_cast<T>( static_cast<CharT>(zero + 5)), static_cast<T>(5), (std::numeric_limits<T>::epsilon()) );
-    BOOST_CHECK_CLOSE_FRACTION(lexical_cast<T>( static_cast<CharT>(zero + 6)), static_cast<T>(6), (std::numeric_limits<T>::epsilon()) );
-    BOOST_CHECK_CLOSE_FRACTION(lexical_cast<T>( static_cast<CharT>(zero + 7)), static_cast<T>(7), (std::numeric_limits<T>::epsilon()) );
-    BOOST_CHECK_CLOSE_FRACTION(lexical_cast<T>( static_cast<CharT>(zero + 8)), static_cast<T>(8), (std::numeric_limits<T>::epsilon()) );
-    BOOST_CHECK_CLOSE_FRACTION(lexical_cast<T>( static_cast<CharT>(zero + 9)), static_cast<T>(9), (std::numeric_limits<T>::epsilon()) );
+    BOOST_TEST_CLOSE_FRACTION(lexical_cast<T>( static_cast<CharT>(zero + 0)), static_cast<T>(0), (std::numeric_limits<T>::epsilon()) );
+    BOOST_TEST_CLOSE_FRACTION(lexical_cast<T>( static_cast<CharT>(zero + 1)), static_cast<T>(1), (std::numeric_limits<T>::epsilon()) );
+    BOOST_TEST_CLOSE_FRACTION(lexical_cast<T>( static_cast<CharT>(zero + 2)), static_cast<T>(2), (std::numeric_limits<T>::epsilon()) );
+    BOOST_TEST_CLOSE_FRACTION(lexical_cast<T>( static_cast<CharT>(zero + 3)), static_cast<T>(3), (std::numeric_limits<T>::epsilon()) );
+    BOOST_TEST_CLOSE_FRACTION(lexical_cast<T>( static_cast<CharT>(zero + 4)), static_cast<T>(4), (std::numeric_limits<T>::epsilon()) );
+    BOOST_TEST_CLOSE_FRACTION(lexical_cast<T>( static_cast<CharT>(zero + 5)), static_cast<T>(5), (std::numeric_limits<T>::epsilon()) );
+    BOOST_TEST_CLOSE_FRACTION(lexical_cast<T>( static_cast<CharT>(zero + 6)), static_cast<T>(6), (std::numeric_limits<T>::epsilon()) );
+    BOOST_TEST_CLOSE_FRACTION(lexical_cast<T>( static_cast<CharT>(zero + 7)), static_cast<T>(7), (std::numeric_limits<T>::epsilon()) );
+    BOOST_TEST_CLOSE_FRACTION(lexical_cast<T>( static_cast<CharT>(zero + 8)), static_cast<T>(8), (std::numeric_limits<T>::epsilon()) );
+    BOOST_TEST_CLOSE_FRACTION(lexical_cast<T>( static_cast<CharT>(zero + 9)), static_cast<T>(9), (std::numeric_limits<T>::epsilon()) );
 
-    BOOST_CHECK_THROW(lexical_cast<T>( static_cast<CharT>(zero + 10)), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<T>( static_cast<CharT>(zero - 1)), bad_lexical_cast);
+    BOOST_TEST_THROWS(lexical_cast<T>( static_cast<CharT>(zero + 10)), bad_lexical_cast);
+    BOOST_TEST_THROWS(lexical_cast<T>( static_cast<CharT>(zero - 1)), bad_lexical_cast);
 }
 
 struct restore_oldloc
@@ -465,13 +443,13 @@ void test_conversion_from_to_float()
     test_conversion_from_char_to_float<T>(wzero);
     #endif
 
-    BOOST_CHECK_CLOSE_FRACTION(lexical_cast<T>("+1"), 1, std::numeric_limits<T>::epsilon());
-    BOOST_CHECK_CLOSE_FRACTION(lexical_cast<T>("+9"), 9, std::numeric_limits<T>::epsilon());
+    BOOST_TEST_CLOSE_FRACTION(lexical_cast<T>("+1"), 1, std::numeric_limits<T>::epsilon());
+    BOOST_TEST_CLOSE_FRACTION(lexical_cast<T>("+9"), 9, std::numeric_limits<T>::epsilon());
 
-    BOOST_CHECK_THROW(lexical_cast<T>("++1"), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<T>("-+9"), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<T>("--1"), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<T>("+-9"), bad_lexical_cast);
+    BOOST_TEST_THROWS(lexical_cast<T>("++1"), bad_lexical_cast);
+    BOOST_TEST_THROWS(lexical_cast<T>("-+9"), bad_lexical_cast);
+    BOOST_TEST_THROWS(lexical_cast<T>("--1"), bad_lexical_cast);
+    BOOST_TEST_THROWS(lexical_cast<T>("+-9"), bad_lexical_cast);
 
     test_converion_to_float_types<T>();
     test_float_typess_for_overflows<T>();
@@ -499,14 +477,14 @@ void test_conversion_from_to_float()
     {
         std::string msg("Failed to set system locale: ");
         msg += ex.what();
-        BOOST_TEST_MESSAGE(msg);
+        std::cerr << msg;
     }
 
     if(grouping1 != grouping2)
         test_conversion_from_to_float_for_locale<T>();
 
     if(grouping1.empty() && grouping2.empty())
-        BOOST_TEST_MESSAGE("Formatting with thousands_sep has not been tested");
+        std::cerr << "Formatting with thousands_sep has not been tested";
 }
 
 
@@ -524,7 +502,7 @@ void test_conversion_from_to_long_double()
 #if !defined(BOOST_LEXICAL_CAST_NO_LONG_DOUBLE_MATH_FUNCTIONS)
     test_conversion_from_to_float<long double>();
 #endif
-    BOOST_CHECK(true);
+    BOOST_TEST(true);
 }
 
 
@@ -537,15 +515,26 @@ double make_volatile_float_roundtrip() {
 void test_volatile_floats()
 {
     // Inspired by test case from https://github.com/boostorg/lexical_cast/issues/50
-    BOOST_CHECK_EQUAL(make_volatile_float_roundtrip<float>(), 1.0);
-    BOOST_CHECK_EQUAL(make_volatile_float_roundtrip<double>(), 1.0);
+    BOOST_TEST_EQ(make_volatile_float_roundtrip<float>(), 1.0);
+    BOOST_TEST_EQ(make_volatile_float_roundtrip<double>(), 1.0);
 #if !defined(BOOST_LEXICAL_CAST_NO_LONG_DOUBLE_MATH_FUNCTIONS)
-    BOOST_CHECK_EQUAL(make_volatile_float_roundtrip<long double>(), 1.0);
+    BOOST_TEST_EQ(make_volatile_float_roundtrip<long double>(), 1.0);
 #endif
 
     volatile float v = 1.0;
-    BOOST_CHECK_EQUAL(boost::lexical_cast<float>(v), 1.0f);
+    BOOST_TEST_EQ(boost::lexical_cast<float>(v), 1.0f);
 #if !defined(BOOST_LEXICAL_CAST_NO_LONG_DOUBLE_MATH_FUNCTIONS)
-    BOOST_CHECK_EQUAL(boost::lexical_cast<long double>(v), 1.0);
+    BOOST_TEST_EQ(boost::lexical_cast<long double>(v), 1.0);
 #endif
 }
+
+
+int main()
+{
+    test_conversion_from_to_float();
+    test_conversion_from_to_double();
+    test_conversion_from_to_long_double();
+    test_volatile_floats();
+
+    return boost::report_errors();
+}
diff --git a/test/inf_nan_test.cpp b/test/inf_nan_test.cpp
index 4bc7dcd..edb6ac3 100644
--- a/test/inf_nan_test.cpp
+++ b/test/inf_nan_test.cpp
@@ -8,21 +8,12 @@
 //  Software License, Version 1.0. (See accompanying file
 //  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt).
 
-#include <boost/config.hpp>
-
-#if defined(__INTEL_COMPILER)
-#pragma warning(disable: 193 383 488 981 1418 1419)
-#elif defined(BOOST_MSVC)
-#pragma warning(disable: 4097 4100 4121 4127 4146 4244 4245 4511 4512 4701 4800)
-#endif
-
 #include <boost/lexical_cast.hpp>
 
-
 #include <boost/core/cmath.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <boost/test/unit_test.hpp>
-#include <boost/test/tools/floating_point_comparison.hpp>
+
+#include <boost/core/lightweight_test.hpp>
 
 #if defined(BOOST_NO_STRINGSTREAM) || defined(BOOST_NO_STD_WSTRING)
 #define BOOST_LCAST_NO_WCHAR_T
@@ -66,106 +57,106 @@ void test_inf_nan_templated()
 {
     typedef T test_t;
 
-    BOOST_CHECK( is_pos_inf( lexical_cast<test_t>("inf") ) );
-    BOOST_CHECK( is_pos_inf( lexical_cast<test_t>("INF") ) );
+    BOOST_TEST( is_pos_inf( lexical_cast<test_t>("inf") ) );
+    BOOST_TEST( is_pos_inf( lexical_cast<test_t>("INF") ) );
 
-    BOOST_CHECK( is_neg_inf( lexical_cast<test_t>("-inf") ) );
-    BOOST_CHECK( is_neg_inf( lexical_cast<test_t>("-INF") ) );
+    BOOST_TEST( is_neg_inf( lexical_cast<test_t>("-inf") ) );
+    BOOST_TEST( is_neg_inf( lexical_cast<test_t>("-INF") ) );
 
-    BOOST_CHECK( is_pos_inf( lexical_cast<test_t>("+inf") ) );
-    BOOST_CHECK( is_pos_inf( lexical_cast<test_t>("+INF") ) );
+    BOOST_TEST( is_pos_inf( lexical_cast<test_t>("+inf") ) );
+    BOOST_TEST( is_pos_inf( lexical_cast<test_t>("+INF") ) );
 
-    BOOST_CHECK( is_pos_inf( lexical_cast<test_t>("infinity") ) );
-    BOOST_CHECK( is_pos_inf( lexical_cast<test_t>("INFINITY") ) );
+    BOOST_TEST( is_pos_inf( lexical_cast<test_t>("infinity") ) );
+    BOOST_TEST( is_pos_inf( lexical_cast<test_t>("INFINITY") ) );
 
-    BOOST_CHECK( is_neg_inf( lexical_cast<test_t>("-infinity") ) );
-    BOOST_CHECK( is_neg_inf( lexical_cast<test_t>("-INFINITY") ) );
+    BOOST_TEST( is_neg_inf( lexical_cast<test_t>("-infinity") ) );
+    BOOST_TEST( is_neg_inf( lexical_cast<test_t>("-INFINITY") ) );
 
-    BOOST_CHECK( is_pos_inf( lexical_cast<test_t>("+infinity") ) );
-    BOOST_CHECK( is_pos_inf( lexical_cast<test_t>("+INFINITY") ) );
+    BOOST_TEST( is_pos_inf( lexical_cast<test_t>("+infinity") ) );
+    BOOST_TEST( is_pos_inf( lexical_cast<test_t>("+INFINITY") ) );
 
-    BOOST_CHECK( is_pos_inf( lexical_cast<test_t>("iNfiNity") ) );
-    BOOST_CHECK( is_pos_inf( lexical_cast<test_t>("INfinity") ) );
+    BOOST_TEST( is_pos_inf( lexical_cast<test_t>("iNfiNity") ) );
+    BOOST_TEST( is_pos_inf( lexical_cast<test_t>("INfinity") ) );
 
-    BOOST_CHECK( is_neg_inf( lexical_cast<test_t>("-inFINITY") ) );
-    BOOST_CHECK( is_neg_inf( lexical_cast<test_t>("-INFINITY") ) );
+    BOOST_TEST( is_neg_inf( lexical_cast<test_t>("-inFINITY") ) );
+    BOOST_TEST( is_neg_inf( lexical_cast<test_t>("-INFINITY") ) );
 
-    BOOST_CHECK( is_pos_nan( lexical_cast<test_t>("nan") ) );
-    BOOST_CHECK( is_pos_nan( lexical_cast<test_t>("NAN") ) );
+    BOOST_TEST( is_pos_nan( lexical_cast<test_t>("nan") ) );
+    BOOST_TEST( is_pos_nan( lexical_cast<test_t>("NAN") ) );
 
-    BOOST_CHECK( is_neg_nan( lexical_cast<test_t>("-nan") ) );
-    BOOST_CHECK( is_neg_nan( lexical_cast<test_t>("-NAN") ) );
+    BOOST_TEST( is_neg_nan( lexical_cast<test_t>("-nan") ) );
+    BOOST_TEST( is_neg_nan( lexical_cast<test_t>("-NAN") ) );
 
-    BOOST_CHECK( is_pos_nan( lexical_cast<test_t>("+nan") ) );
-    BOOST_CHECK( is_pos_nan( lexical_cast<test_t>("+NAN") ) );
+    BOOST_TEST( is_pos_nan( lexical_cast<test_t>("+nan") ) );
+    BOOST_TEST( is_pos_nan( lexical_cast<test_t>("+NAN") ) );
 
-    BOOST_CHECK( is_pos_nan( lexical_cast<test_t>("nAn") ) );
-    BOOST_CHECK( is_pos_nan( lexical_cast<test_t>("NaN") ) );
+    BOOST_TEST( is_pos_nan( lexical_cast<test_t>("nAn") ) );
+    BOOST_TEST( is_pos_nan( lexical_cast<test_t>("NaN") ) );
 
-    BOOST_CHECK( is_neg_nan( lexical_cast<test_t>("-nAn") ) );
-    BOOST_CHECK( is_neg_nan( lexical_cast<test_t>("-NaN") ) );
+    BOOST_TEST( is_neg_nan( lexical_cast<test_t>("-nAn") ) );
+    BOOST_TEST( is_neg_nan( lexical_cast<test_t>("-NaN") ) );
 
-    BOOST_CHECK( is_pos_nan( lexical_cast<test_t>("+Nan") ) );
-    BOOST_CHECK( is_pos_nan( lexical_cast<test_t>("+nAN") ) );
+    BOOST_TEST( is_pos_nan( lexical_cast<test_t>("+Nan") ) );
+    BOOST_TEST( is_pos_nan( lexical_cast<test_t>("+nAN") ) );
 
-    BOOST_CHECK( is_pos_nan( lexical_cast<test_t>("nan()") ) );
-    BOOST_CHECK( is_pos_nan( lexical_cast<test_t>("NAN(some string)") ) );
-    BOOST_CHECK_THROW( lexical_cast<test_t>("NAN(some string"), bad_lexical_cast );
+    BOOST_TEST( is_pos_nan( lexical_cast<test_t>("nan()") ) );
+    BOOST_TEST( is_pos_nan( lexical_cast<test_t>("NAN(some string)") ) );
+    BOOST_TEST_THROWS( lexical_cast<test_t>("NAN(some string"), bad_lexical_cast );
 
-    BOOST_CHECK(lexical_cast<std::string>( (boost::core::copysign)(std::numeric_limits<test_t >::infinity(), static_cast<test_t>(-1.0)))
+    BOOST_TEST(lexical_cast<std::string>( (boost::core::copysign)(std::numeric_limits<test_t >::infinity(), static_cast<test_t>(-1.0)))
                 == "-inf" );
-    BOOST_CHECK(lexical_cast<std::string>( std::numeric_limits<test_t >::infinity()) == "inf" );
-    BOOST_CHECK(lexical_cast<std::string>( std::numeric_limits<test_t >::quiet_NaN()) == "nan" );
+    BOOST_TEST(lexical_cast<std::string>( std::numeric_limits<test_t >::infinity()) == "inf" );
+    BOOST_TEST(lexical_cast<std::string>( std::numeric_limits<test_t >::quiet_NaN()) == "nan" );
 #if !defined(__ia64__) && !defined(_M_IA64)
-    BOOST_CHECK(lexical_cast<std::string>(
+    BOOST_TEST(lexical_cast<std::string>(
                 (boost::core::copysign)(std::numeric_limits<test_t >::quiet_NaN(), static_cast<test_t>(-1.0)))
                 == "-nan" );
 #endif
 
 #ifndef  BOOST_LCAST_NO_WCHAR_T
-    BOOST_CHECK( is_pos_inf( lexical_cast<test_t>(L"inf") ) );
-    BOOST_CHECK( is_pos_inf( lexical_cast<test_t>(L"INF") ) );
+    BOOST_TEST( is_pos_inf( lexical_cast<test_t>(L"inf") ) );
+    BOOST_TEST( is_pos_inf( lexical_cast<test_t>(L"INF") ) );
 
-    BOOST_CHECK( is_neg_inf( lexical_cast<test_t>(L"-inf") ) );
-    BOOST_CHECK( is_neg_inf( lexical_cast<test_t>(L"-INF") ) );
+    BOOST_TEST( is_neg_inf( lexical_cast<test_t>(L"-inf") ) );
+    BOOST_TEST( is_neg_inf( lexical_cast<test_t>(L"-INF") ) );
 
-    BOOST_CHECK( is_pos_inf( lexical_cast<test_t>(L"+inf") ) );
-    BOOST_CHECK( is_pos_inf( lexical_cast<test_t>(L"+INF") ) );
+    BOOST_TEST( is_pos_inf( lexical_cast<test_t>(L"+inf") ) );
+    BOOST_TEST( is_pos_inf( lexical_cast<test_t>(L"+INF") ) );
 
-    BOOST_CHECK( is_pos_inf( lexical_cast<test_t>(L"infinity") ) );
-    BOOST_CHECK( is_pos_inf( lexical_cast<test_t>(L"INFINITY") ) );
+    BOOST_TEST( is_pos_inf( lexical_cast<test_t>(L"infinity") ) );
+    BOOST_TEST( is_pos_inf( lexical_cast<test_t>(L"INFINITY") ) );
 
-    BOOST_CHECK( is_neg_inf( lexical_cast<test_t>(L"-infinity") ) );
-    BOOST_CHECK( is_neg_inf( lexical_cast<test_t>(L"-INFINITY") ) );
+    BOOST_TEST( is_neg_inf( lexical_cast<test_t>(L"-infinity") ) );
+    BOOST_TEST( is_neg_inf( lexical_cast<test_t>(L"-INFINITY") ) );
 
-    BOOST_CHECK( is_pos_inf( lexical_cast<test_t>(L"+infinity") ) );
-    BOOST_CHECK( is_pos_inf( lexical_cast<test_t>(L"+INFINITY") ) );
+    BOOST_TEST( is_pos_inf( lexical_cast<test_t>(L"+infinity") ) );
+    BOOST_TEST( is_pos_inf( lexical_cast<test_t>(L"+INFINITY") ) );
 
-    BOOST_CHECK( is_neg_inf( lexical_cast<test_t>(L"-infINIty") ) );
-    BOOST_CHECK( is_neg_inf( lexical_cast<test_t>(L"-INFiniTY") ) );
+    BOOST_TEST( is_neg_inf( lexical_cast<test_t>(L"-infINIty") ) );
+    BOOST_TEST( is_neg_inf( lexical_cast<test_t>(L"-INFiniTY") ) );
 
-    BOOST_CHECK( is_pos_inf( lexical_cast<test_t>(L"+inFINIty") ) );
-    BOOST_CHECK( is_pos_inf( lexical_cast<test_t>(L"+INfinITY") ) );
+    BOOST_TEST( is_pos_inf( lexical_cast<test_t>(L"+inFINIty") ) );
+    BOOST_TEST( is_pos_inf( lexical_cast<test_t>(L"+INfinITY") ) );
 
-    BOOST_CHECK( is_pos_nan( lexical_cast<test_t>(L"nan") ) );
-    BOOST_CHECK( is_pos_nan( lexical_cast<test_t>(L"NAN") ) );
+    BOOST_TEST( is_pos_nan( lexical_cast<test_t>(L"nan") ) );
+    BOOST_TEST( is_pos_nan( lexical_cast<test_t>(L"NAN") ) );
 
-    BOOST_CHECK( is_neg_nan( lexical_cast<test_t>(L"-nan") ) );
-    BOOST_CHECK( is_neg_nan( lexical_cast<test_t>(L"-NAN") ) );
+    BOOST_TEST( is_neg_nan( lexical_cast<test_t>(L"-nan") ) );
+    BOOST_TEST( is_neg_nan( lexical_cast<test_t>(L"-NAN") ) );
 
-    BOOST_CHECK( is_pos_nan( lexical_cast<test_t>(L"+nan") ) );
-    BOOST_CHECK( is_pos_nan( lexical_cast<test_t>(L"+NAN") ) );
+    BOOST_TEST( is_pos_nan( lexical_cast<test_t>(L"+nan") ) );
+    BOOST_TEST( is_pos_nan( lexical_cast<test_t>(L"+NAN") ) );
 
-    BOOST_CHECK( is_pos_nan( lexical_cast<test_t>(L"nan()") ) );
-    BOOST_CHECK( is_pos_nan( lexical_cast<test_t>(L"NAN(some string)") ) );
-    BOOST_CHECK_THROW( lexical_cast<test_t>(L"NAN(some string"), bad_lexical_cast );
+    BOOST_TEST( is_pos_nan( lexical_cast<test_t>(L"nan()") ) );
+    BOOST_TEST( is_pos_nan( lexical_cast<test_t>(L"NAN(some string)") ) );
+    BOOST_TEST_THROWS( lexical_cast<test_t>(L"NAN(some string"), bad_lexical_cast );
 
-    BOOST_CHECK(lexical_cast<std::wstring>( (boost::core::copysign)(std::numeric_limits<test_t >::infinity(), static_cast<test_t>(-1.0)))
+    BOOST_TEST(lexical_cast<std::wstring>( (boost::core::copysign)(std::numeric_limits<test_t >::infinity(), static_cast<test_t>(-1.0)))
                 == L"-inf" );
-    BOOST_CHECK(lexical_cast<std::wstring>( std::numeric_limits<test_t >::infinity()) == L"inf" );
-    BOOST_CHECK(lexical_cast<std::wstring>( std::numeric_limits<test_t >::quiet_NaN()) == L"nan" );
+    BOOST_TEST(lexical_cast<std::wstring>( std::numeric_limits<test_t >::infinity()) == L"inf" );
+    BOOST_TEST(lexical_cast<std::wstring>( std::numeric_limits<test_t >::quiet_NaN()) == L"nan" );
 #if !defined(__ia64__) && !defined(_M_IA64)
-    BOOST_CHECK(lexical_cast<std::wstring>(
+    BOOST_TEST(lexical_cast<std::wstring>(
                 (boost::core::copysign)(std::numeric_limits<test_t >::quiet_NaN(), static_cast<test_t>(-1.0)))
                 == L"-nan" );
 #endif
@@ -189,16 +180,14 @@ void test_inf_nan_long_double()
 #ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
     test_inf_nan_templated<long double >();
 #endif
-    BOOST_CHECK(true);
+    BOOST_TEST(true);
 }
 
-unit_test::test_suite *init_unit_test_suite(int, char *[])
+int main()
 {
-    unit_test::test_suite *suite =
-        BOOST_TEST_SUITE("lexical_cast inf anf nan parsing unit test");
-    suite->add(BOOST_TEST_CASE(&test_inf_nan_float));
-    suite->add(BOOST_TEST_CASE(&test_inf_nan_double));
-    suite->add(BOOST_TEST_CASE(&test_inf_nan_long_double));
+    test_inf_nan_float();
+    test_inf_nan_double();
+    test_inf_nan_long_double();
 
-    return suite;
+    return boost::report_errors();
 }
diff --git a/test/integral_types_test.cpp b/test/integral_types_test.cpp
index f31c1be..de6acb3 100644
--- a/test/integral_types_test.cpp
+++ b/test/integral_types_test.cpp
@@ -19,19 +19,11 @@
 //
 #define _SCL_SECURE_NO_WARNINGS
 
-#include <boost/config.hpp>
-
-#if defined(__INTEL_COMPILER)
-#pragma warning(disable: 193 383 488 981 1418 1419)
-#elif defined(BOOST_MSVC)
-#pragma warning(disable: 4097 4100 4121 4127 4146 4244 4245 4511 4512 4701 4800)
-#endif
-
 #include <boost/lexical_cast.hpp>
 
 #include <boost/cstdint.hpp>
-#include <boost/test/unit_test.hpp>
-#include <boost/test/tools/floating_point_comparison.hpp>
+
+#include <boost/core/lightweight_test.hpp>
 
 #include <boost/type_traits/integral_promotion.hpp>
 #include <boost/type_traits/make_unsigned.hpp>
@@ -61,113 +53,65 @@ 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();
-void test_conversion_from_to_uint();
-void test_conversion_from_to_long();
-void test_conversion_from_to_ulong();
-void test_conversion_from_to_intmax_t();
-void test_conversion_from_to_uintmax_t();
-#ifdef LCAST_TEST_LONGLONG
-void test_conversion_from_to_longlong();
-void test_conversion_from_to_ulonglong();
-#endif
-#ifdef BOOST_LCAST_TEST_128
-void test_conversion_from_to_int128();
-void test_conversion_from_to_uint128();
-#endif
-void test_integral_conversions_on_min_max();
-void test_volatile_integers();
-
-unit_test::test_suite *init_unit_test_suite(int, char *[])
-{
-    unit_test::test_suite *suite =
-        BOOST_TEST_SUITE("lexical_cast unit test on integral types");
-
-    suite->add(BOOST_TEST_CASE(&test_conversion_from_to_short));
-    suite->add(BOOST_TEST_CASE(&test_conversion_from_to_ushort));
-    suite->add(BOOST_TEST_CASE(&test_conversion_from_to_int));
-    suite->add(BOOST_TEST_CASE(&test_conversion_from_to_uint));
-    suite->add(BOOST_TEST_CASE(&test_conversion_from_to_long));
-    suite->add(BOOST_TEST_CASE(&test_conversion_from_to_ulong));
-    suite->add(BOOST_TEST_CASE(&test_conversion_from_to_intmax_t));
-    suite->add(BOOST_TEST_CASE(&test_conversion_from_to_uintmax_t));
-#ifdef LCAST_TEST_LONGLONG
-    suite->add(BOOST_TEST_CASE(&test_conversion_from_to_longlong));
-    suite->add(BOOST_TEST_CASE(&test_conversion_from_to_ulonglong));
-#endif
-#ifdef BOOST_LCAST_TEST_128
-    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));
-    suite->add(BOOST_TEST_CASE(&test_volatile_integers));
-
-    return suite;
-}
-
 template<class T, class CharT>
 void test_conversion_from_integral_to_char(CharT zero)
 {
-    BOOST_CHECK(lexical_cast<CharT>(static_cast<T>(0)) == zero + 0);
-    BOOST_CHECK(lexical_cast<CharT>(static_cast<T>(1)) == zero + 1);
-    BOOST_CHECK(lexical_cast<CharT>(static_cast<T>(2)) == zero + 2);
-    BOOST_CHECK(lexical_cast<CharT>(static_cast<T>(3)) == zero + 3);
-    BOOST_CHECK(lexical_cast<CharT>(static_cast<T>(4)) == zero + 4);
-    BOOST_CHECK(lexical_cast<CharT>(static_cast<T>(5)) == zero + 5);
-    BOOST_CHECK(lexical_cast<CharT>(static_cast<T>(6)) == zero + 6);
-    BOOST_CHECK(lexical_cast<CharT>(static_cast<T>(7)) == zero + 7);
-    BOOST_CHECK(lexical_cast<CharT>(static_cast<T>(8)) == zero + 8);
-    BOOST_CHECK(lexical_cast<CharT>(static_cast<T>(9)) == zero + 9);
+    BOOST_TEST(lexical_cast<CharT>(static_cast<T>(0)) == zero + 0);
+    BOOST_TEST(lexical_cast<CharT>(static_cast<T>(1)) == zero + 1);
+    BOOST_TEST(lexical_cast<CharT>(static_cast<T>(2)) == zero + 2);
+    BOOST_TEST(lexical_cast<CharT>(static_cast<T>(3)) == zero + 3);
+    BOOST_TEST(lexical_cast<CharT>(static_cast<T>(4)) == zero + 4);
+    BOOST_TEST(lexical_cast<CharT>(static_cast<T>(5)) == zero + 5);
+    BOOST_TEST(lexical_cast<CharT>(static_cast<T>(6)) == zero + 6);
+    BOOST_TEST(lexical_cast<CharT>(static_cast<T>(7)) == zero + 7);
+    BOOST_TEST(lexical_cast<CharT>(static_cast<T>(8)) == zero + 8);
+    BOOST_TEST(lexical_cast<CharT>(static_cast<T>(9)) == zero + 9);
 
-    BOOST_CHECK_THROW(lexical_cast<CharT>(static_cast<T>(10)), bad_lexical_cast);
+    BOOST_TEST_THROWS(lexical_cast<CharT>(static_cast<T>(10)), bad_lexical_cast);
 
     T t = (std::numeric_limits<T>::max)();
-    BOOST_CHECK_THROW(lexical_cast<CharT>(t), bad_lexical_cast);
+    BOOST_TEST_THROWS(lexical_cast<CharT>(t), bad_lexical_cast);
 }
 
 template<class T, class CharT>
 void test_conversion_from_char_to_integral(CharT zero)
 {
-    BOOST_CHECK(lexical_cast<T>( static_cast<CharT>(zero + 0)) == static_cast<T>(0) );
-    BOOST_CHECK(lexical_cast<T>( static_cast<CharT>(zero + 1)) == static_cast<T>(1) );
-    BOOST_CHECK(lexical_cast<T>( static_cast<CharT>(zero + 2)) == static_cast<T>(2) );
-    BOOST_CHECK(lexical_cast<T>( static_cast<CharT>(zero + 3)) == static_cast<T>(3) );
-    BOOST_CHECK(lexical_cast<T>( static_cast<CharT>(zero + 4)) == static_cast<T>(4) );
-    BOOST_CHECK(lexical_cast<T>( static_cast<CharT>(zero + 5)) == static_cast<T>(5) );
-    BOOST_CHECK(lexical_cast<T>( static_cast<CharT>(zero + 6)) == static_cast<T>(6) );
-    BOOST_CHECK(lexical_cast<T>( static_cast<CharT>(zero + 7)) == static_cast<T>(7) );
-    BOOST_CHECK(lexical_cast<T>( static_cast<CharT>(zero + 8)) == static_cast<T>(8) );
-    BOOST_CHECK(lexical_cast<T>( static_cast<CharT>(zero + 9)) == static_cast<T>(9) );
+    BOOST_TEST(lexical_cast<T>( static_cast<CharT>(zero + 0)) == static_cast<T>(0) );
+    BOOST_TEST(lexical_cast<T>( static_cast<CharT>(zero + 1)) == static_cast<T>(1) );
+    BOOST_TEST(lexical_cast<T>( static_cast<CharT>(zero + 2)) == static_cast<T>(2) );
+    BOOST_TEST(lexical_cast<T>( static_cast<CharT>(zero + 3)) == static_cast<T>(3) );
+    BOOST_TEST(lexical_cast<T>( static_cast<CharT>(zero + 4)) == static_cast<T>(4) );
+    BOOST_TEST(lexical_cast<T>( static_cast<CharT>(zero + 5)) == static_cast<T>(5) );
+    BOOST_TEST(lexical_cast<T>( static_cast<CharT>(zero + 6)) == static_cast<T>(6) );
+    BOOST_TEST(lexical_cast<T>( static_cast<CharT>(zero + 7)) == static_cast<T>(7) );
+    BOOST_TEST(lexical_cast<T>( static_cast<CharT>(zero + 8)) == static_cast<T>(8) );
+    BOOST_TEST(lexical_cast<T>( static_cast<CharT>(zero + 9)) == static_cast<T>(9) );
 
-    BOOST_CHECK_THROW(lexical_cast<T>( static_cast<CharT>(zero + 10)), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<T>( static_cast<CharT>(zero - 1)), bad_lexical_cast);
+    BOOST_TEST_THROWS(lexical_cast<T>( static_cast<CharT>(zero + 10)), bad_lexical_cast);
+    BOOST_TEST_THROWS(lexical_cast<T>( static_cast<CharT>(zero - 1)), bad_lexical_cast);
 }
 
 template<class T>
 void test_conversion_from_integral_to_integral()
 {
     T t = 0;
-    BOOST_CHECK(lexical_cast<T>(t) == t);
+    BOOST_TEST(lexical_cast<T>(t) == t);
 
     // Next two variables are used to suppress warnings.
     int st = 32767; unsigned int ut = st;
     t = st;
-    BOOST_CHECK(lexical_cast<short>(t) == st);
-    BOOST_CHECK(lexical_cast<unsigned short>(t) == ut);
-    BOOST_CHECK(lexical_cast<int>(t) == st);
-    BOOST_CHECK(lexical_cast<unsigned int>(t) == ut);
-    BOOST_CHECK(lexical_cast<long>(t) == st);
-    BOOST_CHECK(lexical_cast<unsigned long>(t) == ut);
+    BOOST_TEST(lexical_cast<short>(t) == st);
+    BOOST_TEST(lexical_cast<unsigned short>(t) == ut);
+    BOOST_TEST(lexical_cast<int>(t) == st);
+    BOOST_TEST(lexical_cast<unsigned int>(t) == ut);
+    BOOST_TEST(lexical_cast<long>(t) == st);
+    BOOST_TEST(lexical_cast<unsigned long>(t) == ut);
 
     t = (std::numeric_limits<T>::max)();
-    BOOST_CHECK(lexical_cast<T>(t) == t);
+    BOOST_TEST(lexical_cast<T>(t) == t);
 
     t = (std::numeric_limits<T>::min)();
-    BOOST_CHECK(lexical_cast<T>(t) == t);
+    BOOST_TEST(lexical_cast<T>(t) == t);
 }
 
 
@@ -212,15 +156,15 @@ void test_conversion_from_integral_to_string(CharT)
     T t;
 
     t = (limits::min)();
-    BOOST_CHECK(lexical_cast<string_type>(t) == to_str<CharT>(t));
+    BOOST_TEST(lexical_cast<string_type>(t) == to_str<CharT>(t));
 
     t = (limits::max)();
-    BOOST_CHECK(lexical_cast<string_type>(t) == to_str<CharT>(t));
+    BOOST_TEST(lexical_cast<string_type>(t) == to_str<CharT>(t));
 
     if(limits::digits <= 16 && lcast_test_small_integral_types_completely)
         // min and max have already been tested.
         for(t = 1 + (limits::min)(); t != (limits::max)(); ++t)
-            BOOST_CHECK(lexical_cast<string_type>(t) == to_str<CharT>(t));
+            BOOST_TEST(lexical_cast<string_type>(t) == to_str<CharT>(t));
     else
     {
         T const min_val = (limits::min)();
@@ -234,17 +178,17 @@ void test_conversion_from_integral_to_string(CharT)
         // Test values around min:
         t = min_val;
         for(i = 0; i < counter; ++i, ++t)
-            BOOST_CHECK(lexical_cast<string_type>(t) == to_str<CharT>(t));
+            BOOST_TEST(lexical_cast<string_type>(t) == to_str<CharT>(t));
 
         // Test values around max:
         t = max_val;
         for(i = 0; i < counter; ++i, --t)
-            BOOST_CHECK(lexical_cast<string_type>(t) == to_str<CharT>(t));
+            BOOST_TEST(lexical_cast<string_type>(t) == to_str<CharT>(t));
 
         // Test values around zero:
         if(limits::is_signed)
             for(t = static_cast<T>(-counter); t < static_cast<T>(counter); ++t)
-                BOOST_CHECK(lexical_cast<string_type>(t) == to_str<CharT>(t));
+                BOOST_TEST(lexical_cast<string_type>(t) == to_str<CharT>(t));
 
         // Test values around 100, 1000, 10000, ...
         T ten_power = 100;
@@ -252,7 +196,7 @@ void test_conversion_from_integral_to_string(CharT)
         {
             // ten_power + 100 probably never overflows
             for(t = ten_power - 100; t != ten_power + 100; ++t)
-                BOOST_CHECK(lexical_cast<string_type>(t) == to_str<CharT>(t));
+                BOOST_TEST(lexical_cast<string_type>(t) == to_str<CharT>(t));
         }
     }
 }
@@ -270,23 +214,23 @@ void test_conversion_from_string_to_integral(CharT)
     T const max_val = (limits::max)();
 
     s = to_str<CharT>(min_val);
-    BOOST_CHECK_EQUAL(lexical_cast<T>(s), min_val);
+    BOOST_TEST_EQ(lexical_cast<T>(s), min_val);
     if(limits::is_signed)
     {
-        BOOST_CHECK_THROW(lexical_cast<T>(s + zero), bad_lexical_cast);
-        BOOST_CHECK_THROW(lexical_cast<T>(s + nine), bad_lexical_cast);
+        BOOST_TEST_THROWS(lexical_cast<T>(s + zero), bad_lexical_cast);
+        BOOST_TEST_THROWS(lexical_cast<T>(s + nine), bad_lexical_cast);
     }
 
     s = to_str<CharT>(max_val);
-    BOOST_CHECK_EQUAL(lexical_cast<T>(s), max_val);
+    BOOST_TEST_EQ(lexical_cast<T>(s), max_val);
     {
-        BOOST_CHECK_THROW(lexical_cast<T>(s + zero), bad_lexical_cast);
-        BOOST_CHECK_THROW(lexical_cast<T>(s + nine), bad_lexical_cast);
+        BOOST_TEST_THROWS(lexical_cast<T>(s + zero), bad_lexical_cast);
+        BOOST_TEST_THROWS(lexical_cast<T>(s + nine), bad_lexical_cast);
 
         s = to_str<CharT>(max_val);
         for (int i =1; i <=10; ++i) {
             s[s.size()-1] += 1;
-            BOOST_CHECK_THROW(lexical_cast<T>( s ), bad_lexical_cast);
+            BOOST_TEST_THROWS(lexical_cast<T>( s ), bad_lexical_cast);
         }
 
         s = to_str<CharT>(max_val);
@@ -294,23 +238,23 @@ void test_conversion_from_string_to_integral(CharT)
         typedef std::numpunct<char> numpunct;
         if ( BOOST_USE_FACET(numpunct, loc).grouping().empty() ) {
             // Following tests work well for locale C
-            BOOST_CHECK_EQUAL(lexical_cast<T>(to_str<CharT>(0)+s), max_val);
-            BOOST_CHECK_EQUAL(lexical_cast<T>(to_str<CharT>(0)+to_str<CharT>(0)+s), max_val);
-            BOOST_CHECK_EQUAL(lexical_cast<T>(to_str<CharT>(0)+to_str<CharT>(0)+to_str<CharT>(0)+s), max_val);
+            BOOST_TEST_EQ(lexical_cast<T>(to_str<CharT>(0)+s), max_val);
+            BOOST_TEST_EQ(lexical_cast<T>(to_str<CharT>(0)+to_str<CharT>(0)+s), max_val);
+            BOOST_TEST_EQ(lexical_cast<T>(to_str<CharT>(0)+to_str<CharT>(0)+to_str<CharT>(0)+s), max_val);
         }
 
         for (int i =1; i <=256; ++i) {
-            BOOST_CHECK_THROW(lexical_cast<T>( to_str<CharT>(i)+s ), bad_lexical_cast);
+            BOOST_TEST_THROWS(lexical_cast<T>( to_str<CharT>(i)+s ), bad_lexical_cast);
         }
 
-        typedef BOOST_DEDUCED_TYPENAME boost::integral_promotion<T>::type promoted;
+        typedef typename boost::integral_promotion<T>::type promoted;
         if ( !(boost::is_same<T, promoted>::value) )
         {
             promoted prom = max_val;
             s = to_str<CharT>(max_val);
             for (int i =1; i <=256; ++i) {
-                BOOST_CHECK_THROW(lexical_cast<T>( to_str<CharT>(prom+i) ), bad_lexical_cast);
-                BOOST_CHECK_THROW(lexical_cast<T>( to_str<CharT>(i)+s ), bad_lexical_cast);
+                BOOST_TEST_THROWS(lexical_cast<T>( to_str<CharT>(prom+i) ), bad_lexical_cast);
+                BOOST_TEST_THROWS(lexical_cast<T>( to_str<CharT>(i)+s ), bad_lexical_cast);
             }
         }
     }
@@ -318,7 +262,7 @@ void test_conversion_from_string_to_integral(CharT)
     if(limits::digits <= 16 && lcast_test_small_integral_types_completely)
         // min and max have already been tested.
         for(T t = 1 + min_val; t != max_val; ++t)
-            BOOST_CHECK(lexical_cast<T>(to_str<CharT>(t)) == t);
+            BOOST_TEST(lexical_cast<T>(to_str<CharT>(t)) == t);
     else
     {
         T const half_max_val = max_val / 2;
@@ -331,17 +275,17 @@ void test_conversion_from_string_to_integral(CharT)
         // Test values around min:
         t = min_val;
         for(i = 0; i < counter; ++i, ++t)
-            BOOST_CHECK(lexical_cast<T>(to_str<CharT>(t)) == t);
+            BOOST_TEST(lexical_cast<T>(to_str<CharT>(t)) == t);
 
         // Test values around max:
         t = max_val;
         for(i = 0; i < counter; ++i, --t)
-            BOOST_CHECK(lexical_cast<T>(to_str<CharT>(t)) == t);
+            BOOST_TEST(lexical_cast<T>(to_str<CharT>(t)) == t);
 
         // Test values around zero:
         if(limits::is_signed)
             for(t = static_cast<T>(-counter); t < static_cast<T>(counter); ++t)
-                BOOST_CHECK(lexical_cast<T>(to_str<CharT>(t)) == t);
+                BOOST_TEST(lexical_cast<T>(to_str<CharT>(t)) == t);
 
         // Test values around 100, 1000, 10000, ...
         T ten_power = 100;
@@ -349,7 +293,7 @@ void test_conversion_from_string_to_integral(CharT)
         {
             // ten_power + 100 probably never overflows
             for(t = ten_power - 100; t != ten_power + 100; ++t)
-                BOOST_CHECK(lexical_cast<T>(to_str<CharT>(t)) == t);
+                BOOST_TEST(lexical_cast<T>(to_str<CharT>(t)) == t);
         }
     }
 }
@@ -362,26 +306,26 @@ void test_conversion_from_to_integral_for_locale()
     numpunct const& np = BOOST_USE_FACET(numpunct, current_locale);
     if ( !np.grouping().empty() )
     {
-        BOOST_CHECK_THROW(
+        BOOST_TEST_THROWS(
                 lexical_cast<T>( std::string("100") + np.thousands_sep() + np.thousands_sep() + "0" )
                 , bad_lexical_cast);
-        BOOST_CHECK_THROW(lexical_cast<T>( std::string("100") + np.thousands_sep() ), bad_lexical_cast);
-        BOOST_CHECK_THROW(lexical_cast<T>( np.thousands_sep() + std::string("100") ), bad_lexical_cast);
+        BOOST_TEST_THROWS(lexical_cast<T>( std::string("100") + np.thousands_sep() ), bad_lexical_cast);
+        BOOST_TEST_THROWS(lexical_cast<T>( np.thousands_sep() + std::string("100") ), bad_lexical_cast);
 
         // Exception must not be thrown, when we are using no separators at all
-        BOOST_CHECK( lexical_cast<T>("30000") == static_cast<T>(30000) );
+        BOOST_TEST( lexical_cast<T>("30000") == static_cast<T>(30000) );
     }
 
 
     test_conversion_from_integral_to_integral<T>();
 
     // This is a part of test_conversion_from_integral_to_string<T>('0') method,
-    // but with BOOST_CHECK_EQUAL instead of BOOST_CHECK. It is required to see
+    // but with BOOST_TEST_EQ instead of BOOST_TEST. It is required to see
     // what is produced by the to_str<char>(t) method in situations when result
-    // is different. BOOST_CHECK does not work with wchar_t.
+    // is different. BOOST_TEST does not work with wchar_t.
     typedef std::numeric_limits<T> limits;
     T t = (limits::min)();
-    BOOST_CHECK_EQUAL(lexical_cast<std::string>(t), to_str<char>(t));
+    BOOST_TEST_EQ(lexical_cast<std::string>(t), to_str<char>(t));
 
     test_conversion_from_integral_to_string<T>('0');
     test_conversion_from_string_to_integral<T>('0');
@@ -397,9 +341,9 @@ void test_conversion_from_to_integral_for_locale()
             str.push_back(static_cast<char>(wstr[i]));
         }
 
-        BOOST_CHECK_EQUAL(lcast_str.length(), lexical_cast<std::wstring>(t).length());
-        BOOST_CHECK_EQUAL(to_str<char>(t), str);
-        BOOST_CHECK_EQUAL(lcast_str, str);
+        BOOST_TEST_EQ(lcast_str.length(), lexical_cast<std::wstring>(t).length());
+        BOOST_TEST_EQ(to_str<char>(t), str);
+        BOOST_TEST_EQ(lcast_str, str);
     }
 
     test_conversion_from_integral_to_string<T>(L'0');
@@ -441,41 +385,41 @@ void test_conversion_from_to_integral_minimal()
     test_conversion_from_char_to_integral<T>(u32zero);
 #endif
 
-    BOOST_CHECK(lexical_cast<T>("-1") == static_cast<T>(-1));
-    BOOST_CHECK(lexical_cast<T>("-9") == static_cast<T>(-9));
-    BOOST_CHECK(lexical_cast<T>(-1) == static_cast<T>(-1));
-    BOOST_CHECK(lexical_cast<T>(-9) == static_cast<T>(-9));
+    BOOST_TEST(lexical_cast<T>("-1") == static_cast<T>(-1));
+    BOOST_TEST(lexical_cast<T>("-9") == static_cast<T>(-9));
+    BOOST_TEST(lexical_cast<T>(-1) == static_cast<T>(-1));
+    BOOST_TEST(lexical_cast<T>(-9) == static_cast<T>(-9));
 
-    BOOST_CHECK_THROW(lexical_cast<T>("-1.0"), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<T>("-9.0"), bad_lexical_cast);
-    BOOST_CHECK(lexical_cast<T>(-1.0) == static_cast<T>(-1));
-    BOOST_CHECK(lexical_cast<T>(-9.0) == static_cast<T>(-9));
+    BOOST_TEST_THROWS(lexical_cast<T>("-1.0"), bad_lexical_cast);
+    BOOST_TEST_THROWS(lexical_cast<T>("-9.0"), bad_lexical_cast);
+    BOOST_TEST(lexical_cast<T>(-1.0) == static_cast<T>(-1));
+    BOOST_TEST(lexical_cast<T>(-9.0) == static_cast<T>(-9));
 
-    BOOST_CHECK(lexical_cast<T>(static_cast<T>(1)) == static_cast<T>(1));
-    BOOST_CHECK(lexical_cast<T>(static_cast<T>(9)) == static_cast<T>(9));
-    BOOST_CHECK_THROW(lexical_cast<T>(1.1f), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<T>(1.1), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<T>(1.1L), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<T>(1.0001f), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<T>(1.0001), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<T>(1.0001L), bad_lexical_cast);
+    BOOST_TEST(lexical_cast<T>(static_cast<T>(1)) == static_cast<T>(1));
+    BOOST_TEST(lexical_cast<T>(static_cast<T>(9)) == static_cast<T>(9));
+    BOOST_TEST_THROWS(lexical_cast<T>(1.1f), bad_lexical_cast);
+    BOOST_TEST_THROWS(lexical_cast<T>(1.1), bad_lexical_cast);
+    BOOST_TEST_THROWS(lexical_cast<T>(1.1L), bad_lexical_cast);
+    BOOST_TEST_THROWS(lexical_cast<T>(1.0001f), bad_lexical_cast);
+    BOOST_TEST_THROWS(lexical_cast<T>(1.0001), bad_lexical_cast);
+    BOOST_TEST_THROWS(lexical_cast<T>(1.0001L), bad_lexical_cast);
 
-    BOOST_CHECK(lexical_cast<T>("+1") == static_cast<T>(1) );
-    BOOST_CHECK(lexical_cast<T>("+9") == static_cast<T>(9) );
-    BOOST_CHECK(lexical_cast<T>("+10") == static_cast<T>(10) );
-    BOOST_CHECK(lexical_cast<T>("+90") == static_cast<T>(90) );
-    BOOST_CHECK_THROW(lexical_cast<T>("++1"), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<T>("-+9"), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<T>("--1"), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<T>("+-9"), bad_lexical_cast);
+    BOOST_TEST(lexical_cast<T>("+1") == static_cast<T>(1) );
+    BOOST_TEST(lexical_cast<T>("+9") == static_cast<T>(9) );
+    BOOST_TEST(lexical_cast<T>("+10") == static_cast<T>(10) );
+    BOOST_TEST(lexical_cast<T>("+90") == static_cast<T>(90) );
+    BOOST_TEST_THROWS(lexical_cast<T>("++1"), bad_lexical_cast);
+    BOOST_TEST_THROWS(lexical_cast<T>("-+9"), bad_lexical_cast);
+    BOOST_TEST_THROWS(lexical_cast<T>("--1"), bad_lexical_cast);
+    BOOST_TEST_THROWS(lexical_cast<T>("+-9"), bad_lexical_cast);
     // test_conversion_from_to_integral_for_locale
 
     // Overflow test case from David W. Birdsall
     std::string must_owerflow_str =             (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);
+        BOOST_TEST_THROWS(lexical_cast<T>(must_owerflow_str), bad_lexical_cast);
+        BOOST_TEST_THROWS(lexical_cast<T>(must_owerflow_negative_str), bad_lexical_cast);
 
         must_owerflow_str += '0';
         must_owerflow_negative_str += '0';
@@ -507,14 +451,14 @@ void test_conversion_from_to_integral()
     {
         std::string msg("Failed to set system locale: ");
         msg += ex.what();
-        BOOST_TEST_MESSAGE(msg);
+        std::cerr << msg;
     }
 
     if(grouping1 != grouping2)
         test_conversion_from_to_integral_for_locale<T>();
 
     if(grouping1.empty() && grouping2.empty())
-        BOOST_TEST_MESSAGE("Formatting with thousands_sep has not been tested");
+        std::cerr << "Formatting with thousands_sep has not been tested";
 }
 
 void test_conversion_from_to_short()
@@ -619,19 +563,19 @@ 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 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_TEST_EQ(lexical_cast<unsigned_t>((uns_limits::max)()), (uns_limits::max)());
+    BOOST_TEST_EQ(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_TEST_EQ(lexical_cast<signed_t>((s_limits::max)()), (s_limits::max)());
+    BOOST_TEST_EQ(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)()));
+    BOOST_TEST_EQ(lexical_cast<unsigned_t>((s_limits::max)()), static_cast<unsigned_t>((s_limits::max)()));
+    BOOST_TEST_EQ(lexical_cast<unsigned_t>((s_limits::min)()), static_cast<unsigned_t>((s_limits::min)()));
 }
 
 void test_integral_conversions_on_min_max()
@@ -664,27 +608,51 @@ int make_volatile_int_roundtrip() {
 void test_volatile_integers()
 {
     // Inspired by test case from https://github.com/boostorg/lexical_cast/issues/50
-    BOOST_CHECK_EQUAL(make_volatile_int_roundtrip<signed char>(), 42);
-    BOOST_CHECK_EQUAL(make_volatile_int_roundtrip<signed short>(), 42);
-    BOOST_CHECK_EQUAL(make_volatile_int_roundtrip<signed int>(), 42);
-    BOOST_CHECK_EQUAL(make_volatile_int_roundtrip<signed long>(), 42);
-    BOOST_CHECK_EQUAL(make_volatile_int_roundtrip<signed long long>(), 42);
+    BOOST_TEST_EQ(make_volatile_int_roundtrip<signed char>(), 42);
+    BOOST_TEST_EQ(make_volatile_int_roundtrip<signed short>(), 42);
+    BOOST_TEST_EQ(make_volatile_int_roundtrip<signed int>(), 42);
+    BOOST_TEST_EQ(make_volatile_int_roundtrip<signed long>(), 42);
+    BOOST_TEST_EQ(make_volatile_int_roundtrip<signed long long>(), 42);
 
-    BOOST_CHECK_EQUAL(make_volatile_int_roundtrip<unsigned char>(), 42);
-    BOOST_CHECK_EQUAL(make_volatile_int_roundtrip<unsigned short>(), 42);
-    BOOST_CHECK_EQUAL(make_volatile_int_roundtrip<unsigned int>(), 42);
-    BOOST_CHECK_EQUAL(make_volatile_int_roundtrip<unsigned long>(), 42);
-    BOOST_CHECK_EQUAL(make_volatile_int_roundtrip<unsigned long long>(), 42);
+    BOOST_TEST_EQ(make_volatile_int_roundtrip<unsigned char>(), 42);
+    BOOST_TEST_EQ(make_volatile_int_roundtrip<unsigned short>(), 42);
+    BOOST_TEST_EQ(make_volatile_int_roundtrip<unsigned int>(), 42);
+    BOOST_TEST_EQ(make_volatile_int_roundtrip<unsigned long>(), 42);
+    BOOST_TEST_EQ(make_volatile_int_roundtrip<unsigned long long>(), 42);
 
     volatile int v = 42;
-    BOOST_CHECK_EQUAL(boost::lexical_cast<signed short>(v), 42);
-    BOOST_CHECK_EQUAL(boost::lexical_cast<signed int>(v), 42);
-    BOOST_CHECK_EQUAL(boost::lexical_cast<signed long>(v), 42);
-    BOOST_CHECK_EQUAL(boost::lexical_cast<signed long long>(v), 42);
+    BOOST_TEST_EQ(boost::lexical_cast<signed short>(v), 42);
+    BOOST_TEST_EQ(boost::lexical_cast<signed int>(v), 42);
+    BOOST_TEST_EQ(boost::lexical_cast<signed long>(v), 42);
+    BOOST_TEST_EQ(boost::lexical_cast<signed long long>(v), 42);
 
-    BOOST_CHECK_EQUAL(boost::lexical_cast<unsigned short>(v), 42u);
-    BOOST_CHECK_EQUAL(boost::lexical_cast<unsigned int>(v), 42u);
-    BOOST_CHECK_EQUAL(boost::lexical_cast<unsigned long>(v), 42u);
-    BOOST_CHECK_EQUAL(boost::lexical_cast<unsigned long long>(v), 42u);
+    BOOST_TEST_EQ(boost::lexical_cast<unsigned short>(v), 42u);
+    BOOST_TEST_EQ(boost::lexical_cast<unsigned int>(v), 42u);
+    BOOST_TEST_EQ(boost::lexical_cast<unsigned long>(v), 42u);
+    BOOST_TEST_EQ(boost::lexical_cast<unsigned long long>(v), 42u);
+}
+
+int main()
+{
+    test_conversion_from_to_short();
+    test_conversion_from_to_ushort();
+    test_conversion_from_to_int();
+    test_conversion_from_to_uint();
+    test_conversion_from_to_long();
+    test_conversion_from_to_ulong();
+    test_conversion_from_to_intmax_t();
+    test_conversion_from_to_uintmax_t();
+#ifdef LCAST_TEST_LONGLONG
+    test_conversion_from_to_longlong();
+    test_conversion_from_to_ulonglong();
+#endif
+#ifdef BOOST_LCAST_TEST_128
+    test_conversion_from_to_int128();
+    test_conversion_from_to_uint128();
+#endif
+    test_integral_conversions_on_min_max();
+    test_volatile_integers();
+
+    return boost::report_errors();
 }
 
diff --git a/test/iterator_range_test.cpp b/test/iterator_range_test.cpp
index c93d65f..23fe703 100644
--- a/test/iterator_range_test.cpp
+++ b/test/iterator_range_test.cpp
@@ -8,19 +8,13 @@
 //  Software License, Version 1.0. (See accompanying file
 //  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt).
 
-#include <boost/config.hpp>
-
-#if defined(__INTEL_COMPILER)
-#pragma warning(disable: 193 383 488 981 1418 1419)
-#elif defined(BOOST_MSVC)
-#pragma warning(disable: 4097 4100 4121 4127 4146 4244 4245 4511 4512 4701 4800)
-#endif
 
 #include <boost/lexical_cast.hpp>
 
-#include <boost/test/unit_test.hpp>
 #include <boost/range/iterator_range.hpp>
 
+#include <boost/core/lightweight_test.hpp>
+
 using namespace boost;
 
 #if defined(BOOST_NO_STRINGSTREAM) || defined(BOOST_NO_STD_WSTRING)
@@ -54,40 +48,40 @@ inline std::basic_istream<CharT>& operator >> (std::basic_istream<CharT>& istr,
 template <class RngT>
 void do_test_iterator_range_impl(const RngT& rng)
 {
-    BOOST_CHECK_EQUAL(lexical_cast<int>(rng), 1);
-    BOOST_CHECK_EQUAL(lexical_cast<int>(rng.begin(), rng.size()), 1);
-    BOOST_CHECK_EQUAL(lexical_cast<unsigned int>(rng), 1u);
-    BOOST_CHECK_EQUAL(lexical_cast<unsigned int>(rng.begin(), rng.size()), 1u);
-    BOOST_CHECK_EQUAL(lexical_cast<short>(rng), 1);
-    BOOST_CHECK_EQUAL(lexical_cast<short>(rng.begin(), rng.size()), 1);
-    BOOST_CHECK_EQUAL(lexical_cast<unsigned short>(rng), 1u);
-    BOOST_CHECK_EQUAL(lexical_cast<unsigned short>(rng.begin(), rng.size()), 1u);
-    BOOST_CHECK_EQUAL(lexical_cast<long int>(rng), 1);
-    BOOST_CHECK_EQUAL(lexical_cast<long int>(rng.begin(), rng.size()), 1);
-    BOOST_CHECK_EQUAL(lexical_cast<unsigned long int>(rng), 1u);
-    BOOST_CHECK_EQUAL(lexical_cast<unsigned long int>(rng.begin(), rng.size()), 1u);
+    BOOST_TEST_EQ(lexical_cast<int>(rng), 1);
+    BOOST_TEST_EQ(lexical_cast<int>(rng.begin(), rng.size()), 1);
+    BOOST_TEST_EQ(lexical_cast<unsigned int>(rng), 1u);
+    BOOST_TEST_EQ(lexical_cast<unsigned int>(rng.begin(), rng.size()), 1u);
+    BOOST_TEST_EQ(lexical_cast<short>(rng), 1);
+    BOOST_TEST_EQ(lexical_cast<short>(rng.begin(), rng.size()), 1);
+    BOOST_TEST_EQ(lexical_cast<unsigned short>(rng), 1u);
+    BOOST_TEST_EQ(lexical_cast<unsigned short>(rng.begin(), rng.size()), 1u);
+    BOOST_TEST_EQ(lexical_cast<long int>(rng), 1);
+    BOOST_TEST_EQ(lexical_cast<long int>(rng.begin(), rng.size()), 1);
+    BOOST_TEST_EQ(lexical_cast<unsigned long int>(rng), 1u);
+    BOOST_TEST_EQ(lexical_cast<unsigned long int>(rng.begin(), rng.size()), 1u);
 
 #ifdef BOOST_STL_SUPPORTS_NEW_UNICODE_LOCALES
-    BOOST_CHECK_EQUAL(lexical_cast<float>(rng), 1.0f);
-    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);
+    BOOST_TEST_EQ(lexical_cast<float>(rng), 1.0f);
+    BOOST_TEST_EQ(lexical_cast<float>(rng.begin(), rng.size()), 1.0f);
+    BOOST_TEST_EQ(lexical_cast<double>(rng), 1.0);
+    BOOST_TEST_EQ(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);
+    BOOST_TEST_EQ(lexical_cast<long double>(rng), 1.0L);
+    BOOST_TEST_EQ(lexical_cast<long double>(rng.begin(), rng.size()), 1.0L);
 #endif
-    BOOST_CHECK_EQUAL(lexical_cast<class_with_user_defined_sream_operators>(rng), 1);
+    BOOST_TEST_EQ(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::ulong_long_type>(rng.begin(), rng.size()), 1u);
-    BOOST_CHECK_EQUAL(lexical_cast<boost::long_long_type>(rng), 1);
-    BOOST_CHECK_EQUAL(lexical_cast<boost::long_long_type>(rng.begin(), rng.size()), 1);
+    BOOST_TEST_EQ(lexical_cast<boost::ulong_long_type>(rng), 1u);
+    BOOST_TEST_EQ(lexical_cast<boost::ulong_long_type>(rng.begin(), rng.size()), 1u);
+    BOOST_TEST_EQ(lexical_cast<boost::long_long_type>(rng), 1);
+    BOOST_TEST_EQ(lexical_cast<boost::long_long_type>(rng.begin(), rng.size()), 1);
 #elif defined(BOOST_HAS_MS_INT64)
-    BOOST_CHECK_EQUAL(lexical_cast<unsigned __int64>(rng), 1u);
-    BOOST_CHECK_EQUAL(lexical_cast<unsigned __int64>(rng.begin(), rng.size()), 1u);
-    BOOST_CHECK_EQUAL(lexical_cast<__int64>(rng), 1);
-    BOOST_CHECK_EQUAL(lexical_cast<__int64>(rng.begin(), rng.size()), 1);
+    BOOST_TEST_EQ(lexical_cast<unsigned __int64>(rng), 1u);
+    BOOST_TEST_EQ(lexical_cast<unsigned __int64>(rng.begin(), rng.size()), 1u);
+    BOOST_TEST_EQ(lexical_cast<__int64>(rng), 1);
+    BOOST_TEST_EQ(lexical_cast<__int64>(rng.begin(), rng.size()), 1);
 #endif
 }
 
@@ -117,52 +111,52 @@ 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");
+    BOOST_TEST_EQ(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");
+    BOOST_TEST_EQ(lexical_cast<std::string>(crng1), "1");
 
     iterator_range<test_char_type*> rng2(eleven, eleven + 1);
-    BOOST_CHECK_EQUAL(lexical_cast<std::string>(rng2), "1");
+    BOOST_TEST_EQ(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_TEST_EQ(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_TEST_EQ(lexical_cast<float>(rng1), 1.0f);
+    BOOST_TEST_EQ(lexical_cast<double>(rng1), 1.0);
 #ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
-    BOOST_CHECK_EQUAL(lexical_cast<long double>(rng1), 1.0L);
+    BOOST_TEST_EQ(lexical_cast<long double>(rng1), 1.0L);
 #endif
-    BOOST_CHECK_EQUAL(lexical_cast<class_with_user_defined_sream_operators>(rng1), 1);
+    BOOST_TEST_EQ(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_TEST_EQ(lexical_cast<float>(crng2), 1.0f);
+    BOOST_TEST_EQ(lexical_cast<double>(crng2), 1.0);
 #ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
-    BOOST_CHECK_EQUAL(lexical_cast<long double>(crng2), 1.0L);
+    BOOST_TEST_EQ(lexical_cast<long double>(crng2), 1.0L);
 #endif
-    BOOST_CHECK_EQUAL(lexical_cast<class_with_user_defined_sream_operators>(crng2), 1);
+    BOOST_TEST_EQ(lexical_cast<class_with_user_defined_sream_operators>(crng2), 1);
 
 #ifndef BOOST_LCAST_NO_WCHAR_T
-    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");
+    BOOST_TEST(lexical_cast<std::wstring>(rng1) == L"1");
+    BOOST_TEST(lexical_cast<std::wstring>(crng1) == L"1");
+    BOOST_TEST(lexical_cast<std::wstring>(rng2) == L"1");
+    BOOST_TEST(lexical_cast<std::wstring>(crng2) == L"1");
 #endif
 
 #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");
-    BOOST_CHECK(lexical_cast<my_char16_string>(rng2) == u"1");
-    BOOST_CHECK(lexical_cast<my_char16_string>(crng2) == u"1");
+    BOOST_TEST(lexical_cast<my_char16_string>(rng1) == u"1");
+    BOOST_TEST(lexical_cast<my_char16_string>(crng1) == u"1");
+    BOOST_TEST(lexical_cast<my_char16_string>(rng2) == u"1");
+    BOOST_TEST(lexical_cast<my_char16_string>(crng2) == u"1");
 #endif
 
 #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");
-    BOOST_CHECK(lexical_cast<my_char32_string>(rng2) == U"1");
-    BOOST_CHECK(lexical_cast<my_char32_string>(crng2) == U"1");
+    BOOST_TEST(lexical_cast<my_char32_string>(rng1) == U"1");
+    BOOST_TEST(lexical_cast<my_char32_string>(crng1) == U"1");
+    BOOST_TEST(lexical_cast<my_char32_string>(rng2) == U"1");
+    BOOST_TEST(lexical_cast<my_char32_string>(crng2) == U"1");
 #endif
 }
 
@@ -204,7 +198,7 @@ void test_wchar_iterator_ranges()
     test_it_range_using_any_chars(data1, data2);
 #endif
 
-    BOOST_CHECK(true);
+    BOOST_TEST(true);
 }
 
 void test_char16_iterator_ranges()
@@ -216,7 +210,7 @@ void test_char16_iterator_ranges()
     test_it_range_using_any_chars(data1, data2);
 #endif
 
-    BOOST_CHECK(true);
+    BOOST_TEST(true);
 }
 
 void test_char32_iterator_ranges()
@@ -228,18 +222,17 @@ void test_char32_iterator_ranges()
     test_it_range_using_any_chars(data1, data2);
 #endif
 
-    BOOST_CHECK(true);
+    BOOST_TEST(true);
 }
 
-unit_test::test_suite *init_unit_test_suite(int, char *[])
+int main()
 {
-    unit_test::test_suite *suite = BOOST_TEST_SUITE("lexical_cast. Testing conversions using iterator_range<>");
-    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_wchar_iterator_ranges));
-    suite->add(BOOST_TEST_CASE(&test_char16_iterator_ranges));
-    suite->add(BOOST_TEST_CASE(&test_char32_iterator_ranges));
+    test_char_iterator_ranges();
+    test_unsigned_char_iterator_ranges();
+    test_signed_char_iterator_ranges();
+    test_wchar_iterator_ranges();
+    test_char16_iterator_ranges();
+    test_char32_iterator_ranges();
 
-    return suite;
+    return boost::report_errors();
 }
diff --git a/test/lexical_cast_test.cpp b/test/lexical_cast_test.cpp
index 64b4965..70b3b58 100644
--- a/test/lexical_cast_test.cpp
+++ b/test/lexical_cast_test.cpp
@@ -19,19 +19,11 @@
 //
 #define _SCL_SECURE_NO_WARNINGS
 
-#include <boost/config.hpp>
-
-#if defined(__INTEL_COMPILER)
-#pragma warning(disable: 193 383 488 981 1418 1419)
-#elif defined(BOOST_MSVC)
-#pragma warning(disable: 4097 4100 4121 4127 4146 4244 4245 4511 4512 4701 4800)
-#endif
-
 #include <boost/lexical_cast.hpp>
 
 #include <boost/cstdint.hpp>
-#include <boost/test/unit_test.hpp>
-#include <boost/test/tools/floating_point_comparison.hpp>
+
+#include <boost/core/lightweight_test.hpp>
 
 #include <boost/type_traits/integral_promotion.hpp>
 #include <string>
@@ -48,6 +40,11 @@
 #define BOOST_LCAST_NO_WCHAR_T
 #endif
 
+#ifndef BOOST_TEST_CLOSE_FRACTION
+// Naiive, but works for tests in this file 
+#define BOOST_TEST_CLOSE_FRACTION(x, y, eps) BOOST_TEST(x - y + eps <= eps * 2)
+#endif
+
 template<class CharT>
 struct my_traits : std::char_traits<CharT>
 {
@@ -66,131 +63,61 @@ struct my_allocator : std::allocator<CharT>
 
 using namespace boost;
 
-void test_conversion_to_char();
-void test_conversion_to_int();
-void test_conversion_to_double();
-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_from_wchar_t();
-void test_conversion_to_wchar_t();
-void test_conversion_from_wstring();
-void test_conversion_to_wstring();
-void test_bad_lexical_cast();
-void test_no_whitespace_stripping();
-void test_volatile_types_conversions();
-#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-void test_traits();
-void test_wtraits();
-void test_allocator();
-void test_wallocator();
-#endif
-void test_char_types_conversions();
-void operators_overload_test();
-#if !defined(BOOST_NO_CXX11_CHAR16_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS)
-void test_char16_conversions();
-#endif
-#if !defined(BOOST_NO_CXX11_CHAR32_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS)
-void test_char32_conversions();
-#endif
-void test_getting_pointer_to_function();
-
-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_conversion_to_char));
-    suite->add(BOOST_TEST_CASE(test_conversion_to_int));
-    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_string));
-    suite->add(BOOST_TEST_CASE(test_conversion_with_nonconst_char));
-#ifndef BOOST_LCAST_NO_WCHAR_T
-    suite->add(BOOST_TEST_CASE(test_conversion_from_wchar_t));
-    suite->add(BOOST_TEST_CASE(test_conversion_to_wchar_t));
-    suite->add(BOOST_TEST_CASE(test_conversion_from_wstring));
-    suite->add(BOOST_TEST_CASE(test_conversion_to_wstring));
-#endif
-    suite->add(BOOST_TEST_CASE(test_bad_lexical_cast));
-    suite->add(BOOST_TEST_CASE(test_no_whitespace_stripping));
-    suite->add(BOOST_TEST_CASE(test_volatile_types_conversions));
-#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-    suite->add(BOOST_TEST_CASE(&test_traits));
-    suite->add(BOOST_TEST_CASE(&test_wtraits));
-    suite->add(BOOST_TEST_CASE(&test_allocator));
-    suite->add(BOOST_TEST_CASE(&test_wallocator));
-#endif
-
-    suite->add(BOOST_TEST_CASE(&test_char_types_conversions));
-    suite->add(BOOST_TEST_CASE(&operators_overload_test));
-#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_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));
-
-    return suite;
-}
-
 void test_conversion_to_char()
 {
-    BOOST_CHECK_EQUAL('A', lexical_cast<char>('A'));
-    BOOST_CHECK_EQUAL(' ', lexical_cast<char>(' '));
-    BOOST_CHECK_EQUAL('1', lexical_cast<char>(1));
-    BOOST_CHECK_EQUAL('0', lexical_cast<char>(0));
-    BOOST_CHECK_THROW(lexical_cast<char>(123), bad_lexical_cast);
-    BOOST_CHECK_EQUAL('1', lexical_cast<char>(1.0));
-    BOOST_CHECK_EQUAL('1', lexical_cast<char>(true));
-    BOOST_CHECK_EQUAL('0', lexical_cast<char>(false));
-    BOOST_CHECK_EQUAL('A', lexical_cast<char>("A"));
-    BOOST_CHECK_EQUAL(' ', lexical_cast<char>(" "));
-    BOOST_CHECK_THROW(lexical_cast<char>(""), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<char>("Test"), bad_lexical_cast);
-    BOOST_CHECK_EQUAL('A', lexical_cast<char>(std::string("A")));
-    BOOST_CHECK_EQUAL(' ', lexical_cast<char>(std::string(" ")));
-    BOOST_CHECK_THROW(
+    BOOST_TEST_EQ('A', lexical_cast<char>('A'));
+    BOOST_TEST_EQ(' ', lexical_cast<char>(' '));
+    BOOST_TEST_EQ('1', lexical_cast<char>(1));
+    BOOST_TEST_EQ('0', lexical_cast<char>(0));
+    BOOST_TEST_THROWS(lexical_cast<char>(123), bad_lexical_cast);
+    BOOST_TEST_EQ('1', lexical_cast<char>(1.0));
+    BOOST_TEST_EQ('1', lexical_cast<char>(true));
+    BOOST_TEST_EQ('0', lexical_cast<char>(false));
+    BOOST_TEST_EQ('A', lexical_cast<char>("A"));
+    BOOST_TEST_EQ(' ', lexical_cast<char>(" "));
+    BOOST_TEST_THROWS(lexical_cast<char>(""), bad_lexical_cast);
+    BOOST_TEST_THROWS(lexical_cast<char>("Test"), bad_lexical_cast);
+    BOOST_TEST_EQ('A', lexical_cast<char>(std::string("A")));
+    BOOST_TEST_EQ(' ', lexical_cast<char>(std::string(" ")));
+    BOOST_TEST_THROWS(
         lexical_cast<char>(std::string("")), bad_lexical_cast);
-    BOOST_CHECK_THROW(
+    BOOST_TEST_THROWS(
         lexical_cast<char>(std::string("Test")), bad_lexical_cast);
 }
 
 void test_conversion_to_int()
 {
-    BOOST_CHECK_EQUAL(1, lexical_cast<int>('1'));
-    BOOST_CHECK_EQUAL(0, lexical_cast<int>('0'));
-    BOOST_CHECK_THROW(lexical_cast<int>('A'), bad_lexical_cast);
-    BOOST_CHECK_EQUAL(1, lexical_cast<int>(1));
-    BOOST_CHECK_EQUAL(1, lexical_cast<int>(1.0));
+    BOOST_TEST_EQ(1, lexical_cast<int>('1'));
+    BOOST_TEST_EQ(0, lexical_cast<int>('0'));
+    BOOST_TEST_THROWS(lexical_cast<int>('A'), bad_lexical_cast);
+    BOOST_TEST_EQ(1, lexical_cast<int>(1));
+    BOOST_TEST_EQ(1, lexical_cast<int>(1.0));
 
-    BOOST_CHECK_EQUAL(
+    BOOST_TEST_EQ(
         (std::numeric_limits<int>::max)(),
         lexical_cast<int>((std::numeric_limits<int>::max)()));
 
-    BOOST_CHECK_EQUAL(
+    BOOST_TEST_EQ(
         (std::numeric_limits<int>::min)(),
         lexical_cast<int>((std::numeric_limits<int>::min)()));
 
-    BOOST_CHECK_THROW(lexical_cast<int>(1.23), bad_lexical_cast);
+    BOOST_TEST_THROWS(lexical_cast<int>(1.23), bad_lexical_cast);
 
-    BOOST_CHECK_THROW(lexical_cast<int>(1e20), bad_lexical_cast);
-    BOOST_CHECK_EQUAL(1, lexical_cast<int>(true));
-    BOOST_CHECK_EQUAL(0, lexical_cast<int>(false));
-    BOOST_CHECK_EQUAL(123, lexical_cast<int>("123"));
-    BOOST_CHECK_THROW(
+    BOOST_TEST_THROWS(lexical_cast<int>(1e20), bad_lexical_cast);
+    BOOST_TEST_EQ(1, lexical_cast<int>(true));
+    BOOST_TEST_EQ(0, lexical_cast<int>(false));
+    BOOST_TEST_EQ(123, lexical_cast<int>("123"));
+    BOOST_TEST_THROWS(
         lexical_cast<int>(" 123"), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<int>(""), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<int>("Test"), bad_lexical_cast);
-    BOOST_CHECK_EQUAL(123, lexical_cast<int>("123"));
-    BOOST_CHECK_EQUAL(123, lexical_cast<int>(std::string("123")));
-    BOOST_CHECK_THROW(
+    BOOST_TEST_THROWS(lexical_cast<int>(""), bad_lexical_cast);
+    BOOST_TEST_THROWS(lexical_cast<int>("Test"), bad_lexical_cast);
+    BOOST_TEST_EQ(123, lexical_cast<int>("123"));
+    BOOST_TEST_EQ(123, lexical_cast<int>(std::string("123")));
+    BOOST_TEST_THROWS(
         lexical_cast<int>(std::string(" 123")), bad_lexical_cast);
-    BOOST_CHECK_THROW(
+    BOOST_TEST_THROWS(
         lexical_cast<int>(std::string("")), bad_lexical_cast);
-    BOOST_CHECK_THROW(
+    BOOST_TEST_THROWS(
         lexical_cast<int>(std::string("Test")), bad_lexical_cast);
 }
 
@@ -199,222 +126,222 @@ void test_conversion_with_nonconst_char()
     std::vector<char> buffer;
     buffer.push_back('1');
     buffer.push_back('\0');
-    BOOST_CHECK_EQUAL(boost::lexical_cast<int>(&buffer[0]), 1);
+    BOOST_TEST_EQ(boost::lexical_cast<int>(&buffer[0]), 1);
 
     std::vector<unsigned char> buffer2;
     buffer2.push_back('1');
     buffer2.push_back('\0');
-    BOOST_CHECK_EQUAL(boost::lexical_cast<int>(&buffer2[0]), 1);
+    BOOST_TEST_EQ(boost::lexical_cast<int>(&buffer2[0]), 1);
 
     std::vector<unsigned char> buffer3;
     buffer3.push_back('1');
     buffer3.push_back('\0');
-    BOOST_CHECK_EQUAL(boost::lexical_cast<int>(&buffer3[0]), 1);
+    BOOST_TEST_EQ(boost::lexical_cast<int>(&buffer3[0]), 1);
 
 #ifndef BOOST_LCAST_NO_WCHAR_T
     std::vector<wchar_t> buffer4;
     buffer4.push_back(L'1');
     buffer4.push_back(L'\0');
-    BOOST_CHECK_EQUAL(boost::lexical_cast<int>(&buffer4[0]), 1);
+    BOOST_TEST_EQ(boost::lexical_cast<int>(&buffer4[0]), 1);
 #endif
 }
 
 void test_conversion_to_double()
 {
-    BOOST_CHECK_CLOSE_FRACTION(1.0, lexical_cast<double>('1'), (std::numeric_limits<double>::epsilon()));
-    BOOST_CHECK_THROW(lexical_cast<double>('A'), bad_lexical_cast);
-    BOOST_CHECK_CLOSE_FRACTION(1.0, lexical_cast<double>(1), (std::numeric_limits<double>::epsilon()));
-    BOOST_CHECK_CLOSE_FRACTION(1.23, lexical_cast<double>(1.23), (std::numeric_limits<double>::epsilon()));
-    BOOST_CHECK_CLOSE_FRACTION(1.234567890, lexical_cast<double>(1.234567890), std::numeric_limits<double>::epsilon());
-    BOOST_CHECK_CLOSE_FRACTION(1.234567890, lexical_cast<double>("1.234567890"), std::numeric_limits<double>::epsilon());
-    BOOST_CHECK_CLOSE_FRACTION(1.0, lexical_cast<double>(true), (std::numeric_limits<double>::epsilon()));
-    BOOST_CHECK_CLOSE_FRACTION(0.0, lexical_cast<double>(false), (std::numeric_limits<double>::epsilon()));
-    BOOST_CHECK_CLOSE_FRACTION(1.23, lexical_cast<double>("1.23"), (std::numeric_limits<double>::epsilon()));
-    BOOST_CHECK_THROW(lexical_cast<double>(""), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<double>("Test"), bad_lexical_cast);
-    BOOST_CHECK_CLOSE_FRACTION(1.23, lexical_cast<double>(std::string("1.23")), (std::numeric_limits<double>::epsilon()));
-    BOOST_CHECK_THROW(
+    BOOST_TEST_CLOSE_FRACTION(1.0, lexical_cast<double>('1'), (std::numeric_limits<double>::epsilon()));
+    BOOST_TEST_THROWS(lexical_cast<double>('A'), bad_lexical_cast);
+    BOOST_TEST_CLOSE_FRACTION(1.0, lexical_cast<double>(1), (std::numeric_limits<double>::epsilon()));
+    BOOST_TEST_CLOSE_FRACTION(1.23, lexical_cast<double>(1.23), (std::numeric_limits<double>::epsilon()));
+    BOOST_TEST_CLOSE_FRACTION(1.234567890, lexical_cast<double>(1.234567890), std::numeric_limits<double>::epsilon());
+    BOOST_TEST_CLOSE_FRACTION(1.234567890, lexical_cast<double>("1.234567890"), std::numeric_limits<double>::epsilon());
+    BOOST_TEST_CLOSE_FRACTION(1.0, lexical_cast<double>(true), (std::numeric_limits<double>::epsilon()));
+    BOOST_TEST_CLOSE_FRACTION(0.0, lexical_cast<double>(false), (std::numeric_limits<double>::epsilon()));
+    BOOST_TEST_CLOSE_FRACTION(1.23, lexical_cast<double>("1.23"), (std::numeric_limits<double>::epsilon()));
+    BOOST_TEST_THROWS(lexical_cast<double>(""), bad_lexical_cast);
+    BOOST_TEST_THROWS(lexical_cast<double>("Test"), bad_lexical_cast);
+    BOOST_TEST_CLOSE_FRACTION(1.23, lexical_cast<double>(std::string("1.23")), (std::numeric_limits<double>::epsilon()));
+    BOOST_TEST_THROWS(
         lexical_cast<double>(std::string("")), bad_lexical_cast);
-    BOOST_CHECK_THROW(
+    BOOST_TEST_THROWS(
         lexical_cast<double>(std::string("Test")), bad_lexical_cast);
 }
 
 void test_conversion_to_bool()
 {
-    BOOST_CHECK_EQUAL(true, lexical_cast<bool>('1'));
-    BOOST_CHECK_EQUAL(false, lexical_cast<bool>('0'));
-    BOOST_CHECK_THROW(lexical_cast<bool>('A'), bad_lexical_cast);
-    BOOST_CHECK_EQUAL(true, lexical_cast<bool>(1));
-    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);
+    BOOST_TEST_EQ(true, lexical_cast<bool>('1'));
+    BOOST_TEST_EQ(false, lexical_cast<bool>('0'));
+    BOOST_TEST_THROWS(lexical_cast<bool>('A'), bad_lexical_cast);
+    BOOST_TEST_EQ(true, lexical_cast<bool>(1));
+    BOOST_TEST_EQ(false, lexical_cast<bool>(0));
+    BOOST_TEST_THROWS(lexical_cast<bool>(123), bad_lexical_cast);
+    BOOST_TEST_EQ(true, lexical_cast<bool>(1.0));
+    BOOST_TEST_THROWS(lexical_cast<bool>(-123), bad_lexical_cast);
+    BOOST_TEST_EQ(false, lexical_cast<bool>(0.0));
+    BOOST_TEST_THROWS(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));
+    BOOST_TEST_EQ(true, lexical_cast<bool>(true));
+    BOOST_TEST_EQ(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);
-    BOOST_CHECK_THROW(lexical_cast<bool>("Test"), bad_lexical_cast);
-    BOOST_CHECK_EQUAL(true, lexical_cast<bool>("1"));
-    BOOST_CHECK_EQUAL(false, lexical_cast<bool>("0"));
-    BOOST_CHECK_EQUAL(true, lexical_cast<bool>(std::string("1")));
-    BOOST_CHECK_EQUAL(false, lexical_cast<bool>(std::string("0")));
+    BOOST_TEST_EQ(true, lexical_cast<bool>("1"));
+    BOOST_TEST_EQ(false, lexical_cast<bool>("0"));
+    BOOST_TEST_THROWS(lexical_cast<bool>(""), bad_lexical_cast);
+    BOOST_TEST_THROWS(lexical_cast<bool>("Test"), bad_lexical_cast);
+    BOOST_TEST_EQ(true, lexical_cast<bool>("1"));
+    BOOST_TEST_EQ(false, lexical_cast<bool>("0"));
+    BOOST_TEST_EQ(true, lexical_cast<bool>(std::string("1")));
+    BOOST_TEST_EQ(false, lexical_cast<bool>(std::string("0")));
 
-    BOOST_CHECK_THROW(lexical_cast<bool>(1.0001L), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<bool>(2), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<bool>(2u), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<bool>(-1), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<bool>(-2), bad_lexical_cast);
+    BOOST_TEST_THROWS(lexical_cast<bool>(1.0001L), bad_lexical_cast);
+    BOOST_TEST_THROWS(lexical_cast<bool>(2), bad_lexical_cast);
+    BOOST_TEST_THROWS(lexical_cast<bool>(2u), bad_lexical_cast);
+    BOOST_TEST_THROWS(lexical_cast<bool>(-1), bad_lexical_cast);
+    BOOST_TEST_THROWS(lexical_cast<bool>(-2), bad_lexical_cast);
 
 
-    BOOST_CHECK_THROW(
+    BOOST_TEST_THROWS(
         lexical_cast<bool>(std::string("")), bad_lexical_cast);
-    BOOST_CHECK_THROW(
+    BOOST_TEST_THROWS(
         lexical_cast<bool>(std::string("Test")), bad_lexical_cast);
 
-    BOOST_CHECK(lexical_cast<bool>("+1") == true);
-    BOOST_CHECK(lexical_cast<bool>("+0") == false);
-    BOOST_CHECK(lexical_cast<bool>("-0") == false);
-    BOOST_CHECK_THROW(lexical_cast<bool>("--0"), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<bool>("-+-0"), bad_lexical_cast);
+    BOOST_TEST(lexical_cast<bool>("+1") == true);
+    BOOST_TEST(lexical_cast<bool>("+0") == false);
+    BOOST_TEST(lexical_cast<bool>("-0") == false);
+    BOOST_TEST_THROWS(lexical_cast<bool>("--0"), bad_lexical_cast);
+    BOOST_TEST_THROWS(lexical_cast<bool>("-+-0"), bad_lexical_cast);
 
-    BOOST_CHECK(lexical_cast<bool>("0") == false);
-    BOOST_CHECK(lexical_cast<bool>("1") == true);
-    BOOST_CHECK(lexical_cast<bool>("00") == false);
-    BOOST_CHECK(lexical_cast<bool>("00000000000") == false);
-    BOOST_CHECK(lexical_cast<bool>("000000000001") == true);
-    BOOST_CHECK(lexical_cast<bool>("+00") == false );
-    BOOST_CHECK(lexical_cast<bool>("-00") == false );
-    BOOST_CHECK(lexical_cast<bool>("+00000000001") == true );
+    BOOST_TEST(lexical_cast<bool>("0") == false);
+    BOOST_TEST(lexical_cast<bool>("1") == true);
+    BOOST_TEST(lexical_cast<bool>("00") == false);
+    BOOST_TEST(lexical_cast<bool>("00000000000") == false);
+    BOOST_TEST(lexical_cast<bool>("000000000001") == true);
+    BOOST_TEST(lexical_cast<bool>("+00") == false );
+    BOOST_TEST(lexical_cast<bool>("-00") == false );
+    BOOST_TEST(lexical_cast<bool>("+00000000001") == true );
 
-    BOOST_CHECK_THROW(lexical_cast<bool>("020"), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<bool>("00200"), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<bool>("-00200"), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<bool>("+00200"), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<bool>("000000000002"), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<bool>("-1"), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<bool>("-0000000001"), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<bool>("00000000011"), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<bool>("001001"), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<bool>("-00000000010"), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<bool>("-000000000100"), bad_lexical_cast);
+    BOOST_TEST_THROWS(lexical_cast<bool>("020"), bad_lexical_cast);
+    BOOST_TEST_THROWS(lexical_cast<bool>("00200"), bad_lexical_cast);
+    BOOST_TEST_THROWS(lexical_cast<bool>("-00200"), bad_lexical_cast);
+    BOOST_TEST_THROWS(lexical_cast<bool>("+00200"), bad_lexical_cast);
+    BOOST_TEST_THROWS(lexical_cast<bool>("000000000002"), bad_lexical_cast);
+    BOOST_TEST_THROWS(lexical_cast<bool>("-1"), bad_lexical_cast);
+    BOOST_TEST_THROWS(lexical_cast<bool>("-0000000001"), bad_lexical_cast);
+    BOOST_TEST_THROWS(lexical_cast<bool>("00000000011"), bad_lexical_cast);
+    BOOST_TEST_THROWS(lexical_cast<bool>("001001"), bad_lexical_cast);
+    BOOST_TEST_THROWS(lexical_cast<bool>("-00000000010"), bad_lexical_cast);
+    BOOST_TEST_THROWS(lexical_cast<bool>("-000000000100"), bad_lexical_cast);
 }
 
 void test_conversion_to_string()
 {
     char buf[] = "hello";
     char* str = buf;
-    BOOST_CHECK_EQUAL(str, lexical_cast<std::string>(str));
-    BOOST_CHECK_EQUAL("A", lexical_cast<std::string>('A'));
-    BOOST_CHECK_EQUAL(" ", lexical_cast<std::string>(' '));
-    BOOST_CHECK_EQUAL("123", lexical_cast<std::string>(123));
-    BOOST_CHECK_EQUAL("1.23", lexical_cast<std::string>(1.23));
-    BOOST_CHECK_EQUAL("1.111111111", lexical_cast<std::string>(1.111111111));
-    BOOST_CHECK_EQUAL("1", lexical_cast<std::string>(true));
-    BOOST_CHECK_EQUAL("0", lexical_cast<std::string>(false));
-    BOOST_CHECK_EQUAL("Test", lexical_cast<std::string>("Test"));
-    BOOST_CHECK_EQUAL(" ", lexical_cast<std::string>(" "));
-    BOOST_CHECK_EQUAL("", lexical_cast<std::string>(""));
-    BOOST_CHECK_EQUAL("Test", lexical_cast<std::string>(std::string("Test")));
-    BOOST_CHECK_EQUAL(" ", lexical_cast<std::string>(std::string(" ")));
-    BOOST_CHECK_EQUAL("", lexical_cast<std::string>(std::string("")));
+    BOOST_TEST_EQ(str, lexical_cast<std::string>(str));
+    BOOST_TEST_EQ("A", lexical_cast<std::string>('A'));
+    BOOST_TEST_EQ(" ", lexical_cast<std::string>(' '));
+    BOOST_TEST_EQ("123", lexical_cast<std::string>(123));
+    BOOST_TEST_EQ("1.23", lexical_cast<std::string>(1.23));
+    BOOST_TEST_EQ("1.111111111", lexical_cast<std::string>(1.111111111));
+    BOOST_TEST_EQ("1", lexical_cast<std::string>(true));
+    BOOST_TEST_EQ("0", lexical_cast<std::string>(false));
+    BOOST_TEST_EQ("Test", lexical_cast<std::string>("Test"));
+    BOOST_TEST_EQ(" ", lexical_cast<std::string>(" "));
+    BOOST_TEST_EQ("", lexical_cast<std::string>(""));
+    BOOST_TEST_EQ("Test", lexical_cast<std::string>(std::string("Test")));
+    BOOST_TEST_EQ(" ", lexical_cast<std::string>(std::string(" ")));
+    BOOST_TEST_EQ("", lexical_cast<std::string>(std::string("")));
 }
 
 void test_conversion_from_to_wchar_t_alias()
 {
-    BOOST_CHECK_EQUAL(123u, lexical_cast<unsigned short>("123"));
-    BOOST_CHECK_EQUAL(123u, lexical_cast<unsigned int>("123"));
-    BOOST_CHECK_EQUAL(123u, lexical_cast<unsigned long>("123"));
-    BOOST_CHECK_EQUAL(std::string("123"),
+    BOOST_TEST_EQ(123u, lexical_cast<unsigned short>("123"));
+    BOOST_TEST_EQ(123u, lexical_cast<unsigned int>("123"));
+    BOOST_TEST_EQ(123u, lexical_cast<unsigned long>("123"));
+    BOOST_TEST_EQ(std::string("123"),
         lexical_cast<std::string>(static_cast<unsigned short>(123)));
-    BOOST_CHECK_EQUAL(std::string("123"), lexical_cast<std::string>(123u));
-    BOOST_CHECK_EQUAL(std::string("123"), lexical_cast<std::string>(123ul));
+    BOOST_TEST_EQ(std::string("123"), lexical_cast<std::string>(123u));
+    BOOST_TEST_EQ(std::string("123"), lexical_cast<std::string>(123ul));
 }
 
 void test_conversion_from_wchar_t()
 {
 #ifndef BOOST_LCAST_NO_WCHAR_T
 #if !defined(BOOST_NO_INTRINSIC_WCHAR_T)
-    BOOST_CHECK_EQUAL(1, lexical_cast<int>(L'1'));
-    BOOST_CHECK_THROW(lexical_cast<int>(L'A'), bad_lexical_cast);
+    BOOST_TEST_EQ(1, lexical_cast<int>(L'1'));
+    BOOST_TEST_THROWS(lexical_cast<int>(L'A'), bad_lexical_cast);
 #endif
 
-    BOOST_CHECK_EQUAL(123, lexical_cast<int>(L"123"));
-    BOOST_CHECK_THROW(lexical_cast<int>(L""), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<int>(L"Test"), bad_lexical_cast);
+    BOOST_TEST_EQ(123, lexical_cast<int>(L"123"));
+    BOOST_TEST_THROWS(lexical_cast<int>(L""), bad_lexical_cast);
+    BOOST_TEST_THROWS(lexical_cast<int>(L"Test"), bad_lexical_cast);
 
 #if !defined(BOOST_NO_INTRINSIC_WCHAR_T)
-    BOOST_CHECK_EQUAL(1.0, lexical_cast<double>(L'1'));
-    BOOST_CHECK_THROW(lexical_cast<double>(L'A'), bad_lexical_cast);
+    BOOST_TEST_EQ(1.0, lexical_cast<double>(L'1'));
+    BOOST_TEST_THROWS(lexical_cast<double>(L'A'), bad_lexical_cast);
 #endif
 
-    BOOST_CHECK_EQUAL(1.23, lexical_cast<double>(L"1.23"));
-    BOOST_CHECK_THROW(lexical_cast<double>(L""), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<double>(L"Test"), bad_lexical_cast);
+    BOOST_TEST_EQ(1.23, lexical_cast<double>(L"1.23"));
+    BOOST_TEST_THROWS(lexical_cast<double>(L""), bad_lexical_cast);
+    BOOST_TEST_THROWS(lexical_cast<double>(L"Test"), bad_lexical_cast);
 
 #if !defined(BOOST_NO_INTRINSIC_WCHAR_T)
-    BOOST_CHECK_EQUAL(true, lexical_cast<bool>(L'1'));
-    BOOST_CHECK_EQUAL(false, lexical_cast<bool>(L'0'));
-    BOOST_CHECK_THROW(lexical_cast<bool>(L'A'), bad_lexical_cast);
+    BOOST_TEST_EQ(true, lexical_cast<bool>(L'1'));
+    BOOST_TEST_EQ(false, lexical_cast<bool>(L'0'));
+    BOOST_TEST_THROWS(lexical_cast<bool>(L'A'), bad_lexical_cast);
 #endif
-    BOOST_CHECK_EQUAL(true, lexical_cast<bool>(L"1"));
-    BOOST_CHECK_EQUAL(false, lexical_cast<bool>(L"0"));
-    BOOST_CHECK_THROW(lexical_cast<bool>(L""), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<bool>(L"Test"), bad_lexical_cast);
+    BOOST_TEST_EQ(true, lexical_cast<bool>(L"1"));
+    BOOST_TEST_EQ(false, lexical_cast<bool>(L"0"));
+    BOOST_TEST_THROWS(lexical_cast<bool>(L""), bad_lexical_cast);
+    BOOST_TEST_THROWS(lexical_cast<bool>(L"Test"), bad_lexical_cast);
 #endif
 }
 
 void test_conversion_to_wchar_t()
 {
 #if !defined(BOOST_LCAST_NO_WCHAR_T) && !defined(BOOST_NO_INTRINSIC_WCHAR_T)
-    BOOST_CHECK(L'1' == lexical_cast<wchar_t>(1));
-    BOOST_CHECK(L'0' == lexical_cast<wchar_t>(0));
-    BOOST_CHECK(L'1' == lexical_cast<wchar_t>('1'));
-    BOOST_CHECK(L'0' == lexical_cast<wchar_t>('0'));
-    BOOST_CHECK_THROW(lexical_cast<wchar_t>(123), bad_lexical_cast);
-    BOOST_CHECK(L'1' == lexical_cast<wchar_t>(1.0));
-    BOOST_CHECK(L'0' == lexical_cast<wchar_t>(0.0));
-    BOOST_CHECK(L'1' == lexical_cast<wchar_t>(true));
-    BOOST_CHECK(L'0' == lexical_cast<wchar_t>(false));
-    BOOST_CHECK(L'A' == lexical_cast<wchar_t>(L'A'));
-    BOOST_CHECK(L' ' == lexical_cast<wchar_t>(L' '));
-    BOOST_CHECK(L'A' == lexical_cast<wchar_t>(L"A"));
-    BOOST_CHECK(L' ' == lexical_cast<wchar_t>(L" "));
-    BOOST_CHECK_THROW(lexical_cast<wchar_t>(L""), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<wchar_t>(L"Test"), bad_lexical_cast);
-    BOOST_CHECK(L'A' == lexical_cast<wchar_t>(std::wstring(L"A")));
-    BOOST_CHECK(L' ' == lexical_cast<wchar_t>(std::wstring(L" ")));
-    BOOST_CHECK_THROW(
+    BOOST_TEST(L'1' == lexical_cast<wchar_t>(1));
+    BOOST_TEST(L'0' == lexical_cast<wchar_t>(0));
+    BOOST_TEST(L'1' == lexical_cast<wchar_t>('1'));
+    BOOST_TEST(L'0' == lexical_cast<wchar_t>('0'));
+    BOOST_TEST_THROWS(lexical_cast<wchar_t>(123), bad_lexical_cast);
+    BOOST_TEST(L'1' == lexical_cast<wchar_t>(1.0));
+    BOOST_TEST(L'0' == lexical_cast<wchar_t>(0.0));
+    BOOST_TEST(L'1' == lexical_cast<wchar_t>(true));
+    BOOST_TEST(L'0' == lexical_cast<wchar_t>(false));
+    BOOST_TEST(L'A' == lexical_cast<wchar_t>(L'A'));
+    BOOST_TEST(L' ' == lexical_cast<wchar_t>(L' '));
+    BOOST_TEST(L'A' == lexical_cast<wchar_t>(L"A"));
+    BOOST_TEST(L' ' == lexical_cast<wchar_t>(L" "));
+    BOOST_TEST_THROWS(lexical_cast<wchar_t>(L""), bad_lexical_cast);
+    BOOST_TEST_THROWS(lexical_cast<wchar_t>(L"Test"), bad_lexical_cast);
+    BOOST_TEST(L'A' == lexical_cast<wchar_t>(std::wstring(L"A")));
+    BOOST_TEST(L' ' == lexical_cast<wchar_t>(std::wstring(L" ")));
+    BOOST_TEST_THROWS(
         lexical_cast<wchar_t>(std::wstring(L"")), bad_lexical_cast);
-    BOOST_CHECK_THROW(
+    BOOST_TEST_THROWS(
         lexical_cast<wchar_t>(std::wstring(L"Test")), bad_lexical_cast);
 #endif
-    BOOST_CHECK(true);
+    BOOST_TEST(true);
 }
 
 void test_conversion_from_wstring()
 {
 #ifndef BOOST_LCAST_NO_WCHAR_T
-    BOOST_CHECK_EQUAL(123, lexical_cast<int>(std::wstring(L"123")));
-    BOOST_CHECK_THROW(
+    BOOST_TEST_EQ(123, lexical_cast<int>(std::wstring(L"123")));
+    BOOST_TEST_THROWS(
         lexical_cast<int>(std::wstring(L"")), bad_lexical_cast);
-    BOOST_CHECK_THROW(
+    BOOST_TEST_THROWS(
         lexical_cast<int>(std::wstring(L"Test")), bad_lexical_cast);
 
-    BOOST_CHECK_EQUAL(true, lexical_cast<bool>(std::wstring(L"1")));
-    BOOST_CHECK_EQUAL(false, lexical_cast<bool>(std::wstring(L"0")));
-    BOOST_CHECK_THROW(
+    BOOST_TEST_EQ(true, lexical_cast<bool>(std::wstring(L"1")));
+    BOOST_TEST_EQ(false, lexical_cast<bool>(std::wstring(L"0")));
+    BOOST_TEST_THROWS(
         lexical_cast<bool>(std::wstring(L"")), bad_lexical_cast);
-    BOOST_CHECK_THROW(
+    BOOST_TEST_THROWS(
         lexical_cast<bool>(std::wstring(L"Test")), bad_lexical_cast);
 #endif
-    BOOST_CHECK(true);
+    BOOST_TEST(true);
 }
 
 void test_conversion_to_wstring()
@@ -422,24 +349,24 @@ void test_conversion_to_wstring()
 #ifndef BOOST_LCAST_NO_WCHAR_T
     wchar_t buf[] = L"hello";
     wchar_t* str = buf;
-    BOOST_CHECK(str == lexical_cast<std::wstring>(str));
-    BOOST_CHECK(L"123" == lexical_cast<std::wstring>(123));
-    BOOST_CHECK(L"1.23" == lexical_cast<std::wstring>(1.23));
-    BOOST_CHECK(L"1" == lexical_cast<std::wstring>(true));
-    BOOST_CHECK(L"0" == lexical_cast<std::wstring>(false));
+    BOOST_TEST(str == lexical_cast<std::wstring>(str));
+    BOOST_TEST(L"123" == lexical_cast<std::wstring>(123));
+    BOOST_TEST(L"1.23" == lexical_cast<std::wstring>(1.23));
+    BOOST_TEST(L"1" == lexical_cast<std::wstring>(true));
+    BOOST_TEST(L"0" == lexical_cast<std::wstring>(false));
 #if !defined(BOOST_NO_INTRINSIC_WCHAR_T)
-    BOOST_CHECK(L"A" == lexical_cast<std::wstring>(L'A'));
-    BOOST_CHECK(L" " == lexical_cast<std::wstring>(L' '));
-    BOOST_CHECK(L"A" == lexical_cast<std::wstring>('A'));
+    BOOST_TEST(L"A" == lexical_cast<std::wstring>(L'A'));
+    BOOST_TEST(L" " == lexical_cast<std::wstring>(L' '));
+    BOOST_TEST(L"A" == lexical_cast<std::wstring>('A'));
 #endif
-    BOOST_CHECK(L"Test" == lexical_cast<std::wstring>(L"Test"));
-    BOOST_CHECK(L" " == lexical_cast<std::wstring>(L" "));
-    BOOST_CHECK(L"" == lexical_cast<std::wstring>(L""));
-    BOOST_CHECK(L"Test" == lexical_cast<std::wstring>(std::wstring(L"Test")));
-    BOOST_CHECK(L" " == lexical_cast<std::wstring>(std::wstring(L" ")));
-    BOOST_CHECK(L"" == lexical_cast<std::wstring>(std::wstring(L"")));
+    BOOST_TEST(L"Test" == lexical_cast<std::wstring>(L"Test"));
+    BOOST_TEST(L" " == lexical_cast<std::wstring>(L" "));
+    BOOST_TEST(L"" == lexical_cast<std::wstring>(L""));
+    BOOST_TEST(L"Test" == lexical_cast<std::wstring>(std::wstring(L"Test")));
+    BOOST_TEST(L" " == lexical_cast<std::wstring>(std::wstring(L" ")));
+    BOOST_TEST(L"" == lexical_cast<std::wstring>(std::wstring(L"")));
 #endif
-    BOOST_CHECK(true);
+    BOOST_TEST(true);
 }
 
 void test_bad_lexical_cast()
@@ -448,31 +375,31 @@ void test_bad_lexical_cast()
     {
         lexical_cast<int>(std::string("Test"));
 
-        BOOST_CHECK(false); // Exception expected
+        BOOST_TEST(false); // Exception expected
     }
     catch(const bad_lexical_cast &e)
     {
-        BOOST_CHECK(e.source_type() == typeid(std::string));
-        BOOST_CHECK(e.target_type() == typeid(int));
+        BOOST_TEST(e.source_type() == typeid(std::string));
+        BOOST_TEST(e.target_type() == typeid(int));
     }
 }
 
 void test_no_whitespace_stripping()
 {
-    BOOST_CHECK_THROW(lexical_cast<int>(" 123"), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<int>("123 "), bad_lexical_cast);
+    BOOST_TEST_THROWS(lexical_cast<int>(" 123"), bad_lexical_cast);
+    BOOST_TEST_THROWS(lexical_cast<int>("123 "), bad_lexical_cast);
 }
 
 void test_volatile_types_conversions()
 {
     volatile int i1 = 100000;
-    BOOST_CHECK_EQUAL("100000", boost::lexical_cast<std::string>(i1));
+    BOOST_TEST_EQ("100000", boost::lexical_cast<std::string>(i1));
 
     volatile const int i2 = 100000;
-    BOOST_CHECK_EQUAL("100000", boost::lexical_cast<std::string>(i2));
+    BOOST_TEST_EQ("100000", boost::lexical_cast<std::string>(i2));
 
     volatile const long int i3 = 1000000;
-    BOOST_CHECK_EQUAL("1000000", boost::lexical_cast<std::string>(i3));
+    BOOST_TEST_EQ("1000000", boost::lexical_cast<std::string>(i3));
 }
 
 #ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
@@ -481,9 +408,9 @@ void test_traits()
     typedef std::basic_string<char, my_traits<char> > my_string;
 
     my_string const s("s");
-    BOOST_CHECK(boost::lexical_cast<char>(s) == s[0]);
-    BOOST_CHECK(boost::lexical_cast<my_string>(s) == s);
-    BOOST_CHECK(boost::lexical_cast<my_string>(-1) == "-1");
+    BOOST_TEST(boost::lexical_cast<char>(s) == s[0]);
+    BOOST_TEST(boost::lexical_cast<my_string>(s) == s);
+    BOOST_TEST(boost::lexical_cast<my_string>(-1) == "-1");
 }
 
 void test_wtraits()
@@ -491,9 +418,9 @@ void test_wtraits()
     typedef std::basic_string<wchar_t, my_traits<wchar_t> > my_string;
 
     my_string const s(L"s");
-    BOOST_CHECK(boost::lexical_cast<wchar_t>(s) == s[0]);
-    BOOST_CHECK(boost::lexical_cast<my_string>(s) == s);
-    //BOOST_CHECK(boost::lexical_cast<my_string>(-1) == L"-1");
+    BOOST_TEST(boost::lexical_cast<wchar_t>(s) == s[0]);
+    BOOST_TEST(boost::lexical_cast<my_string>(s) == s);
+    //BOOST_TEST(boost::lexical_cast<my_string>(-1) == L"-1");
     // Commented out because gcc 3.3 doesn't support this:
     // basic_ostream<wchar_t, my_traits<wchar_t> > o; o << -1;
 }
@@ -511,12 +438,12 @@ void test_allocator()
                              > my_string;
 
     my_string s("s");
-    BOOST_CHECK(boost::lexical_cast<char>(s) == s[0]);
-    BOOST_CHECK(boost::lexical_cast<std::string>(s) == "s");
-    BOOST_CHECK(boost::lexical_cast<my_string>(s) == s);
-    BOOST_CHECK(boost::lexical_cast<my_string>(1) == "1");
-    BOOST_CHECK(boost::lexical_cast<my_string>("s") == s);
-    BOOST_CHECK(boost::lexical_cast<my_string>(std::string("s")) == s);
+    BOOST_TEST(boost::lexical_cast<char>(s) == s[0]);
+    BOOST_TEST(boost::lexical_cast<std::string>(s) == "s");
+    BOOST_TEST(boost::lexical_cast<my_string>(s) == s);
+    BOOST_TEST(boost::lexical_cast<my_string>(1) == "1");
+    BOOST_TEST(boost::lexical_cast<my_string>("s") == s);
+    BOOST_TEST(boost::lexical_cast<my_string>(std::string("s")) == s);
 #endif
 }
 
@@ -533,12 +460,12 @@ void test_wallocator()
                              > my_string;
 
     my_string s(L"s");
-    BOOST_CHECK(boost::lexical_cast<wchar_t>(s) == s[0]);
-    BOOST_CHECK(boost::lexical_cast<std::wstring>(s) == L"s");
-    BOOST_CHECK(boost::lexical_cast<my_string>(s) == s);
-    BOOST_CHECK(boost::lexical_cast<my_string>(1) == L"1");
-    BOOST_CHECK(boost::lexical_cast<my_string>(L"s") == s);
-    BOOST_CHECK(boost::lexical_cast<my_string>(std::wstring(L"s")) == s);
+    BOOST_TEST(boost::lexical_cast<wchar_t>(s) == s[0]);
+    BOOST_TEST(boost::lexical_cast<std::wstring>(s) == L"s");
+    BOOST_TEST(boost::lexical_cast<my_string>(s) == s);
+    BOOST_TEST(boost::lexical_cast<my_string>(1) == L"1");
+    BOOST_TEST(boost::lexical_cast<my_string>(L"s") == s);
+    BOOST_TEST(boost::lexical_cast<my_string>(std::wstring(L"s")) == s);
 #endif
 }
 
@@ -551,27 +478,27 @@ void test_char_types_conversions()
     const unsigned char uc_arr[]  = "Test array of chars";
     const signed char sc_arr[]    = "Test array of chars";
 
-    BOOST_CHECK(boost::lexical_cast<std::string>(c_arr) == std::string(c_arr));
-    BOOST_CHECK(boost::lexical_cast<std::string>(uc_arr) == std::string(c_arr));
-    BOOST_CHECK(boost::lexical_cast<std::string>(sc_arr) == std::string(c_arr));
+    BOOST_TEST(boost::lexical_cast<std::string>(c_arr) == std::string(c_arr));
+    BOOST_TEST(boost::lexical_cast<std::string>(uc_arr) == std::string(c_arr));
+    BOOST_TEST(boost::lexical_cast<std::string>(sc_arr) == std::string(c_arr));
 
-    BOOST_CHECK(boost::lexical_cast<char>(c_arr[0]) == c_arr[0]);
-    BOOST_CHECK(boost::lexical_cast<char>(uc_arr[0]) == c_arr[0]);
-    BOOST_CHECK(boost::lexical_cast<char>(sc_arr[0]) == c_arr[0]);
+    BOOST_TEST(boost::lexical_cast<char>(c_arr[0]) == c_arr[0]);
+    BOOST_TEST(boost::lexical_cast<char>(uc_arr[0]) == c_arr[0]);
+    BOOST_TEST(boost::lexical_cast<char>(sc_arr[0]) == c_arr[0]);
 
-    BOOST_CHECK(boost::lexical_cast<unsigned char>(c_arr[0]) == uc_arr[0]);
-    BOOST_CHECK(boost::lexical_cast<unsigned char>(uc_arr[0]) == uc_arr[0]);
-    BOOST_CHECK(boost::lexical_cast<unsigned char>(sc_arr[0]) == uc_arr[0]);
+    BOOST_TEST(boost::lexical_cast<unsigned char>(c_arr[0]) == uc_arr[0]);
+    BOOST_TEST(boost::lexical_cast<unsigned char>(uc_arr[0]) == uc_arr[0]);
+    BOOST_TEST(boost::lexical_cast<unsigned char>(sc_arr[0]) == uc_arr[0]);
 
-    BOOST_CHECK(boost::lexical_cast<signed char>(c_arr[0]) == sc_arr[0]);
-    BOOST_CHECK(boost::lexical_cast<signed char>(uc_arr[0]) == sc_arr[0]);
-    BOOST_CHECK(boost::lexical_cast<signed char>(sc_arr[0]) == sc_arr[0]);
+    BOOST_TEST(boost::lexical_cast<signed char>(c_arr[0]) == sc_arr[0]);
+    BOOST_TEST(boost::lexical_cast<signed char>(uc_arr[0]) == sc_arr[0]);
+    BOOST_TEST(boost::lexical_cast<signed char>(sc_arr[0]) == sc_arr[0]);
 
 #ifndef BOOST_LCAST_NO_WCHAR_T
     const wchar_t wc_arr[]=L"Test array of chars";
 
-    BOOST_CHECK(boost::lexical_cast<std::wstring>(wc_arr) == std::wstring(wc_arr));
-    BOOST_CHECK(boost::lexical_cast<wchar_t>(wc_arr[0]) == wc_arr[0]);
+    BOOST_TEST(boost::lexical_cast<std::wstring>(wc_arr) == std::wstring(wc_arr));
+    BOOST_TEST(boost::lexical_cast<wchar_t>(wc_arr[0]) == wc_arr[0]);
 
 #endif
 }
@@ -601,8 +528,8 @@ IStream& operator>>(IStream& istr, foo_operators_test& foo)
 void operators_overload_test()
 {
     foo_operators_test foo;
-    BOOST_CHECK_EQUAL(boost::lexical_cast<std::string>(foo), "2");
-    BOOST_CHECK_EQUAL((boost::lexical_cast<foo_operators_test>("2")).f, 2);
+    BOOST_TEST_EQ(boost::lexical_cast<std::string>(foo), "2");
+    BOOST_TEST_EQ((boost::lexical_cast<foo_operators_test>("2")).f, 2);
 
     // Must compile
     (void)boost::lexical_cast<foo_operators_test>(foo);
@@ -612,16 +539,16 @@ void operators_overload_test()
 #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"));
-    BOOST_CHECK(u"1" == lexical_cast<std::u16string>(u'1'));
+    BOOST_TEST(u"100" == lexical_cast<std::u16string>(u"100"));
+    BOOST_TEST(u"1" == lexical_cast<std::u16string>(u'1'));
 }
 #endif
 
 #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"));
-    BOOST_CHECK(U"1" == lexical_cast<std::u32string>(U'1'));
+    BOOST_TEST(U"100" == lexical_cast<std::u32string>(U"100"));
+    BOOST_TEST(U"1" == lexical_cast<std::u32string>(U'1'));
 }
 #endif
 
@@ -631,19 +558,57 @@ void test_getting_pointer_to_function()
     typedef char char_arr[4];
     typedef int(*f1)(const char_arr&);
     f1 p1 = &boost::lexical_cast<int, char_arr>;
-    BOOST_CHECK(p1);
+    BOOST_TEST(p1);
 
     typedef int(*f2)(const std::string&);
     f2 p2 = &boost::lexical_cast<int, std::string>;
-    BOOST_CHECK(p2);
+    BOOST_TEST(p2);
 
     typedef std::string(*f3)(const int&);
     f3 p3 = &boost::lexical_cast<std::string, int>;
-    BOOST_CHECK(p3);
+    BOOST_TEST(p3);
 
     std::vector<int> values;
     std::vector<std::string> ret;
     std::transform(values.begin(), values.end(), ret.begin(), boost::lexical_cast<std::string, int>);
 }
 
+int main()
+{
+    test_conversion_to_char();
+    test_conversion_to_int();
+    test_conversion_to_double();
+    test_conversion_to_bool();
+    test_conversion_from_to_wchar_t_alias();
+    test_conversion_to_string();
+    test_conversion_with_nonconst_char();
+#ifndef BOOST_LCAST_NO_WCHAR_T
+    test_conversion_from_wchar_t();
+    test_conversion_to_wchar_t();
+    test_conversion_from_wstring();
+    test_conversion_to_wstring();
+#endif
+    test_bad_lexical_cast();
+    test_no_whitespace_stripping();
+    test_volatile_types_conversions();
+#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+    test_traits();
+    test_wtraits();
+    test_allocator();
+    test_wallocator();
+#endif
+
+    test_char_types_conversions();
+    operators_overload_test();
+#if !defined(BOOST_NO_CXX11_CHAR16_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS)
+    test_char16_conversions();
+#endif
+#if !defined(BOOST_NO_CXX11_CHAR32_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS)
+    test_char32_conversions();
+#endif
+    test_getting_pointer_to_function();
+
+    return boost::report_errors();
+}
+
 
diff --git a/test/loopback_test.cpp b/test/loopback_test.cpp
index 026b054..c0a34d6 100644
--- a/test/loopback_test.cpp
+++ b/test/loopback_test.cpp
@@ -3,6 +3,7 @@
 //  See http://www.boost.org for most recent version, including documentation.
 //
 //  Copyright Alexander Nasonov, 2006.
+//  Copyright Antony Polukhin, 2023.
 //
 //  Distributed under the Boost
 //  Software License, Version 1.0. (See accompanying file
@@ -11,16 +12,9 @@
 //  Test round-tripping conversion FPT -> string -> FPT,
 //  where FPT is Floating Point Type.
 
-#include <boost/config.hpp>
-
-#if defined(__INTEL_COMPILER)
-#pragma warning(disable: 193 383 488 981 1418 1419)
-#elif defined(BOOST_MSVC)
-#pragma warning(disable: 4097 4100 4121 4127 4146 4244 4245 4511 4512 4701 4800)
-#endif
-
 #include <boost/lexical_cast.hpp>
-#include <boost/test/unit_test.hpp>
+
+#include <boost/core/lightweight_test.hpp>
 
 #if (defined(__CYGWIN__) || defined(__FreeBSD__) || defined(__NetBSD__) \
    || (defined(__hppa) && !defined(__OpenBSD__)) || (defined(__NO_LONG_DOUBLE_MATH) && (DBL_MANT_DIG != LDBL_MANT_DIG))) \
@@ -28,45 +22,28 @@
 #  define BOOST_LEXICAL_CAST_NO_LONG_DOUBLE_MATH_FUNCTIONS
 #endif
 
-using namespace boost;
-
-void test_round_conversion_float();
-void test_round_conversion_double();
-void test_round_conversion_long_double();
-
-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_round_conversion_float));
-    suite->add(BOOST_TEST_CASE(&test_round_conversion_double));
-    suite->add(BOOST_TEST_CASE(&test_round_conversion_long_double));
-
-    return suite;
-}
-
 template<class T>
 void test_round_conversion()
 {
     T epsilon = std::numeric_limits<T>::epsilon();
     std::string const epsilon_s = boost::lexical_cast<std::string>(epsilon);
-    BOOST_CHECK(epsilon == lexical_cast<T>(epsilon_s));
+    BOOST_TEST(epsilon == boost::lexical_cast<T>(epsilon_s));
 
     T max_ = (std::numeric_limits<T>::max)();
     std::string const max_s = boost::lexical_cast<std::string>(max_);
-    BOOST_CHECK(max_ == lexical_cast<T>(max_s));
+    BOOST_TEST(max_ == boost::lexical_cast<T>(max_s));
 
     T min_ = (std::numeric_limits<T>::min)();
     std::string const min_s = boost::lexical_cast<std::string>(min_);
-    BOOST_CHECK(min_ == lexical_cast<T>(min_s));
+    BOOST_TEST(min_ == boost::lexical_cast<T>(min_s));
 
     T max_div137 = max_ / 137;
     std::string max_div137_s = boost::lexical_cast<std::string>(max_div137);
-    BOOST_CHECK(max_div137 == lexical_cast<T>(max_div137_s));
+    BOOST_TEST(max_div137 == boost::lexical_cast<T>(max_div137_s));
 
     T epsilon_mult137 = epsilon * 137;
-    std::string epsilon_mult137_s(lexical_cast<std::string>(epsilon_mult137));
-    BOOST_CHECK(epsilon_mult137 == lexical_cast<T>(epsilon_mult137_s));
+    std::string epsilon_mult137_s(boost::lexical_cast<std::string>(epsilon_mult137));
+    BOOST_TEST(epsilon_mult137 == boost::lexical_cast<T>(epsilon_mult137_s));
 
 }
 
@@ -76,7 +53,7 @@ void test_msvc_magic_values()
 {
     T magic_msvc = 0.00010000433948393407;
     std::string magic_msvc_s = boost::lexical_cast<std::string>(magic_msvc);
-    BOOST_CHECK(magic_msvc == lexical_cast<T>(magic_msvc_s));
+    BOOST_TEST(magic_msvc == boost::lexical_cast<T>(magic_msvc_s));
 }
 
 void test_round_conversion_float()
@@ -97,6 +74,15 @@ void test_round_conversion_long_double()
     test_round_conversion<long double>();
     test_msvc_magic_values<long double>();
 #endif
-    BOOST_CHECK(true);
+    BOOST_TEST(true);
+}
+
+int main()
+{
+    test_round_conversion_float();
+    test_round_conversion_double();
+    test_round_conversion_long_double();
+
+    return boost::report_errors();
 }
 
diff --git a/test/no_comp_time_prcision.cpp b/test/no_comp_time_prcision.cpp
deleted file mode 100644
index 64b1513..0000000
--- a/test/no_comp_time_prcision.cpp
+++ /dev/null
@@ -1,28 +0,0 @@
-//  Unit test for boost::lexical_cast for https://svn.boost.org/trac/boost/ticket/11669.
-//
-//  See http://www.boost.org for most recent version, including documentation.
-//
-//  Copyright Antony Polukhin, 2015-2023.
-//
-//  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 <string>
-#define BOOST_LCAST_NO_COMPILE_TIME_PRECISION
-#include <boost/lexical_cast.hpp>
-
-#include <boost/test/unit_test.hpp>
-
-void main_check() {
-    BOOST_CHECK(!boost::lexical_cast<std::string>(2.12345).empty());
-    BOOST_CHECK(!boost::lexical_cast<std::string>(2.12345678).empty());
-}
-
-boost::unit_test::test_suite *init_unit_test_suite(int, char *[])
-{
-    boost::unit_test::test_suite *suite =
-        BOOST_TEST_SUITE("lexical_cast no-compile-time-precision check");
-    suite->add(BOOST_TEST_CASE(main_check));
-    return suite;
-}
diff --git a/test/no_locale_test.cpp b/test/no_locale_test.cpp
index 2423fee..6a01f22 100644
--- a/test/no_locale_test.cpp
+++ b/test/no_locale_test.cpp
@@ -8,20 +8,15 @@
 //  Software License, Version 1.0. (See accompanying file
 //  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt).
 
-#include <boost/config.hpp>
-
-#if defined(__INTEL_COMPILER)
-#pragma warning(disable: 193 383 488 981 1418 1419)
-#elif defined(BOOST_MSVC)
-#pragma warning(disable: 4097 4100 4121 4127 4146 4244 4245 4511 4512 4701 4800)
-#endif
-
 #include <boost/lexical_cast.hpp>
-#include <boost/test/unit_test.hpp>
+
+#include <boost/core/lightweight_test.hpp>
 #include <boost/range/iterator_range.hpp>
 
 #include "escape_struct.hpp"
 
+#include <vector>
+
 using namespace boost;
 
 // Testing compilation and some basic usage with BOOST_NO_STD_LOCALE
@@ -36,20 +31,20 @@ using namespace boost;
 template <class T>
 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);
+    BOOST_TEST_THROWS(lexical_cast<int>(v), bad_lexical_cast);
+    BOOST_TEST_THROWS(lexical_cast<float>(v), bad_lexical_cast);
+    BOOST_TEST_THROWS(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);
+    BOOST_TEST_THROWS(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);
+    BOOST_TEST_THROWS(lexical_cast<unsigned int>(v), bad_lexical_cast);
+    BOOST_TEST_THROWS(lexical_cast<unsigned short>(v), bad_lexical_cast);
 #if defined(BOOST_HAS_LONG_LONG)
-    BOOST_CHECK_THROW(lexical_cast<boost::ulong_long_type>(v), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<boost::long_long_type>(v), bad_lexical_cast);
+    BOOST_TEST_THROWS(lexical_cast<boost::ulong_long_type>(v), bad_lexical_cast);
+    BOOST_TEST_THROWS(lexical_cast<boost::long_long_type>(v), bad_lexical_cast);
 #elif defined(BOOST_HAS_MS_INT64)
-    BOOST_CHECK_THROW(lexical_cast<unsigned __int64>(v), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<__int64>(v), bad_lexical_cast);
+    BOOST_TEST_THROWS(lexical_cast<unsigned __int64>(v), bad_lexical_cast);
+    BOOST_TEST_THROWS(lexical_cast<__int64>(v), bad_lexical_cast);
 #endif
 }
 
@@ -57,33 +52,33 @@ void test_empty_1()
 {
     boost::iterator_range<char*> v;
     do_test_on_empty_input(v);
-    BOOST_CHECK_EQUAL(lexical_cast<std::string>(v), std::string());
-    BOOST_CHECK_THROW(lexical_cast<char>(v), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<unsigned char>(v), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<signed char>(v), bad_lexical_cast);
+    BOOST_TEST_EQ(lexical_cast<std::string>(v), std::string());
+    BOOST_TEST_THROWS(lexical_cast<char>(v), bad_lexical_cast);
+    BOOST_TEST_THROWS(lexical_cast<unsigned char>(v), bad_lexical_cast);
+    BOOST_TEST_THROWS(lexical_cast<signed char>(v), bad_lexical_cast);
 
     boost::iterator_range<const char*> cv;
     do_test_on_empty_input(cv);
-    BOOST_CHECK_EQUAL(lexical_cast<std::string>(cv), std::string());
-    BOOST_CHECK_THROW(lexical_cast<char>(cv), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<unsigned char>(cv), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<signed char>(cv), bad_lexical_cast);
+    BOOST_TEST_EQ(lexical_cast<std::string>(cv), std::string());
+    BOOST_TEST_THROWS(lexical_cast<char>(cv), bad_lexical_cast);
+    BOOST_TEST_THROWS(lexical_cast<unsigned char>(cv), bad_lexical_cast);
+    BOOST_TEST_THROWS(lexical_cast<signed char>(cv), bad_lexical_cast);
 
     const boost::iterator_range<const char*> ccv;
     do_test_on_empty_input(ccv);
-    BOOST_CHECK_EQUAL(lexical_cast<std::string>(ccv), std::string());
-    BOOST_CHECK_THROW(lexical_cast<char>(ccv), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<unsigned char>(ccv), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<signed char>(ccv), bad_lexical_cast);
+    BOOST_TEST_EQ(lexical_cast<std::string>(ccv), std::string());
+    BOOST_TEST_THROWS(lexical_cast<char>(ccv), bad_lexical_cast);
+    BOOST_TEST_THROWS(lexical_cast<unsigned char>(ccv), bad_lexical_cast);
+    BOOST_TEST_THROWS(lexical_cast<signed char>(ccv), bad_lexical_cast);
 }
 
 void test_empty_2()
 {
     std::string v;
     do_test_on_empty_input(v);
-    BOOST_CHECK_THROW(lexical_cast<char>(v), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<unsigned char>(v), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<signed char>(v), bad_lexical_cast);
+    BOOST_TEST_THROWS(lexical_cast<char>(v), bad_lexical_cast);
+    BOOST_TEST_THROWS(lexical_cast<unsigned char>(v), bad_lexical_cast);
+    BOOST_TEST_THROWS(lexical_cast<signed char>(v), bad_lexical_cast);
 }
 
 void test_empty_3()
@@ -91,16 +86,16 @@ void test_empty_3()
     EscapeStruct v("");
     do_test_on_empty_input(v);
 
-    BOOST_CHECK_THROW(lexical_cast<char>(v), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<unsigned char>(v), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<signed char>(v), bad_lexical_cast);
+    BOOST_TEST_THROWS(lexical_cast<char>(v), bad_lexical_cast);
+    BOOST_TEST_THROWS(lexical_cast<unsigned char>(v), bad_lexical_cast);
+    BOOST_TEST_THROWS(lexical_cast<signed char>(v), bad_lexical_cast);
 
     v = lexical_cast<EscapeStruct>(100);
-    BOOST_CHECK_EQUAL(lexical_cast<int>(v), 100);
-    BOOST_CHECK_EQUAL(lexical_cast<unsigned int>(v), 100u);
+    BOOST_TEST_EQ(lexical_cast<int>(v), 100);
+    BOOST_TEST_EQ(lexical_cast<unsigned int>(v), 100u);
 
     v = lexical_cast<EscapeStruct>(0.0);
-    BOOST_CHECK_EQUAL(lexical_cast<double>(v), 0.0);
+    BOOST_TEST_EQ(lexical_cast<double>(v), 0.0);
 }
 
 namespace std {
@@ -108,7 +103,7 @@ inline std::ostream & operator<<(std::ostream & out, const std::vector<long> & v
 {
     std::ostream_iterator<long> it(out);
     std::copy(v.begin(), v.end(), it);
-    BOOST_CHECK(out);
+    BOOST_TEST(out);
     return out;
 }
 }
@@ -117,9 +112,9 @@ void test_empty_4()
 {
     std::vector<long> v;
     do_test_on_empty_input(v);
-    BOOST_CHECK_THROW(lexical_cast<char>(v), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<unsigned char>(v), bad_lexical_cast);
-    BOOST_CHECK_THROW(lexical_cast<signed char>(v), bad_lexical_cast);
+    BOOST_TEST_THROWS(lexical_cast<char>(v), bad_lexical_cast);
+    BOOST_TEST_THROWS(lexical_cast<unsigned char>(v), bad_lexical_cast);
+    BOOST_TEST_THROWS(lexical_cast<signed char>(v), bad_lexical_cast);
 }
 
 
@@ -132,19 +127,17 @@ struct my_string {
 void test_empty_5()
 {
     my_string st;
-    BOOST_CHECK_EQUAL(boost::lexical_cast<std::string>(st), std::string());;
+    BOOST_TEST_EQ(boost::lexical_cast<std::string>(st), std::string());;
 }
 
-unit_test::test_suite *init_unit_test_suite(int, char *[])
+int main()
 {
-    unit_test::test_suite *suite =
-        BOOST_TEST_SUITE("lexical_cast. Testing with BOOST_NO_STD_LOCALE");
-    suite->add(BOOST_TEST_CASE(&test_empty_1));
-    suite->add(BOOST_TEST_CASE(&test_empty_2));
-    suite->add(BOOST_TEST_CASE(&test_empty_3));
-    suite->add(BOOST_TEST_CASE(&test_empty_4));
-    suite->add(BOOST_TEST_CASE(&test_empty_5));
+    test_empty_1();
+    test_empty_2();
+    test_empty_3();
+    test_empty_4();
+    test_empty_5();
 
-    return suite;
+    return boost::report_errors();
 }
 
diff --git a/test/noncopyable_test.cpp b/test/noncopyable_test.cpp
index 9c155c4..cb4fb3f 100644
--- a/test/noncopyable_test.cpp
+++ b/test/noncopyable_test.cpp
@@ -3,6 +3,7 @@
 //  See http://www.boost.org for most recent version, including documentation.
 //
 //  Copyright Alexander Nasonov, 2007.
+//  Copyright Antony Polukhin, 2023.
 //
 //  Distributed under the Boost
 //  Software License, Version 1.0. (See accompanying file
@@ -10,30 +11,10 @@
 //
 //  Test that Source can be non-copyable.
 
-#include <boost/config.hpp>
-
-#if defined(__INTEL_COMPILER)
-#pragma warning(disable: 193 383 488 981 1418 1419)
-#elif defined(BOOST_MSVC)
-#pragma warning(disable: 4097 4100 4121 4127 4146 4244 4245 4511 4512 4701 4800)
-#endif
-
 #include <boost/lexical_cast.hpp>
 #include <boost/core/noncopyable.hpp>
-#include <boost/test/unit_test.hpp>
 
-using namespace boost;
-
-void test_noncopyable();
-
-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_noncopyable));
-
-    return suite;
-}
+#include <boost/core/lightweight_test.hpp>
 
 class Noncopyable : private boost::noncopyable
 {
@@ -49,6 +30,11 @@ inline std::ostream &operator<<(std::ostream &out, const Noncopyable&)
 void test_noncopyable()
 {
     Noncopyable x;
-    BOOST_CHECK(boost::lexical_cast<std::string>(x) == "Noncopyable");
+    BOOST_TEST(boost::lexical_cast<std::string>(x) == "Noncopyable");
 }
 
+int main()
+{
+    test_noncopyable();
+    return boost::report_errors();
+}
diff --git a/test/pointers_test.cpp b/test/pointers_test.cpp
index ed2de54..527c1f5 100644
--- a/test/pointers_test.cpp
+++ b/test/pointers_test.cpp
@@ -8,18 +8,9 @@
 //  Software License, Version 1.0. (See accompanying file
 //  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt).
 
-#include <boost/config.hpp>
-
-#if defined(__INTEL_COMPILER)
-#pragma warning(disable: 193 383 488 981 1418 1419)
-#elif defined(BOOST_MSVC)
-#pragma warning(disable: 4097 4100 4121 4127 4146 4244 4245 4511 4512 4701 4800)
-#endif
-
 #include <boost/lexical_cast.hpp>
-#include <boost/test/unit_test.hpp>
 
-using namespace boost;
+#include <boost/core/lightweight_test.hpp>
 
 #if defined(BOOST_NO_STRINGSTREAM)
             typedef std::strstream ss_t;
@@ -36,15 +27,15 @@ void test_void_pointers_conversions()
     ss_t ss;
 
     ss << p_to_null;
-    BOOST_CHECK_EQUAL(boost::lexical_cast<std::string>(p_to_null), ss.str());
+    BOOST_TEST_EQ(boost::lexical_cast<std::string>(p_to_null), ss.str());
     ss.str(std::string());
 
     ss << cp_to_data;
-    BOOST_CHECK_EQUAL(boost::lexical_cast<std::string>(cp_to_data), ss.str());
+    BOOST_TEST_EQ(boost::lexical_cast<std::string>(cp_to_data), ss.str());
     ss.str(std::string());
 
     ss << p_to_data;
-    BOOST_CHECK_EQUAL(boost::lexical_cast<std::string>(p_to_data), ss.str());
+    BOOST_TEST_EQ(boost::lexical_cast<std::string>(p_to_data), ss.str());
     ss.str(std::string());
 }
 
@@ -59,15 +50,15 @@ void test_incomplete_type_pointers_conversions()
     ss_t ss;
 
     ss << p_to_null;
-    BOOST_CHECK_EQUAL(boost::lexical_cast<std::string>(p_to_null), ss.str());
+    BOOST_TEST_EQ(boost::lexical_cast<std::string>(p_to_null), ss.str());
     ss.str(std::string());
 
     ss << cp_to_data;
-    BOOST_CHECK_EQUAL(boost::lexical_cast<std::string>(cp_to_data), ss.str());
+    BOOST_TEST_EQ(boost::lexical_cast<std::string>(cp_to_data), ss.str());
     ss.str(std::string());
 
     ss << p_to_data;
-    BOOST_CHECK_EQUAL(boost::lexical_cast<std::string>(p_to_data), ss.str());
+    BOOST_TEST_EQ(boost::lexical_cast<std::string>(p_to_data), ss.str());
     ss.str(std::string());
 }
 
@@ -82,15 +73,14 @@ void test_inomplete_type_with_overloaded_ostream_op() {
     meh heh = NULL;
     ss_t ss;
     ss << heh;
-    BOOST_CHECK_EQUAL(boost::lexical_cast<std::string>(heh), ss.str());
+    BOOST_TEST_EQ(boost::lexical_cast<std::string>(heh), ss.str());
 }
 
-unit_test::test_suite *init_unit_test_suite(int, char *[])
+int main()
 {
-    unit_test::test_suite *suite =
-        BOOST_TEST_SUITE("lexical_cast pinters test");
-    suite->add(BOOST_TEST_CASE(&test_void_pointers_conversions));
-    suite->add(BOOST_TEST_CASE(&test_incomplete_type_pointers_conversions));
-    suite->add(BOOST_TEST_CASE(&test_inomplete_type_with_overloaded_ostream_op));
-    return suite;
+    test_void_pointers_conversions();
+    test_incomplete_type_pointers_conversions();
+    test_inomplete_type_with_overloaded_ostream_op();
+
+    return boost::report_errors();
 }
diff --git a/test/stream_detection_test.cpp b/test/stream_detection_test.cpp
index 2634728..f65d598 100644
--- a/test/stream_detection_test.cpp
+++ b/test/stream_detection_test.cpp
@@ -8,12 +8,10 @@
 //  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 <boost/core/lightweight_test.hpp>
+
 #include <iostream>
 
 
@@ -24,7 +22,7 @@ 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);
+    int i; istr >> i; BOOST_TEST_EQ(i, streamable_easy::value);
     return istr;
 }
 
@@ -37,7 +35,7 @@ operator << (std::basic_ostream<CharT>& ostr, const streamable_medium&) {
 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);
+    int i; istr >> i; BOOST_TEST_EQ(i, streamable_medium::value);
     return istr;
 }
 
@@ -50,7 +48,7 @@ operator << (std::basic_ostream<CharT, TraitsT>& ostr, const streamable_hard&) {
 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);
+    int i; istr >> i; BOOST_TEST_EQ(i, streamable_hard::value);
     return istr;
 }
 
@@ -61,7 +59,7 @@ std::basic_ostream<char, TraitsT>& operator << (std::basic_ostream<char, TraitsT
 }
 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);
+    int i; istr >> i; BOOST_TEST_EQ(i, streamable_hard2::value);
     return istr;
 }
 
@@ -73,7 +71,7 @@ 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);
+    int i; istr >> i; BOOST_TEST_EQ(i, wstreamable_easy::value);
     return istr;
 }
 
@@ -86,7 +84,7 @@ operator << (std::basic_ostream<CharT>& ostr, const wstreamable_medium&) {
 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);
+    int i; istr >> i; BOOST_TEST_EQ(i, wstreamable_medium::value);
     return istr;
 }
 
@@ -99,7 +97,7 @@ operator << (std::basic_ostream<CharT, TraitsT>& ostr, const wstreamable_hard&)
 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);
+    int i; istr >> i; BOOST_TEST_EQ(i, wstreamable_hard::value);
     return istr;
 }
 
@@ -110,7 +108,7 @@ std::basic_ostream<wchar_t, TraitsT>& operator << (std::basic_ostream<wchar_t, T
 }
 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);
+    int i; istr >> i; BOOST_TEST_EQ(i, wstreamable_hard2::value);
     return istr;
 }
 
@@ -122,7 +120,7 @@ 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);
+    int i; istr >> i; BOOST_TEST_EQ(i, bistreamable_easy::value);
     return istr;
 }
 
@@ -130,7 +128,7 @@ 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);
+    int i; istr >> i; BOOST_TEST_EQ(i, bistreamable_easy::value + 100);
     return istr;
 }
 
@@ -141,7 +139,7 @@ std::basic_ostream<CharT>& operator << (std::basic_ostream<CharT>& ostr, const b
 }
 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));
+    int i; istr >> i; BOOST_TEST_EQ(i, bistreamable_medium::value + (sizeof(CharT) == 1 ? 0 : 100));
     return istr;
 }
 
@@ -152,7 +150,7 @@ std::basic_ostream<CharT, TraitsT>& operator << (std::basic_ostream<CharT, Trait
 }
 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));
+    int i; istr >> i; BOOST_TEST_EQ(i, bistreamable_hard::value + (sizeof(CharT) == 1 ? 0 : 100));
     return istr;
 }
 
@@ -163,7 +161,7 @@ std::basic_ostream<char, TraitsT>& operator << (std::basic_ostream<char, TraitsT
 }
 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);
+    int i; istr >> i; BOOST_TEST_EQ(i, bistreamable_hard2::value);
     return istr;
 }
 
@@ -173,49 +171,33 @@ std::basic_ostream<wchar_t, TraitsT>& operator << (std::basic_ostream<wchar_t, T
 }
 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);
+    int i; istr >> i; BOOST_TEST_EQ(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));
+    BOOST_TEST_EQ(T::value,  boost::lexical_cast<int>(streamable));
+    BOOST_TEST_EQ(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));
+    BOOST_TEST_EQ(T::value,  boost::lexical_cast<int>(streamable));
+    // BOOST_TEST_EQ(boost::lexical_cast<std::string>(T::value), boost::lexical_cast<std::string>(streamable)); // Shall not compile???
+    BOOST_TEST(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_TEST_EQ(T::value,  boost::lexical_cast<int>(streamable));
+    BOOST_TEST_EQ(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));
+    BOOST_TEST(boost::lexical_cast<std::wstring>(T::value + 100) == boost::lexical_cast<std::wstring>(streamable));
 }
 
 void test_ostream_character_detection() {
@@ -274,16 +256,12 @@ void test_istream_character_detection() {
 }
 
 
-
-
-
-
 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);
+    int i; istr >> i; BOOST_TEST_EQ(i, wistreamble_ostreamable::value);
     return istr;
 }
 
@@ -292,7 +270,7 @@ 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);
+    int i; istr >> i; BOOST_TEST_EQ(i, istreamble_wostreamable::value);
     return istr;
 }
 
@@ -300,8 +278,18 @@ 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_TEST_EQ(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);
+    BOOST_TEST_EQ(boost::lexical_cast<int>(istreamble_wostreamable()), istreamble_wostreamable::value);
+}
+
+
+int main()
+{
+    test_ostream_character_detection();
+    test_istream_character_detection();
+    test_mixed_stream_character_detection();
+
+    return boost::report_errors();
 }
diff --git a/test/stream_traits_test.cpp b/test/stream_traits_test.cpp
index bb1441c..a0febb4 100644
--- a/test/stream_traits_test.cpp
+++ b/test/stream_traits_test.cpp
@@ -8,41 +8,39 @@
 //  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/detail/converter_lexical.hpp>
 
-#include <boost/test/unit_test.hpp>
+#include <boost/core/lightweight_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);
+    BOOST_TEST(!trait_1::is_source_input_not_optimized_t::value);
+    BOOST_TEST((boost::is_same<typename trait_1::src_char_t, char>::value));
+    BOOST_TEST((boost::is_same<typename trait_1::target_char_t, char>::value));
+    BOOST_TEST((boost::is_same<typename trait_1::char_type, char>::value));
+    BOOST_TEST(!trait_1::is_string_widening_required_t::value);
+    BOOST_TEST(!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);
+    BOOST_TEST(!trait_2::is_source_input_not_optimized_t::value);
+    BOOST_TEST((boost::is_same<typename trait_2::src_char_t, char>::value));
+    BOOST_TEST((boost::is_same<typename trait_2::target_char_t, char>::value));
+    BOOST_TEST((boost::is_same<typename trait_2::char_type, char>::value));
+    BOOST_TEST(!trait_2::is_string_widening_required_t::value);
+    BOOST_TEST(!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_TEST(!trait_3::is_source_input_not_optimized_t::value);
+    BOOST_TEST((boost::is_same<typename trait_3::src_char_t, char>::value));
+    BOOST_TEST((boost::is_same<typename trait_3::target_char_t, wchar_t>::value));
+    BOOST_TEST((boost::is_same<typename trait_3::char_type, wchar_t>::value));
 
-    BOOST_CHECK((boost::detail::is_character<BOOST_DEDUCED_TYPENAME trait_3::no_cv_src>::value != trait_3::is_string_widening_required_t::value));
+    BOOST_TEST((boost::detail::is_character<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);
+    BOOST_TEST(!trait_3::is_source_input_not_optimized_t::value);
 }
 
 
@@ -53,27 +51,27 @@ static void test_optimized_types_to_string()
 
     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);
+    BOOST_TEST(!trait_4::is_source_input_not_optimized_t::value);
+    BOOST_TEST((boost::is_same<typename trait_4::src_char_t, char>::value));
+    BOOST_TEST((boost::is_same<typename trait_4::target_char_t, char>::value));
+    BOOST_TEST((boost::is_same<typename trait_4::char_type, char>::value));
+    BOOST_TEST(!trait_4::is_string_widening_required_t::value);
+    BOOST_TEST(!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);
+    BOOST_TEST(!trait_5::is_source_input_not_optimized_t::value);
+    BOOST_TEST((boost::is_same<typename trait_5::src_char_t, char>::value));
+    BOOST_TEST((boost::is_same<typename trait_5::target_char_t, char>::value));
+    BOOST_TEST((boost::is_same<typename trait_5::char_type, char>::value));
+    BOOST_TEST(!trait_5::is_string_widening_required_t::value);
+    BOOST_TEST(!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);
+    BOOST_TEST(!trait_6::is_source_input_not_optimized_t::value);
+    BOOST_TEST((boost::is_same<typename trait_6::src_char_t, wchar_t>::value));
+    BOOST_TEST((boost::is_same<typename trait_6::target_char_t, char>::value));
+    BOOST_TEST((boost::is_same<typename trait_6::char_type, wchar_t>::value));
+    BOOST_TEST(!trait_6::is_string_widening_required_t::value);
 }
 
 void test_metafunctions()
@@ -144,11 +142,11 @@ void test_metafunctions()
 #endif
 }
 
-boost::unit_test::test_suite *init_unit_test_suite(int, char *[])
+
+int main()
 {
-    boost::unit_test::test_suite *suite =
-        BOOST_TEST_SUITE("lexical_cast traits tests");
-    suite->add(BOOST_TEST_CASE(&test_metafunctions));
-    return suite;
+    test_metafunctions();
+
+    return boost::report_errors();
 }
 
diff --git a/test/to_pointer_test.cpp b/test/to_pointer_test.cpp
index adfaf5b..1693ec8 100644
--- a/test/to_pointer_test.cpp
+++ b/test/to_pointer_test.cpp
@@ -9,15 +9,10 @@
 //  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*[])
+int main()
 {
     boost::lexical_cast<char*>("Hello");
-    BOOST_CHECK(false); // suppressing warning about 'boost::unit_test::{anonymous}::unit_test_log' defined but not used
-    return 0;
+    return 1;
 }
 
diff --git a/test/try_lexical_convert.cpp b/test/try_lexical_convert.cpp
index b9aaf5e..83e500e 100644
--- a/test/try_lexical_convert.cpp
+++ b/test/try_lexical_convert.cpp
@@ -2,16 +2,15 @@
 //
 //  See http://www.boost.org for most recent version, including documentation.
 //
-//  Copyright Antony Polukhin, 2014-2019.
+//  Copyright Antony Polukhin, 2014-2023.
 //
 //  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/try_lexical_convert.hpp>
-#include <boost/test/unit_test.hpp>
+
+#include <boost/core/lightweight_test.hpp>
 
 using namespace boost::conversion;
 
@@ -19,28 +18,28 @@ void try_uncommon_cases()
 {
     std::string sres;
     const bool res1 = try_lexical_convert(std::string("Test string"), sres);
-    BOOST_CHECK(res1);
-    BOOST_CHECK_EQUAL(sres, "Test string");
+    BOOST_TEST(res1);
+    BOOST_TEST_EQ(sres, "Test string");
 
     volatile int vires;
     const bool res2 = try_lexical_convert(100, vires);
-    BOOST_CHECK(res2);
-    BOOST_CHECK_EQUAL(vires, 100);
+    BOOST_TEST(res2);
+    BOOST_TEST_EQ(vires, 100);
 
     const bool res3 = try_lexical_convert("Test string", sres);
-    BOOST_CHECK(res3);
-    BOOST_CHECK_EQUAL(sres, "Test string");
+    BOOST_TEST(res3);
+    BOOST_TEST_EQ(sres, "Test string");
 
     const bool res4 = try_lexical_convert("Test string", sizeof("Test string") - 1, sres);
-    BOOST_CHECK(res4);
-    BOOST_CHECK_EQUAL(sres, "Test string");
+    BOOST_TEST(res4);
+    BOOST_TEST_EQ(sres, "Test string");
 
     int ires;
-    BOOST_CHECK(!try_lexical_convert("Test string", ires));
-    BOOST_CHECK(!try_lexical_convert(1.1, ires));
-    BOOST_CHECK(!try_lexical_convert(-1.9, ires));
-    BOOST_CHECK(!try_lexical_convert("1.1", ires));
-    BOOST_CHECK(!try_lexical_convert("1000000000000000000000000000000000000000", ires));
+    BOOST_TEST(!try_lexical_convert("Test string", ires));
+    BOOST_TEST(!try_lexical_convert(1.1, ires));
+    BOOST_TEST(!try_lexical_convert(-1.9, ires));
+    BOOST_TEST(!try_lexical_convert("1.1", ires));
+    BOOST_TEST(!try_lexical_convert("1000000000000000000000000000000000000000", ires));
 }
 
 
@@ -48,31 +47,29 @@ void try_common_cases()
 {
     int ires = 0;
     const bool res1 = try_lexical_convert(std::string("100"), ires);
-    BOOST_CHECK(res1);
-    BOOST_CHECK_EQUAL(ires, 100);
+    BOOST_TEST(res1);
+    BOOST_TEST_EQ(ires, 100);
 
     ires = 0;
     const bool res2 = try_lexical_convert("-100", ires);
-    BOOST_CHECK(res2);
-    BOOST_CHECK_EQUAL(ires, -100);
+    BOOST_TEST(res2);
+    BOOST_TEST_EQ(ires, -100);
 
     float fres = 1.0f;
     const bool res3 = try_lexical_convert("0.0", fres);
-    BOOST_CHECK(res3);
-    BOOST_CHECK_EQUAL(fres, 0.0f);
+    BOOST_TEST(res3);
+    BOOST_TEST_EQ(fres, 0.0f);
 
     fres = 1.0f;
     const bool res4 = try_lexical_convert("0.0", sizeof("0.0") - 1, fres);
-    BOOST_CHECK(res4);
-    BOOST_CHECK_EQUAL(fres, 0.0f);
+    BOOST_TEST(res4);
+    BOOST_TEST_EQ(fres, 0.0f);
 }
 
-boost::unit_test::test_suite *init_unit_test_suite(int, char *[])
+int main()
 {
-    boost::unit_test::test_suite *suite =
-        BOOST_TEST_SUITE("Tests for try_lexical_convert");
-    suite->add(BOOST_TEST_CASE(&try_uncommon_cases));
-    suite->add(BOOST_TEST_CASE(&try_common_cases));
+    try_uncommon_cases();
+    try_common_cases();
 
-    return suite;
+    return boost::report_errors();
 }
diff --git a/test/typedefed_wchar_test.cpp b/test/typedefed_wchar_test.cpp
index b945599..e8583ec 100644
--- a/test/typedefed_wchar_test.cpp
+++ b/test/typedefed_wchar_test.cpp
@@ -8,11 +8,9 @@
 //  Software License, Version 1.0. (See accompanying file
 //  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt).
 
-#include <boost/config.hpp>
-
-#include <boost/static_assert.hpp>
 #include <boost/lexical_cast.hpp>
 
+#include <boost/static_assert.hpp>
 #include <boost/date_time/gregorian/gregorian.hpp>
 #include <boost/date_time/posix_time/posix_time.hpp>
 
diff --git a/test/typedefed_wchar_test_runtime.cpp b/test/typedefed_wchar_test_runtime.cpp
index 17211ba..ae432eb 100644
--- a/test/typedefed_wchar_test_runtime.cpp
+++ b/test/typedefed_wchar_test_runtime.cpp
@@ -8,46 +8,33 @@
 //  Software License, Version 1.0. (See accompanying file
 //  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt).
 
-#include <boost/config.hpp>
-
-#if defined(__INTEL_COMPILER)
-#pragma warning(disable: 193 383 488 981 1418 1419)
-#elif defined(BOOST_MSVC)
-#pragma warning(disable: 4097 4100 4121 4127 4146 4244 4245 4511 4512 4701 4800)
-#endif
-
 #include <boost/lexical_cast.hpp>
 
-#include <boost/test/unit_test.hpp>
-using namespace boost;
+#include <boost/core/lightweight_test.hpp>
 
 void test_typedefed_wchar_t(unsigned short)  // wchar_t is a typedef for unsigned short
 {
-    BOOST_CHECK(boost::lexical_cast<int>(L'A') == 65);
-    BOOST_CHECK(boost::lexical_cast<int>(L'B') == 66);
+    BOOST_TEST(boost::lexical_cast<int>(L'A') == 65);
+    BOOST_TEST(boost::lexical_cast<int>(L'B') == 66);
 
-    BOOST_CHECK(boost::lexical_cast<wchar_t>(L"65") == 65);
-    BOOST_CHECK(boost::lexical_cast<wchar_t>(L"66") == 66);
+    BOOST_TEST(boost::lexical_cast<wchar_t>(L"65") == 65);
+    BOOST_TEST(boost::lexical_cast<wchar_t>(L"66") == 66);
 }
 
 template <class T>
 void test_typedefed_wchar_t(T)
 {
-    BOOST_CHECK(1);
+    BOOST_TEST(1);
 }
 
-
-
 void test_typedefed_wchar_t_runtime()
 {
     test_typedefed_wchar_t(L'0');
 }
 
-unit_test::test_suite *init_unit_test_suite(int, char *[])
+int main()
 {
-    unit_test::test_suite *suite =
-        BOOST_TEST_SUITE("lexical_cast typedefed wchar_t runtime test");
-    suite->add(BOOST_TEST_CASE(&test_typedefed_wchar_t_runtime));
+    test_typedefed_wchar_t_runtime();
 
-    return suite;
+    return boost::report_errors();
 }
diff --git a/test/vc8_bug_test.cpp b/test/vc8_bug_test.cpp
index 0f5b24f..281c7e5 100644
--- a/test/vc8_bug_test.cpp
+++ b/test/vc8_bug_test.cpp
@@ -12,10 +12,10 @@
 // implementation has changed and it does not use stringstream for casts
 // to integral types
 
-#include <boost/config.hpp>
 #include <boost/lexical_cast.hpp>
 #include <boost/cstdint.hpp>
-#include <boost/test/unit_test.hpp>
+
+#include <boost/core/lightweight_test.hpp>
 
 #include <string>
 
@@ -37,22 +37,22 @@ void test_too_long_number(CharT zero)
     std::basic_ostringstream<CharT> o;
     o << (limits::max)() << zero;
     s = o.str();
-    BOOST_CHECK_THROW(lexical_cast<T>(s), bad_lexical_cast);
+    BOOST_TEST_THROWS(lexical_cast<T>(s), bad_lexical_cast);
     s[s.size()-1] += static_cast<CharT>(9); // '0' -> '9'
-    BOOST_CHECK_THROW(lexical_cast<T>(s), bad_lexical_cast);
+    BOOST_TEST_THROWS(lexical_cast<T>(s), bad_lexical_cast);
 
     if (limits::is_signed)
     {
         std::basic_ostringstream<CharT> o2;
         o2 << (limits::min)() << zero;
         s = o2.str();
-        BOOST_CHECK_THROW(lexical_cast<T>(s), bad_lexical_cast);
+        BOOST_TEST_THROWS(lexical_cast<T>(s), bad_lexical_cast);
         s[s.size()-1] += static_cast<CharT>(9); // '0' -> '9'
-        BOOST_CHECK_THROW(lexical_cast<T>(s), bad_lexical_cast);
+        BOOST_TEST_THROWS(lexical_cast<T>(s), bad_lexical_cast);
     }
 }
 
-void test_vc8_bug()
+int main()
 {
     test_too_long_number<boost::intmax_t>('0');
     test_too_long_number<boost::uintmax_t>('0');
@@ -60,12 +60,6 @@ void test_vc8_bug()
     test_too_long_number<boost::intmax_t>(L'0');
     test_too_long_number<boost::uintmax_t>(L'0');
 #endif
-}
 
-unit_test::test_suite *init_unit_test_suite(int, char *[])
-{
-    unit_test::test_suite *suite =
-        BOOST_TEST_SUITE("lexical_cast vc8 bug unit test");
-    suite->add(BOOST_TEST_CASE(test_vc8_bug));
-    return suite;
+    return boost::report_errors();
 }
diff --git a/test/wchars_test.cpp b/test/wchars_test.cpp
index f8eb679..a4390d9 100644
--- a/test/wchars_test.cpp
+++ b/test/wchars_test.cpp
@@ -8,18 +8,9 @@
 //  Software License, Version 1.0. (See accompanying file
 //  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt).
 
-#include <boost/config.hpp>
-
-#if defined(__INTEL_COMPILER)
-#pragma warning(disable: 193 383 488 981 1418 1419)
-#elif defined(BOOST_MSVC)
-#pragma warning(disable: 4097 4100 4121 4127 4146 4244 4245 4511 4512 4701 4800)
-#endif
-
 #include <boost/lexical_cast.hpp>
-#include <boost/test/unit_test.hpp>
 
-using namespace boost;
+#include <boost/core/lightweight_test.hpp>
 
 #if defined(BOOST_NO_STRINGSTREAM) || defined(BOOST_NO_STD_WSTRING)
 #define BOOST_LCAST_NO_WCHAR_T
@@ -36,14 +27,14 @@ void test_impl(const CharT* wc_arr)
 
     // Following tests depend on realization of std::locale
     // and pass for popular compilers and STL realizations
-    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_TEST(boost::lexical_cast<wide_char>(c_arr[0]) == wc_arr[0]);
+    BOOST_TEST(boost::lexical_cast<wide_string>(c_arr) == wide_string(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_TEST(boost::lexical_cast<wide_string>(sc_arr) == wide_string(wc_arr) );
+    BOOST_TEST(boost::lexical_cast<wide_string>(uc_arr) == wide_string(wc_arr) );
 
-    BOOST_CHECK(boost::lexical_cast<wide_char>(uc_arr[0]) == wc_arr[0]);
-    BOOST_CHECK(boost::lexical_cast<wide_char>(sc_arr[0]) == wc_arr[0]);
+    BOOST_TEST(boost::lexical_cast<wide_char>(uc_arr[0]) == wc_arr[0]);
+    BOOST_TEST(boost::lexical_cast<wide_char>(sc_arr[0]) == wc_arr[0]);
 }
 
 
@@ -52,25 +43,25 @@ void test_char_types_conversions_wchar_t()
 #ifndef BOOST_LCAST_NO_WCHAR_T
     test_impl(L"Test array of chars");
     wchar_t c = boost::detail::lcast_char_constants<wchar_t>::zero;
-    BOOST_CHECK(L'0' == c);
+    BOOST_TEST(L'0' == c);
 
     c = boost::detail::lcast_char_constants<wchar_t>::minus;
-    BOOST_CHECK(L'-' == c);
+    BOOST_TEST(L'-' == c);
 
     c = boost::detail::lcast_char_constants<wchar_t>::plus;
-    BOOST_CHECK(L'+' == c);
+    BOOST_TEST(L'+' == c);
 
     c = boost::detail::lcast_char_constants<wchar_t>::lowercase_e;
-    BOOST_CHECK(L'e' == c);
+    BOOST_TEST(L'e' == c);
 
     c = boost::detail::lcast_char_constants<wchar_t>::capital_e;
-    BOOST_CHECK(L'E' == c);
+    BOOST_TEST(L'E' == c);
 
     c = boost::detail::lcast_char_constants<wchar_t>::c_decimal_separator;
-    BOOST_CHECK(L'.' == c);
+    BOOST_TEST(L'.' == c);
 #endif
 
-    BOOST_CHECK(true);
+    BOOST_TEST(true);
 }
 
 void test_char_types_conversions_char16_t()
@@ -78,25 +69,25 @@ void test_char_types_conversions_char16_t()
 #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");
     char16_t c = boost::detail::lcast_char_constants<char16_t>::zero;
-    BOOST_CHECK(u'0' == c);
+    BOOST_TEST(u'0' == c);
 
     c = boost::detail::lcast_char_constants<char16_t>::minus;
-    BOOST_CHECK(u'-' == c);
+    BOOST_TEST(u'-' == c);
 
     c = boost::detail::lcast_char_constants<char16_t>::plus;
-    BOOST_CHECK(u'+' == c);
+    BOOST_TEST(u'+' == c);
 
     c = boost::detail::lcast_char_constants<char16_t>::lowercase_e;
-    BOOST_CHECK(u'e' == c);
+    BOOST_TEST(u'e' == c);
 
     c = boost::detail::lcast_char_constants<char16_t>::capital_e;
-    BOOST_CHECK(u'E' == c);
+    BOOST_TEST(u'E' == c);
 
     c = boost::detail::lcast_char_constants<char16_t>::c_decimal_separator;
-    BOOST_CHECK(u'.' == c);
+    BOOST_TEST(u'.' == c);
 #endif
 
-    BOOST_CHECK(true);
+    BOOST_TEST(true);
 }
 
 void test_char_types_conversions_char32_t()
@@ -104,34 +95,32 @@ void test_char_types_conversions_char32_t()
 #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");
     char32_t c = boost::detail::lcast_char_constants<char32_t>::zero;
-    BOOST_CHECK(U'0' == c);
+    BOOST_TEST(U'0' == c);
 
     c = boost::detail::lcast_char_constants<char32_t>::minus;
-    BOOST_CHECK(U'-' == c);
+    BOOST_TEST(U'-' == c);
 
     c = boost::detail::lcast_char_constants<char32_t>::plus;
-    BOOST_CHECK(U'+' == c);
+    BOOST_TEST(U'+' == c);
 
     c = boost::detail::lcast_char_constants<char32_t>::lowercase_e;
-    BOOST_CHECK(U'e' == c);
+    BOOST_TEST(U'e' == c);
 
     c = boost::detail::lcast_char_constants<char32_t>::capital_e;
-    BOOST_CHECK(U'E', == c);
+    BOOST_TEST(U'E', == c);
 
     c = boost::detail::lcast_char_constants<char32_t>::c_decimal_separator;
-    BOOST_CHECK(U'.' == c);
+    BOOST_TEST(U'.' == c);
 #endif
 
-    BOOST_CHECK(true);
+    BOOST_TEST(true);
 }
 
-unit_test::test_suite *init_unit_test_suite(int, char *[])
+int main()
 {
-    unit_test::test_suite *suite =
-        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));
+    test_char_types_conversions_wchar_t();
+    test_char_types_conversions_char16_t();
+    test_char_types_conversions_char32_t();
 
-    return suite;
+    return boost::report_errors();
 }