Apply workaround for Intel-16

Without this I see: ``` /boost/core/noncopyable.hpp(42): error: defaulted default constructor cannot be constexpr because the corresponding implicitly declared default constructor would not be constexpr BOOST_CONSTEXPR noncopyable() = default; ``` See: https://travis-ci.org/boostorg/type_traits/jobs/4722892817 Not sure if later Intel versions also require this... still working on that.
2018-12-30 18:29:54 +00:00
47 changed files with 86 additions and 2409 deletions
--- a/.travis.yml
+++ b/.travis.yml
@@ -240,7 +240,6 @@ matrix:
        apt:
          packages:
            - libc++-dev
-            - libc++abi-dev

    - os: linux
      compiler: clang++-libc++
@@ -249,40 +248,13 @@ matrix:
        apt:
          packages:
            - libc++-dev
-            - libc++abi-dev

    - os: osx
      compiler: clang++
      env: TOOLSET=clang COMPILER=clang++ CXXSTD=03,11,14,1z
-      osx_image: xcode7.3
-
-    - os: osx
-      compiler: clang++
-      env: TOOLSET=clang COMPILER=clang++ CXXSTD=03,11,14,1z
-      osx_image: xcode8.3
-
-    - os: osx
-      compiler: clang++
-      env: TOOLSET=clang COMPILER=clang++ CXXSTD=03,11,14,1z
-      osx_image: xcode9.4
-
-    - os: osx
-      compiler: clang++
-      env: TOOLSET=clang COMPILER=clang++ CXXSTD=03,11,14,1z
-      osx_image: xcode10.1
-
-    - os: linux
-      compiler: g++
-      env: CMAKE_SUBDIR_TEST=1
-      script:
-      - cd libs/core/test/cmake_subdir_test && mkdir __build__ && cd __build__
-      - cmake ..
-      - cmake --build .
-      - cmake --build . --target check

 install:
-  - BOOST_BRANCH=develop
-  - if [ "$TRAVIS_BRANCH" = "master" ]; then BOOST_BRANCH=master; fi
+  - BOOST_BRANCH=develop && [ "$TRAVIS_BRANCH" == "master" ] && BOOST_BRANCH=master || true
  - cd ..
  - git clone -b $BOOST_BRANCH https://github.com/boostorg/boost.git boost-root
  - cd boost-root
@@ -291,7 +263,6 @@ install:
  - git submodule init libs/config
  - git submodule init libs/predef
  - git submodule init libs/static_assert
-  - git submodule init libs/throw_exception
  - git submodule init libs/type_traits
  - git submodule init tools/build
  - git submodule init tools/boost_install
@@ -303,8 +274,7 @@ install:
 script:
  - |-
    echo "using $TOOLSET : : $COMPILER ;" > ~/user-config.jam
-  - BUILD_JOBS=`(nproc || sysctl -n hw.ncpu) 2> /dev/null`
-  - ./b2 -j $BUILD_JOBS libs/core/test toolset=$TOOLSET cxxstd=$CXXSTD variant=debug,release ${UBSAN:+cxxflags=-fsanitize=undefined cxxflags=-fno-sanitize-recover=undefined linkflags=-fsanitize=undefined define=UBSAN=1 debug-symbols=on} ${LINKFLAGS:+linkflags=$LINKFLAGS}
+  - ./b2 -j 3 libs/core/test toolset=$TOOLSET cxxstd=$CXXSTD variant=debug,release ${UBSAN:+cxxflags=-fsanitize=undefined cxxflags=-fno-sanitize-recover=undefined linkflags=-fsanitize=undefined define=UBSAN=1 debug-symbols=on} ${LINKFLAGS:+linkflags=$LINKFLAGS}

 notifications:
  email:
--- a/appveyor.yml
+++ b/appveyor.yml
@@ -1,4 +1,4 @@
-# Copyright 2016-2019 Peter Dimov
+# Copyright 2016, 2017 Peter Dimov
 # Distributed under the Boost Software License, Version 1.0.
 # (See accompanying file LICENSE_1_0.txt or copy at http://boost.org/LICENSE_1_0.txt)

@@ -14,39 +14,37 @@ branches:

 environment:
  matrix:
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
-      TOOLSET: msvc-9.0,msvc-10.0,msvc-11.0
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2013
+      TOOLSET: msvc-9.0,msvc-10.0,msvc-11.0,msvc-12.0

    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
-      TOOLSET: msvc-12.0,msvc-14.0
-      ADDRMD: 32,64
+      TOOLSET: msvc-14.0

    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
-      TOOLSET: msvc-14.1,clang-win
-      ADDRMD: 32,64
+      TOOLSET: msvc-14.1
      CXXSTD: 14,17

-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2013
      ADDPATH: C:\cygwin\bin;
      TOOLSET: gcc
      CXXSTD: 03,11,14,1z

-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2013
      ADDPATH: C:\cygwin64\bin;
      TOOLSET: gcc
      CXXSTD: 03,11,14,1z

-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2013
      ADDPATH: C:\mingw\bin;
      TOOLSET: gcc
      CXXSTD: 03,11,14,1z

-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2013
      ADDPATH: C:\mingw-w64\x86_64-6.3.0-posix-seh-rt_v5-rev1\mingw64\bin;
      TOOLSET: gcc
      CXXSTD: 03,11,14,1z

-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2013
      ADDPATH: C:\mingw-w64\x86_64-7.2.0-posix-seh-rt_v5-rev1\mingw64\bin;
      TOOLSET: gcc
      CXXSTD: 03,11,14,1z
@@ -62,12 +60,11 @@ install:
  - git submodule init libs/config
  - git submodule init libs/predef
  - git submodule init libs/static_assert
-  - git submodule init libs/throw_exception
  - git submodule init libs/type_traits
  - git submodule init tools/build
  - git submodule init tools/boost_install
  - git submodule update --jobs 4
-  - xcopy /s /e /q %APPVEYOR_BUILD_FOLDER% libs\core\
+  - xcopy /s /e /q %APPVEYOR_BUILD_FOLDER% libs\core
  - cmd /c bootstrap
  - b2 headers

@@ -76,5 +73,4 @@ build: off
 test_script:
  - PATH=%ADDPATH%%PATH%
  - if not "%CXXSTD%" == "" set CXXSTD=cxxstd=%CXXSTD%
-  - if not "%ADDRMD%" == "" set ADDRMD=address-model=%ADDRMD%
-  - b2 -j %NUMBER_OF_PROCESSORS% libs/core/test toolset=%TOOLSET% %CXXSTD% %ADDRMD% variant=debug,release
+  - b2 -j 3 libs/core/test toolset=%TOOLSET% %CXXSTD%
--- a/doc/Jamfile.v2
+++ b/doc/Jamfile.v2
@@ -49,7 +49,7 @@ boostbook standalone
    <xsl:param>boost.root=../../../..
    <xsl:param>generate.section.toc.level=1
    <xsl:param>toc.max.depth=1
-    <format>pdf:<xsl:param>boost.url.prefix="http://www.boost.org/doc/libs/release/libs/core/doc/html"
+    <format>pdf:<xsl:param>boost.url.prefix=http://www.boost.org/doc/libs/release/libs/core/doc/html
  ;

 ###############################################################################
