Do not run lightweight_test_fail16.cpp under CMake, as CTest doesn't like std::abort

Moved is_same implementation to detail (both directory and namespace)
to use in the public headers and avoid introducing new dependencies.
The documentation now recommends users to use Boost.TypeTraits or
C++ standard library instead.

Also, removed unnecessary includes and added missing ones in a few
places.

doc/changes.qbk

@@ -1,16 +1,55 @@
 [/
   Copyright 2021 Peter Dimov
+  Copyright 2022 Andrey Semashev
   Distributed under the Boost Software License, Version 1.0.
   https://boost.org/LICENSE_1_0.txt)
 ]
 
 [section Revision History]
 
+[section Changes in 1.82.0]
+
+* Added [link core.snprintf `boost/core/snprintf.hpp`] header with portable definitions of `snprintf`, `vsnprintf` and
+  their `wchar_t` counterparts.
+* Deprecated `boost/core/is_same.hpp` and `boost::core::is_same`. The header will be removed in a future release.
+  Users are advised to use [@http://www.boost.org/doc/libs/release/libs/type_traits/doc/html/index.html Boost.TypeTraits]
+  or C++ standard library type traits instead.
+
+[endsect]
+
+[section Changes in 1.81.0]
+
+* [link core.empty_value `empty_value`] members are now marked as `constexpr`.
+* Added [link core.fclose_deleter `fclose_deleter`], a deleter that calls `std::fclose` on a pointer to `std::FILE`.
+* Bit manipulation utilities in [link core.bit `boost/core/bit.hpp`] now explicitly require unsigned integers on input.
+  ([@https://github.com/boostorg/core/issues/129 #129])
+* `bit_width` now returns `int` instead of a value of the input argument type. This follows the
+  resolution of [@https://cplusplus.github.io/LWG/issue3656 LWG3656].
+
+[endsect]
+
+[section Changes in 1.80.0]
+
+* In [link core.allocator_access `boost/core/allocator_access.hpp`], added detection of `construct` and `destroy`
+  members of an allocator.
+* `boost/core/alloc_construct.hpp` header is now deprecated and will be removed in a future release. Its functionality
+  was moved to [link core.allocator_access `boost/core/allocator_access.hpp`]. In particular, new methods
+  `allocator_construct_n` and `allocator_destroy_n` were added for allocating and destroying arrays.
+* Worked around MSVC bug that failed to compile [link core.span `span`] in C++17 mode when Boost.Range headers were included.
+  ([@https://github.com/boostorg/core/issues/105 #105], [@https://github.com/boostorg/core/pull/115 PR#115])
+* Added support for 128-bit integer types in [link core.type_name `type_name`].
+* In [link core.pointer_traits `pointer_traits`], pointer rebinding now supports C++03 compilers.
+
+[endsect]
+
 [section Changes in 1.79.0]
 
 * Added `boost::allocator_traits`, an implementation of `std::allocator_traits`.
 * Made `boost::pointer_traits` SFINAE friendly.
-* `boost/iterator.hpp` is deprecated and will be removed in a future release. The header defines `boost::iterator` template, which is equivalent to `std::iterator` in `<iterator>` header. However, since `std::iterator` is itself deprecated in C++17, users are advised to remove `boost::iterator` or `std::iterator` use from their code.
+* `boost/iterator.hpp` is deprecated and will be removed in a future release. The header defines the
+  `boost::iterator` template, which is equivalent to `std::iterator` in the `<iterator>` header. However,
+  since `std::iterator` is itself deprecated in C++17, users are advised to remove the use of `boost::iterator`
+  or `std::iterator` from their code.
 * Added `boost::core::verbose_terminate_handler`, a utility function intended
   to be passed to `std::set_terminate` that prints information about the
   uncaught exception to `stderr`.

doc/core.qbk

@@ -70,6 +70,7 @@ criteria for inclusion is that the utility component be:
 [include swap.qbk]
 [include typeinfo.qbk]
 [include type_name.qbk]
+[include snprintf.qbk]
 [include uncaught_exceptions.qbk]
 [include use_default.qbk]
 [include verbose_terminate_handler.qbk]

doc/is_same.qbk

@@ -17,6 +17,11 @@
 
 [section Header <boost/core/is_same.hpp>]
 
+[warning This component is deprecated and will be removed in a future release.
+Users are recommended to use `boost::is_same` from
+[@http://www.boost.org/doc/libs/release/libs/type_traits/doc/html/index.html Boost.TypeTraits]
+or `std::is_same` from C++ standard library `<type_traits>` instead.]
+
 The header `<boost/core/is_same.hpp>` defines the class template
 `boost::core::is_same<T1,T2>`. It defines a nested integral constant
 `value` which is `true` when `T1` and `T2` are the same type, and

doc/lightweight_test.qbk

@@ -51,8 +51,16 @@ When using `lightweight_test.hpp`, *do not forget* to
 
 namespace boost
 {
-    int report_errors();
-}
+
+int report_errors();
+
+namespace core
+{
+
+void lwt_init();
+
+} // namespace core
+} // namespace boost
 ``
 
 [endsect]
@@ -246,6 +254,25 @@ Return the error count from `main`.
 
 [endsect]
 
+[section lwt_init]
+
+``
+void boost::core::lwt_init()
+``
+
+Performs one-time initialization. Disables the interactive message
+boxes displayed by the Microsoft Windows debug runtime library on
+`abort`, failing `assert`, and other abnormal program terminations
+(to facilitate unattended testing), and ensures that in case
+`boost::report_errors` is not called (a common mistake), the program
+ends with a nonzero exit code.
+
+`lwt_init` is automatically called by the test macros. There is
+no need to call it explicitly, except in cases where a test fails due
+to e.g. an assertion failure before the first test macro is invoked.
+
+[endsect]
+
 [section Example]
 
 ``
@@ -326,14 +353,14 @@ parentheses.)
 
 ``
 #include <boost/core/lightweight_test_trait.hpp>
-#include <boost/core/is_same.hpp>
+#include <boost/type_traits/is_same.hpp>
 
 template<class T, class U> struct X
 {
     typedef T type;
 };
 
-using boost::core::is_same;
+using boost::is_same;
 
 int main()
 {

doc/snprintf.qbk

@@ -0,0 +1,47 @@
+[/
+ / Copyright (c) 2022 Andrey Semashev
+ /
+ / 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)
+ /]
+
+[section:snprintf snprintf]
+
+[simplesect Authors]
+
+* Andrey Semashev
+
+[endsimplesect]
+
+[section Header <boost/core/snprintf.hpp>]
+
+The header `<boost/core/snprintf.hpp>` provides portable definition of [@https://en.cppreference.com/w/c/io/fprintf `snprintf`],
+`vsnprintf` and their corresponding `wchar_t` counterparts. On a platform that supports these functions in the standard library,
+these definitions are equivalent to the standard functions. On other platforms (mainly, older MSVC versions) these functions
+are emulated through non-standard functions that have similar behavior.
+
+Depending on the standard library, certain implementation differences are exposed to the user:
+
+* Any non-standard behavior with respect to string format description are not hidden by the emulation.
+* Returned value of `boost::core::snprintf` in case if the output buffer is too small may not be equal to the number of characters
+  that would have been written if the buffer was large enough. It is, however, equal or larger than the buffer size,
+  which still allows the caller to detect the buffer overflow condition. The formatted output is still properly null-terminated
+  in this case.
+
+[note Unlike `snprintf`, `swprintf` does not return the number of characters to be written if the output buffer is too small
+but returns -1 instead. Furthermore, `swprintf` may or may not produce characters in the output buffer in this case.]
+
+[section Example]
+``
+char buf[10];
+int n = boost::core::snprintf(buf, sizeof(buf), "%d", i);
+if (n < 0)
+    throw std::runtime_error("Formatting error");
+if (n >= sizeof(buf))
+    throw std::runtime_error("Formatting buffer overflow");
+``
+[endsect]
+
+[endsect]
+
+[endsect]

include/boost/core/allocator_access.hpp

@@ -807,14 +807,14 @@ using allocator_rebind_t = typename allocator_rebind<A, T>::type;
 
 } /* boost */
 
-#if defined(_LIBCPP_SUPPRESS_DEPRECATED_POP)
-_LIBCPP_SUPPRESS_DEPRECATED_POP
+#if defined(_MSC_VER)
+#pragma warning(pop)
 #endif
 #if defined(_STL_RESTORE_DEPRECATED_WARNING)
 _STL_RESTORE_DEPRECATED_WARNING
 #endif
-#if defined(_MSC_VER)
-#pragma warning(pop)
+#if defined(_LIBCPP_SUPPRESS_DEPRECATED_POP)
+_LIBCPP_SUPPRESS_DEPRECATED_POP
 #endif
 
 #endif

include/boost/core/detail/is_same.hpp

@@ -0,0 +1,39 @@
+#ifndef BOOST_CORE_DETAIL_IS_SAME_HPP_INCLUDED
+#define BOOST_CORE_DETAIL_IS_SAME_HPP_INCLUDED
+
+// is_same<T1,T2>::value is true when T1 == T2
+//
+// Copyright 2014 Peter Dimov
+//
+// Distributed under the Boost Software License, Version 1.0.
+// See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/config.hpp>
+
+#if defined(BOOST_HAS_PRAGMA_ONCE)
+# pragma once
+#endif
+
+namespace boost
+{
+namespace core
+{
+namespace detail
+{
+
+template< class T1, class T2 > struct is_same
+{
+    BOOST_STATIC_CONSTANT( bool, value = false );
+};
+
+template< class T > struct is_same< T, T >
+{
+    BOOST_STATIC_CONSTANT( bool, value = true );
+};
+
+} // namespace detail
+} // namespace core
+} // namespace boost
+
+#endif // #ifndef BOOST_CORE_DETAIL_IS_SAME_HPP_INCLUDED

include/boost/core/detail/lwt_unattended.hpp

@@ -0,0 +1,45 @@
+#ifndef BOOST_CORE_DETAIL_LWT_UNATTENDED_HPP_INCLUDED
+#define BOOST_CORE_DETAIL_LWT_UNATTENDED_HPP_INCLUDED
+
+// Copyright 2014, 2022 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <cstdlib>
+#if defined(_MSC_VER) && defined(_CPPLIB_VER) && defined(_DEBUG)
+# include <crtdbg.h>
+#endif
+
+namespace boost
+{
+namespace core
+{
+namespace detail
+{
+
+// Setup unattended mode by disabling interactive popups on
+// assertion failures
+
+inline void lwt_unattended()
+{
+#if defined(_MSC_VER) && (_MSC_VER > 1310)
+
+    // disable message boxes on assert(), abort()
+    ::_set_abort_behavior( 0, _WRITE_ABORT_MSG | _CALL_REPORTFAULT );
+
+#endif
+
+#if defined(_MSC_VER) && defined(_CPPLIB_VER) && defined(_DEBUG)
+
+    // disable message boxes on iterator debugging violations
+    _CrtSetReportMode( _CRT_ASSERT, _CRTDBG_MODE_FILE );
+    _CrtSetReportFile( _CRT_ASSERT, _CRTDBG_FILE_STDERR );
+
+#endif
+}
+
+} // namespace detail
+} // namespace core
+} // namespace boost
+
+#endif // #ifndef BOOST_CORE_DETAIL_LWT_UNATTENDED_HPP_INCLUDED

include/boost/core/detail/string_view.hpp

@@ -14,7 +14,7 @@
 // https://www.boost.org/LICENSE_1_0.txt
 
 #include <boost/core/enable_if.hpp>
-#include <boost/core/is_same.hpp>
+#include <boost/core/detail/is_same.hpp>
 #include <boost/assert.hpp>
 #include <boost/assert/source_location.hpp>
 #include <boost/throw_exception.hpp>
@@ -381,7 +381,7 @@ public:
     }
 
     template<class End> BOOST_CXX14_CONSTEXPR basic_string_view( Ch const* first, End last,
-        typename boost::enable_if<is_same<End, Ch const*> >::type* = 0 ) BOOST_NOEXCEPT: p_( first ), n_( last - first )
+        typename boost::enable_if<boost::core::detail::is_same<End, Ch const*> >::type* = 0 ) BOOST_NOEXCEPT: p_( first ), n_( last - first )
     {
         BOOST_ASSERT( last - first >= 0 );
     }
@@ -399,7 +399,7 @@ public:
 #endif
 
     template<class Ch2> basic_string_view( boost::basic_string_view<Ch2, std::char_traits<Ch2> > const& str,
-        typename boost::enable_if<is_same<Ch, Ch2> >::type* = 0 ) BOOST_NOEXCEPT: p_( str.data() ), n_( str.size() )
+        typename boost::enable_if<boost::core::detail::is_same<Ch, Ch2> >::type* = 0 ) BOOST_NOEXCEPT: p_( str.data() ), n_( str.size() )
     {
     }
 
@@ -430,7 +430,7 @@ public:
 
 #if !defined(BOOST_NO_CXX17_HDR_STRING_VIEW)
 
-    template<class Ch2, class En = typename boost::enable_if<is_same<Ch2, Ch> >::type>
+    template<class Ch2, class En = typename boost::enable_if<boost::core::detail::is_same<Ch2, Ch> >::type>
     operator std::basic_string_view<Ch2>() const BOOST_NOEXCEPT
     {
         return std::basic_string_view<Ch>( data(), size() );
@@ -439,7 +439,7 @@ public:
 #endif
 
     template<class Ch2> operator boost::basic_string_view<Ch2,
-        typename boost::enable_if<boost::core::is_same<Ch2, Ch>, std::char_traits<Ch> >::type> () const BOOST_NOEXCEPT
+        typename boost::enable_if<boost::core::detail::is_same<Ch2, Ch>, std::char_traits<Ch> >::type> () const BOOST_NOEXCEPT
     {
         return boost::basic_string_view< Ch, std::char_traits<Ch> >( data(), size() );
     }
@@ -605,7 +605,7 @@ public:
         if( cmp != 0 ) return cmp;
 
         if( size() == str.size() ) return 0;
-        
+
         return size() < str.size()? -1: +1;
     }
 

include/boost/core/is_same.hpp

@@ -1,12 +1,6 @@
 #ifndef BOOST_CORE_IS_SAME_HPP_INCLUDED
 #define BOOST_CORE_IS_SAME_HPP_INCLUDED
 
-// MS compatible compilers support #pragma once
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
-# pragma once
-#endif
-
 // is_same<T1,T2>::value is true when T1 == T2
 //
 // Copyright 2014 Peter Dimov
@@ -16,6 +10,15 @@
 // http://www.boost.org/LICENSE_1_0.txt
 
 #include <boost/config.hpp>
+#include <boost/core/detail/is_same.hpp>
+
+#if defined(BOOST_HAS_PRAGMA_ONCE)
+# pragma once
+#endif
+
+#include <boost/config/header_deprecated.hpp>
+
+BOOST_HEADER_DEPRECATED("<boost/type_traits/is_same.hpp>")
 
 namespace boost
 {
@@ -23,15 +26,7 @@ namespace boost
 namespace core
 {
 
-template< class T1, class T2 > struct is_same
-{
-    BOOST_STATIC_CONSTANT( bool, value = false );
-};
-
-template< class T > struct is_same< T, T >
-{
-    BOOST_STATIC_CONSTANT( bool, value = true );
-};
+using boost::core::detail::is_same;
 
 } // namespace core
 

include/boost/core/lightweight_test.hpp

@@ -22,6 +22,7 @@
 //  http://www.boost.org/LICENSE_1_0.txt
 //
 
+#include <boost/core/detail/lwt_unattended.hpp>
 #include <boost/current_function.hpp>
 #include <boost/config.hpp>
 #include <exception>
@@ -32,11 +33,6 @@
 #include <cstring>
 #include <cstddef>
 #include <cctype>
-#include <cstdio>
-
-#if defined(_MSC_VER) && defined(_CPPLIB_VER) && defined(_DEBUG)
-# include <crtdbg.h>
-#endif
 
 //  IDE's like Visual Studio perform better if output goes to std::cout or
 //  some other stream, so allow user to configure output stream:
@@ -46,42 +42,39 @@
 
 namespace boost
 {
-
 namespace detail
 {
 
-class test_result {
+class test_result
+{
 public:
-    test_result()
-        : report_(false)
-        , errors_(0) {
-#if defined(_MSC_VER) && (_MSC_VER > 1310)
-        // disable message boxes on assert(), abort()
-        ::_set_abort_behavior(0, _WRITE_ABORT_MSG | _CALL_REPORTFAULT);
-#endif
-#if defined(_MSC_VER) && defined(_CPPLIB_VER) && defined(_DEBUG)
-        // disable message boxes on iterator debugging violations
-        _CrtSetReportMode( _CRT_ASSERT, _CRTDBG_MODE_FILE );
-        _CrtSetReportFile( _CRT_ASSERT, _CRTDBG_FILE_STDERR );
-#endif
+
+    test_result(): report_( false ), errors_( 0 )
+    {
+        core::detail::lwt_unattended();
     }
 
-    ~test_result() {
-        if (!report_) {
+    ~test_result()
+    {
+        if( !report_ )
+        {
             BOOST_LIGHTWEIGHT_TEST_OSTREAM << "main() should return report_errors()" << std::endl;
             std::abort();
         }
     }
 
-    int& errors() {
+    int& errors()
+    {
         return errors_;
     }
 
-    void done() {
+    void done()
+    {
         report_ = true;
     }
 
 private:
+
     bool report_;
     int errors_;
 };
@@ -197,11 +190,6 @@ inline unsigned long test_output_impl( char16_t const& v ) { return v; }
 inline unsigned long test_output_impl( char32_t const& v ) { return v; }
 #endif
 
-#if defined(_MSC_VER)
-#pragma warning(push)
-#pragma warning(disable: 4996)
-#endif
-
 inline std::string test_output_impl( char const& v )
 {
     if( std::isprint( static_cast<unsigned char>( v ) ) )
@@ -210,17 +198,17 @@ inline std::string test_output_impl( char const& v )
     }
     else
     {
-        char buffer[ 8 ];
-        std::sprintf( buffer, "\\x%02X", static_cast<unsigned char>( v ) );
+        static const char char_table[16] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };
+        char buffer[ 4 ];
+        buffer[ 0 ] = '\\';
+        buffer[ 1 ] = 'x';
+        buffer[ 2 ] = char_table[ (static_cast<unsigned char>( v ) >> 4u) & 0x0f ];
+        buffer[ 3 ] = char_table[ static_cast<unsigned char>( v ) & 0x0f ];
 
-        return buffer;
+        return std::string( buffer, 4u );
     }
 }
 
-#if defined(_MSC_VER)
-#pragma warning(pop)
-#endif
-
 // predicates
 
 struct lw_test_eq
@@ -530,6 +518,15 @@ inline int report_errors()
     return errors < 256? errors: 255;
 }
 
+namespace core
+{
+
+inline void lwt_init()
+{
+    boost::detail::test_results();
+}
+
+} // namespace core
 } // namespace boost
 
 #define BOOST_TEST(expr) ( ::boost::detail::test_impl(#expr, __FILE__, __LINE__, BOOST_CURRENT_FUNCTION, (expr)? true: false) )

include/boost/core/lightweight_test_trait.hpp

@@ -22,7 +22,7 @@
 
 #include <boost/core/lightweight_test.hpp>
 #include <boost/core/type_name.hpp>
-#include <boost/core/is_same.hpp>
+#include <boost/core/detail/is_same.hpp>
 #include <boost/config.hpp>
 
 namespace boost
@@ -56,7 +56,7 @@ template<class T> inline bool test_trait_same_impl_( T )
 }
 
 template<class T1, class T2> inline void test_trait_same_impl( char const * types,
-  boost::core::is_same<T1, T2> same, char const * file, int line, char const * function )
+  boost::core::detail::is_same<T1, T2> same, char const * file, int line, char const * function )
 {
     if( test_trait_same_impl_( same ) )
     {
@@ -86,6 +86,6 @@ template<class T1, class T2> inline void test_trait_same_impl( char const * type
 # pragma GCC system_header
 #endif
 
-#define BOOST_TEST_TRAIT_SAME(...) ( ::boost::detail::test_trait_same_impl(#__VA_ARGS__, ::boost::core::is_same<__VA_ARGS__>(), __FILE__, __LINE__, BOOST_CURRENT_FUNCTION) )
+#define BOOST_TEST_TRAIT_SAME(...) ( ::boost::detail::test_trait_same_impl(#__VA_ARGS__, ::boost::core::detail::is_same< __VA_ARGS__ >(), __FILE__, __LINE__, BOOST_CURRENT_FUNCTION) )
 
 #endif // #ifndef BOOST_CORE_LIGHTWEIGHT_TEST_TRAIT_HPP

include/boost/core/snprintf.hpp

@@ -0,0 +1,173 @@
+/*
+ *             Copyright Andrey Semashev 2022.
+ * 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)
+ */
+/*!
+ * \file   snprintf.hpp
+ * \author Andrey Semashev
+ * \date   06.12.2022
+ *
+ * \brief  The header provides more portable definition of snprintf and vsnprintf,
+ *         as well as \c wchar_t counterparts.
+ */
+
+#ifndef BOOST_CORE_SNPRINTF_HPP_INCLUDED_
+#define BOOST_CORE_SNPRINTF_HPP_INCLUDED_
+
+#include <stdio.h>
+#include <wchar.h>
+#include <boost/config.hpp>
+
+#ifdef BOOST_HAS_PRAGMA_ONCE
+#pragma once
+#endif
+
+#if defined(__MINGW32__)
+
+#include <cstddef>
+#include <cstdarg>
+#if !defined(__MINGW64_VERSION_MAJOR)
+#include <climits>
+#endif
+
+// MinGW32 and MinGW-w64 provide their own snprintf implementations that are compliant with the C standard.
+#define BOOST_CORE_DETAIL_MINGW_SNPRINTF
+
+#elif (defined(BOOST_MSSTL_VERSION) && BOOST_MSSTL_VERSION < 140)
+
+#include <cstddef>
+#include <cstdarg>
+#include <climits>
+
+// MSVC snprintfs are not conforming but they are good enough for typical use cases.
+#define BOOST_CORE_DETAIL_MSVC_LEGACY_SNPRINTF
+
+#endif
+
+namespace boost {
+
+namespace core {
+
+#if defined(BOOST_CORE_DETAIL_MINGW_SNPRINTF) || defined(BOOST_CORE_DETAIL_MSVC_LEGACY_SNPRINTF)
+
+#if defined(BOOST_CORE_DETAIL_MINGW_SNPRINTF)
+
+inline int vsnprintf(char* buf, std::size_t size, const char* format, std::va_list args)
+{
+    return __mingw_vsnprintf(buf, size, format, args);
+}
+
+inline int vswprintf(wchar_t* buf, std::size_t size, const wchar_t* format, std::va_list args)
+{
+#if defined(__MINGW64_VERSION_MAJOR)
+    int res = __mingw_vsnwprintf(buf, size, format, args);
+    // __mingw_vsnwprintf returns the number of characters to be printed, but (v)swprintf is expected to return -1 on truncation
+    if (static_cast< unsigned int >(res) >= size)
+        res = -1;
+    return res;
+#else
+    // Legacy MinGW32 does not provide __mingw_vsnwprintf, so use _vsnwprintf from MSVC CRT
+    if (BOOST_UNLIKELY(size == 0u || size > static_cast< std::size_t >(INT_MAX)))
+        return -1;
+
+    int res = _vsnwprintf(buf, size, format, args);
+    // (v)swprintf is expected to return -1 on truncation, so we only need to ensure the output is null-terminated
+    if (static_cast< unsigned int >(res) >= size)
+    {
+        buf[size - 1u] = L'\0';
+        res = -1;
+    }
+
+    return res;
+#endif
+}
+
+#elif defined(BOOST_CORE_DETAIL_MSVC_LEGACY_SNPRINTF)
+
+#if defined(_MSC_VER)
+#pragma warning(push)
+// '_vsnprintf': This function or variable may be unsafe. Consider using _vsnprintf_s instead.
+#pragma warning(disable: 4996)
+#endif
+
+inline int vsnprintf(char* buf, std::size_t size, const char* format, std::va_list args)
+{
+    if (BOOST_UNLIKELY(size == 0u))
+        return 0;
+    if (BOOST_UNLIKELY(size > static_cast< std::size_t >(INT_MAX)))
+        return -1;
+
+    buf[size - 1u] = '\0';
+    int res = _vsnprintf(buf, size, format, args);
+    if (static_cast< unsigned int >(res) >= size)
+    {
+        // _vsnprintf returns -1 if the output was truncated and in case of other errors.
+        // Detect truncation by checking whether the output buffer was written over entirely.
+        if (buf[size - 1u] != '\0')
+        {
+            buf[size - 1u] = '\0';
+            res = static_cast< int >(size);
+        }
+    }
+
+    return res;
+}
+
+inline int vswprintf(wchar_t* buf, std::size_t size, const wchar_t* format, std::va_list args)
+{
+    if (BOOST_UNLIKELY(size == 0u || size > static_cast< std::size_t >(INT_MAX)))
+        return -1;
+
+    int res = _vsnwprintf(buf, size, format, args);
+    // (v)swprintf is expected to return -1 on truncation, so we only need to ensure the output is null-terminated
+    if (static_cast< unsigned int >(res) >= size)
+    {
+        buf[size - 1u] = L'\0';
+        res = -1;
+    }
+
+    return res;
+}
+
+#if defined(_MSC_VER)
+#pragma warning(pop)
+#endif
+
+#endif
+
+inline int snprintf(char* buf, std::size_t size, const char* format, ...)
+{
+    std::va_list args;
+    va_start(args, format);
+    int res = vsnprintf(buf, size, format, args);
+    va_end(args);
+    return res;
+}
+
+inline int swprintf(wchar_t* buf, std::size_t size, const wchar_t* format, ...)
+{
+    std::va_list args;
+    va_start(args, format);
+    int res = vswprintf(buf, size, format, args);
+    va_end(args);
+    return res;
+}
+
+#else // defined(BOOST_CORE_DETAIL_MINGW_SNPRINTF) || defined(BOOST_CORE_DETAIL_MSVC_LEGACY_SNPRINTF)
+
+// Standard-conforming compilers already have the correct snprintfs
+using ::snprintf;
+using ::vsnprintf;
+
+using ::swprintf;
+using ::vswprintf;
+
+#endif // defined(BOOST_CORE_DETAIL_MINGW_SNPRINTF) || defined(BOOST_CORE_DETAIL_MSVC_LEGACY_SNPRINTF)
+
+} // namespace core
+
+} // namespace boost
+
+#endif // BOOST_CORE_SNPRINTF_HPP_INCLUDED_

include/boost/core/type_name.hpp

@@ -14,7 +14,6 @@
 // https://www.boost.org/LICENSE_1_0.txt
 
 #include <boost/core/demangle.hpp>
-#include <boost/core/is_same.hpp>
 #include <boost/config.hpp>
 #include <string>
 #include <functional>
@@ -185,14 +184,23 @@ template<class T> std::string array_template_name()
 # pragma warning( disable: 4996 )
 #endif
 
+// Use snprintf if available as some compilers (clang 14.0) issue deprecation warnings for sprintf
+#if ( defined(_MSC_VER) && _MSC_VER < 1900 ) || ( defined(__MINGW32__) && !defined(__MINGW64_VERSION_MAJOR) )
+# define BOOST_CORE_DETAIL_SNPRINTF(buffer, format, arg) std::sprintf(buffer, format, arg)
+#else
+# define BOOST_CORE_DETAIL_SNPRINTF(buffer, format, arg) std::snprintf(buffer, sizeof(buffer)/sizeof(buffer[0]), format, arg)
+#endif
+
 inline std::string tn_to_string( std::size_t n )
 {
     char buffer[ 32 ];
-    std::sprintf( buffer, "%lu", static_cast< unsigned long >( n ) );
+    BOOST_CORE_DETAIL_SNPRINTF( buffer, "%lu", static_cast< unsigned long >( n ) );
 
     return buffer;
 }
 
+#undef BOOST_CORE_DETAIL_SNPRINTF
+
 #if defined(BOOST_MSVC)
 # pragma warning( pop )
 #endif

test/CMakeLists.txt

@@ -6,7 +6,7 @@ include(BoostTestJamfile OPTIONAL RESULT_VARIABLE HAVE_BOOST_TEST)
 
 if(HAVE_BOOST_TEST)
 
-boost_test_jamfile(FILE Jamfile.v2 LINK_LIBRARIES Boost::core Boost::static_assert)
+boost_test_jamfile(FILE Jamfile.v2 LINK_LIBRARIES Boost::core Boost::static_assert Boost::type_traits)
 
 set(BOOST_TEST_LINK_LIBRARIES Boost::core Boost::type_traits)
 

test/Jamfile.v2

@@ -14,8 +14,6 @@ project : requirements
   <warnings>extra
   <toolset>msvc:<warnings-as-errors>on
   <toolset>clang:<warnings-as-errors>on
-  # https://github.com/boostorg/type_traits/issues/173
-  <toolset>clang-15:<cxxflags>-Wno-deprecated-builtins
   <toolset>gcc:<warnings-as-errors>on
   <toolset>gcc-4.4:<cxxflags>-Wno-sign-compare ;
 
@@ -150,6 +148,7 @@ run-fail lightweight_test_fail12.cpp ;
 run-fail lightweight_test_fail13.cpp ;
 run-fail lightweight_test_fail14.cpp ;
 run-fail lightweight_test_fail15.cpp ;
+run-fail lightweight_test_fail16.cpp : ;
 run-fail lightweight_test_lt_fail.cpp ;
 run-fail lightweight_test_le_fail.cpp ;
 run-fail lightweight_test_gt_fail.cpp ;
@@ -303,6 +302,8 @@ compile-fail bit_width_fail.cpp
 
 run type_name_test.cpp ;
 
+run snprintf_test.cpp ;
+
 run sv_types_test.cpp ;
 run sv_construct_test.cpp ;
 run sv_iteration_test.cpp ;

test/allocator_const_pointer_test.cpp

@@ -6,8 +6,8 @@ Distributed under the Boost Software License, Version 1.0.
 (http://www.boost.org/LICENSE_1_0.txt)
 */
 #include <boost/core/allocator_access.hpp>
-#include <boost/core/is_same.hpp>
 #include <boost/core/lightweight_test_trait.hpp>
+#include <boost/core/detail/is_same.hpp>
 
 template<class T>
 struct A1 {
@@ -22,9 +22,9 @@ struct A2 {
 
 int main()
 {
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<int*,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<int*,
         boost::allocator_const_pointer<A1<char> >::type>));
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<const int*,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<const int*,
         boost::allocator_const_pointer<A2<int> >::type>));
     return boost::report_errors();
 }

test/allocator_const_void_pointer_test.cpp

@@ -6,8 +6,8 @@ Distributed under the Boost Software License, Version 1.0.
 (http://www.boost.org/LICENSE_1_0.txt)
 */
 #include <boost/core/allocator_access.hpp>
-#include <boost/core/is_same.hpp>
 #include <boost/core/lightweight_test_trait.hpp>
+#include <boost/core/detail/is_same.hpp>
 
 template<class T>
 struct A1 {
@@ -27,9 +27,9 @@ struct A2 {
 
 int main()
 {
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<int*,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<int*,
         boost::allocator_const_void_pointer<A1<char> >::type>));
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<const void*,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<const void*,
         boost::allocator_const_void_pointer<A2<int> >::type>));
     return boost::report_errors();
 }

test/allocator_difference_type_test.cpp

@@ -6,8 +6,8 @@ Distributed under the Boost Software License, Version 1.0.
 (http://www.boost.org/LICENSE_1_0.txt)
 */
 #include <boost/core/allocator_access.hpp>
-#include <boost/core/is_same.hpp>
 #include <boost/core/lightweight_test_trait.hpp>
+#include <boost/core/detail/is_same.hpp>
 
 template<class T>
 struct A1 {
@@ -22,9 +22,9 @@ struct A2 {
 
 int main()
 {
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<short,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<short,
         boost::allocator_difference_type<A1<char> >::type>));
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<std::ptrdiff_t,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<std::ptrdiff_t,
         boost::allocator_difference_type<A2<int> >::type>));
     return boost::report_errors();
 }

test/allocator_is_always_equal_test.cpp

@@ -6,7 +6,6 @@ Distributed under the Boost Software License, Version 1.0.
 (http://www.boost.org/LICENSE_1_0.txt)
 */
 #include <boost/core/allocator_access.hpp>
-#include <boost/core/is_same.hpp>
 #include <boost/core/lightweight_test_trait.hpp>
 
 template<class T>

test/allocator_pocca_test.cpp

@@ -6,7 +6,6 @@ Distributed under the Boost Software License, Version 1.0.
 (http://www.boost.org/LICENSE_1_0.txt)
 */
 #include <boost/core/allocator_access.hpp>
-#include <boost/core/is_same.hpp>
 #include <boost/core/lightweight_test_trait.hpp>
 
 template<class T>

test/allocator_pocma_test.cpp

@@ -6,7 +6,6 @@ Distributed under the Boost Software License, Version 1.0.
 (http://www.boost.org/LICENSE_1_0.txt)
 */
 #include <boost/core/allocator_access.hpp>
-#include <boost/core/is_same.hpp>
 #include <boost/core/lightweight_test_trait.hpp>
 
 template<class T>

test/allocator_pocs_test.cpp

@@ -6,7 +6,6 @@ Distributed under the Boost Software License, Version 1.0.
 (http://www.boost.org/LICENSE_1_0.txt)
 */
 #include <boost/core/allocator_access.hpp>
-#include <boost/core/is_same.hpp>
 #include <boost/core/lightweight_test_trait.hpp>
 
 template<class T>

test/allocator_pointer_test.cpp

@@ -6,8 +6,8 @@ Distributed under the Boost Software License, Version 1.0.
 (http://www.boost.org/LICENSE_1_0.txt)
 */
 #include <boost/core/allocator_access.hpp>
-#include <boost/core/is_same.hpp>
 #include <boost/core/lightweight_test_trait.hpp>
+#include <boost/core/detail/is_same.hpp>
 
 template<class T>
 struct A1 {
@@ -22,9 +22,9 @@ struct A2 {
 
 int main()
 {
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<int*,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<int*,
         boost::allocator_pointer<A1<char> >::type>));
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<int*,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<int*,
         boost::allocator_pointer<A2<int> >::type>));
     return boost::report_errors();
 }

test/allocator_rebind_test.cpp

@@ -6,8 +6,8 @@ Distributed under the Boost Software License, Version 1.0.
 (http://www.boost.org/LICENSE_1_0.txt)
 */
 #include <boost/core/allocator_access.hpp>
-#include <boost/core/is_same.hpp>
 #include <boost/core/lightweight_test_trait.hpp>
+#include <boost/core/detail/is_same.hpp>
 
 template<class T>
 struct A1 {
@@ -25,9 +25,9 @@ struct A2 {
 
 int main()
 {
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<A1<int>,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<A1<int>,
         boost::allocator_rebind<A1<char>, bool>::type>));
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<A2<int>,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<A2<int>,
         boost::allocator_rebind<A2<char>, int>::type>));
     return boost::report_errors();
 }

test/allocator_size_type_test.cpp

@@ -6,8 +6,11 @@ Distributed under the Boost Software License, Version 1.0.
 (http://www.boost.org/LICENSE_1_0.txt)
 */
 #include <boost/core/allocator_access.hpp>
-#include <boost/core/is_same.hpp>
 #include <boost/core/lightweight_test_trait.hpp>
+#include <boost/type_traits/is_same.hpp>
+#if !defined(BOOST_NO_CXX11_ALLOCATOR)
+#include <boost/type_traits/make_unsigned.hpp>
+#endif
 
 template<class T>
 struct A1 {
@@ -24,11 +27,11 @@ struct A2 {
 
 int main()
 {
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<int,
+    BOOST_TEST_TRAIT_TRUE((boost::is_same<int,
         boost::allocator_size_type<A1<char> >::type>));
 #if !defined(BOOST_NO_CXX11_ALLOCATOR)
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<
-        std::make_unsigned<std::ptrdiff_t>::type,
+    BOOST_TEST_TRAIT_TRUE((boost::is_same<
+        boost::make_unsigned<std::ptrdiff_t>::type,
         boost::allocator_size_type<A2<int> >::type>));
 #endif
     return boost::report_errors();

test/allocator_value_type_test.cpp

@@ -6,8 +6,8 @@ Distributed under the Boost Software License, Version 1.0.
 (http://www.boost.org/LICENSE_1_0.txt)
 */
 #include <boost/core/allocator_access.hpp>
-#include <boost/core/is_same.hpp>
 #include <boost/core/lightweight_test_trait.hpp>
+#include <boost/core/detail/is_same.hpp>
 
 template<class T>
 struct A {
@@ -16,7 +16,7 @@ struct A {
 
 int main()
 {
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<int,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<int,
         boost::allocator_value_type<A<int> >::type>));
     return boost::report_errors();
 }

test/allocator_void_pointer_test.cpp

@@ -6,8 +6,8 @@ Distributed under the Boost Software License, Version 1.0.
 (http://www.boost.org/LICENSE_1_0.txt)
 */
 #include <boost/core/allocator_access.hpp>
-#include <boost/core/is_same.hpp>
 #include <boost/core/lightweight_test_trait.hpp>
+#include <boost/core/detail/is_same.hpp>
 
 template<class T>
 struct A1 {
@@ -27,9 +27,9 @@ struct A2 {
 
 int main()
 {
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<int*,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<int*,
         boost::allocator_void_pointer<A1<char> >::type>));
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<void*,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<void*,
         boost::allocator_void_pointer<A2<int> >::type>));
     return boost::report_errors();
 }

test/detail_iterator_test.cpp

@@ -10,8 +10,8 @@
 
 #define BOOST_ALLOW_DEPRECATED_HEADERS
 #include <boost/detail/iterator.hpp>
-#include <boost/core/is_same.hpp>
 #include <boost/core/lightweight_test_trait.hpp>
+#include <boost/type_traits/is_same.hpp>
 #include <cstddef>
 #include <list>
 
@@ -62,7 +62,7 @@ struct iterator
 
 int main()
 {
-    using boost::core::is_same;
+    using boost::is_same;
 
 /*
     template<class Iterator> struct iterator_traits {

test/eif_lazy_test.cpp

@@ -12,7 +12,7 @@
 
 // Testing all variations of lazy_enable_if.
 
-#include <boost/utility/enable_if.hpp>
+#include <boost/core/enable_if.hpp>
 #include <boost/type_traits/is_same.hpp>
 #include <boost/core/lightweight_test.hpp>
 
@@ -26,7 +26,7 @@ using boost::lazy_disable_if_c;
 template <class T>
 struct is_int_or_double {
   BOOST_STATIC_CONSTANT(bool, 
-    value = (boost::is_same<T, int>::value || 
+    value = (boost::is_same<T, int>::value ||
              boost::is_same<T, double>::value));
 };
 
@@ -84,14 +84,14 @@ int main()
   BOOST_TEST(foo(1));
   BOOST_TEST(foo(1.0));
 
-  BOOST_TEST(!foo("1"));  
-  BOOST_TEST(!foo(static_cast<void*>(0)));  
+  BOOST_TEST(!foo("1"));
+  BOOST_TEST(!foo(static_cast<void*>(0)));
 
   BOOST_TEST(foo2(1));
   BOOST_TEST(foo2(1.0));
 
-  BOOST_TEST(!foo2("1"));  
-  BOOST_TEST(!foo2(static_cast<void*>(0)));  
+  BOOST_TEST(!foo2("1"));
+  BOOST_TEST(!foo2(static_cast<void*>(0)));
 
   return boost::report_errors();
 }

test/is_same_test.cpp

@@ -1,5 +1,5 @@
 //
-// Test for core::is_same<T1,T2>
+// Test for core::detail::is_same<T1,T2>
 //
 // Copyright 2014 Peter Dimov
 //
@@ -8,7 +8,7 @@
 // http://www.boost.org/LICENSE_1_0.txt
 //
 
-#include <boost/core/is_same.hpp>
+#include <boost/core/detail/is_same.hpp>
 #include <boost/core/lightweight_test_trait.hpp>
 
 struct X
@@ -21,18 +21,18 @@ struct Y
 
 int main()
 {
-    BOOST_TEST_TRAIT_TRUE(( boost::core::is_same<X, X> ));
-    BOOST_TEST_TRAIT_TRUE(( boost::core::is_same<Y, Y> ));
-    BOOST_TEST_TRAIT_TRUE(( boost::core::is_same<void, void> ));
-    BOOST_TEST_TRAIT_TRUE(( boost::core::is_same<int, int> ));
-    BOOST_TEST_TRAIT_TRUE(( boost::core::is_same<void const volatile, void const volatile> ));
+    BOOST_TEST_TRAIT_TRUE(( boost::core::detail::is_same<X, X> ));
+    BOOST_TEST_TRAIT_TRUE(( boost::core::detail::is_same<Y, Y> ));
+    BOOST_TEST_TRAIT_TRUE(( boost::core::detail::is_same<void, void> ));
+    BOOST_TEST_TRAIT_TRUE(( boost::core::detail::is_same<int, int> ));
+    BOOST_TEST_TRAIT_TRUE(( boost::core::detail::is_same<void const volatile, void const volatile> ));
 
-    BOOST_TEST_TRAIT_FALSE(( boost::core::is_same<X, Y> ));
-    BOOST_TEST_TRAIT_FALSE(( boost::core::is_same<X, X const> ));
-    BOOST_TEST_TRAIT_FALSE(( boost::core::is_same<X, void> ));
-    BOOST_TEST_TRAIT_FALSE(( boost::core::is_same<X, int> ));
-    BOOST_TEST_TRAIT_FALSE(( boost::core::is_same<int, void> ));
-    BOOST_TEST_TRAIT_FALSE(( boost::core::is_same<void, void const volatile> ));
+    BOOST_TEST_TRAIT_FALSE(( boost::core::detail::is_same<X, Y> ));
+    BOOST_TEST_TRAIT_FALSE(( boost::core::detail::is_same<X, X const> ));
+    BOOST_TEST_TRAIT_FALSE(( boost::core::detail::is_same<X, void> ));
+    BOOST_TEST_TRAIT_FALSE(( boost::core::detail::is_same<X, int> ));
+    BOOST_TEST_TRAIT_FALSE(( boost::core::detail::is_same<int, void> ));
+    BOOST_TEST_TRAIT_FALSE(( boost::core::detail::is_same<void, void const volatile> ));
 
     return boost::report_errors();
 }

test/iterator_test.cpp

@@ -18,8 +18,8 @@
 #if BOOST_CXX_VERSION < 201703
 
 #include <boost/iterator.hpp>
-#include <boost/core/is_same.hpp>
 #include <boost/core/lightweight_test_trait.hpp>
+#include <boost/type_traits/is_same.hpp>
 
 /*
 
@@ -60,7 +60,7 @@ struct R
 
 int main()
 {
-    using boost::core::is_same;
+    using boost::is_same;
 
     BOOST_TEST_TRAIT_TRUE((is_same<boost::iterator<C,T,D,P,R>::iterator_category,C>));
     BOOST_TEST_TRAIT_TRUE((is_same<boost::iterator<C,T,D,P,R>::value_type,T>));

test/lightweight_test_fail16.cpp

@@ -0,0 +1,12 @@
+// Copyright 2022 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/core/lightweight_test.hpp>
+
+// Should fail, because boost::report_errors() hasn't been called
+
+int main()
+{
+    boost::core::lwt_init();
+}

test/pointer_traits_difference_type_test.cpp

@@ -6,8 +6,8 @@ Distributed under the Boost Software License, Version 1.0.
 (http://www.boost.org/LICENSE_1_0.txt)
 */
 #include <boost/core/pointer_traits.hpp>
-#include <boost/core/is_same.hpp>
 #include <boost/core/lightweight_test_trait.hpp>
+#include <boost/core/detail/is_same.hpp>
 
 template<class T>
 struct P { };
@@ -19,23 +19,23 @@ struct E {
 
 int main()
 {
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<std::ptrdiff_t,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<std::ptrdiff_t,
         boost::pointer_traits<int*>::difference_type>));
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<std::ptrdiff_t,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<std::ptrdiff_t,
         boost::pointer_traits<P<int> >::difference_type>));
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<long,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<long,
         boost::pointer_traits<E<int> >::difference_type>));
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<std::ptrdiff_t,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<std::ptrdiff_t,
         boost::pointer_traits<void*>::difference_type>));
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<std::ptrdiff_t,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<std::ptrdiff_t,
         boost::pointer_traits<P<void> >::difference_type>));
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<long,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<long,
         boost::pointer_traits<E<void> >::difference_type>));
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<std::ptrdiff_t,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<std::ptrdiff_t,
         boost::pointer_traits<const int*>::difference_type>));
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<std::ptrdiff_t,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<std::ptrdiff_t,
         boost::pointer_traits<P<const int> >::difference_type>));
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<long,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<long,
         boost::pointer_traits<E<const int> >::difference_type>));
     return boost::report_errors();
 }