--- a/doc/alloc_construct.qbk
+++ b/doc/alloc_construct.qbk
@@ -1,149 +0,0 @@
-[/
-Copyright 2019 Glen Joseph Fernandes
-(glenjofe@gmail.com)
-
-Distributed under the Boost Software License, Version 1.0.
-(http://www.boost.org/LICENSE_1_0.txt)
-]
-
-[section:alloc_construct alloc_construct, alloc_destroy]
-
-[simplesect Authors]
-
-* Glen Fernandes
-
-[endsimplesect]
-
-[section Overview]
-
-The header <boost/core/alloc_construct.hpp> provides function templates
-`alloc_construct`, `alloc_construct_n`, `alloc_destroy`, and `alloc_destroy_n`
-for allocator aware and exception safe construction and destruction of objects
-and arrays.
-
-[endsect]
-
-[section Example]
-
-The following example allocates storage for an array of `n` elements of `T`
-using an allocator `a` and constructs `T` elements in that storage. If any
-exception was thrown during construction of an element, the constructed
-elements are destroyed in reverse order.
-
-```
-template<class A>
-auto create(A& a, std::size_t n)
-{
-    auto p = a.allocate(n);
-    try {
-        boost::alloc_construct_n(a, boost::to_address(p), n);
-    } catch (...) {
-        a.deallocate(p, n);
-        throw;
-    }
-    return p;
-}
-```
-
-[endsect]
-
-[section Reference]
-
-```
-namespace boost {
-
-template<class A, class T>
-void alloc_destroy(A& a, T* p);
-
-template<class A, class T>
-void alloc_destroy_n(A& a, T* p, std::size_t n);
-
-template<class A, class T, class Args>
-void alloc_construct(A& a, T* p, Args&&... args);
-
-template<class A, class T>
-void alloc_construct_n(A& a, T* p, std::size_t n);
-
-template<class A, class T>
-void alloc_construct_n(A& a, T* p, std::size_t n, const T* l, std::size_t m);
-
-template<class A, class T, class I>
-void alloc_construct_n(A& a, T* p, std::size_t n, I begin);
-
-} /* boost */
-```
-
-[section Functions]
-
-[variablelist
-[[`template<class A, class T> void alloc_destroy(A& a, T* p);`]
-[[variablelist
-[[Requires][`A` is an /Allocator/]]
-[[Effects][`std::allocator_traits<A>::destroy(a, p)`.]]]]]
-[[`template<class A, class T> void alloc_destroy_n(A& a, T* p,
-std::size_t n);`]
-[[variablelist
-[[Requires][`A` is an /Allocator/]]
-[[Effects]
-[Destroys each `i`-th element in reverse order by calling
-`std::allocator_traits<A>::destroy(a, &p[i])`.]]]]]
-[[`template<class A, class T, class Args> void alloc_construct(A& a, T* p,
-Args&&... args);`]
-[[variablelist
-[[Requires][`A` is an /Allocator/]]
-[[Effects]
-[`std::allocator_traits<A>::construct(a, p, std::forward<Args>(args)...)`.]]]]]
-[[`template<class A, class T> void alloc_construct_n(A& a, T* p,
-std::size_t n);`]
-[[variablelist
-[[Requires][`A` is an /Allocator/]]
-[[Effects]
-[Constructs each `i`-th element in order by calling
-`std::allocator_traits<A>::construct(a, &p[i])`.]]
-[[Remarks]
-[If an exception is thrown destroys each already constructed `j`-th element in
-reverse order by calling `std::allocator_traits<A>::destroy(a, &p[j])`.]]]]]
-[[`template<class A, class T> void alloc_construct_n(A& a, T* p, std::size_t n,
-const T* l, std::size_t m);`]
-[[variablelist
-[[Requires][`A` is an /Allocator/]]
-[[Effects]
-[Constructs each `i`-th element in order by calling
-`std::allocator_traits<A>::construct(a, &p[i], l[i % m])`.]]
-[[Remarks]
-[If an exception is thrown destroys each already constructed `j`-th element in
-reverse order by calling `std::allocator_traits<A>::destroy(a, &p[j])`.]]]]]
-[[`template<class A, class T, class I> void alloc_construct_n(A& a, T* p,
-std::size_t n, I begin);`]
-[[variablelist
-[[Requires]
-[[itemized_list
-[`A` is an /Allocator/][`I` is an /InputIterator/]]]]
-[[Effects]
-[Constructs each `i`-th element in order by calling
-`std::allocator_traits<A>::construct(a, &p[i], *begin++])`.]]
-[[Remarks]
-[If an exception is thrown destroys each already constructed `j`-th element in
-reverse order by calling `std::allocator_traits<A>::destroy(a, &p[j])`.]]]]]]
-
-[endsect]
-
-[endsect]
-
-[section Compatibility]
-
-When `BOOST_NO_CXX11_ALLOCATOR` is defined, and the C++11 allocator model is
-not supported, these functions invoke constructors and destructors directly
-without going through the supplied allocator.
-
-[endsect]
-
-[section Acknowledgments]
-
-Glen Fernandes originally implemented this functionality in Boost.Smart_Ptr and
-later moved these functions to Boost.Core for use in other Boost libraries,
-such as Boost.Multi_Array and Boost.Histogram.
-
-[endsect]
-
-[endsect]
--- a/doc/core.qbk
+++ b/doc/core.qbk
@@ -39,20 +39,16 @@ criteria for inclusion is that the utility component be:
 [endsect]

 [include addressof.qbk]
-[include alloc_construct.qbk]
 [include checked_delete.qbk]
-[include default_allocator.qbk]
 [include demangle.qbk]
 [include empty_value.qbk]
 [include enable_if.qbk]
 [include exchange.qbk]
 [include explicit_operator_bool.qbk]
-[include first_scalar.qbk]
 [include ignore_unused.qbk]
 [include is_same.qbk]
 [include lightweight_test.qbk]
 [include no_exceptions_support.qbk]
-[include noinit_adaptor.qbk]
 [include noncopyable.qbk]
 [include null_deleter.qbk]
 [include pointer_traits.qbk]
@@ -62,4 +58,3 @@ criteria for inclusion is that the utility component be:
 [include swap.qbk]
 [include typeinfo.qbk]
 [include uncaught_exceptions.qbk]
-[include use_default.qbk]
--- a/doc/default_allocator.qbk
+++ b/doc/default_allocator.qbk
@@ -1,140 +0,0 @@
-[/
-Copyright 2019 Glen Joseph Fernandes
-(glenjofe@gmail.com)
-
-Distributed under the Boost Software License, Version 1.0.
-(http://www.boost.org/LICENSE_1_0.txt)
-]
-
-[section:default_allocator default_allocator]
-
-[simplesect Authors]
-
-* Glen Fernandes
-
-[endsimplesect]
-
-[section Overview]
-
-The header <boost/core/default_allocator.hpp> provides the class template
-`boost::default_allocator` to serve as a minimal default allocator that:
-
-* Like C++2a's `std::allocator`, does not provide members such as `construct()`
-and `destroy()` to be eligible for optimizations by allocator-aware code that
-detects the absence of these members to provide more optimal construction.
-* Supports `BOOST_NO_EXCEPTIONS` in allocation.
-* Does not have `std` as an associated namespace.
-
-[endsect]
-
-[section Examples]
-
-The following snippet shows the use of this allocator as the default allocator
-for a container.
-
-```
-template<class Key, class Compare = std::less<Key>,
-    class Allocator = boost::default_allocator<Key> >
-class FlatSet;
-```
-
-Facilities like `make_shared` can be implemented using `allocate_shared` with
-`default_allocator`.
-
-```
-template<class T, class... Args>
-enable_if_t<!is_array_v<T>, shared_ptr<T> >
-make_shared(Args&&... args)
-{
-    return allocate_shared<T>(boost::default_allocator<remove_cv_t<T> >(),
-        std::forward<Args>(args)...);
-}
-```
-
-[endsect]
-
-[section Reference]
-
-```
-namespace boost {
-
-template<class T>
-struct default_allocator {
-    typedef T value_type;
-    typedef T* pointer;
-    typedef const T* const_pointer;
-    typedef std::add_lvalue_reference_t<T> reference;
-    typedef std::add_lvalue_reference_t<const T> const_reference;
-    typedef std::size_t size_type;
-    typedef std::ptrdiff_t difference_type;
-    typedef ``['true_type]`` propagate_on_container_move_assignment;
-    typedef ``['true_type]`` is_always_equal;
-
-    template<class U>
-    struct rebind {
-        typedef default_allocator<U> other;
-    };
-
-    constexpr default_allocator() = default;
-
-    template<class U>
-    constexpr default_allocator(const default_allocator<U>&) noexcept { }
-
-    constexpr std::size_t max_size() const noexcept;
-    T* allocate(std::size_t n);
-    void deallocate(T* p, std::size_t);
-};
-
-template<class T, class U>
-constexpr bool operator==(const default_allocator<T>&,
-    const default_allocator<U>&) noexcept;
-
-template<class T, class U>
-constexpr bool operator!=(const default_allocator<T>&,
-    const default_allocator<U>&) noexcept;
-
-} /* boost */
-```
-
-[section Members]
-
-[variablelist
-[[`constexpr std::size_t max_size() const noexcept;`]
-[[variablelist
-[[Returns][The largest value `N` for which the call `allocate(N)` might
-succeed.]]]]]
-[[`T* allocate(std::size_t n);`]
-[[variablelist
-[[Returns]
-[A pointer to the initial element of an array of storage of size
-`n * sizeof(T)`, aligned appropriately for objects of type `T`.]]
-[[Remarks][The storage is obtained by calling `::operator new`.]]
-[[Throws][`std::bad_alloc` if the storage cannot be obtained.]]]]]
-[[`void deallocate(T* p, std::size_t n);`]
-[[variablelist
-[[Requires]
-[`p` shall be a pointer value obtained from `allocate()`. `n` shall equal the
-value passed as the first argument to the invocation of `allocate` which
-returned `p`.]]
-[[Effects][Deallocates the storage referenced by `p`.]]
-[[Remarks][Uses `::operator delete`.]]]]]]
-
-[endsect]
-
-[section Operators]
-
-[variablelist
-[[`template<class T, class U> constexpr bool operator==(const
-default_allocator<T>&, const default_allocator<U>&) noexcept;`]
-[[variablelist
-[[Returns][`true`.]]]]]
-[[`template<class T, class U> constexpr bool operator!=(const
-default_allocator<T>&, const default_allocator<U>&) noexcept;`]
-[[variablelist
-[[Returns][`false`.]]]]]]
-
-[endsect]
-
-[endsect]
-
-[endsect]
--- a/doc/empty_value.qbk
+++ b/doc/empty_value.qbk
@@ -111,8 +111,7 @@ public:

 [section Member types]

-[variablelist
-[[`type`][The template parameter `T`]]]
+[variablelist [[`type`][The template parameter `T`]]]

 [endsect]

--- a/doc/exchange.qbk
+++ b/doc/exchange.qbk
@@ -18,8 +18,7 @@ Distributed under the Boost Software License, Version 1.0.

 The header <boost/core/exchange.hpp> provides the function template
 `boost::exchange` which is an implementation of the `std::exchange`
-function introduced in C++14. `boost::exchange(o, v)` replaces the
-value of `o` with `v` and returns the old value of `o`.
+function introduced in C++14.

 [endsect]

--- a/doc/first_scalar.qbk
+++ b/doc/first_scalar.qbk
@@ -1,91 +0,0 @@
-[/
-Copyright 2019 Glen Joseph Fernandes
-(glenjofe@gmail.com)
-
-Distributed under the Boost Software License, Version 1.0.
-(http://www.boost.org/LICENSE_1_0.txt)
-]
-
-[section:first_scalar first_scalar]
-
-[simplesect Authors]
-
-* Glen Fernandes
-
-[endsimplesect]
-
-[section Overview]
-
-The header <boost/core/first_scalar.hpp> provides the function templates
-`boost::first_scalar` that can be used to obtain a pointer to the first scalar
-element of an array. Given a pointer of type `T*` they return a pointer of
-type `remove_all_extents_t<T>*`. The functions are `constexpr` and can be used
-in constant expressions.
-
-[endsect]
-
-[section Examples]
-
-The following function uses an allocator to allocate an array of arrays and
-constructs each scalar element in it.
-
-```
-#include <boost/alloc_construct.hpp>
-#include <boost/first_scalar.hpp>
-
-template<class A>
-auto create(const A& allocator)
-{
-    typename std::allocator_traits<A>::template
-        rebind_alloc<int[2][3]> other(allocator);
-    auto ptr = other.allocate(4);
-    try {
-        boost::alloc_construct_n(other,
-            boost::first_scalar(boost::to_address(ptr)), 24);
-    } catch (...) {
-        other.deallocate(ptr, 4);
-        throw;
-    }
-    return ptr;
-}
-```
-
-[endsect]
-
-[section Reference]
-
-```
-namespace boost {
-
-template<class T>
-constexpr T* first_scalar(T* p) noexcept;
-
-template<class T, std::size_t N>
-constexpr auto first_scalar(T (*p)[N]) noexcept;
-
-} /* boost */
-```
-
-[section Functions]
-
-[variablelist
-[[`template<class T> constexpr T* first_scalar(T* p) noexcept;`]
-[[variablelist
-[[Returns][`p`.]]]]]
-[[`template<class T, std::size_t N> constexpr auto first_scalar(T (*p)[N])
-noexcept;`]
-[[variablelist
-[[Returns][`first_scalar(&(*p)[0])`.]]]]]]
-
-[endsect]
-
-[endsect]
-
-[section History]
-
-Glen Fernandes implemented `first_scalar`. Peter Dimov suggested a change for
-GCC to support an additional `constexpr` use.
-
-[endsect]
-
-[endsect]
--- a/doc/lightweight_test.qbk
+++ b/doc/lightweight_test.qbk
@@ -1,7 +1,7 @@
 [/
  Copyright 2010, 2011 Beman Dawes
  Copyright 2013 Ion Gaztanaga
-  Copyright 2014-2019 Peter Dimov
+  Copyright 2014, 2017 Peter Dimov
  Copyright 2017 Kohei Takahashi

  Distributed under the Boost Software License, Version 1.0.
@@ -253,7 +253,6 @@ return a boolean value.
 ``
 #define BOOST_TEST_TRAIT_TRUE((Trait)) /*unspecified*/
 #define BOOST_TEST_TRAIT_FALSE((Trait)) /*unspecified*/
-#define BOOST_TEST_TRAIT_SAME(Type1, Type2) /*unspecified*/
 ``

 [endsect]
@@ -281,20 +280,6 @@ message containing `Trait`. Note the double set of parentheses.

 [endsect]

-[section BOOST_TEST_TRAIT_SAME]
-
-``
-BOOST_TEST_TRAIT_SAME(Type1, Type2)
-``
-
-If the two types are not the same, increases the error count and outputs a
-message containing them. This macro requires that the compiler supports
-variadic macros and `__VA_ARGS__`. (Note that unlike `BOOST_TEST_TRAIT_TRUE`
-and `BOOST_TEST_TRAIT_FALSE`, this macro only requires a single set of
-parentheses.)
-
-[endsect]
-
 [section Example]

 ``
@@ -312,8 +297,6 @@ int main()
 {
    BOOST_TEST_TRAIT_TRUE(( is_same<X<int, long>::type, int> ));

-    BOOST_TEST_TRAIT_SAME( X<int, long>::type, int );
-
    return boost::report_errors();
 }
 ``
--- a/doc/noinit_adaptor.qbk
+++ b/doc/noinit_adaptor.qbk
@@ -1,172 +0,0 @@
-[/
-Copyright 2019 Glen Joseph Fernandes
-(glenjofe@gmail.com)
-
-Distributed under the Boost Software License, Version 1.0.
-(http://www.boost.org/LICENSE_1_0.txt)
-]
-
-[section:noinit_adaptor noinit_adaptor]
-
-[simplesect Authors]
-
-* Glen Fernandes
-
-[endsimplesect]
-
-[section Overview]
-
-The header <boost/core/noinit_adaptor.hpp> provides the class
-template `boost::noinit_adaptor` that converts any allocator into
-one whose `construct(ptr)` performs default initialization via placement new,
-and whose `destroy(ptr)` invokes `value_type` destructor directly.
-
-[endsect]
-
-[section Examples]
-
-The following example shows use of this allocator adaptor to achieve default
-initialization of elements of a trivial type, which are later assigned values.
-
-```
-#include <boost/core/noinit_adaptor.hpp>
-#include <numeric>
-#include <vector>
-
-int main()
-{
-    std::vector<int, boost::noinit_adaptor<std::allocator<int> > > v(5);
-    std::iota(v.begin(), v.end(), 1);
-}
-```
-
-The `allocate_shared_noinit` function templates are now implemented simply
-using `allocate_shared` with `noinit_adaptor`.
-
-```
-template<class T, class A>
-enable_if_t<is_unbounded_array_v<T>, shared_ptr<T> >
-allocate_shared_noinit(const A& a, size_t n)
-{
-    return allocate_shared<T>(boost::noinit_adapt(a), n);
-}
-
-template<class T, class A>
-enable_if_t<!is_unbounded_array_v<T>, shared_ptr<T> >
-allocate_shared_noinit(const A& a)
-{
-    return allocate_shared<T>(boost::noinit_adapt(a));
-}
-```
-
-[endsect]
-
-[section Reference]
-
-```
-namespace boost {
-
-template<class A>
-struct noinit_adaptor
-    : A {
-    template<class U>
-    struct rebind {
-        typedef noinit_adaptor<typename std::allocator_traits<A>::template
-            rebind_alloc<U> > other;
-    };
-
-    noinit_adaptor() noexcept;
-
-    template<class U>
-    noinit_adaptor(U&& u) noexcept;
-
-    template<class U>
-    noinit_adaptor(const noinit_adaptor<U>& u) noexcept;
-
-    template<class U>
-    void construct(U* p);
-
-    template<class U, class V, class... Args>
-    void construct(U* p, V&& v, Args&&... args);
-
-    template<class U>
-    void destroy(U* p);
-};
-
-template<class T, class U>
-bool operator==(const noinit_adaptor<T>& lhs,
-    const noinit_adaptor<U>& rhs) noexcept;
-
-template<class T, class U>
-bool operator!=(const noinit_adaptor<T>& lhs,
-    const noinit_adaptor<U>& rhs) noexcept;
-
-template<class A>
-noinit_adaptor<A> noinit_adapt(const A& a) noexcept;
-
-} /* boost */
-```
-
-[section Constructors]
-
-[variablelist
-[[`noinit_adaptor() noexcept;`]
-[[variablelist
-[[Effects][Value initializes the A base class.]]]]]
-[[`template<class U> noinit_adaptor(U&& u) noexcept;`]
-[[variablelist
-[[Requires][`A` shall be constructible from `U`.]]
-[[Effects][Initializes the `A` base class with `std::forward<U>(u)`.]]]]]
-[[`template<class U> noinit_adaptor(const noinit_adaptor<U>& u) noexcept;`]
-[[variablelist
-[[Requires][`A` shall be constructible from `U`.]]
-[[Effects][Initializes the `A` base class with
-`static_cast<const U&>(u)`.]]]]]]
-
-[endsect]
-
-[section Member functions]
-
-[variablelist
-[[`template<class U> void construct(U* p);`]
-[[variablelist
-[[Effects][`::new((void*)p) U`.]]]]]
-[[`template<class U, class V, class... Args> void construct(U* p, V&& v,
-Args&&... args);`]
-[[variablelist
-[[Effects][`::new(void*)p) U(std::forward<V>(v),
-std::forward<Args>(args)...)`.]]]]]
-[[`template<class U> void destroy(U* p);`]
-[[variablelist
-[[Effects][`p->~U()`.]]]]]]
-
-[endsect]
-
-[section Operators]
-
-[variablelist
-[[`template<class T, class U> constexpr bool
-operator==(const noinit_adaptor<T>& lhs,
-const noinit_adaptor<U>& rhs) noexcept;`]
-[[variablelist
-[[Returns][`static_cast<const T&>(lhs) == static_cast<const U&>(rhs)`.]]]]]
-[[`template<class T, class U> constexpr bool
-operator!=(const noinit_adaptor<T>& lhs,
-const noinit_adaptor<U>& rhs) noexcept;`]
-[[variablelist
-[[Returns][`!(lhs == rhs)`.]]]]]]
-
-[endsect]
-
-[section Free functions]
-
-[variablelist
-[[`template<class A> noinit_adaptor<A> noinit_adapt(const A& a) noexcept;`]
-[[variablelist
-[[Returns][`noinit_adaptor<A>(a)`.]]]]]]
-
-[endsect]
-
-[endsect]
-
-[endsect]
--- a/doc/pointer_traits.qbk
+++ b/doc/pointer_traits.qbk
@@ -109,7 +109,7 @@ namespace boost {
 [[Remark]
 [If `element_type` is a void type, the type of `v` is unspecified; otherwise,
  it is `element_type&`.]]
-[[Returns][`addressof(v)`.]]]]]]
+[[Returns] [`addressof(v)`.]]]]]]

 [endsect]

@@ -131,11 +131,9 @@ namespace boost {

 [variablelist
 [[`template<class T> constexpr T* to_address(T* v) noexcept;`]
-[[variablelist
-[[Returns][`v`.]]]]]
+[[variablelist [[Returns] [`v`.]]]]]
 [[`template<class T> auto to_address(const T& v) noexcept;`]
-[[variablelist
-[[Returns][`pointer_traits<T>::to_address(v)` if that
+[[variablelist [[Returns] [`pointer_traits<T>::to_address(v)` if that
  expression is well-formed, otherwise `to_address(v.operator->())`.]]]]]]

 [endsect]
--- a/doc/scoped_enum.qbk
+++ b/doc/scoped_enum.qbk
@@ -67,9 +67,9 @@ The enumeration can be forward declared:

    BOOST_SCOPED_ENUM_FORWARD_DECLARE(future_errc);

-There are however some limitations. The emulated scoped enum is not a C++ enum, so `is_enum< future_errc >` will be `false_type`.
+There are however some limitations. First, the emulated scoped enum is not a C++ enum, so `is_enum< future_errc >` will be `false_type`.

-The emulated scoped enum can not be used in switch nor in template arguments. For these cases the user needs to use some helpers. Instead of
+Second, the emulated scoped enum can not be used in switch nor in template arguments. For these cases the user needs to use some helpers. Instead of

    switch (ev)
    {
@@ -99,29 +99,10 @@ use
    {
    };

-Explicit conversion to the underlying type should be performed with `boost::underlying_cast` instead of `static_cast`:
+Lastly, explicit conversion to the underlying type should be performed with `boost::underlying_cast` instead of `static_cast`:

    unsigned int val = boost::underlying_cast< unsigned int >(ev);

-In C++03, scoped enums behave differently in case of calling an overloaded function when one overload takes a scoped enum as a parameter, and the other takes a parameter of an integral type. Consider the following code:
-
-    enum enum_regular { REGULAR_A, REGULAR_B };
-
-    BOOST_SCOPED_ENUM_DECLARE_BEGIN(enum_scoped)
-    {
-        a, b
-    }
-    BOOST_SCOPED_ENUM_DECLARE_END(enum_scoped)
-
-    void regular_or_int(enum_regular); // (1)
-    void regular_or_int(int);          // (2)
-    void scoped_or_int(enum_scoped);   // (3)
-    void scoped_or_int(int);           // (4)
-
-    regular_or_int(REGULAR_A);                  // calls (1) in C++03 and C++11
-    scoped_or_int(enum_scoped::a);              // calls (3) in C++11 but (4) in C++03!
-    scoped_or_int(enum_scoped(enum_scoped::a)); // calls (3) in C++03 and C++11
-
 Here is usage example:

    BOOST_SCOPED_ENUM_UT_DECLARE_BEGIN(algae, char)
--- a/doc/use_default.qbk
+++ b/doc/use_default.qbk
@@ -1,47 +0,0 @@
-[/
-Copyright 2019 Glen Joseph Fernandes
-(glenjofe@gmail.com)
-
-Distributed under the Boost Software License, Version 1.0.
-(http://www.boost.org/LICENSE_1_0.txt)
-]
-
-[section:use_default use_default]
-
-[section Overview]
-
-The header <boost/core/use_default.hpp> provides the type `boost::use_default`
-which is used by other Boost libraries as a sentinel type in a templates to
-indicate defaults.
-
-[endsect]
-
-[section Example]
-
-```
-template<class Derived, class Base,
-   class Value = boost::use_default,
-   class CategoryOrTraversal = boost::use_default,
-   class Reference = boost::use_default,
-   class Difference = boost::use_default>
-class iterator_adaptor;
-
-template<class Value>
-class node_iterator
-    : public iterator_adaptor<node_iterator<Value>, Value*,
-        boost::use_default, boost::forward_traversal_tag>;
-```
-
-[endsect]
-
-[section Reference]
-
-```
-namespace boost {
-  struct use_default { };
-}
-```
-
-[endsect]
-
-[endsect]
--- a/include/boost/core/alloc_construct.hpp
+++ b/include/boost/core/alloc_construct.hpp
@@ -1,245 +0,0 @@
-/*
-Copyright 2019 Glen Joseph Fernandes
-(glenjofe@gmail.com)
-
-Distributed under the Boost Software License, Version 1.0.
-(http://www.boost.org/LICENSE_1_0.txt)
-*/
-#ifndef BOOST_CORE_ALLOC_CONSTRUCT_HPP
-#define BOOST_CORE_ALLOC_CONSTRUCT_HPP
-
-#include <boost/core/noinit_adaptor.hpp>
-
-namespace boost {
-
-#if !defined(BOOST_NO_CXX11_ALLOCATOR)
-template<class A, class T>
-inline void
-alloc_destroy(A& a, T* p)
-{
-    std::allocator_traits<A>::destroy(a, p);
-}
-
-template<class A, class T>
-inline void
-alloc_destroy_n(A& a, T* p, std::size_t n)
-{
-    while (n > 0) {
-        std::allocator_traits<A>::destroy(a, p + --n);
-    }
-}
-#else
-template<class A, class T>
-inline void
-alloc_destroy(A&, T* p)
-{
-    p->~T();
-}
-
-template<class A, class T>
-inline void
-alloc_destroy_n(A&, T* p, std::size_t n)
-{
-    while (n > 0) {
-        p[--n].~T();
-    }
-}
-#endif
-
-namespace detail {
-
-template<class A, class T>
-class alloc_destroyer {
-public:
-    alloc_destroyer(A& a, T* p) BOOST_NOEXCEPT
-        : a_(a),
-          p_(p),
-          n_(0) { }
-
-    ~alloc_destroyer() {
-        boost::alloc_destroy_n(a_, p_, n_);
-    }
-
-    std::size_t& size() BOOST_NOEXCEPT {
-        return n_;
-    }
-
-private:
-    alloc_destroyer(const alloc_destroyer&);
-    alloc_destroyer& operator=(const alloc_destroyer&);
-
-    A& a_;
-    T* p_;
-    std::size_t n_;
-};
-
-} /* detail */
-
-#if !defined(BOOST_NO_CXX11_ALLOCATOR)
-template<class A, class T>
-inline void
-alloc_construct(A& a, T* p)
-{
-    std::allocator_traits<A>::construct(a, p);
-}
-
-#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
-template<class A, class T, class U, class... V>
-inline void
-alloc_construct(A& a, T* p, U&& u, V&&... v)
-{
-    std::allocator_traits<A>::construct(a, p, std::forward<U>(u),
-        std::forward<V>(v)...);
-}
-#else
-template<class A, class T, class U>
-inline void
-alloc_construct(A& a, T* p, U&& u)
-{
-    std::allocator_traits<A>::construct(a, p, std::forward<U>(u));
-}
-#endif
-#else
-template<class A, class T, class U>
-inline void
-alloc_construct(A& a, T* p, const U& u)
-{
-    std::allocator_traits<A>::construct(a, p, u);
-}
-
-template<class A, class T, class U>
-inline void
-alloc_construct(A& a, T* p, U& u)
-{
-    std::allocator_traits<A>::construct(a, p, u);
-}
-#endif
-
-template<class A, class T>
-inline void
-alloc_construct_n(A& a, T* p, std::size_t n)
-{
-    detail::alloc_destroyer<A, T> hold(a, p);
-    for (std::size_t& i = hold.size(); i < n; ++i) {
-        std::allocator_traits<A>::construct(a, p + i);
-    }
-    hold.size() = 0;
-}
-
-template<class A, class T>
-inline void
-alloc_construct_n(A& a, T* p, std::size_t n, const T* l, std::size_t m)
-{
-    detail::alloc_destroyer<A, T> hold(a, p);
-    for (std::size_t& i = hold.size(); i < n; ++i) {
-        std::allocator_traits<A>::construct(a, p + i, l[i % m]);
-    }
-    hold.size() = 0;
-}
-
-template<class A, class T, class I>
-inline void
-alloc_construct_n(A& a, T* p, std::size_t n, I b)
-{
-    detail::alloc_destroyer<A, T> hold(a, p);
-    for (std::size_t& i = hold.size(); i < n; void(++i), void(++b)) {
-        std::allocator_traits<A>::construct(a, p + i, *b);
-    }
-    hold.size() = 0;
-}
-#else
-template<class A, class T>
-inline void
-alloc_construct(A&, T* p)
-{
-    ::new(static_cast<void*>(p)) T();
-}
-
-template<class A, class T>
-inline void
-alloc_construct(noinit_adaptor<A>&, T* p)
-{
-    ::new(static_cast<void*>(p)) T;
-}
-
-#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
-template<class A, class T, class U, class... V>
-inline void
-alloc_construct(A&, T* p, U&& u, V&&... v)
-{
-    ::new(static_cast<void*>(p)) T(std::forward<U>(u), std::forward<V>(v)...);
-}
-#else
-template<class A, class T, class U>
-inline void
-alloc_construct(A& a, T* p, U&& u)
-{
-    ::new(static_cast<void*>(p)) T(std::forward<U>(u));
-}
-#endif
-#else
-template<class A, class T, class U>
-inline void
-alloc_construct(A&, T* p, const U& u)
-{
-    ::new(static_cast<void*>(p)) T(u);
-}
-
-template<class A, class T, class U>
-inline void
-alloc_construct(A&, T* p, U& u)
-{
-    ::new(static_cast<void*>(p)) T(u);
-}
-#endif
-
-template<class A, class T>
-inline void
-alloc_construct_n(A& a, T* p, std::size_t n)
-{
-    detail::alloc_destroyer<A, T> hold(a, p);
-    for (std::size_t& i = hold.size(); i < n; ++i) {
-        ::new(static_cast<void*>(p + i)) T();
-    }
-    hold.size() = 0;
-}
-
-template<class A, class T>
-inline void
-alloc_construct_n(noinit_adaptor<A>& a, T* p, std::size_t n)
-{
-    detail::alloc_destroyer<noinit_adaptor<A>, T> hold(a, p);
-    for (std::size_t& i = hold.size(); i < n; ++i) {
-        ::new(static_cast<void*>(p + i)) T;
-    }
-    hold.size() = 0;
-}
-
-template<class A, class T>
-inline void
-alloc_construct_n(A& a, T* p, std::size_t n, const T* l, std::size_t m)
-{
-    detail::alloc_destroyer<A, T> hold(a, p);
-    for (std::size_t& i = hold.size(); i < n; ++i) {
-        ::new(static_cast<void*>(p + i)) T(l[i % m]);
-    }
-    hold.size() = 0;
-}
-
-template<class A, class T, class I>
-inline void
-alloc_construct_n(A& a, T* p, std::size_t n, I b)
-{
-    detail::alloc_destroyer<A, T> hold(a, p);
-    for (std::size_t& i = hold.size(); i < n; void(++i), void(++b)) {
-        ::new(static_cast<void*>(p + i)) T(*b);
-    }
-    hold.size() = 0;
-}
-#endif
-
-} /* boost */
-
-#endif
--- a/include/boost/core/checked_delete.hpp
+++ b/include/boost/core/checked_delete.hpp
@@ -7,8 +7,6 @@
 # pragma once
 #endif

-#include <boost/config.hpp>
-
 //
 //  boost/checked_delete.hpp
 //
@@ -28,7 +26,7 @@ namespace boost

 // verify that types are complete for increased safety

-template<class T> inline void checked_delete(T * x) BOOST_NOEXCEPT
+template<class T> inline void checked_delete(T * x)
 {
    // intentionally complex - simplification causes regressions
    typedef char type_must_be_complete[ sizeof(T)? 1: -1 ];
@@ -36,7 +34,7 @@ template<class T> inline void checked_delete(T * x) BOOST_NOEXCEPT
    delete x;
 }

-template<class T> inline void checked_array_delete(T * x) BOOST_NOEXCEPT
+template<class T> inline void checked_array_delete(T * x)
 {
    typedef char type_must_be_complete[ sizeof(T)? 1: -1 ];
    (void) sizeof(type_must_be_complete);
@@ -48,7 +46,7 @@ template<class T> struct checked_deleter
    typedef void result_type;
    typedef T * argument_type;

-    void operator()(T * x) const BOOST_NOEXCEPT
+    void operator()(T * x) const
    {
        // boost:: disables ADL
        boost::checked_delete(x);
@@ -60,7 +58,7 @@ template<class T> struct checked_array_deleter
    typedef void result_type;
    typedef T * argument_type;

-    void operator()(T * x) const BOOST_NOEXCEPT
+    void operator()(T * x) const
    {
        boost::checked_array_delete(x);
    }
--- a/include/boost/core/default_allocator.hpp
+++ b/include/boost/core/default_allocator.hpp
@@ -1,158 +0,0 @@
-/*
-Copyright 2019 Glen Joseph Fernandes
-(glenjofe@gmail.com)
-
-Distributed under the Boost Software License, Version 1.0.
-(http://www.boost.org/LICENSE_1_0.txt)
-*/
-#ifndef BOOST_CORE_DEFAULT_ALLOCATOR_HPP
-#define BOOST_CORE_DEFAULT_ALLOCATOR_HPP
-
-#include <boost/config.hpp>
-#include <new>
-#include <climits>
-
-#if defined(BOOST_LIBSTDCXX_VERSION) && BOOST_LIBSTDCXX_VERSION < 60000
-#define BOOST_CORE_NO_CXX11_ALLOCATOR
-#endif
-
-namespace boost {
-
-#if defined(BOOST_NO_EXCEPTIONS)
-void throw_exception(const std::exception&);
-#endif
-
-namespace default_ {
-
-struct true_type {
-    typedef bool value_type;
-    typedef true_type type;
-
-    BOOST_STATIC_CONSTANT(bool, value = true);
-
-    BOOST_CONSTEXPR operator bool() const BOOST_NOEXCEPT {
-        return true;
-    }
-
-    BOOST_CONSTEXPR bool operator()() const BOOST_NOEXCEPT {
-        return true;
-    }
-};
-
-template<class T>
-struct add_reference {
-    typedef T& type;
-};
-
-template<>
-struct add_reference<void> {
-    typedef void type;
-};
-
-template<>
-struct add_reference<const void> {
-    typedef const void type;
-};
-
-template<class T>
-struct default_allocator {
-    typedef T value_type;
-    typedef T* pointer;
-    typedef const T* const_pointer;
-    typedef typename add_reference<T>::type reference;
-    typedef typename add_reference<const T>::type const_reference;
-    typedef std::size_t size_type;
-    typedef std::ptrdiff_t difference_type;
-    typedef true_type propagate_on_container_move_assignment;
-    typedef true_type is_always_equal;
-
-    template<class U>
-    struct rebind {
-        typedef default_allocator<U> other;
-    };
-
-#if !defined(BOOST_NO_CXX11_DEFAULTED_FUNCTIONS)
-    default_allocator() = default;
-#else
-    BOOST_CONSTEXPR default_allocator() BOOST_NOEXCEPT { }
-#endif
-
-    template<class U>
-    BOOST_CONSTEXPR default_allocator(const default_allocator<U>&)
-        BOOST_NOEXCEPT { }
-
-#if defined(PTRDIFF_MAX) && defined(SIZE_MAX)
-    BOOST_CONSTEXPR std::size_t max_size() const BOOST_NOEXCEPT {
-        return PTRDIFF_MAX < SIZE_MAX / sizeof(T)
-            ? PTRDIFF_MAX : SIZE_MAX / sizeof(T);
-    }
-#else
-    BOOST_CONSTEXPR std::size_t max_size() const BOOST_NOEXCEPT {
-        return ~static_cast<std::size_t>(0) / sizeof(T);
-    }
-#endif
-
-#if !defined(BOOST_NO_EXCEPTIONS)
-    T* allocate(std::size_t n) {
-        if (n > max_size()) {
-            throw std::bad_alloc();
-        }
-        return static_cast<T*>(::operator new(sizeof(T) * n));
-    }
-
-    void deallocate(T* p, std::size_t) {
-        ::operator delete(p);
-    }
-#else
-    T* allocate(std::size_t n) {
-        if (n > max_size()) {
-            boost::throw_exception(std::bad_alloc());
-        }
-        void* p = ::operator new(sizeof(T) * n, std::nothrow);
-        if (!p) {
-            boost::throw_exception(std::bad_alloc());
-        }
-        return static_cast<T*>(p);
-    }
-
-    void deallocate(T* p, std::size_t) {
-        ::operator delete(p, std::nothrow);
-    }
-#endif
-
-#if defined(BOOST_NO_CXX11_ALLOCATOR) || defined(BOOST_CORE_NO_CXX11_ALLOCATOR)
-    template<class U, class V>
-    void construct(U* p, const V& v) {
-        ::new(p) U(v);
-    }
-
-    template<class U>
-    void destroy(U* p) {
-        p->~U();
-    }
-#endif
-};
-
-template<class T, class U>
-BOOST_CONSTEXPR inline bool
-operator==(const default_allocator<T>&,
-    const default_allocator<U>&) BOOST_NOEXCEPT
-{
-    return true;
-}
-
-template<class T, class U>
-BOOST_CONSTEXPR inline bool
-operator!=(const default_allocator<T>&,
-    const default_allocator<U>&) BOOST_NOEXCEPT
-{
-    return false;
-}
-
-} /* default_ */
-
-using default_::default_allocator;
-
-} /* boost */
-
-#endif
--- a/include/boost/core/empty_value.hpp
+++ b/include/boost/core/empty_value.hpp
@@ -71,10 +71,6 @@ public:
    template<class U>
    empty_value(boost::empty_init_t, const U& value)
        : value_(value) { }
-
-    template<class U>
-    empty_value(boost::empty_init_t, U& value)
-        : value_(value) { }
 #endif

    const T& get() const BOOST_NOEXCEPT {
@@ -119,10 +115,6 @@ public:
    template<class U>
    empty_value(boost::empty_init_t, const U& value)
        : T(value) { }
-
-    template<class U>
-    empty_value(boost::empty_init_t, U& value)
-        : T(value) { }
 #endif

    const T& get() const BOOST_NOEXCEPT {
--- a/include/boost/core/first_scalar.hpp
+++ b/include/boost/core/first_scalar.hpp
@@ -1,45 +0,0 @@
-/*
-Copyright 2019 Glen Joseph Fernandes
-(glenjofe@gmail.com)
-
-Distributed under the Boost Software License, Version 1.0.
-(http://www.boost.org/LICENSE_1_0.txt)
-*/
-#ifndef BOOST_CORE_FIRST_SCALAR_HPP
-#define BOOST_CORE_FIRST_SCALAR_HPP
-
-#include <boost/config.hpp>
-#include <cstddef>
-
-namespace boost {
-namespace detail {
-
-template<class T>
-struct make_scalar {
-    typedef T type;
-};
-
-template<class T, std::size_t N>
-struct make_scalar<T[N]> {
-    typedef typename make_scalar<T>::type type;
-};
-
-} /* detail */
-
-template<class T>
-BOOST_CONSTEXPR inline T*
-first_scalar(T* p) BOOST_NOEXCEPT
-{
-    return p;
-}
-
-template<class T, std::size_t N>
-BOOST_CONSTEXPR inline typename detail::make_scalar<T>::type*
-first_scalar(T (*p)[N]) BOOST_NOEXCEPT
-{
-    return boost::first_scalar(&(*p)[0]);
-}
-
-} /* boost */
-
-#endif
--- a/include/boost/core/lightweight_test.hpp
+++ b/include/boost/core/lightweight_test.hpp
@@ -22,8 +22,8 @@
 //  http://www.boost.org/LICENSE_1_0.txt
 //

+#include <boost/core/no_exceptions_support.hpp>
 #include <boost/current_function.hpp>
-#include <boost/config.hpp>
 #include <iostream>
 #include <iterator>
 #include <cstdlib>
@@ -379,20 +379,18 @@ inline int report_errors()
    result.done();

    int errors = result.errors();
-
    if( errors == 0 )
    {
        BOOST_LIGHTWEIGHT_TEST_OSTREAM
          << "No errors detected." << std::endl;
+        return 0;
    }
    else
    {
        BOOST_LIGHTWEIGHT_TEST_OSTREAM
          << errors << " error" << (errors == 1? "": "s") << " detected." << std::endl;
+        return 1;
    }
-
-    // `return report_errors();` from main only supports 8 bit exit codes
-    return errors < 256? errors: 255;
 }

 } // namespace boost
--- a/include/boost/core/lightweight_test_trait.hpp
+++ b/include/boost/core/lightweight_test_trait.hpp
@@ -9,21 +9,16 @@

 // boost/core/lightweight_test_trait.hpp
 //
-// BOOST_TEST_TRAIT_TRUE, BOOST_TEST_TRAIT_FALSE, BOOST_TEST_TRAIT_SAME
+// BOOST_TEST_TRAIT_TRUE, BOOST_TEST_TRAIT_FALSE
 //
 // Copyright 2014 Peter Dimov
 //
-// Copyright 2019 Glen Joseph Fernandes
-// (glenjofe@gmail.com)
-//
 // 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/core/lightweight_test.hpp>
 #include <boost/core/typeinfo.hpp>
-#include <boost/core/is_same.hpp>
-#include <boost/config.hpp>

 namespace boost
 {
@@ -31,50 +26,6 @@ namespace boost
 namespace detail
 {

-template<class, int = 0> struct test_print { };
-
-template<class T> inline std::ostream& operator<<(std::ostream& o, test_print<T, 2>)
-{
-    return o << boost::core::demangled_name(BOOST_CORE_TYPEID(T));
-}
-
-template<class T> inline std::ostream& operator<<(std::ostream& o, test_print<T, 1>)
-{
-    return o << test_print<T, 2>();
-}
-
-template<class T> inline std::ostream& operator<<(std::ostream& o, test_print<const T, 1>)
-{
-    return o << test_print<T, 2>() << " const";
-}
-
-template<class T> inline std::ostream& operator<<(std::ostream& o, test_print<volatile T, 1>)
-{
-    return o << test_print<T, 2>() << " volatile";
-}
-
-template<class T> inline std::ostream& operator<<(std::ostream& o, test_print<const volatile T, 1>)
-{
-    return o << test_print<T, 2>() << " const volatile";
-}
-
-template<class T> inline std::ostream& operator<<(std::ostream& o, test_print<T>)
-{
-    return o << test_print<T, 1>();
-}
-
-template<class T> inline std::ostream& operator<<(std::ostream& o, test_print<T&>)
-{
-    return o << test_print<T, 1>() << " &";
-}
-
-#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-template<class T> inline std::ostream& operator<<(std::ostream& o, test_print<T&&>)
-{
-    return o << test_print<T, 1>() << " &&";
-}
-#endif
-
 template< class T > inline void test_trait_impl( char const * trait, void (*)( T ),
  bool expected, char const * file, int line, char const * function )
 {
@@ -95,37 +46,11 @@ template< class T > inline void test_trait_impl( char const * trait, void (*)( T
    }
 }

-template<class T> inline bool test_trait_same_impl_( T )
-{
-    return T::value;
-}
-
-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 )
-{
-    if( test_trait_same_impl_( same ) )
-    {
-        test_results();
-    }
-    else
-    {
-        BOOST_LIGHTWEIGHT_TEST_OSTREAM
-            << file << "(" << line << "): test 'is_same<" << types << ">'"
-            << " failed in function '" << function
-            << "' ('" << test_print<T1>()
-            << "' != '" << test_print<T2>() << "')"
-            << std::endl;
-
-        ++test_results().errors();
-    }
-}
-
 } // namespace detail

 } // namespace boost

 #define BOOST_TEST_TRAIT_TRUE(type) ( ::boost::detail::test_trait_impl(#type, (void(*)type)0, true, __FILE__, __LINE__, BOOST_CURRENT_FUNCTION) )
 #define BOOST_TEST_TRAIT_FALSE(type) ( ::boost::detail::test_trait_impl(#type, (void(*)type)0, false, __FILE__, __LINE__, BOOST_CURRENT_FUNCTION) )
-#define BOOST_TEST_TRAIT_SAME(...) ( ::boost::detail::test_trait_same_impl(#__VA_ARGS__, ::boost::core::is_same<__VA_ARGS__>(), __FILE__, __LINE__, BOOST_CURRENT_FUNCTION) )

 #endif // #ifndef BOOST_CORE_LIGHTWEIGHT_TEST_TRAIT_HPP
--- a/include/boost/core/no_exceptions_support.hpp
+++ b/include/boost/core/no_exceptions_support.hpp
@@ -32,21 +32,9 @@
 #    if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
 #        define BOOST_TRY { if ("")
 #        define BOOST_CATCH(x) else if (!"")
-#    elif !defined(BOOST_MSVC) || BOOST_MSVC >= 1900
+#    else
 #        define BOOST_TRY { if (true)
 #        define BOOST_CATCH(x) else if (false)
-#    else
-         // warning C4127: conditional expression is constant
-#        define BOOST_TRY { \
-             __pragma(warning(push)) \
-             __pragma(warning(disable: 4127)) \
-             if (true) \
-             __pragma(warning(pop))
-#        define BOOST_CATCH(x) else \
-             __pragma(warning(push)) \
-             __pragma(warning(disable: 4127)) \
-             if (false) \
-             __pragma(warning(pop))
 #    endif
 #    define BOOST_RETHROW
 #    define BOOST_CATCH_END }
--- a/include/boost/core/noinit_adaptor.hpp
+++ b/include/boost/core/noinit_adaptor.hpp
@@ -1,112 +0,0 @@
-/*
-Copyright 2019 Glen Joseph Fernandes
-(glenjofe@gmail.com)
-
-Distributed under the Boost Software License, Version 1.0.
-(http://www.boost.org/LICENSE_1_0.txt)
-*/
-#ifndef BOOST_CORE_NOINIT_ADAPTOR_HPP
-#define BOOST_CORE_NOINIT_ADAPTOR_HPP
-
-#include <boost/config.hpp>
-#if !defined(BOOST_NO_CXX11_ALLOCATOR)
-#include <memory>
-#endif
-#include <new>
-#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-#include <utility>
-#endif
-
-namespace boost {
-
-template<class A>
-struct noinit_adaptor
-    : A {
-    template<class U>
-    struct rebind {
-#if !defined(BOOST_NO_CXX11_ALLOCATOR)
-        typedef noinit_adaptor<typename std::allocator_traits<A>::template
-            rebind_alloc<U> > other;
-#else
-        typedef noinit_adaptor<typename A::template rebind<U>::other> other;
-#endif
-    };
-
-    noinit_adaptor()
-        : A() { }
-
-#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-    template<class U>
-    noinit_adaptor(U&& u) BOOST_NOEXCEPT
-        : A(std::forward<U>(u)) { }
-#else
-    template<class U>
-    noinit_adaptor(const U& u) BOOST_NOEXCEPT
-        : A(u) { }
-#endif
-
-    template<class U>
-    noinit_adaptor(const noinit_adaptor<U>& u) BOOST_NOEXCEPT
-        : A(static_cast<const U&>(u)) { }
-
-    template<class U>
-    void construct(U* p) {
-        ::new((void*)p) U;
-    }
-
-#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
-    template<class U, class V, class... Args>
-    void construct(U* p, V&& v, Args&&... args) {
-        ::new((void*)p) U(std::forward<V>(v), std::forward<Args>(args)...);
-    }
-#else
-    template<class U, class V>
-    void construct(U* p, V&& v) {
-        ::new((void*)p) U(std::forward<V>(v));
-    }
-#endif
-#else
-    template<class U, class V>
-    void construct(U* p, const V& v) {
-        ::new((void*)p) U(v);
-    }
-
-    template<class U, class V>
-    void construct(U* p, V& v) {
-        ::new((void*)p) U(v);
-    }
-#endif
-
-    template<class U>
-    void destroy(U* p) {
-        p->~U();
-    }
-};
-
-template<class T, class U>
-inline bool
-operator==(const noinit_adaptor<T>& lhs,
-    const noinit_adaptor<U>& rhs) BOOST_NOEXCEPT
-{
-    return static_cast<const T&>(lhs) == static_cast<const U&>(rhs);
-}
-
-template<class T, class U>
-inline bool
-operator!=(const noinit_adaptor<T>& lhs,
-    const noinit_adaptor<U>& rhs) BOOST_NOEXCEPT
-{
-    return !(lhs == rhs);
-}
-
-template<class A>
-inline noinit_adaptor<A>
-noinit_adapt(const A& a) BOOST_NOEXCEPT
-{
-    return noinit_adaptor<A>(a);
-}
-
-} /* boost */
-
-#endif
--- a/include/boost/core/noncopyable.hpp
+++ b/include/boost/core/noncopyable.hpp
@@ -38,7 +38,8 @@ namespace noncopyable_  // protection from unintended ADL
  class noncopyable: base_token
  {
  protected:
-#if !defined(BOOST_NO_CXX11_DEFAULTED_FUNCTIONS) && !defined(BOOST_NO_CXX11_NON_PUBLIC_DEFAULTED_FUNCTIONS)
+#if !defined(BOOST_NO_CXX11_DEFAULTED_FUNCTIONS) && !defined(BOOST_NO_CXX11_NON_PUBLIC_DEFAULTED_FUNCTIONS)\
+      && !BOOST_WORKAROUND(__ICC, <= 1600)
      BOOST_CONSTEXPR noncopyable() = default;
      ~noncopyable() = default;
 #else
--- a/include/boost/core/typeinfo.hpp
+++ b/include/boost/core/typeinfo.hpp
@@ -47,7 +47,7 @@ public:

    bool operator==( typeinfo const& rhs ) const
    {
-#if ( defined(_WIN32) || defined(__CYGWIN__) ) && ( defined(__GNUC__) || defined(__clang__) ) && !defined(BOOST_DISABLE_CURRENT_FUNCTION)
+#if ( defined(_WIN32) || defined(__CYGWIN__) ) && defined(__GNUC__) && !defined(BOOST_DISABLE_CURRENT_FUNCTION)

        return lib_id_ == rhs.lib_id_? this == &rhs: std::strcmp( name_, rhs.name_ ) == 0;

@@ -65,7 +65,7 @@ public:

    bool before( typeinfo const& rhs ) const
    {
-#if ( defined(_WIN32) || defined(__CYGWIN__) ) && ( defined(__GNUC__) || defined(__clang__) ) && !defined(BOOST_DISABLE_CURRENT_FUNCTION)
+#if ( defined(_WIN32) || defined(__CYGWIN__) ) && defined(__GNUC__) && !defined(BOOST_DISABLE_CURRENT_FUNCTION)

        return lib_id_ == rhs.lib_id_? std::less< typeinfo const* >()( this, &rhs ): std::strcmp( name_, rhs.name_ ) < 0;

--- a/include/boost/core/uncaught_exceptions.hpp
+++ b/include/boost/core/uncaught_exceptions.hpp
@@ -9,7 +9,7 @@
 * \author Andrey Semashev
 * \date   2018-11-10
 *
- * \brief  This header provides an `uncaught_exceptions` function implementation, which was introduced in C++17.
+ * \brief  This header provides an `uncaught_exception` function implementation, which was introduced in C++17.
 *
 * The code in this file is based on the implementation by Evgeny Panasyuk:
 *
@@ -46,41 +46,20 @@
 #if defined(BOOST_CORE_HAS_CXXABI_H)
 // MinGW GCC 4.4 seem to not work the same way the newer GCC versions do. As a result, __cxa_get_globals based implementation will always return 0.
 // Just disable it for now and fall back to std::uncaught_exception().
-#if !(defined(__MINGW32__) && (defined(__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__) < 405))
-#include <cxxabi.h>
-#include <cstring>
+#if !defined(__MINGW32__) || (defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 5)))
 #define BOOST_CORE_HAS_CXA_GET_GLOBALS
-// At least on MinGW and Linux, only GCC since 4.7 declares __cxa_get_globals() in cxxabi.h. Older versions of GCC do not expose this function but it's there.
-// On OpenBSD, it seems, the declaration is also missing.
-// Note that at least on FreeBSD 11, cxxabi.h declares __cxa_get_globals with a different exception specification, so we can't declare the function unconditionally.
-// On Linux with clang and libc++ and on OS X, there is a version of cxxabi.h from libc++abi that doesn't declare __cxa_get_globals, but provides __cxa_uncaught_exceptions.
-// The function only appeared in version _LIBCPPABI_VERSION >= 1002 of the library. Unfortunately, there are linking errors about undefined reference to __cxa_uncaught_exceptions
-// on Ubuntu Trusty and OS X, so we avoid using it and forward-declare __cxa_get_globals instead.
-// On QNX SDP 7.0 (QCC 5.4.0), there are multiple cxxabi.h, one from glibcxx from gcc and another from libc++abi from LLVM. Which one is included will be determined by the qcc
-// command line arguments (-V and/or -Y; http://www.qnx.com/developers/docs/7.0.0/#com.qnx.doc.neutrino.utilities/topic/q/qcc.html). The LLVM libc++abi is missing the declaration
-// of __cxa_get_globals but it is also patched by QNX developers to not define _LIBCPPABI_VERSION. Older QNX SDP versions, up to and including 6.6, don't provide LLVM and libc++abi.
-// See https://github.com/boostorg/core/issues/59.
-#if !defined(__FreeBSD__) && \
-    ( \
-        (defined(__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__) < 407) || \
-        defined(__OpenBSD__) || \
-        (defined(__QNXNTO__) && !defined(__GLIBCXX__) && !defined(__GLIBCPP__)) || \
-        defined(_LIBCPPABI_VERSION) \
-    )
+#include <cxxabi.h>
+// Only GCC 4.7 declares __cxa_get_globals() in cxxabi.h, older compilers do not expose this function but it's there
+#if defined(__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__) < 407
 namespace __cxxabiv1 {
 struct __cxa_eh_globals;
-#if defined(__OpenBSD__)
-extern "C" __cxa_eh_globals* __cxa_get_globals();
-#else
 extern "C" __cxa_eh_globals* __cxa_get_globals() BOOST_NOEXCEPT_OR_NOTHROW __attribute__((__const__));
-#endif
 } // namespace __cxxabiv1
+#endif // defined(__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__) < 407
 #endif
-#endif // !(defined(__MINGW32__) && (defined(__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__) < 405))
 #endif // defined(BOOST_CORE_HAS_CXXABI_H)

 #if defined(_MSC_VER) && _MSC_VER >= 1400
-#include <cstring>
 #define BOOST_CORE_HAS_GETPTD
 namespace boost {
 namespace core {
@@ -110,14 +89,10 @@ inline unsigned int uncaught_exceptions() BOOST_NOEXCEPT
    return static_cast< unsigned int >(std::uncaught_exceptions());
 #elif defined(BOOST_CORE_HAS_CXA_GET_GLOBALS)
    // Tested on {clang 3.2,GCC 3.5.6,GCC 4.1.2,GCC 4.4.6,GCC 4.4.7}x{x32,x64}
-    unsigned int count;
-    std::memcpy(&count, reinterpret_cast< const unsigned char* >(::abi::__cxa_get_globals()) + sizeof(void*), sizeof(count)); // __cxa_eh_globals::uncaughtExceptions, x32 offset - 0x4, x64 - 0x8
-    return count;
+    return *(reinterpret_cast< const unsigned int* >(reinterpret_cast< const char* >(::abi::__cxa_get_globals()) + sizeof(void*))); // __cxa_eh_globals::uncaughtExceptions, x32 offset - 0x4, x64 - 0x8
 #elif defined(BOOST_CORE_HAS_GETPTD)
    // MSVC specific. Tested on {MSVC2005SP1,MSVC2008SP1,MSVC2010SP1,MSVC2012}x{x32,x64}.
-    unsigned int count;
-    std::memcpy(&count, static_cast< const unsigned char* >(boost::core::detail::_getptd()) + (sizeof(void*) == 8u ? 0x100 : 0x90), sizeof(count)); // _tiddata::_ProcessingThrow, x32 offset - 0x90, x64 - 0x100
-    return count;
+    return *(reinterpret_cast< const unsigned int* >(static_cast< const char* >(boost::core::detail::_getptd()) + (sizeof(void*) == 8 ? 0x100 : 0x90))); // _tiddata::_ProcessingThrow, x32 offset - 0x90, x64 - 0x100
 #else
    // Portable C++03 implementation. Does not allow to detect multiple nested exceptions.
    return static_cast< unsigned int >(std::uncaught_exception());
--- a/include/boost/core/use_default.hpp
+++ b/include/boost/core/use_default.hpp
@@ -1,17 +0,0 @@
-/*
-Copyright 2019 Glen Joseph Fernandes
-(glenjofe@gmail.com)
-
-Distributed under the Boost Software License, Version 1.0.
-(http://www.boost.org/LICENSE_1_0.txt)
-*/
-#ifndef BOOST_CORE_USE_DEFAULT_HPP
-#define BOOST_CORE_USE_DEFAULT_HPP
-
-namespace boost {
-
-struct use_default { };
-
-} /* boost */
-
-#endif
--- a/include/boost/detail/sp_typeinfo.hpp
+++ b/include/boost/detail/sp_typeinfo.hpp
@@ -18,9 +18,6 @@
 //  http://www.boost.org/LICENSE_1_0.txt)

 #include <boost/core/typeinfo.hpp>
-#include <boost/config/header_deprecated.hpp>
-
-BOOST_HEADER_DEPRECATED( "<boost/core/typeinfo.hpp>" )

 namespace boost
 {
--- a/test/Jamfile.v2
+++ b/test/Jamfile.v2
@@ -69,15 +69,13 @@ run get_pointer_test.cpp ;
 run lightweight_test_test.cpp ;
 run lightweight_test_test.cpp : : : <exception-handling>off : lightweight_test_test_no_except ;
 run lightweight_test_test2.cpp ;
+run lightweight_test_all_eq_test.cpp ;
 run lightweight_test_all_with_test.cpp ;
+run lightweight_test_all_with_fail.cpp ;
 run lightweight_test_lt_le_test.cpp ;
 run lightweight_test_gt_ge_test.cpp ;
 run lightweight_test_eq_nullptr.cpp ;
 run lightweight_test_test3.cpp ;
-run lightweight_test_test4.cpp ;
-
-run-fail lightweight_test_all_eq_test.cpp ;
-run-fail lightweight_test_all_with_fail.cpp ;

 run-fail lightweight_test_fail.cpp ;
 run-fail lightweight_test_fail2.cpp ;
@@ -92,7 +90,6 @@ run-fail lightweight_test_fail8.cpp : : : <rtti>off : lightweight_test_fail8_no_
 run-fail lightweight_test_fail9.cpp ;
 run-fail lightweight_test_fail10.cpp ;
 run-fail lightweight_test_fail11.cpp ;
-run-fail lightweight_test_fail12.cpp ;
 run-fail lightweight_test_lt_fail.cpp ;
 run-fail lightweight_test_le_fail.cpp ;
 run-fail lightweight_test_gt_fail.cpp ;
@@ -127,37 +124,22 @@ run to_address_test.cpp ;
 run exchange_test.cpp ;
 run exchange_move_test.cpp ;

-run first_scalar_test.cpp ;
-compile first_scalar_constexpr_test.cpp ;
-
 run empty_value_test.cpp ;
 run empty_value_size_test.cpp ;
-run empty_value_final_test.cpp ;

 run quick_exit_test.cpp ;
 run-fail quick_exit_fail.cpp ;

-compile use_default_test.cpp ;
-
-run default_allocator_test.cpp ;
-run noinit_adaptor_test.cpp ;
-run alloc_construct_test.cpp ;
-run alloc_construct_throws_test.cpp ;
-run alloc_construct_cxx11_test.cpp ;
-
 lib lib_typeid : lib_typeid.cpp : <link>shared:<define>LIB_TYPEID_DYN_LINK=1 ;

 run test_lib_typeid.cpp lib_typeid : : : <link>shared : test_lib_typeid_shared ;
 run test_lib_typeid.cpp lib_typeid : : : <link>static : test_lib_typeid_static ;

 run test_lib_typeid.cpp lib_typeid : : : <link>shared <rtti>off : test_lib_typeid_shared_no_rtti ;
-run test_lib_typeid.cpp lib_typeid : : : <link>static <rtti>off : test_lib_typeid_static_no_rtti ;
+run test_lib_typeid.cpp lib_typeid : : : <link>static <rtti>off  : test_lib_typeid_static_no_rtti ;

 run uncaught_exceptions.cpp : : : <exception-handling>on ;
 run uncaught_exceptions_np.cpp : : : <exception-handling>on ;

-run no_exceptions_support_test.cpp ;
-run no_exceptions_support_test.cpp : : : <exception-handling>off : no_exceptions_support_test_nx ;
-
 use-project /boost/core/swap : ./swap ;
 build-project ./swap ;
--- a/test/alloc_construct_cxx11_test.cpp
+++ b/test/alloc_construct_cxx11_test.cpp
@@ -1,78 +0,0 @@
-/*
-Copyright 2019 Glen Joseph Fernandes
-(glenjofe@gmail.com)
-
-Distributed under the Boost Software License, Version 1.0.
-(http://www.boost.org/LICENSE_1_0.txt)
-*/
-#include <boost/config.hpp>
-#if !defined(BOOST_NO_CXX11_ALLOCATOR)
-#include <boost/core/alloc_construct.hpp>
-#include <boost/core/lightweight_test.hpp>
-
-class type {
-public:
-    explicit type(int x)
-        : value_(x) { }
-
-    int value() const {
-        return value_;
-    }
-
-    static int count;
-
-private:
-    type(const type&);
-    type& operator=(const type&);
-
-    int value_;
-};
-
-int type::count = 0;
-
-template<class T>
-struct creator {
-    typedef T value_type;
-
-    creator() { }
-
-    template<class U>
-    creator(const creator<U>&) { }
-
-    T* allocate(std::size_t size) {
-        return static_cast<T*>(::operator new(sizeof(T) * size));
-    }
-
-    void deallocate(T* ptr, std::size_t) {
-        ::operator delete(ptr);
-    }
-
-    template<class V>
-    void construct(type* ptr, const V& value) {
-        ::new(static_cast<void*>(ptr)) type(value + 1);
-        ++type::count;
-    }
-
-    void destroy(type* ptr) {
-        ptr->~type();
-        --type::count;
-    }
-};
-
-int main()
-{
-    creator<type> a;
-    type* p = a.allocate(1);
-    boost::alloc_construct(a, p, 1);
-    BOOST_TEST_EQ(type::count, 1);
-    BOOST_TEST_EQ(p->value(), 2);
-    boost::alloc_destroy(a, p);
-    BOOST_TEST_EQ(type::count, 0);
-    return boost::report_errors();
-}
-#else
-int main()
-{
-    return 0;
-}
-#endif
--- a/test/alloc_construct_test.cpp
+++ b/test/alloc_construct_test.cpp
@@ -1,135 +0,0 @@
-/*
-Copyright 2019 Glen Joseph Fernandes
-(glenjofe@gmail.com)
-
-Distributed under the Boost Software License, Version 1.0.
-(http://www.boost.org/LICENSE_1_0.txt)
-*/
-#include <boost/core/alloc_construct.hpp>
-#include <boost/core/default_allocator.hpp>
-#include <boost/core/lightweight_test.hpp>
-
-class type {
-public:
-    explicit type(int x = 0, int y = 0)
-        : value_(x + y) {
-        ++count;
-    }
-
-    type(const type& other)
-        : value_(other.value_) {
-        ++count;
-    }
-
-    ~type() {
-        --count;
-    }
-
-    int value() const {
-        return value_;
-    }
-
-    static int count;
-
-private:
-    int value_;
-};
-
-int type::count = 0;
-
-void test_construct()
-{
-    boost::default_allocator<type> a;
-    type* p = a.allocate(1);
-    boost::alloc_construct(a, p);
-    BOOST_TEST_EQ(type::count, 1);
-    BOOST_TEST_EQ(p->value(), 0);
-    boost::alloc_destroy(a, p);
-    BOOST_TEST_EQ(type::count, 0);
-    a.deallocate(p, 1);
-}
-
-void test_construct_value()
-{
-    boost::default_allocator<type> a;
-    type* p = a.allocate(1);
-    boost::alloc_construct(a, p, 1);
-    BOOST_TEST_EQ(type::count, 1);
-    BOOST_TEST_EQ(p->value(), 1);
-    boost::alloc_destroy(a, p);
-    BOOST_TEST_EQ(type::count, 0);
-    a.deallocate(p, 1);
-}
-
-#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && \
-    !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
-void test_construct_args()
-{
-    boost::default_allocator<type> a;
-    type* p = a.allocate(1);
-    boost::alloc_construct(a, p, 1, 2);
-    BOOST_TEST_EQ(type::count, 1);
-    BOOST_TEST_EQ(p->value(), 3);
-    boost::alloc_destroy(a, p);
-    BOOST_TEST_EQ(type::count, 0);
-    a.deallocate(p, 1);
-}
-#endif
-
-void test_construct_n()
-{
-    boost::default_allocator<type> a;
-    type* p = a.allocate(3);
-    boost::alloc_construct_n(a, p, 3);
-    BOOST_TEST_EQ(type::count, 3);
-    BOOST_TEST_EQ(p[0].value(), 0);
-    BOOST_TEST_EQ(p[1].value(), 0);
-    BOOST_TEST_EQ(p[2].value(), 0);
-    boost::alloc_destroy_n(a, p, 3);
-    BOOST_TEST_EQ(type::count, 0);
-    a.deallocate(p, 3);
-}
-
-void test_construct_n_list()
-{
-    boost::default_allocator<type> a;
-    type* p = a.allocate(3);
-    type q(1);
-    boost::alloc_construct_n(a, p, 3, &q, 1);
-    BOOST_TEST_EQ(type::count, 4);
-    BOOST_TEST_EQ(p[0].value(), 1);
-    BOOST_TEST_EQ(p[1].value(), 1);
-    BOOST_TEST_EQ(p[2].value(), 1);
-    boost::alloc_destroy_n(a, p, 3);
-    BOOST_TEST_EQ(type::count, 1);
-    a.deallocate(p, 3);
-}
-
-void test_construct_n_iterator()
-{
-    boost::default_allocator<type> a;
-    type* p = a.allocate(3);
-    type l[] = { type(1), type(2), type(3) };
-    boost::alloc_construct_n(a, p, 3, &l[0]);
-    BOOST_TEST_EQ(type::count, 6);
-    BOOST_TEST_EQ(p[0].value(), 1);
-    BOOST_TEST_EQ(p[1].value(), 2);
-    BOOST_TEST_EQ(p[2].value(), 3);
-    boost::alloc_destroy_n(a, p, 3);
-    BOOST_TEST_EQ(type::count, 3);
-    a.deallocate(p, 3);
-}
-
-int main()
-{
-    test_construct();
-    test_construct_value();
-#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && \
-    !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
-    test_construct_args();
-#endif
-    test_construct_n();
-    test_construct_n_list();
-    test_construct_n_iterator();
-    return boost::report_errors();
-}
--- a/test/alloc_construct_throws_test.cpp
+++ b/test/alloc_construct_throws_test.cpp
@@ -1,46 +0,0 @@
-/*
-Copyright 2019 Glen Joseph Fernandes
-(glenjofe@gmail.com)
-
-Distributed under the Boost Software License, Version 1.0.
-(http://www.boost.org/LICENSE_1_0.txt)
-*/
-#include <boost/core/alloc_construct.hpp>
-#include <boost/core/default_allocator.hpp>
-#include <boost/core/lightweight_test.hpp>
-
-class type {
-public:
-    type() {
-        if (count == 4) {
-            throw true;
-        }
-        ++count;
-    }
-
-    ~type() {
-        --count;
-    }
-
-    static int count;
-
-private:
-    type(const type&);
-    type& operator=(const type&);
-};
-
-int type::count = 0;
-
-int main()
-{
-    boost::default_allocator<type> a;
-    type* p = a.allocate(5);
-    try {
-        boost::alloc_construct_n(a, p, 5);
-        BOOST_ERROR("construct_n did not throw");
-    } catch (...) {
-        BOOST_TEST_EQ(type::count, 0);
-    }
-    a.deallocate(p, 5);
-    return boost::report_errors();
-}
--- a/test/cmake_subdir_test/CMakeLists.txt
+++ b/test/cmake_subdir_test/CMakeLists.txt
@@ -1,19 +0,0 @@
-# Copyright 2018, 2019 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
-
-cmake_minimum_required(VERSION 3.5)
-
-project(cmake_subdir_test LANGUAGES CXX)
-
-add_subdirectory(../.. boostorg/core)
-add_subdirectory(../../../assert boostorg/assert)
-add_subdirectory(../../../config boostorg/config)
-
-add_executable(quick ../quick.cpp)
-target_link_libraries(quick Boost::core)
-
-enable_testing()
-add_test(quick quick)
-
-add_custom_target(check COMMAND ${CMAKE_CTEST_COMMAND} --output-on-failure -C $<CONFIG>)
--- a/test/default_allocator_test.cpp
+++ b/test/default_allocator_test.cpp
@@ -1,277 +0,0 @@
-/*
-Copyright 2019 Glen Joseph Fernandes
-(glenjofe@gmail.com)
-
-Distributed under the Boost Software License, Version 1.0.
-(http://www.boost.org/LICENSE_1_0.txt)
-*/
-#include <boost/core/default_allocator.hpp>
-#include <boost/core/lightweight_test_trait.hpp>
-#include <vector>
-#include <list>
-
-class type {
-public:
-    explicit type(double value)
-        : value_(value) { }
-
-private:
-    type(const type&);
-    type& operator=(const type&);
-
-    double value_;
-};
-
-void test_value_type()
-{
-    BOOST_TEST_TRAIT_SAME(int,
-        boost::default_allocator<int>::value_type);
-    BOOST_TEST_TRAIT_SAME(type,
-        boost::default_allocator<type>::value_type);
-    BOOST_TEST_TRAIT_SAME(int[5],
-        boost::default_allocator<int[5]>::value_type);
-    BOOST_TEST_TRAIT_SAME(void,
-        boost::default_allocator<void>::value_type);
-}
-
-void test_pointer()
-{
-    BOOST_TEST_TRAIT_SAME(int*,
-        boost::default_allocator<int>::pointer);
-    BOOST_TEST_TRAIT_SAME(type*,
-        boost::default_allocator<type>::pointer);
-    BOOST_TEST_TRAIT_SAME(int(*)[5],
-        boost::default_allocator<int[5]>::pointer);
-    BOOST_TEST_TRAIT_SAME(void*,
-        boost::default_allocator<void>::pointer);
-}
-
-void test_const_pointer()
-{
-    BOOST_TEST_TRAIT_SAME(const int*,
-        boost::default_allocator<int>::const_pointer);
-    BOOST_TEST_TRAIT_SAME(const type*,
-        boost::default_allocator<type>::const_pointer);
-    BOOST_TEST_TRAIT_SAME(const int(*)[5],
-        boost::default_allocator<int[5]>::const_pointer);
-    BOOST_TEST_TRAIT_SAME(const void*,
-        boost::default_allocator<void>::const_pointer);
-}
-
-void test_reference()
-{
-    BOOST_TEST_TRAIT_SAME(int&,
-        boost::default_allocator<int>::reference);
-    BOOST_TEST_TRAIT_SAME(type&,
-        boost::default_allocator<type>::reference);
-    BOOST_TEST_TRAIT_SAME(int(&)[5],
-        boost::default_allocator<int[5]>::reference);
-    BOOST_TEST_TRAIT_SAME(void,
-        boost::default_allocator<void>::reference);
-}
-
-void test_const_reference()
-{
-    BOOST_TEST_TRAIT_SAME(const int&,
-        boost::default_allocator<int>::const_reference);
-    BOOST_TEST_TRAIT_SAME(const type&,
-        boost::default_allocator<type>::const_reference);
-    BOOST_TEST_TRAIT_SAME(const int(&)[5],
-        boost::default_allocator<int[5]>::const_reference);
-    BOOST_TEST_TRAIT_SAME(const void,
-        boost::default_allocator<void>::const_reference);
-}
-
-void test_size_type()
-{
-    BOOST_TEST_TRAIT_SAME(std::size_t,
-        boost::default_allocator<int>::size_type);
-    BOOST_TEST_TRAIT_SAME(std::size_t,
-        boost::default_allocator<type>::size_type);
-    BOOST_TEST_TRAIT_SAME(std::size_t,
-        boost::default_allocator<int[5]>::size_type);
-    BOOST_TEST_TRAIT_SAME(std::size_t,
-        boost::default_allocator<void>::size_type);
-}
-
-void test_difference_type()
-{
-    BOOST_TEST_TRAIT_SAME(std::ptrdiff_t,
-        boost::default_allocator<int>::difference_type);
-    BOOST_TEST_TRAIT_SAME(std::ptrdiff_t,
-        boost::default_allocator<type>::difference_type);
-    BOOST_TEST_TRAIT_SAME(std::ptrdiff_t,
-        boost::default_allocator<int[5]>::difference_type);
-    BOOST_TEST_TRAIT_SAME(std::ptrdiff_t,
-        boost::default_allocator<void>::difference_type);
-}
-
-void test_propagate_on_container_move_assignment()
-{
-    BOOST_TEST_TRAIT_TRUE((boost::default_allocator<int>::
-        propagate_on_container_move_assignment));
-    BOOST_TEST_TRAIT_TRUE((boost::default_allocator<type>::
-        propagate_on_container_move_assignment));
-    BOOST_TEST_TRAIT_TRUE((boost::default_allocator<int[5]>::
-        propagate_on_container_move_assignment));
-    BOOST_TEST_TRAIT_TRUE((boost::default_allocator<void>::
-        propagate_on_container_move_assignment));
-}
-
-void test_is_always_equal()
-{
-    BOOST_TEST_TRAIT_TRUE((boost::default_allocator<int>::is_always_equal));
-    BOOST_TEST_TRAIT_TRUE((boost::default_allocator<type>::is_always_equal));
-    BOOST_TEST_TRAIT_TRUE((boost::default_allocator<int[5]>::is_always_equal));
-    BOOST_TEST_TRAIT_TRUE((boost::default_allocator<void>::is_always_equal));
-}
-
-void test_rebind()
-{
-    BOOST_TEST_TRAIT_SAME(boost::default_allocator<type>,
-        boost::default_allocator<int>::rebind<type>::other);
-    BOOST_TEST_TRAIT_SAME(boost::default_allocator<int[5]>,
-        boost::default_allocator<type>::rebind<int[5]>::other);
-    BOOST_TEST_TRAIT_SAME(boost::default_allocator<void>,
-        boost::default_allocator<int[5]>::rebind<void>::other);
-    BOOST_TEST_TRAIT_SAME(boost::default_allocator<int>,
-        boost::default_allocator<void>::rebind<int>::other);
-}
-
-void test_default_construct()
-{
-    boost::default_allocator<int> a1;
-    (void)a1;
-    boost::default_allocator<type> a2;
-    (void)a2;
-    boost::default_allocator<int[5]> a3;
-    (void)a3;
-    boost::default_allocator<void> a4;
-    (void)a4;
-}
-
-void test_copy()
-{
-    boost::default_allocator<int> a1;
-    boost::default_allocator<int> a2(a1);
-    (void)a2;
-    boost::default_allocator<int[5]> a3;
-    boost::default_allocator<int[5]> a4(a3);
-    (void)a4;
-    boost::default_allocator<void> a5;
-    boost::default_allocator<void> a6(a5);
-    (void)a6;
-}
-
-void test_construct_other()
-{
-    boost::default_allocator<int> a1;
-    boost::default_allocator<type> a2(a1);
-    boost::default_allocator<int[5]> a3(a2);
-    boost::default_allocator<void> a4(a3);
-    boost::default_allocator<int> a5(a4);
-    (void)a5;
-}
-
-#if defined(PTRDIFF_MAX) && defined(SIZE_MAX)
-template<class T>
-std::size_t max_size()
-{
-    return PTRDIFF_MAX < SIZE_MAX / sizeof(T)
-        ? PTRDIFF_MAX : SIZE_MAX / sizeof(T);
-}
-#else
-template<class T>
-std::size_t max_size()
-{
-    return ~static_cast<std::size_t>(0) / sizeof(T);
-}
-#endif
-
-void test_max_size()
-{
-    BOOST_TEST_EQ(max_size<int>(),
-        boost::default_allocator<int>().max_size());
-    BOOST_TEST_EQ(max_size<type>(),
-        boost::default_allocator<type>().max_size());
-    BOOST_TEST_EQ(max_size<int[5]>(),
-        boost::default_allocator<int[5]>().max_size());
-}
-
-template<class T>
-void test_allocate()
-{
-    boost::default_allocator<T> a;
-    T* p = a.allocate(1);
-    BOOST_TEST(p != 0);
-    a.deallocate(p, 1);
-    p = a.allocate(0);
-    a.deallocate(p, 0);
-    BOOST_TEST_THROWS(a.allocate(a.max_size() + 1), std::bad_alloc);
-}
-
-void test_allocate_deallocate()
-{
-    test_allocate<int>();
-    test_allocate<type>();
-    test_allocate<int[5]>();
-}
-
-void test_equals()
-{
-    BOOST_TEST(boost::default_allocator<int>() ==
-        boost::default_allocator<type>());
-    BOOST_TEST(boost::default_allocator<type>() ==
-        boost::default_allocator<int[5]>());
-    BOOST_TEST(boost::default_allocator<int[5]>() ==
-        boost::default_allocator<void>());
-    BOOST_TEST(boost::default_allocator<void>() ==
-        boost::default_allocator<int>());
-}
-
-void test_not_equals()
-{
-    BOOST_TEST(!(boost::default_allocator<int>() !=
-        boost::default_allocator<type>()));
-    BOOST_TEST(!(boost::default_allocator<type>() !=
-        boost::default_allocator<int[5]>()));
-    BOOST_TEST(!(boost::default_allocator<int[5]>() !=
-        boost::default_allocator<void>()));
-    BOOST_TEST(!(boost::default_allocator<void>() !=
-        boost::default_allocator<int>()));
-}
-
-void test_container()
-{
-    std::vector<int, boost::default_allocator<int> > v;
-    v.push_back(1);
-    BOOST_TEST(v.size() == 1);
-    BOOST_TEST(v.front() == 1);
-    std::list<int, boost::default_allocator<int> > l;
-    l.push_back(1);
-    BOOST_TEST(l.size() == 1);
-    BOOST_TEST(l.front() == 1);
-}
-
-int main()
-{
-    test_value_type();
-    test_pointer();
-    test_const_pointer();
-    test_reference();
-    test_const_reference();
-    test_size_type();
-    test_difference_type();
-    test_propagate_on_container_move_assignment();
-    test_is_always_equal();
-    test_rebind();
-    test_default_construct();
-    test_copy();
-    test_construct_other();
-    test_max_size();
-    test_allocate_deallocate();
-    test_equals();
-    test_not_equals();
-    test_container();
-    return boost::report_errors();
-}
--- a/test/empty_value_final_test.cpp
+++ b/test/empty_value_final_test.cpp
@@ -1,62 +0,0 @@
-/*
-Copyright 2018 Glen Joseph Fernandes
-(glenjofe@gmail.com)
-
-Distributed under the Boost Software License, Version 1.0.
-(http://www.boost.org/LICENSE_1_0.txt)
-*/
-#include <boost/core/empty_value.hpp>
-#include <boost/core/lightweight_test.hpp>
-
-#if !defined(BOOST_NO_CXX11_FINAL)
-class type final {
-public:
-    explicit type(int count)
-        : value_(count) { }
-    int value() const {
-        return value_ + 1;
-    }
-    int value() {
-        return value_ + 2;
-    }
-private:
-    int value_;
-};
-
-struct empty final {
-    int value() const {
-        return 1;
-    }
-    int value() {
-        return 2;
-    }
-};
-
-void test_type()
-{
-    const boost::empty_value<type> v1(boost::empty_init_t(), 3);
-    BOOST_TEST(v1.get().value() == 4);
-    boost::empty_value<type> v2(boost::empty_init_t(), 3);
-    BOOST_TEST(v2.get().value() == 5);
-}
-
-void test_empty()
-{
-    const boost::empty_value<empty> v1 = boost::empty_init_t();
-    BOOST_TEST(v1.get().value() == 1);
-    boost::empty_value<empty> v2;
-    BOOST_TEST(v2.get().value() == 2);
-}
-
-int main()
-{
-    test_type();
-    test_empty();
-    return boost::report_errors();
-}
-#else
-int main()
-{
-    return 0;
-}
-#endif
--- a/test/empty_value_test.cpp
+++ b/test/empty_value_test.cpp
@@ -9,63 +9,67 @@ Distributed under the Boost Software License, Version 1.0.
 #include <boost/core/lightweight_test.hpp>

 struct empty {
-    int value() const {
-        return 1;
+    operator bool() const {
+        return false;
    }
-    int value() {
-        return 2;
+    operator bool() {
+        return true;
    }
 };

 class type {
 public:
-    explicit type(int count)
-        : value_(count) { }
-    int value() const {
-        return value_ + 1;
-    }
-    int value() {
-        return value_ + 2;
+    type()
+        : value_(false) { }
+    explicit type(bool value)
+        : value_(value) { }
+    operator bool() const {
+        return value_;
    }
 private:
-    int value_;
+    bool value_;
 };

-void test_int()
+void test_bool()
 {
-    const boost::empty_value<int> v1(boost::empty_init_t(), 7);
-    BOOST_TEST(v1.get() == 7);
-    boost::empty_value<int> v2 = boost::empty_init_t();
-    BOOST_TEST(v2.get() == 0);
+    const boost::empty_value<bool> v1(boost::empty_init_t(), true);
+    BOOST_TEST(v1.get());
+    boost::empty_value<bool> v2 = boost::empty_init_t();
+    BOOST_TEST(!v2.get());
    v2 = v1;
-    BOOST_TEST(v2.get() == 7);
-    v2.get() = 8;
-    BOOST_TEST(v2.get() == 8);
+    BOOST_TEST(v2.get());
+    v2.get() = false;
+    BOOST_TEST(!v2.get());
 }

 void test_empty()
 {
-    const boost::empty_value<empty> v1 = boost::empty_init_t();
-    BOOST_TEST(v1.get().value() == 1);
+    empty e;
+    const boost::empty_value<empty> v1(boost::empty_init_t(), e);
+    BOOST_TEST(!v1.get());
    boost::empty_value<empty> v2;
-    BOOST_TEST(v2.get().value() == 2);
+    BOOST_TEST(v2.get());
+    v2 = v1;
+    BOOST_TEST(v2.get());
+    v2.get() = empty();
+    BOOST_TEST(v2.get());
 }

 void test_type()
 {
-    const boost::empty_value<type> v1(boost::empty_init_t(), 2);
-    BOOST_TEST(v1.get().value() == 3);
-    boost::empty_value<type> v2(boost::empty_init_t(), 3);
-    BOOST_TEST(v2.get().value() == 5);
+    const boost::empty_value<type> v1(boost::empty_init_t(), true);
+    BOOST_TEST(v1.get());
+    boost::empty_value<type> v2;
+    BOOST_TEST(!v2.get());
    v2 = v1;
-    BOOST_TEST(v2.get().value() == 4);
-    v2.get() = type(4);
-    BOOST_TEST(v2.get().value() == 6);
+    BOOST_TEST(v2.get());
+    v2.get() = type();
+    BOOST_TEST(!v2.get());
 }

 int main()
 {
-    test_int();
+    test_bool();
    test_empty();
    test_type();
    return boost::report_errors();
--- a/test/first_scalar_constexpr_test.cpp
+++ b/test/first_scalar_constexpr_test.cpp
@@ -1,19 +0,0 @@
-/*
-Copyright 2019 Glen Joseph Fernandes
-(glenjofe@gmail.com)
-
-Distributed under the Boost Software License, Version 1.0.
-(http://www.boost.org/LICENSE_1_0.txt)
-*/
-#include <boost/config.hpp>
-#if !defined(BOOST_NO_CXX14_CONSTEXPR)
-#include <boost/core/first_scalar.hpp>
-#include <boost/static_assert.hpp>
-
-static int i1 = 0;
-BOOST_STATIC_ASSERT(boost::first_scalar(&i1) == &i1);
-static int i2[4] = { };
-BOOST_STATIC_ASSERT(boost::first_scalar(i2) == &i2[0]);
-static int i3[2][4][6] = { };
-BOOST_STATIC_ASSERT(boost::first_scalar(i3) == &i3[0][0][0]);
-#endif
--- a/test/first_scalar_test.cpp
+++ b/test/first_scalar_test.cpp
@@ -1,20 +0,0 @@
-/*
-Copyright 2019 Glen Joseph Fernandes
-(glenjofe@gmail.com)
-
-Distributed under the Boost Software License, Version 1.0.
-(http://www.boost.org/LICENSE_1_0.txt)
-*/
-#include <boost/core/first_scalar.hpp>
-#include <boost/core/lightweight_test.hpp>
-
-int main()
-{
-    int i1 = 0;
-    BOOST_TEST_EQ(boost::first_scalar(&i1), &i1);
-    int i2[4] = { };
-    BOOST_TEST_EQ(boost::first_scalar(i2), &i2[0]);
-    int i3[2][4][6] = { };
-    BOOST_TEST_EQ(boost::first_scalar(i3), &i3[0][0][0]);
-    return boost::report_errors();
-}
--- a/test/lightweight_test_all_eq_test.cpp
+++ b/test/lightweight_test_all_eq_test.cpp
@@ -120,5 +120,5 @@ int main()
        ++test_cases;
    }

-    return boost::report_errors() == test_cases;
+    return !boost::report_errors();
 }
--- a/test/lightweight_test_all_with_fail.cpp
+++ b/test/lightweight_test_all_with_fail.cpp
@@ -101,5 +101,5 @@ int main()
    test_cases += fail_vector();
    test_cases += fail_tolerance_predicate();

-    return boost::report_errors() == test_cases;
+    return !boost::report_errors();
 }
--- a/test/lightweight_test_fail12.cpp
+++ b/test/lightweight_test_fail12.cpp
@@ -1,68 +0,0 @@
-//
-// Negative test for BOOST_TEST_TRAIT_SAME
-//
-// Copyright 2014, 2019 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/core/lightweight_test_trait.hpp>
-#include <boost/config.hpp>
-
-struct X
-{
-    typedef int type;
-};
-
-template<class T1, class T2> struct Y
-{
-    typedef T1 type;
-};
-
-typedef int I1;
-typedef const int I2;
-typedef volatile int I3;
-typedef const volatile int I4;
-typedef int& I5;
-typedef const int& I6;
-typedef volatile int& I7;
-typedef const volatile int& I8;
-#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-typedef int&& I9;
-typedef const int&& I10;
-typedef volatile int&& I11;
-typedef const volatile int&& I12;
-#endif
-
-int main()
-{
-    BOOST_TEST_TRAIT_SAME(char[1], char[2]);
-    BOOST_TEST_TRAIT_SAME(char[1], char[]);
-    BOOST_TEST_TRAIT_SAME(char[1], char*);
-    BOOST_TEST_TRAIT_SAME(void(), void(int));
-    BOOST_TEST_TRAIT_SAME(void(), void(*)());
-    BOOST_TEST_TRAIT_SAME(X, void);
-    BOOST_TEST_TRAIT_SAME(X::type, void);
-    BOOST_TEST_TRAIT_SAME(X, Y<void, void>);
-    BOOST_TEST_TRAIT_SAME(X::type, Y<float, int>::type);
-    BOOST_TEST_TRAIT_SAME(Y<int, float>, Y<int, double>);
-    BOOST_TEST_TRAIT_SAME(I1, I2);
-    BOOST_TEST_TRAIT_SAME(I3, I4);
-    BOOST_TEST_TRAIT_SAME(I5, I6);
-    BOOST_TEST_TRAIT_SAME(I7, I8);
-
-    int expected = 14;
-
-#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-
-    BOOST_TEST_TRAIT_SAME(I9, I10);
-    BOOST_TEST_TRAIT_SAME(I11, I12);
-
-    expected += 2;
-
-#endif
-
-    return boost::report_errors() == expected;
-}
--- a/test/lightweight_test_test4.cpp
+++ b/test/lightweight_test_test4.cpp
@@ -1,36 +0,0 @@
-//
-// Test for BOOST_TEST_TRAIT_SAME
-//
-// Copyright 2014, 2019 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/core/lightweight_test_trait.hpp>
-
-struct X
-{
-    typedef int type;
-};
-
-template<class T1, class T2> struct Y
-{
-    typedef T1 type;
-};
-
-int main()
-{
-    BOOST_TEST_TRAIT_SAME(X, X);
-    BOOST_TEST_TRAIT_SAME(void, void);
-    BOOST_TEST_TRAIT_SAME(char[1], char[1]);
-    BOOST_TEST_TRAIT_SAME(char[], char[]);
-    BOOST_TEST_TRAIT_SAME(void(), void());
-    BOOST_TEST_TRAIT_SAME(X::type, X::type);
-    BOOST_TEST_TRAIT_SAME(X::type, Y<int, float>::type);
-    BOOST_TEST_TRAIT_SAME(Y<int, float>, Y<int, float>);
-    BOOST_TEST_TRAIT_SAME(Y<void, float>::type, void);
-
-    return boost::report_errors();
-}
--- a/test/no_exceptions_support_test.cpp
+++ b/test/no_exceptions_support_test.cpp
@@ -1,52 +0,0 @@
-//
-// Test for no_exceptions_support.hpp
-//
-// Copyright 2019 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/core/no_exceptions_support.hpp>
-#include <boost/core/quick_exit.hpp>
-#include <boost/throw_exception.hpp>
-#include <exception>
-
-void f()
-{
-    boost::throw_exception( std::exception() );
-}
-
-int main()
-{
-    BOOST_TRY
-    {
-        f();
-    }
-    BOOST_CATCH( std::exception const& )
-    {
-        return 0;
-    }
-    BOOST_CATCH( ... )
-    {
-        return 1;
-    }
-    BOOST_CATCH_END
-
-    return 1;
-}
-
-#if defined(BOOST_NO_EXCEPTIONS)
-
-namespace boost
-{
-
-void throw_exception( std::exception const& )
-{
-    boost::quick_exit( 0 );
-}
-
-}
-
-#endif
--- a/test/noinit_adaptor_test.cpp
+++ b/test/noinit_adaptor_test.cpp
@@ -1,100 +0,0 @@
-/*
-Copyright 2019 Glen Joseph Fernandes
-(glenjofe@gmail.com)
-
-Distributed under the Boost Software License, Version 1.0.
-(http://www.boost.org/LICENSE_1_0.txt)
-*/
-#include <boost/core/noinit_adaptor.hpp>
-#include <boost/core/default_allocator.hpp>
-#include <boost/core/lightweight_test.hpp>
-#include <vector>
-
-template<class T>
-class creator
-    : public boost::default_allocator<T> {
-public:
-    template<class U>
-    struct rebind {
-        typedef creator<U> other;
-    };
-
-    creator(int state)
-        : state_(state) { }
-
-    template<class U>
-    creator(const creator<U>& other)
-        : state_(other.state()) { }
-
-    template<class U, class V>
-    void construct(U*, const V&) {
-        BOOST_ERROR("construct");
-    }
-
-    template<class U>
-    void destroy(U*) {
-        BOOST_ERROR("destroy");
-    }
-
-    int state() const {
-        return state_;
-    }
-
-private:
-    int state_;
-};
-
-template<class T, class U>
-inline bool
-operator==(const creator<T>& lhs, const creator<U>& rhs)
-{
-    return lhs.state() == rhs.state();
-}
-
-template<class T, class U>
-inline bool
-operator!=(const creator<T>& lhs, const creator<U>& rhs)
-{
-    return !(lhs == rhs);
-}
-
-class type {
-public:
-    type() { }
-
-    type(int value)
-        : value_(value) { }
-
-    int value() const {
-        return value_;
-    }
-
-private:
-    int value_;
-};
-
-inline bool
-operator==(const type& lhs, const type& rhs)
-{
-    return lhs.value() == rhs.value();
-}
-
-template<class A>
-void test(const A& allocator)
-{
-    std::vector<typename A::value_type, A> v(allocator);
-    v.push_back(1);
-    BOOST_TEST(v.front() == 1);
-    v.clear();
-    v.resize(5);
-    v.front() = 1;
-}
-
-int main()
-{
-    test(boost::noinit_adaptor<creator<int> >(1));
-    test(boost::noinit_adaptor<creator<type> >(2));
-    test(boost::noinit_adapt(creator<int>(3)));
-    test(boost::noinit_adapt(creator<type>(4)));
-    return boost::report_errors();
-}
--- a/test/quick.cpp
+++ b/test/quick.cpp
@@ -24,6 +24,7 @@
 #include <boost/core/pointer_traits.hpp>
 #include <boost/ref.hpp>
 #include <boost/core/scoped_enum.hpp>
+#include <boost/detail/sp_typeinfo.hpp>
 #include <boost/core/typeinfo.hpp>
 #include <boost/core/underlying_type.hpp>
 #include <boost/visit_each.hpp>
--- a/test/sp_typeinfo_test.cpp
+++ b/test/sp_typeinfo_test.cpp
@@ -8,8 +8,6 @@
 // http://www.boost.org/LICENSE_1_0.txt
 //

-#define BOOST_ALLOW_DEPRECATED_HEADERS
-
 #include <boost/detail/sp_typeinfo.hpp>
 #include <boost/detail/lightweight_test.hpp>
 #include <iostream>
--- a/test/use_default_test.cpp
+++ b/test/use_default_test.cpp
@@ -1,15 +0,0 @@
-/*
-Copyright 2019 Glen Joseph Fernandes
-(glenjofe@gmail.com)
-
-Distributed under the Boost Software License, Version 1.0.
-(http://www.boost.org/LICENSE_1_0.txt)
-*/
-
-#include <boost/core/use_default.hpp>
-
-template<class, class = boost::use_default>
-struct type { };
-
-template class type<int>;
-template class type<void, boost::use_default>;