test/pointer_traits_element_type_test.cpp

@@ -6,8 +6,8 @@ Distributed under the Boost Software License, Version 1.0.
 (http://www.boost.org/LICENSE_1_0.txt)
 */
 #include <boost/core/pointer_traits.hpp>
-#include <boost/core/is_same.hpp>
 #include <boost/core/lightweight_test_trait.hpp>
+#include <boost/core/detail/is_same.hpp>
 
 template<class T>
 struct P1 { };
@@ -45,39 +45,39 @@ struct E {
 
 int main()
 {
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<int,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<int,
         boost::pointer_traits<int*>::element_type>));
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<int,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<int,
         boost::pointer_traits<P1<int> >::element_type>));
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<int,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<int,
         boost::pointer_traits<P2<int, char> >::element_type>));
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<int,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<int,
         boost::pointer_traits<P3<int, char, char> >::element_type>));
 #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<int,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<int,
         boost::pointer_traits<P<int, char, char, char> >::element_type>));
 #endif
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<bool,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<bool,
         boost::pointer_traits<E1<int> >::element_type>));
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<bool,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<bool,
         boost::pointer_traits<E2<int, int> >::element_type>));
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<bool,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<bool,
         boost::pointer_traits<E3<int, int, int> >::element_type>));
 #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<bool,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<bool,
         boost::pointer_traits<E<int, int, int, int> >::element_type>));
 #endif
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<void,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<void,
         boost::pointer_traits<void*>::element_type>));
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<void,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<void,
         boost::pointer_traits<P1<void> >::element_type>));
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<bool,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<bool,
         boost::pointer_traits<E1<void> >::element_type>));
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<const int,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<const int,
         boost::pointer_traits<const int*>::element_type>));
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<const int,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<const int,
         boost::pointer_traits<P1<const int> >::element_type>));
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<bool,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<bool,
         boost::pointer_traits<E1<const int> >::element_type>));
     return boost::report_errors();
 }

test/pointer_traits_pointer_test.cpp

@@ -6,25 +6,25 @@ Distributed under the Boost Software License, Version 1.0.
 (http://www.boost.org/LICENSE_1_0.txt)
 */
 #include <boost/core/pointer_traits.hpp>
-#include <boost/core/is_same.hpp>
 #include <boost/core/lightweight_test_trait.hpp>
+#include <boost/core/detail/is_same.hpp>
 
 template<class T>
 struct P { };
 
 int main()
 {
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<int*,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<int*,
         boost::pointer_traits<int*>::pointer>));
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<P<int>,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<P<int>,
         boost::pointer_traits<P<int> >::pointer>));
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<void*,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<void*,
         boost::pointer_traits<void*>::pointer>));
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<P<void>,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<P<void>,
         boost::pointer_traits<P<void> >::pointer>));
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<const int*,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<const int*,
         boost::pointer_traits<const int*>::pointer>));
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<P<const int>,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<P<const int>,
         boost::pointer_traits<P<const int> >::pointer>));
     return boost::report_errors();
 }

test/pointer_traits_rebind_test.cpp

@@ -6,8 +6,8 @@ Distributed under the Boost Software License, Version 1.0.
 (http://www.boost.org/LICENSE_1_0.txt)
 */
 #include <boost/core/pointer_traits.hpp>
-#include <boost/core/is_same.hpp>
 #include <boost/core/lightweight_test_trait.hpp>
+#include <boost/core/detail/is_same.hpp>
 
 template<class T>
 struct P1 { };
@@ -55,94 +55,94 @@ struct R { };
 
 int main()
 {
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<char*,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<char*,
         boost::pointer_traits<R*>::rebind_to<char>::type>));
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<P1<char>,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<P1<char>,
         boost::pointer_traits<P1<R> >::rebind_to<char>::type>));
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<P2<char, R>,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<P2<char, R>,
         boost::pointer_traits<P2<R, R> >::rebind_to<char>::type>));
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<P3<char, R, R>,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<P3<char, R, R>,
         boost::pointer_traits<P3<R, R, R> >::rebind_to<char>::type>));
 #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<P<char, R, R, R>,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<P<char, R, R, R>,
         boost::pointer_traits<P<R, R, R, R> >::rebind_to<char>::type>));
 #endif
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<void*,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<void*,
         boost::pointer_traits<R*>::rebind_to<void>::type>));
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<P1<void>,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<P1<void>,
         boost::pointer_traits<P1<R> >::rebind_to<void>::type>));
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<R*,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<R*,
         boost::pointer_traits<void*>::rebind_to<R>::type>));
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<P1<R>,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<P1<R>,
         boost::pointer_traits<P1<void> >::rebind_to<R>::type>));
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<const int*,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<const int*,
         boost::pointer_traits<R*>::rebind_to<const int>::type>));
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<P1<const int>,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<P1<const int>,
         boost::pointer_traits<P1<R> >::rebind_to<const int>::type>));
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<int*,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<int*,
         boost::pointer_traits<const R*>::rebind_to<int>::type>));
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<P1<int>,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<P1<int>,
         boost::pointer_traits<P1<const R> >::rebind_to<int>::type>));
 #if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<char*,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<char*,
         boost::pointer_traits<R*>::rebind<char> >));
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<P1<char>,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<P1<char>,
         boost::pointer_traits<P1<R> >::rebind<char> >));
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<P2<char, R>,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<P2<char, R>,
         boost::pointer_traits<P2<R, R> >::rebind<char> >));
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<P3<char, R, R>,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<P3<char, R, R>,
         boost::pointer_traits<P3<R, R, R> >::rebind<char> >));
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<void*,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<void*,
         boost::pointer_traits<R*>::rebind<void> >));
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<P1<void>,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<P1<void>,
         boost::pointer_traits<P1<R> >::rebind<void> >));
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<R*,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<R*,
         boost::pointer_traits<void*>::rebind<R> >));
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<P1<R>,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<P1<R>,
         boost::pointer_traits<P1<void> >::rebind<R> >));
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<const int*,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<const int*,
         boost::pointer_traits<R*>::rebind<const int> >));
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<P1<const int>,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<P1<const int>,
         boost::pointer_traits<P1<R> >::rebind<const int> >));
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<int*,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<int*,
         boost::pointer_traits<const R*>::rebind<int> >));
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<P1<int>,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<P1<int>,
         boost::pointer_traits<P1<const R> >::rebind<int> >));
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<E1<bool>,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<E1<bool>,
         boost::pointer_traits<E1<R> >::rebind_to<char>::type>));
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<E2<bool, R>,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<E2<bool, R>,
         boost::pointer_traits<E2<R, R> >::rebind_to<char>::type>));
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<E3<bool, R, R>,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<E3<bool, R, R>,
         boost::pointer_traits<E3<R, R, R> >::rebind_to<char>::type>));
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<E1<bool>,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<E1<bool>,
         boost::pointer_traits<E1<R> >::rebind<char> >));
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<E2<bool, R>,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<E2<bool, R>,
         boost::pointer_traits<E2<R, R> >::rebind<char> >));
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<E3<bool, R, R>,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<E3<bool, R, R>,
         boost::pointer_traits<E3<R, R, R> >::rebind<char> >));
 #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<P<char, R, R, R>,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<P<char, R, R, R>,
         boost::pointer_traits<P<R, R, R, R> >::rebind<char> >));
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<E<bool, R, R, R>,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<E<bool, R, R, R>,
         boost::pointer_traits<E<R, R, R, R> >::rebind_to<char>::type>));
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<E<bool, R, R, R>,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<E<bool, R, R, R>,
         boost::pointer_traits<E<R, R, R, R> >::rebind<char> >));
 #endif
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<E1<bool>,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<E1<bool>,
         boost::pointer_traits<E1<R> >::rebind_to<void>::type>));
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<E1<bool>,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<E1<bool>,
         boost::pointer_traits<E1<void> >::rebind_to<R>::type>));
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<E1<bool>,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<E1<bool>,
         boost::pointer_traits<E1<R> >::rebind_to<const int>::type>));
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<E1<bool>,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<E1<bool>,
         boost::pointer_traits<E1<const R> >::rebind_to<int>::type>));
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<E1<bool>,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<E1<bool>,
         boost::pointer_traits<E1<R> >::rebind<void> >));
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<E1<bool>,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<E1<bool>,
         boost::pointer_traits<E1<void> >::rebind<R> >));
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<E1<bool>,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<E1<bool>,
         boost::pointer_traits<E1<R> >::rebind<const int> >));
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<E1<bool>,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<E1<bool>,
         boost::pointer_traits<E1<const R> >::rebind<int> >));
 #endif
     return boost::report_errors();

test/quick.cpp

@@ -16,13 +16,12 @@
 #include <boost/core/explicit_operator_bool.hpp>
 #include <boost/get_pointer.hpp>
 #include <boost/core/ignore_unused.hpp>
-#include <boost/core/is_same.hpp>
 #include <boost/core/lightweight_test.hpp>
 #include <boost/noncopyable.hpp>
 #include <boost/core/null_deleter.hpp>
 #include <boost/core/fclose_deleter.hpp>
 #include <boost/core/pointer_traits.hpp>
-#include <boost/ref.hpp>
+#include <boost/core/ref.hpp>
 #include <boost/core/scoped_enum.hpp>
 #include <boost/core/typeinfo.hpp>
 #include <boost/core/underlying_type.hpp>

test/ref_conversion_test.cpp

@@ -6,7 +6,7 @@
 //  See accompanying file LICENSE_1_0.txt or copy at
 //  http://www.boost.org/LICENSE_1_0.txt
 
-#include <boost/ref.hpp>
+#include <boost/core/ref.hpp>
 #include <boost/core/lightweight_test.hpp>
 
 struct X

test/ref_ct_test.cpp

@@ -3,13 +3,13 @@
 // 1.0. (See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 
-// compile-time test for "boost/ref.hpp" header content
+// compile-time test for "boost/core/ref.hpp" header content
 // see 'ref_test.cpp' for run-time part
 
-#include <boost/ref.hpp>
-#include <boost/core/is_same.hpp>
+#include <boost/core/ref.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/config/workaround.hpp>
+#include <boost/type_traits/is_same.hpp>
 
 namespace {
 
@@ -17,8 +17,8 @@ template< typename T, typename U >
 void ref_test(boost::reference_wrapper<U>)
 {
     typedef typename boost::reference_wrapper<U>::type type;
-    BOOST_STATIC_ASSERT((boost::core::is_same<U,type>::value));
-    BOOST_STATIC_ASSERT((boost::core::is_same<T,type>::value));
+    BOOST_STATIC_ASSERT((boost::is_same<U,type>::value));
+    BOOST_STATIC_ASSERT((boost::is_same<T,type>::value));
 }
 
 template< typename T >
@@ -42,14 +42,14 @@ void is_reference_wrapper_test(T)
 template< typename R, typename Ref >
 void cxx_reference_test(Ref)
 {
-    BOOST_STATIC_ASSERT((boost::core::is_same<R,Ref>::value));
+    BOOST_STATIC_ASSERT((boost::is_same<R,Ref>::value));
 }
 
 template< typename R, typename Ref >
 void unwrap_reference_test(Ref)
 {
     typedef typename boost::unwrap_reference<Ref>::type type;
-    BOOST_STATIC_ASSERT((boost::core::is_same<R,type>::value));
+    BOOST_STATIC_ASSERT((boost::is_same<R,type>::value));
 }
 
 } // namespace

test/ref_cv_test.cpp

@@ -6,7 +6,7 @@
 //  See accompanying file LICENSE_1_0.txt or copy at
 //  http://www.boost.org/LICENSE_1_0.txt
 
-#include <boost/ref.hpp>
+#include <boost/core/ref.hpp>
 #include <boost/core/lightweight_test.hpp>
 
 #define BOOST_TEST_REF( x ) BOOST_TEST( &boost::ref( x ).get() == &x )

test/ref_fn_test.cpp

@@ -15,7 +15,7 @@
 //  See accompanying file LICENSE_1_0.txt or copy at
 //  http://www.boost.org/LICENSE_1_0.txt
 
-#include <boost/ref.hpp>
+#include <boost/core/ref.hpp>
 #include <boost/core/lightweight_test.hpp>
 
 

test/ref_implicit_fail.cpp

@@ -8,7 +8,7 @@
 // http://www.boost.org/LICENSE_1_0.txt
 //
 
-#include <boost/ref.hpp>
+#include <boost/core/ref.hpp>
 
 void f( boost::reference_wrapper< int > )
 {

test/ref_implicit_fail2.cpp

@@ -8,7 +8,7 @@
 // http://www.boost.org/LICENSE_1_0.txt
 //
 
-#include <boost/ref.hpp>
+#include <boost/core/ref.hpp>
 
 void f( boost::reference_wrapper< int const > )
 {

test/ref_implicit_fail3.cpp

@@ -8,7 +8,7 @@
 // http://www.boost.org/LICENSE_1_0.txt
 //
 
-#include <boost/ref.hpp>
+#include <boost/core/ref.hpp>
 
 struct X
 {

test/ref_implicit_fail4.cpp

@@ -8,7 +8,7 @@
 // http://www.boost.org/LICENSE_1_0.txt
 //
 
-#include <boost/ref.hpp>
+#include <boost/core/ref.hpp>
 
 void f( boost::reference_wrapper< int const > )
 {

test/ref_ref_test.cpp

@@ -11,7 +11,7 @@
 // http://www.boost.org/LICENSE_1_0.txt
 //
 
-#include <boost/ref.hpp>
+#include <boost/core/ref.hpp>
 #include <boost/core/lightweight_test.hpp>
 
 template<class T> void test( T const & t )

test/ref_rv_fail1.cpp

@@ -8,7 +8,7 @@
 // http://www.boost.org/LICENSE_1_0.txt
 //
 
-#include <boost/ref.hpp>
+#include <boost/core/ref.hpp>
 
 #if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
 

test/ref_rv_fail2.cpp

@@ -8,7 +8,7 @@
 // http://www.boost.org/LICENSE_1_0.txt
 //
 
-#include <boost/ref.hpp>
+#include <boost/core/ref.hpp>
 
 int main()
 {

test/ref_rv_fail3.cpp

@@ -8,7 +8,7 @@
 // http://www.boost.org/LICENSE_1_0.txt
 //
 
-#include <boost/ref.hpp>
+#include <boost/core/ref.hpp>
 
 #if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
 

test/ref_rv_fail4.cpp

@@ -9,7 +9,7 @@
 // http://www.boost.org/LICENSE_1_0.txt
 //
 
-#include <boost/ref.hpp>
+#include <boost/core/ref.hpp>
 
 #if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
 

test/ref_rv_fail5.cpp

@@ -9,7 +9,7 @@
 // http://www.boost.org/LICENSE_1_0.txt
 //
 
-#include <boost/ref.hpp>
+#include <boost/core/ref.hpp>
 
 #if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
 

test/ref_test.cpp

@@ -3,10 +3,10 @@
 // 1.0. (See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 
-// run-time test for "boost/ref.hpp" header content
+// run-time test for "boost/core/ref.hpp" header content
 // see 'ref_ct_test.cpp' for compile-time part
 
-#include <boost/ref.hpp>
+#include <boost/core/ref.hpp>
 #include <boost/core/lightweight_test.hpp>
 
 namespace {

test/snprintf_test.cpp

@@ -0,0 +1,86 @@
+/*
+ *             Copyright Andrey Semashev 2022.
+ * 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)
+ */
+/*!
+ * \file   snprintf_test.cpp
+ * \author Andrey Semashev
+ * \date   06.12.2022
+ *
+ * This file contains tests for \c boost::core::snprintf.
+ */
+
+#include <boost/core/snprintf.hpp>
+#include <cstddef>
+#include <cstring>
+#include <boost/core/lightweight_test.hpp>
+
+void test_snprintf()
+{
+    char buf[11];
+    std::memset(buf, 0xFF, sizeof(buf));
+
+    std::size_t buf_size = sizeof(buf) - 1u;
+
+    int res = boost::core::snprintf(buf, buf_size, "%s", "0123");
+    BOOST_TEST_EQ(res, 4);
+    int cmp_res = std::memcmp(buf, "0123", sizeof("0123"));
+    BOOST_TEST_EQ(cmp_res, 0);
+
+    std::memset(buf, 0xFF, sizeof(buf));
+
+    // Suppress compiler checks for buffer overflow
+    const char* volatile str = "0123456789";
+
+    res = boost::core::snprintf(buf, buf_size, "%s", str);
+    BOOST_TEST_GE(res, 10);
+    cmp_res = std::memcmp(buf, "012345678", sizeof("012345678"));
+    BOOST_TEST_EQ(cmp_res, 0);
+    BOOST_TEST_EQ(buf[10], static_cast< char >(~static_cast< char >(0)));
+
+    std::memset(buf, 0xFF, sizeof(buf));
+
+    res = boost::core::snprintf(buf, 0, "%s", str);
+    BOOST_TEST_GE(res, 0);
+    BOOST_TEST_EQ(buf[0], static_cast< char >(~static_cast< char >(0)));
+}
+
+void test_swprintf()
+{
+    wchar_t buf[11];
+    std::memset(buf, 0xFF, sizeof(buf));
+
+    std::size_t buf_size = sizeof(buf) / sizeof(*buf) - 1u;
+
+    int res = boost::core::swprintf(buf, buf_size, L"%ls", L"0123");
+    BOOST_TEST_EQ(res, 4);
+    int cmp_res = std::memcmp(buf, L"0123", sizeof(L"0123"));
+    BOOST_TEST_EQ(cmp_res, 0);
+
+    std::memset(buf, 0xFF, sizeof(buf));
+
+    // Suppress compiler checks for buffer overflow
+    const wchar_t* volatile str = L"0123456789";
+
+    res = boost::core::swprintf(buf, buf_size, L"%ls", str);
+    BOOST_TEST_LT(res, 0);
+    // swprintf may or may not write to the buffer in case of overflow.
+    // E.g. glibc 2.35 doesn't and libc on MacOS 11 does.
+    BOOST_TEST_EQ(buf[10], static_cast< wchar_t >(~static_cast< wchar_t >(0)));
+
+    std::memset(buf, 0xFF, sizeof(buf));
+
+    res = boost::core::swprintf(buf, 0, L"%ls", str);
+    BOOST_TEST_LT(res, 0);
+    BOOST_TEST_EQ(buf[0], static_cast< wchar_t >(~static_cast< wchar_t >(0)));
+}
+
+int main()
+{
+    test_snprintf();
+    test_swprintf();
+
+    return boost::report_errors();
+}

test/sv_types_test.cpp

@@ -5,7 +5,6 @@
 #include <boost/core/detail/string_view.hpp>
 #include <boost/core/lightweight_test.hpp>
 #include <boost/core/lightweight_test_trait.hpp>
-#include <boost/core/is_same.hpp>
 #include <iterator>
 
 struct Ch

test/underlying_type.cpp

@@ -15,7 +15,7 @@
 #include <boost/core/underlying_type.hpp>
 #include <boost/core/scoped_enum.hpp>
 #include <boost/core/lightweight_test_trait.hpp>
-#include <boost/core/is_same.hpp>
+#include <boost/type_traits/is_same.hpp>
 #include <boost/config.hpp>
 
 #if defined(_MSC_VER)
@@ -63,9 +63,9 @@ struct underlying_type< native_enum >
 
 int main(int, char*[])
 {
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same< boost::underlying_type< emulated_enum >::type, unsigned char >));
+    BOOST_TEST_TRAIT_TRUE((boost::is_same< boost::underlying_type< emulated_enum >::type, unsigned char >));
 #if !defined(BOOST_NO_CXX11_SCOPED_ENUMS)
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same< boost::underlying_type< native_enum >::type, unsigned short >));
+    BOOST_TEST_TRAIT_TRUE((boost::is_same< boost::underlying_type< native_enum >::type, unsigned short >));
 #endif
 
     return boost::report_errors();