MinGW doesn't have _exit either

Abort instead of assert if report_errors() not called

.travis.yml

@@ -0,0 +1,238 @@
+# 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)
+
+language: cpp
+
+sudo: false
+
+python: "2.7"
+
+branches:
+  only:
+    - master
+    - develop
+    - /feature\/.*/
+
+env:
+  matrix:
+    - BOGUS_JOB=true
+
+matrix:
+
+  exclude:
+    - env: BOGUS_JOB=true
+
+  include:
+    - os: linux
+      compiler: g++
+      env: TOOLSET=gcc COMPILER=g++ CXXSTD=03,11
+
+    - os: linux
+      compiler: g++-4.4
+      env: TOOLSET=gcc COMPILER=g++-4.4 CXXSTD=98,0x
+      addons:
+        apt:
+          packages:
+            - g++-4.4
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      compiler: g++-4.6
+      env: TOOLSET=gcc COMPILER=g++-4.6 CXXSTD=03,0x
+      addons:
+        apt:
+          packages:
+            - g++-4.6
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      compiler: g++-4.7
+      env: TOOLSET=gcc COMPILER=g++-4.7 CXXSTD=03,11
+      addons:
+        apt:
+          packages:
+            - g++-4.7
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      compiler: g++-4.8
+      env: TOOLSET=gcc COMPILER=g++-4.8 CXXSTD=03,11
+      addons:
+        apt:
+          packages:
+            - g++-4.8
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      compiler: g++-4.9
+      env: TOOLSET=gcc COMPILER=g++-4.9 CXXSTD=03,11
+      addons:
+        apt:
+          packages:
+            - g++-4.9
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      compiler: g++-5
+      env: TOOLSET=gcc COMPILER=g++-5 CXXSTD=03,11,14,1z
+      addons:
+        apt:
+          packages:
+            - g++-5
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      compiler: g++-6
+      env: TOOLSET=gcc COMPILER=g++-6 CXXSTD=03,11,14,1z
+      addons:
+        apt:
+          packages:
+            - g++-6
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      dist: trusty
+      compiler: g++-7
+      env: TOOLSET=gcc COMPILER=g++-7 CXXSTD=03,11,14,17
+      addons:
+        apt:
+          packages:
+            - g++-7
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      compiler: g++-8
+      env: TOOLSET=gcc COMPILER=g++-8 CXXSTD=03,11,14,17
+      addons:
+        apt:
+          packages:
+            - g++-8
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      compiler: clang++
+      env: TOOLSET=clang COMPILER=clang++ CXXSTD=03,11
+
+    - os: linux
+      compiler: clang++-3.5
+      env: TOOLSET=clang COMPILER=clang++-3.5 CXXSTD=03,11,14,1z
+      addons:
+        apt:
+          packages:
+            - clang-3.5
+            - libstdc++-4.9-dev
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      compiler: clang++-3.6
+      env: TOOLSET=clang COMPILER=clang++-3.6 CXXSTD=03,11,14,1z
+      addons:
+        apt:
+          packages:
+            - clang-3.6
+            - libstdc++-4.9-dev
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      compiler: clang++-3.8
+      env: TOOLSET=clang COMPILER=clang++-3.8 CXXSTD=03,11,14,1z
+      addons:
+        apt:
+          packages:
+            - clang-3.8
+            - libstdc++-4.9-dev
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      compiler: clang++-3.9
+      env: TOOLSET=clang COMPILER=clang++-3.9 CXXSTD=03,11,14,1z
+      addons:
+        apt:
+          packages:
+            - clang-3.9
+            - libstdc++-4.9-dev
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      compiler: clang++-4.0
+      env: TOOLSET=clang COMPILER=clang++-4.0 CXXSTD=03,11,14,1z
+      addons:
+        apt:
+          packages:
+            - clang-4.0
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-trusty-4.0
+
+    - os: linux
+      compiler: clang++-5.0
+      env: TOOLSET=clang COMPILER=clang++-5.0 CXXSTD=03,11,14,1z
+      addons:
+        apt:
+          packages:
+            - clang-5.0
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-trusty-5.0
+
+    - os: linux
+      compiler: clang++-6.0
+      env: TOOLSET=clang COMPILER=clang++-6.0 CXXSTD=03,11,14,17
+      addons:
+        apt:
+          packages:
+            - clang-6.0
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-trusty-6.0
+
+    - os: linux
+      compiler: clang++-libc++
+      env: TOOLSET=clang COMPILER=clang++-libc++ CXXSTD=03,11,14,1z
+      addons:
+        apt:
+          packages:
+            - libc++-dev
+
+    - os: osx
+      compiler: clang++
+      env: TOOLSET=clang COMPILER=clang++ CXXSTD=03,11,14,1z
+
+install:
+  - 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
+  - git submodule init libs/assert
+  - git submodule init libs/config
+  - git submodule init libs/predef
+  - git submodule init libs/static_assert
+  - git submodule init libs/type_traits
+  - git submodule init tools/build
+  - git submodule update
+  - cp -r $TRAVIS_BUILD_DIR/* libs/core
+  - ./bootstrap.sh
+  - ./b2 headers
+
+script:
+  - |-
+    echo "using $TOOLSET : : $COMPILER ;" > ~/user-config.jam
+  - ./b2 -j 3 libs/core/test toolset=$TOOLSET cxxstd=$CXXSTD
+
+notifications:
+  email:
+    on_success: always

README.md

@@ -8,6 +8,13 @@ The criteria for inclusion is that the utility component be:
 * used by other Boost libraries, and
 * not dependent on any other Boost modules except Core itself, Config, Assert, Static Assert, or Predef.
 
+### CI Status
+
+Branch   | Travis | Appveyor
+---------|--------|---------
+Develop  | [![Build Status](https://travis-ci.org/boostorg/core.svg?branch=develop)](https://travis-ci.org/boostorg/core) | [![Build Status](https://ci.appveyor.com/api/projects/status/github/boostorg/core?branch=develop&svg=true)](https://ci.appveyor.com/project/pdimov/core)
+Master   | [![Build Status](https://travis-ci.org/boostorg/core.svg?branch=master)](https://travis-ci.org/boostorg/core) | [![Build Status](https://ci.appveyor.com/api/projects/status/github/boostorg/core?branch=master&svg=true)](https://ci.appveyor.com/project/pdimov/core)
+
 ### Directories
 
 * **doc** - Documentation of the components

appveyor.yml

@@ -0,0 +1,64 @@
+# 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)
+
+version: 1.0.{build}-{branch}
+
+shallow_clone: true
+
+branches:
+  only:
+    - master
+    - develop
+    - /feature\/.*/
+
+environment:
+  matrix:
+    - 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 2013
+      ADDPATH: C:\cygwin\bin;
+      TOOLSET: gcc
+      CXXSTD: 03,11
+
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2013
+      ADDPATH: C:\mingw\bin;
+      TOOLSET: gcc
+      CXXSTD: 03,11
+
+    - 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
+
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
+      TOOLSET: msvc-14.0
+
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
+      TOOLSET: msvc-14.1
+      CXXSTD: 14,17
+
+install:
+  - set BOOST_BRANCH=develop
+  - if "%APPVEYOR_REPO_BRANCH%" == "master" set BOOST_BRANCH=master
+  - cd ..
+  - git clone -b %BOOST_BRANCH% https://github.com/boostorg/boost.git boost-root
+  - cd boost-root
+  - git submodule init libs/assert
+  - git submodule init libs/config
+  - git submodule init libs/predef
+  - git submodule init libs/static_assert
+  - git submodule init libs/type_traits
+  - git submodule init tools/build
+  - git submodule update
+  - xcopy /s /e /q %APPVEYOR_BUILD_FOLDER% libs\core
+  - cmd /c bootstrap
+  - b2 headers
+
+build: off
+
+test_script:
+  - PATH=%ADDPATH%%PATH%
+  - if not "%CXXSTD%" == "" set CXXSTD=cxxstd=%CXXSTD%
+  - b2 -j 3 libs/core/test toolset=%TOOLSET% %CXXSTD%

doc/Jamfile.v2

@@ -51,3 +51,9 @@ boostbook standalone
     <xsl:param>toc.max.depth=1
     <format>pdf:<xsl:param>boost.url.prefix=http://www.boost.org/doc/libs/release/libs/core/doc/html
   ;
+
+###############################################################################
+alias boostdoc ;
+explicit boostdoc ;
+alias boostrelease : standalone ;
+explicit boostrelease ;

doc/addressof.qbk

@@ -14,6 +14,7 @@
 * Brad King
 * Douglas Gregor
 * Peter Dimov
+* Glen Fernandes
 
 [endsimplesect]
 
@@ -59,6 +60,19 @@ void f() {
 
 [endsect]
 
+[section Notes]
+
+In C++11 and above, `boost::addressof` is conditionally
+`constexpr` when possible. This is indicated by
+`BOOST_CORE_NO_CONSTEXPR_ADDRESSOF` not being defined.
+
+With supported compilers, `boost::addressof` is always
+`constexpr` by leveraging compiler intrinsics. This is
+indicated by `BOOST_CORE_HAS_BUILTIN_ADDRESSOF` being
+defined.
+
+[endsect]
+
 [endsect]
 
 [endsect]

doc/core.qbk

@@ -41,7 +41,9 @@ criteria for inclusion is that the utility component be:
 [include addressof.qbk]
 [include checked_delete.qbk]
 [include demangle.qbk]
+[include empty_value.qbk]
 [include enable_if.qbk]
+[include exchange.qbk]
 [include explicit_operator_bool.qbk]
 [include ignore_unused.qbk]
 [include is_same.qbk]
@@ -49,6 +51,7 @@ criteria for inclusion is that the utility component be:
 [include no_exceptions_support.qbk]
 [include noncopyable.qbk]
 [include null_deleter.qbk]
+[include pointer_traits.qbk]
 [include ref.qbk]
 [include scoped_enum.qbk]
 [include swap.qbk]

doc/empty_value.qbk

@@ -0,0 +1,129 @@
+[/
+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)
+]
+
+[section:empty_value empty_value]
+
+[simplesect Authors]
+
+* Glen Fernandes
+
+[endsimplesect]
+
+[section Overview]
+
+The header <boost/core/empty_value.hpp> provides the class template
+`boost::empty_value` for library authors to conveniently leverage the Empty
+Base Optimization to store objects of potentially empty types.
+
+[endsect]
+
+[section Examples]
+
+The following example shows `boost::empty_value` used to create a type that
+stores a pointer, comparer, and allocator, where the comparer and allocator
+could be empty types.
+
+```
+template<class Ptr, class Compare, class Allocator>
+class storage
+    : empty_value<Compare, 0>
+    , empty_value<Allocator, 1> {
+public:
+    storage()
+        : empty_value<Compare, 0>(empty_init_t())
+        , empty_value<Allocator, 1>(empty_init_t())
+        , ptr_() { }
+
+    storage(const Compare& c, const Allocator& a)
+        : empty_value<Compare, 0>(empty_init_t(), c)
+        , empty_value<Allocator, 1>(empty_init_t(), a)
+        , ptr_() { }
+
+    const Ptr& pointer() const {
+        return ptr_;
+    }
+
+    Ptr& pointer() {
+        return ptr_;
+    }
+
+    const Compare& compare() const {
+        return empty_value<Compare, 0>::get();
+    }
+
+    Compare& compare() {
+        return empty_value<Compare, 0>::get();
+    }
+
+    const Allocator& allocator() const {
+        return empty_value<Allocator, 1>::get();
+    }
+
+    Allocator& allocator() {
+        return empty_value<Allocator, 1>::get();
+    }
+
+private:
+    Ptr ptr_;
+};
+```
+
+[endsect]
+
+[section Reference]
+
+```
+namespace boost {
+
+struct empty_init_t { };
+
+template<class T, unsigned Index = 0, bool Empty = ``/see below/``>
+class empty_value {
+public:
+    empty_value() = default;
+
+    template<class... Args>
+    explicit empty_value(empty_init_t, Args&&... args);
+
+    const T& get() const;
+
+    T& get();
+};
+
+} /* boost */
+```
+
+[section Template parameters]
+
+[variablelist
+[[`T`][The type of value to store]]
+[[`Index`][Optional: Specify to create a distinct base type]]
+[[`Empty`][Optional: Specify to force inheritance from type]]]
+
+[endsect]
+
+[section Constructors]
+
+[variablelist
+[[`empty_value() = default;`][Default initialize the value]]
+[[`template<class... Args> empty_value(empty_init_t, Args&&... args);`]
+[Initialize the value with `std::forward<Args>(args)...`]]]
+
+[endsect]
+
+[section Member functions]
+
+[variablelist
+[[`const T& get() const;`][Returns the value]]
+[[`T& get();`][Returns the value]]]
+
+[endsect]
+
+[endsect]
+
+[endsect]

doc/exchange.qbk

@@ -0,0 +1,62 @@
+[/
+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)
+]
+
+[section:exchange exchange]
+
+[simplesect Authors]
+
+* Glen Fernandes
+
+[endsimplesect]
+
+[section Overview]
+
+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.
+
+[endsect]
+
+[section Examples]
+
+The following example shows `boost::exchange` used to simplify the
+implementation of a move constructor.
+
+```
+Node(Node&& other)
+  : head_(boost::exchange(other.head_, nullptr))
+  , tail_(boost::exchange(other.tail_, nullptr)) { }
+```
+
+[endsect]
+
+[section Reference]
+
+```
+namespace boost {
+  template<class T, class U = T>
+  constexpr T exchange(T& t, U&& u);
+}
+```
+[section Functions]
+
+[*`template<class T, class U = T> constexpr T exchange(T& t, U&& u);`]
+
+Equivalent to:
+
+```
+T v = std::move(t);
+t = std::forward<U>(u);
+return v;
+```
+
+[endsect]
+
+[endsect]
+
+[endsect]

doc/lightweight_test.qbk

@@ -1,7 +1,8 @@
 [/
   Copyright 2010, 2011 Beman Dawes
   Copyright 2013 Ion Gaztanaga
-  Copyright 2014 Peter Dimov
+  Copyright 2014, 2017 Peter Dimov
+  Copyright 2017 Kohei Takahashi
 
   Distributed under the Boost Software License, Version 1.0.
 
@@ -32,9 +33,18 @@ When using `lightweight_test.hpp`, *do not forget* to
 
 ``
 #define BOOST_TEST(expression) /*unspecified*/
+#define BOOST_TEST_NOT(expression) /*unspecified*/
 #define BOOST_ERROR(message) /*unspecified*/
 #define BOOST_TEST_EQ(expr1, expr2) /*unspecified*/
 #define BOOST_TEST_NE(expr1, expr2) /*unspecified*/
+#define BOOST_TEST_LT(expr1, expr2) /*unspecified*/
+#define BOOST_TEST_LE(expr1, expr2) /*unspecified*/
+#define BOOST_TEST_GT(expr1, expr2) /*unspecified*/
+#define BOOST_TEST_GE(expr1, expr2) /*unspecified*/
+#define BOOST_TEST_CSTR_EQ(expr1, expr2) /*unspecified*/
+#define BOOST_TEST_CSTR_NE(expr1, expr2) /*unspecified*/
+#define BOOST_TEST_ALL_EQ(begin1, end1, begin2, end2) /* unspecified */
+#define BOOST_TEST_ALL_WITH(begin1, end1, begin2, end2, predicate) /* unspecified */
 #define BOOST_TEST_THROWS(expr, excep) /*unspecified*/
 
 namespace boost
@@ -56,6 +66,17 @@ message containing `expression`.
 
 [endsect]
 
+[section BOOST_TEST_NOT]
+
+``
+BOOST_TEST_NOT(expression)
+``
+
+If expression is true increases the error count and outputs a
+message containing `!(expression)`.
+
+[endsect]
+
 [section BOOST_ERROR]
 
 ``
@@ -73,7 +94,7 @@ Increases error count and outputs a message containing
 BOOST_TEST_EQ(expr1, expr2)
 ``
 
-If `expr1 != expr2` increases the error count and outputs a
+If `expr1 == expr2` is not true increases the error count and outputs a
 message containing both expressions.
 
 [endsect]
@@ -84,11 +105,95 @@ message containing both expressions.
 BOOST_TEST_NE(expr1, expr2)
 ``
 
-If `expr1 == expr2` increases the error count and outputs a
+If `expr1 != expr2` is not true increases the error count and outputs a
 message containing both expressions.
 
 [endsect]
 
+[section BOOST_TEST_LT]
+
+``
+BOOST_TEST_LT(expr1, expr2)
+``
+
+If `expr1 < expr2` is not true increases the error count and outputs a
+message containing both expressions.
+
+[endsect]
+
+[section BOOST_TEST_LE]
+
+``
+BOOST_TEST_LE(expr1, expr2)
+``
+
+If `expr1 <= expr2` is not true increases the error count and outputs a
+message containing both expressions.
+
+[endsect]
+
+[section BOOST_TEST_GT]
+
+``
+BOOST_TEST_GT(expr1, expr2)
+``
+
+If `expr1 > expr2` is not true increases the error count and outputs a
+message containing both expressions.
+
+[endsect]
+
+[section BOOST_TEST_GE]
+
+``
+BOOST_TEST_GE(expr1, expr2)
+``
+
+If `expr1 >= expr2` is not true increases the error count and outputs a
+message containing both expressions.
+
+[endsect]
+
+[section BOOST_TEST_CSTR_EQ]
+
+``
+BOOST_TEST_CSTR_EQ(expr1, expr2)
+``
+
+Specialization of `BOOST_TEST_EQ` which interprets `expr1` and `expr2` as pointers to null-terminated byte strings (C strings). If `std::strcmp(expr1, expr2) != 0`, increase the error count and output a message containing both expressions.
+
+[endsect]
+
+[section BOOST_TEST_CSTR_NE]
+
+``
+BOOST_TEST_CSTR_NE(expr1, expr2)
+``
+
+Specialization of `BOOST_TEST_NE` which interprets `expr1` and `expr2` as pointers to null-terminated byte strings (C strings). If `std::strcmp(expr1, expr2) == 0`, increase the error count and output a message containing both expressions.
+
+[endsect]
+
+[section BOOST_TEST_ALL_EQ]
+
+``
+BOOST_TEST_ALL_EQ(begin1, end1, begin2, end2)
+``
+
+Compares the content of two sequences. If they have different sizes, or if any pairwise element differs, increases the error count and outputs a message containing at most 8 differing elements.
+
+[endsect]
+
+[section BOOST_TEST_ALL_WITH]
+
+``
+BOOST_TEST_ALL_WITH(begin1, end1, begin2, end2, predicate)
+``
+
+Compares the content of two sequences. If they have different sizes, or if any pairwise element do not fulfill the binary predicate, increases the error count and outputs a message containing at most 8 differing elements.
+
+[endsect]
+
 [section BOOST_TEST_THROWS]
 
 ``

doc/noncopyable.qbk

@@ -18,9 +18,9 @@
 
 [section Header <boost/core/noncopyable.hpp>]
 
-The header `<boost/noncopyable.hpp>` defines the class
+The header `<boost/core/noncopyable.hpp>` defines the class
 `boost::noncopyable`. It is intended to be used as a private
-base. `boost::noncopyable` has private (under C++03) or
+base class. `boost::noncopyable` has private (under C++03) or
 deleted (under C++11) copy constructor and a copy assignment
 operator and can't be copied or assigned; a class that derives
 from it inherits these properties.

doc/pointer_traits.qbk

@@ -0,0 +1,150 @@
+[/
+Copyright 2017-2018 Glen Joseph Fernandes
+(glenjofe@gmail.com)
+
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
+]
+
+[section:pointer_traits pointer_traits]
+
+[simplesect Authors]
+
+* Glen Fernandes
+
+[endsimplesect]
+
+[section Overview]
+
+The header <boost/core/pointer_traits.hpp> provides the class template
+`boost::pointer_traits` to facilitate use of pointer-like types. The C++11
+standard library introduced `std::pointer_traits` along with an allocator
+model which supported pointer-like types in addition to plain raw pointers.
+This implementation also supports C++98.
+
+It also provides the function template `boost::to_address` to obtain a raw
+pointer from an object of any pointer-like type.
+
+[endsect]
+
+[section Examples]
+
+The following example allocates storage and constructs an object in that
+storage using an allocator.
+
+```
+template<class Allocator>
+void function(Allocator& a)
+{
+    auto p = a.allocate(1);
+    std::allocator_traits<Allocator>::construct(a, boost::to_address(p));
+}
+```
+
+[endsect]
+
+[section Reference]
+
+```
+namespace boost {
+  template<class T> struct pointer_traits {
+    typedef T pointer;
+    typedef ``['see below]`` element_type;
+    typedef ``['see below]`` difference_type;
+
+    template<class U> struct rebind_to { typedef ``['see below]`` type; };
+    template<class U> using rebind = typename rebind_to<U>::type;
+
+    static pointer pointer_to(``['see below]`` v);
+  };
+
+  template<class T> struct pointer_traits<T*> {
+    typedef T* pointer;
+    typedef T element_type;
+    typedef std::ptrdiff_t difference_type;
+
+    template<class U> struct rebind_to { typedef U* type; };
+    template<class U> using rebind = typename rebind_to<U>::type;
+
+    static pointer pointer_to(``['see below]`` v) noexcept;
+  };
+
+  template<class T>
+  constexpr T* to_address(T* v) noexcept;
+
+  template<class T>
+  auto to_address(const T& v) noexcept;
+}
+```
+
+[section Member types]
+
+[variablelist
+[[`typedef` ['see below] `element_type;`]
+[`T::element_type` if such a type exists; otherwise `U` if `T` is a class
+  template instantiation of the form `Pointer<U, Args>`, where `Args` is zero
+  or more type arguments; otherwise the specialization is ill-formed.]]
+[[`typedef` ['see below] `difference_type;`]
+[`T::difference_type` if such a type exists; otherwise `std::ptrdiff_t`.]]
+[[`template<class U> struct rebind_to { typedef` ['see below] `type; };`]
+[`type` is `T::rebind<U>` if such a type exists; otherwise, `Pointer<V, Args>`
+  if `T` is a class template instantiation of the form `Pointer<T, Args>`,
+  where `Args` is zero or more type arguments; otherwise, the instantiation of
+  `rebind_to` is ill-formed.]]]
+
+[endsect]
+
+[section Member functions]
+
+[variablelist
+[[`static pointer pointer_traits::pointer_to(`['see below] `v);`]
+[[variablelist
+[[Remark]
+[If `element_type` is a void type, the type of `v` is unspecified; otherwise,
+  it is `element_type&`.]]
+[[Returns]
+[A pointer to `v` obtained by calling `T::pointer_to(v)`.]]]]]
+[[`static pointer pointer_traits<T*>::pointer_to(`['see below] `v) noexcept;`]
+[[variablelist
+[[Remark]
+[If `element_type` is a void type, the type of `v` is unspecified; otherwise,
+  it is `element_type&`.]]
+[[Returns] [`addressof(v)`.]]]]]]
+
+[endsect]
+
+[section Optional members]
+
+[variablelist
+[[`static element_type* to_address(pointer v) noexcept;`]
+[[variablelist
+[[Returns]
+[A pointer of type `element_type*` that references the same location as the
+  argument `p`.]]
+[[Note]
+[This function should be the inverse of `pointer_to`. If defined, it
+  customizes the behavior of the non-member function `to_address`.]]]]]]
+
+[endsect]
+
+[section Free functions]
+
+[variablelist
+[[`template<class T> constexpr T* to_address(T* v) noexcept;`]
+[[variablelist [[Returns] [`v`.]]]]]
+[[`template<class T> auto to_address(const T& v) noexcept;`]
+[[variablelist [[Returns] [`pointer_traits<T>::to_address(v)` if that
+  expression is well-formed, otherwise `to_address(v.operator->())`.]]]]]]
+
+[endsect]
+
+[endsect]
+
+[section Acknowledgments]
+
+Glen Fernandes implemented `pointer_traits` and `to_address` with reviews and
+guidance from Peter Dimov.
+
+[endsect]
+
+[endsect]

include/boost/core/addressof.hpp

@@ -1,162 +1,274 @@
-// Copyright (C) 2002 Brad King (brad.king@kitware.com)
-//                    Douglas Gregor (gregod@cs.rpi.edu)
-//
-// Copyright (C) 2002, 2008, 2013 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)
+/*
+Copyright (C) 2002 Brad King (brad.king@kitware.com)
+                   Douglas Gregor (gregod@cs.rpi.edu)
 
-// For more information, see http://www.boost.org
+Copyright (C) 2002, 2008, 2013 Peter Dimov
+
+Copyright (C) 2017 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)
+*/
 
 #ifndef BOOST_CORE_ADDRESSOF_HPP
 #define BOOST_CORE_ADDRESSOF_HPP
 
-# include <boost/config.hpp>
-# include <boost/detail/workaround.hpp>
-# include <cstddef>
+#include <boost/config.hpp>
 
-namespace boost
+#if defined(BOOST_MSVC_FULL_VER) && BOOST_MSVC_FULL_VER >= 190024215
+#define BOOST_CORE_HAS_BUILTIN_ADDRESSOF
+#elif defined(BOOST_GCC) && BOOST_GCC >= 70000
+#define BOOST_CORE_HAS_BUILTIN_ADDRESSOF
+#elif defined(__has_builtin)
+#if __has_builtin(__builtin_addressof)
+#define BOOST_CORE_HAS_BUILTIN_ADDRESSOF
+#endif
+#endif
+
+#if defined(BOOST_CORE_HAS_BUILTIN_ADDRESSOF)
+#if defined(BOOST_NO_CXX11_CONSTEXPR)
+#define BOOST_CORE_NO_CONSTEXPR_ADDRESSOF
+#endif
+
+namespace boost {
+
+template<class T>
+BOOST_CONSTEXPR inline T*
+addressof(T& o) BOOST_NOEXCEPT
 {
+    return __builtin_addressof(o);
+}
 
-namespace detail
-{
-
-template<class T> struct addr_impl_ref
-{
-    T & v_;
-
-    BOOST_FORCEINLINE addr_impl_ref( T & v ): v_( v ) {}
-    BOOST_FORCEINLINE operator T& () const { return v_; }
-
-private:
-    addr_impl_ref & operator=(const addr_impl_ref &);
-};
-
-template<class T> struct addressof_impl
-{
-    static BOOST_FORCEINLINE T * f( T & v, long )
-    {
-        return reinterpret_cast<T*>(
-            &const_cast<char&>(reinterpret_cast<const volatile char &>(v)));
-    }
-
-    static BOOST_FORCEINLINE T * f( T * v, int )
-    {
-        return v;
-    }
-};
-
-#if !defined( BOOST_NO_CXX11_NULLPTR )
-
-#if !defined( BOOST_NO_CXX11_DECLTYPE ) && ( ( defined( __clang__ ) && !defined( _LIBCPP_VERSION ) ) || defined( __INTEL_COMPILER ) )
-
-    typedef decltype(nullptr) addr_nullptr_t;
-
+} /* boost */
 #else
+#include <boost/config/workaround.hpp>
+#include <cstddef>
 
-    typedef std::nullptr_t addr_nullptr_t;
+namespace boost {
+namespace detail {
 
+template<class T>
+class addrof_ref {
+public:
+    BOOST_FORCEINLINE addrof_ref(T& o) BOOST_NOEXCEPT
+        : o_(o) { }
+    BOOST_FORCEINLINE operator T&() const BOOST_NOEXCEPT {
+        return o_;
+    }
+private:
+    addrof_ref& operator=(const addrof_ref&);
+    T& o_;
+};
+
+template<class T>
+struct addrof {
+    static BOOST_FORCEINLINE T* get(T& o, long) BOOST_NOEXCEPT {
+        return reinterpret_cast<T*>(&
+            const_cast<char&>(reinterpret_cast<const volatile char&>(o)));
+    }
+    static BOOST_FORCEINLINE T* get(T* p, int) BOOST_NOEXCEPT {
+        return p;
+    }
+};
+
+#if !defined(BOOST_NO_CXX11_NULLPTR)
+#if !defined(BOOST_NO_CXX11_DECLTYPE) && \
+    (defined(__INTEL_COMPILER) || \
+        (defined(__clang__) && !defined(_LIBCPP_VERSION)))
+typedef decltype(nullptr) addrof_null_t;
+#else
+typedef std::nullptr_t addrof_null_t;
 #endif
 
-template<> struct addressof_impl< addr_nullptr_t >
-{
-    typedef addr_nullptr_t T;
-
-    static BOOST_FORCEINLINE T * f( T & v, int )
-    {
-        return &v;
+template<>
+struct addrof<addrof_null_t> {
+    typedef addrof_null_t type;
+    static BOOST_FORCEINLINE type* get(type& o, int) BOOST_NOEXCEPT {
+        return &o;
     }
 };
 
-template<> struct addressof_impl< addr_nullptr_t const >
-{
-    typedef addr_nullptr_t const T;
-
-    static BOOST_FORCEINLINE T * f( T & v, int )
-    {
-        return &v;
+template<>
+struct addrof<const addrof_null_t> {
+    typedef const addrof_null_t type;
+    static BOOST_FORCEINLINE type* get(type& o, int) BOOST_NOEXCEPT {
+        return &o;
     }
 };
 
-template<> struct addressof_impl< addr_nullptr_t volatile >
-{
-    typedef addr_nullptr_t volatile T;
-
-    static BOOST_FORCEINLINE T * f( T & v, int )
-    {
-        return &v;
+template<>
+struct addrof<volatile addrof_null_t> {
+    typedef volatile addrof_null_t type;
+    static BOOST_FORCEINLINE type* get(type& o, int) BOOST_NOEXCEPT {
+        return &o;
     }
 };
 
-template<> struct addressof_impl< addr_nullptr_t const volatile >
-{
-    typedef addr_nullptr_t const volatile T;
-
-    static BOOST_FORCEINLINE T * f( T & v, int )
-    {
-        return &v;
+template<>
+struct addrof<const volatile addrof_null_t> {
+    typedef const volatile addrof_null_t type;
+    static BOOST_FORCEINLINE type* get(type& o, int) BOOST_NOEXCEPT {
+        return &o;
     }
 };
-
 #endif
 
-} // namespace detail
+} /* detail */
+
+#if defined(BOOST_NO_CXX11_SFINAE_EXPR) || \
+    defined(BOOST_NO_CXX11_CONSTEXPR) || \
+    defined(BOOST_NO_CXX11_DECLTYPE)
+#define BOOST_CORE_NO_CONSTEXPR_ADDRESSOF
+
+template<class T>
+BOOST_FORCEINLINE T*
+addressof(T& o) BOOST_NOEXCEPT
+{
+#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x610)) || \
+    BOOST_WORKAROUND(__SUNPRO_CC, <= 0x5120)
+    return boost::detail::addrof<T>::get(o, 0);
+#else
+    return boost::detail::addrof<T>::get(boost::detail::addrof_ref<T>(o), 0);
+#endif
+}
+
+#if BOOST_WORKAROUND(__SUNPRO_CC, BOOST_TESTED_AT(0x590))
+namespace detail {
+
+template<class T>
+struct addrof_result {
+    typedef T* type;
+};
+
+} /* detail */
+
+template<class T, std::size_t N>
+BOOST_FORCEINLINE typename boost::detail::addrof_result<T[N]>::type
+addressof(T (&o)[N]) BOOST_NOEXCEPT
+{
+    return &o;
+}
+#endif
+
+#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+template<class T, std::size_t N>
+BOOST_FORCEINLINE
+T (*addressof(T (&o)[N]) BOOST_NOEXCEPT)[N]
+{
+   return reinterpret_cast<T(*)[N]>(&o);
+}
+
+template<class T, std::size_t N>
+BOOST_FORCEINLINE
+const T (*addressof(const T (&o)[N]) BOOST_NOEXCEPT)[N]
+{
+   return reinterpret_cast<const T(*)[N]>(&o);
+}
+#endif
+#else
+namespace detail {
+
+template<class T>
+T addrof_declval() BOOST_NOEXCEPT;
+
+template<class>
+struct addrof_void {
+    typedef void type;
+};
+
+template<class T, class E = void>
+struct addrof_member_operator {
+    static constexpr bool value = false;
+};
+
+template<class T>
+struct addrof_member_operator<T, typename
+    addrof_void<decltype(addrof_declval<T&>().operator&())>::type> {
+    static constexpr bool value = true;
+};
+
+#if BOOST_WORKAROUND(BOOST_INTEL, < 1600)
+struct addrof_addressable { };
+
+addrof_addressable*
+operator&(addrof_addressable&) BOOST_NOEXCEPT;
+#endif
+
+template<class T, class E = void>
+struct addrof_non_member_operator {
+    static constexpr bool value = false;
+};
+
+template<class T>
+struct addrof_non_member_operator<T, typename
+    addrof_void<decltype(operator&(addrof_declval<T&>()))>::type> {
+    static constexpr bool value = true;
+};
+
+template<class T, class E = void>
+struct addrof_expression {
+    static constexpr bool value = false;
+};
+
+template<class T>
+struct addrof_expression<T,
+    typename addrof_void<decltype(&addrof_declval<T&>())>::type> {
+    static constexpr bool value = true;
+};
+
+template<class T>
+struct addrof_is_constexpr {
+    static constexpr bool value = addrof_expression<T>::value &&
+        !addrof_member_operator<T>::value &&
+        !addrof_non_member_operator<T>::value;
+};
+
+template<bool E, class T>
+struct addrof_if { };
+
+template<class T>
+struct addrof_if<true, T> {
+    typedef T* type;
+};
 
 template<class T>
 BOOST_FORCEINLINE
-T * addressof( T & v )
+typename addrof_if<!addrof_is_constexpr<T>::value, T>::type
+addressof(T& o) BOOST_NOEXCEPT
 {
-#if (defined( __BORLANDC__ ) && BOOST_WORKAROUND( __BORLANDC__, BOOST_TESTED_AT( 0x610 ) ) ) || (defined(__SUNPRO_CC) && BOOST_WORKAROUND(__SUNPRO_CC, <= 0x5120))
-
-    return boost::detail::addressof_impl<T>::f( v, 0 );
-
-#else
-
-    return boost::detail::addressof_impl<T>::f( boost::detail::addr_impl_ref<T>( v ), 0 );
-
-#endif
+    return addrof<T>::get(addrof_ref<T>(o), 0);
 }
 
-#if defined( __SUNPRO_CC ) && BOOST_WORKAROUND( __SUNPRO_CC, BOOST_TESTED_AT( 0x590 ) )
-
-namespace detail
+template<class T>
+constexpr BOOST_FORCEINLINE
+typename addrof_if<addrof_is_constexpr<T>::value, T>::type
+addressof(T& o) BOOST_NOEXCEPT
 {
-
-template<class T> struct addressof_addp
-{
-    typedef T * type;
-};
-
-} // namespace detail
-
-template< class T, std::size_t N >
-BOOST_FORCEINLINE
-typename detail::addressof_addp< T[N] >::type addressof( T (&t)[N] )
-{
-    return &t;
+    return &o;
 }
 
-#endif
+} /* detail */
 
-// Borland doesn't like casting an array reference to a char reference
-// but these overloads work around the problem.
-#if defined( __BORLANDC__ ) && BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
-template<typename T,std::size_t N>
-BOOST_FORCEINLINE
-T (*addressof(T (&t)[N]))[N]
+template<class T>
+constexpr BOOST_FORCEINLINE T*
+addressof(T& o) BOOST_NOEXCEPT
 {
-   return reinterpret_cast<T(*)[N]>(&t);
-}
-
-template<typename T,std::size_t N>
-BOOST_FORCEINLINE
-const T (*addressof(const T (&t)[N]))[N]
-{
-   return reinterpret_cast<const T(*)[N]>(&t);
+    return boost::detail::addressof(o);
 }
 #endif
 
-} // namespace boost
+} /* boost */
+#endif
 
-#endif // BOOST_CORE_ADDRESSOF_HPP
+#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && \
+    !defined(BOOST_NO_CXX11_DELETED_FUNCTIONS)
+namespace boost {
+
+template<class T>
+const T* addressof(const T&&) = delete;
+
+} /* boost */
+#endif
+
+#endif

include/boost/core/demangle.hpp

@@ -17,7 +17,10 @@
 # pragma once
 #endif
 
-#if defined( __clang__ ) && defined( __has_include )
+// __has_include is currently supported by GCC and Clang. However GCC 4.9 may have issues and
+// returns 1 for 'defined( __has_include )', while '__has_include' is actually not supported:
+// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=63662
+#if defined( __has_include ) && (!defined( BOOST_GCC ) || (__GNUC__ + 0) >= 5)
 # if __has_include(<cxxabi.h>)
 #  define BOOST_CORE_HAS_CXXABI_H
 # endif
@@ -90,15 +93,10 @@ inline void demangle_free( char const * name ) BOOST_NOEXCEPT
 inline std::string demangle( char const * name )
 {
     scoped_demangled_name demangled_name( name );
-    char const * const p = demangled_name.get();
-    if( p )
-    {
-        return p;
-    }
-    else
-    {
-        return name;
-    }
+    char const * p = demangled_name.get();
+    if( !p )
+        p = name;
+    return p;
 }
 
 #else

include/boost/core/empty_value.hpp

@@ -0,0 +1,125 @@
+/*
+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)
+*/
+#ifndef BOOST_CORE_EMPTY_VALUE_HPP
+#define BOOST_CORE_EMPTY_VALUE_HPP
+
+#include <boost/config.hpp>
+#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+#include <utility>
+#endif
+
+#if defined(BOOST_GCC_VERSION) && (BOOST_GCC_VERSION >= 40700)
+#define BOOST_DETAIL_EMPTY_VALUE_BASE
+#elif defined(BOOST_INTEL) && defined(_MSC_VER) && (_MSC_VER >= 1800)
+#define BOOST_DETAIL_EMPTY_VALUE_BASE
+#elif defined(BOOST_MSVC) && (BOOST_MSVC >= 1800)
+#define BOOST_DETAIL_EMPTY_VALUE_BASE
+#elif defined(BOOST_CLANG) && !defined(__CUDACC__)
+#if __has_feature(is_empty) && __has_feature(is_final)
+#define BOOST_DETAIL_EMPTY_VALUE_BASE
+#endif
+#endif
+
+namespace boost {
+
+template<class T>
+struct use_empty_value_base {
+    enum {
+#if defined(BOOST_DETAIL_EMPTY_VALUE_BASE)
+        value = __is_empty(T) && !__is_final(T)
+#else
+        value = false
+#endif
+    };
+};
+
+struct empty_init_t { };
+
+template<class T, unsigned N = 0, bool E = use_empty_value_base<T>::value>
+class empty_value {
+public:
+#if !defined(BOOST_NO_CXX11_DEFAULTED_FUNCTIONS)
+    empty_value() = default;
+#else
+    empty_value() { }
+#endif
+
+    empty_value(empty_init_t)
+        : value_() { }
+
+#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+    template<class... Args>
+    explicit empty_value(empty_init_t, Args&&... args)
+        : value_(std::forward<Args>(args)...) { }
+#else
+    template<class U>
+    empty_value(empty_init_t, U&& value)
+        : value_(std::forward<U>(value)) { }
+#endif
+#else
+    template<class U>
+    empty_value(empty_init_t, const U& value)
+        : value_(value) { }
+#endif
+
+    const T& get() const BOOST_NOEXCEPT {
+        return value_;
+    }
+
+    T& get() BOOST_NOEXCEPT {
+        return value_;
+    }
+
+private:
+    T value_;
+};
+
+#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
+template<class T, unsigned N>
+class empty_value<T, N, true>
+    : T {
+public:
+#if !defined(BOOST_NO_CXX11_DEFAULTED_FUNCTIONS)
+    empty_value() = default;
+#else
+    empty_value() { }
+#endif
+
+    empty_value(empty_init_t)
+        : T() { }
+
+#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+    template<class... Args>
+    explicit empty_value(empty_init_t, Args&&... args)
+        : T(std::forward<Args>(args)...) { }
+#else
+    template<class U>
+    empty_value(empty_init_t, U&& value)
+        : T(std::forward<U>(value)) { }
+#endif
+#else
+    template<class U>
+    empty_value(empty_init_t, const U& value)
+        : T(value) { }
+#endif
+
+    const T& get() const BOOST_NOEXCEPT {
+        return *this;
+    }
+
+    T& get() BOOST_NOEXCEPT {
+        return *this;
+    }
+};
+#endif
+
+} /* boost */
+
+#endif

include/boost/core/exchange.hpp

@@ -0,0 +1,49 @@
+/*
+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)
+*/
+#ifndef BOOST_CORE_EXCHANGE_HPP
+#define BOOST_CORE_EXCHANGE_HPP
+
+#include <boost/config.hpp>
+#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+#include <boost/config/workaround.hpp>
+#include <utility>
+#endif
+
+namespace boost {
+
+#if defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+template<class T, class U>
+inline T exchange(T& t, const U& u)
+{
+    T v = t;
+    t = u;
+    return v;
+}
+#else
+#if BOOST_WORKAROUND(BOOST_MSVC, < 1800)
+template<class T, class U>
+inline T exchange(T& t, U&& u)
+{
+    T v = std::move(t);
+    t = std::forward<U>(u);
+    return v;
+}
+#else
+template<class T, class U = T>
+BOOST_CXX14_CONSTEXPR inline T exchange(T& t, U&& u)
+{
+    T v = std::move(t);
+    t = std::forward<U>(u);
+    return v;
+}
+#endif
+#endif
+
+} /* boost */
+
+#endif

include/boost/core/explicit_operator_bool.hpp

@@ -19,6 +19,7 @@
 #define BOOST_CORE_EXPLICIT_OPERATOR_BOOL_HPP
 
 #include <boost/config.hpp>
+#include <boost/config/workaround.hpp>
 
 #ifdef BOOST_HAS_PRAGMA_ONCE
 #pragma once
@@ -52,6 +53,8 @@
         return !this->operator! ();\
     }
 
+#if !BOOST_WORKAROUND(BOOST_GCC, < 40700)
+
 /*!
  * \brief The macro defines a constexpr explicit operator of conversion to \c bool
  *
@@ -65,6 +68,12 @@
         return !this->operator! ();\
     }
 
+#else
+
+#define BOOST_CONSTEXPR_EXPLICIT_OPERATOR_BOOL() BOOST_EXPLICIT_OPERATOR_BOOL_NOEXCEPT()
+
+#endif
+
 #else // !defined(BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS)
 
 #if (defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x530)) && !defined(BOOST_NO_COMPILER_CONFIG)

include/boost/core/lightweight_test.hpp

@@ -14,15 +14,21 @@
 //  Copyright (2) Beman Dawes 2010, 2011
 //  Copyright (3) Ion Gaztanaga 2013
 //
+//  Copyright 2018 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/assert.hpp>
-#include <boost/current_function.hpp>
 #include <boost/core/no_exceptions_support.hpp>
+#include <boost/current_function.hpp>
 #include <iostream>
+#include <iterator>
+#include <cstdlib>
+#include <cstring>
+#include <cstddef>
 
 //  IDE's like Visual Studio perform better if output goes to std::cout or
 //  some other stream, so allow user to configure output stream:
@@ -36,29 +42,52 @@ namespace boost
 namespace detail
 {
 
-struct report_errors_reminder
-{
-    bool called_report_errors_function;
-
-    report_errors_reminder() : called_report_errors_function(false) {}
-
-    ~report_errors_reminder()
-    {
-        BOOST_ASSERT(called_report_errors_function);  // verify report_errors() was called  
+class test_result {
+public:
+    test_result()
+        : report_(false)
+        , errors_(0) {
+#if defined(_MSC_VER)
+        ::_set_abort_behavior(0, _WRITE_ABORT_MSG | _CALL_REPORTFAULT);
+#endif
     }
+
+    ~test_result() {
+        if (!report_) {
+            BOOST_LIGHTWEIGHT_TEST_OSTREAM << "main() should return report_errors()" << std::endl;
+
+#if defined(_MSC_VER)
+            ::_exit( 3 );
+#elif defined(__MINGW32__) && !defined(__MINGW64_VERSION_MAJOR)
+            std::abort();
+#else
+            ::_Exit( 3 );
+#endif
+        }
+    }
+
+    int& errors() {
+        return errors_;
+    }
+
+    void done() {
+        report_ = true;
+    }
+
+private:
+    bool report_;
+    int errors_;
 };
 
-inline report_errors_reminder& report_errors_remind()
+inline test_result& test_results()
 {
-    static report_errors_reminder r;
-    return r;
+    static test_result instance;
+    return instance;
 }
 
-inline int & test_errors()
+inline int& test_errors()
 {
-    static int x = 0;
-    report_errors_remind();
-    return x;
+    return test_results().errors();
 }
 
 inline void test_failed_impl(char const * expr, char const * file, int line, char const * function)
@@ -66,7 +95,7 @@ inline void test_failed_impl(char const * expr, char const * file, int line, cha
     BOOST_LIGHTWEIGHT_TEST_OSTREAM
       << file << "(" << line << "): test '" << expr << "' failed in function '"
       << function << "'" << std::endl;
-    ++test_errors();
+    ++test_results().errors();
 }
 
 inline void error_impl(char const * msg, char const * file, int line, char const * function)
@@ -74,7 +103,7 @@ inline void error_impl(char const * msg, char const * file, int line, char const
     BOOST_LIGHTWEIGHT_TEST_OSTREAM
       << file << "(" << line << "): " << msg << " in function '"
       << function << "'" << std::endl;
-    ++test_errors();
+    ++test_results().errors();
 }
 
 inline void throw_failed_impl(char const * excep, char const * file, int line, char const * function)
@@ -82,51 +111,281 @@ inline void throw_failed_impl(char const * excep, char const * file, int line, c
    BOOST_LIGHTWEIGHT_TEST_OSTREAM
     << file << "(" << line << "): Exception '" << excep << "' not thrown in function '"
     << function << "'" << std::endl;
-   ++test_errors();
+   ++test_results().errors();
 }
 
-template<class T, class U> inline void test_eq_impl( char const * expr1, char const * expr2,
-  char const * file, int line, char const * function, T const & t, U const & u )
+// In the comparisons below, it is possible that T and U are signed and unsigned integer types, which generates warnings in some compilers.
+// A cleaner fix would require common_type trait or some meta-programming, which would introduce a dependency on Boost.TypeTraits. To avoid
+// the dependency we just disable the warnings.
+#if defined(_MSC_VER)
+# pragma warning(push)
+# pragma warning(disable: 4389)
+#elif defined(__clang__) && defined(__has_warning)
+# if __has_warning("-Wsign-compare")
+#  pragma clang diagnostic push
+#  pragma clang diagnostic ignored "-Wsign-compare"
+# endif
+#elif defined(__GNUC__) && !(defined(__INTEL_COMPILER) || defined(__ICL) || defined(__ICC) || defined(__ECC)) && (__GNUC__ * 100 + __GNUC_MINOR__) >= 406
+# pragma GCC diagnostic push
+# pragma GCC diagnostic ignored "-Wsign-compare"
+#endif
+
+// specialize test output for char pointers to avoid printing as cstring
+template <class T> inline const T& test_output_impl(const T& v) { return v; }
+inline const void* test_output_impl(const char* v) { return v; }
+inline const void* test_output_impl(const unsigned char* v) { return v; }
+inline const void* test_output_impl(const signed char* v) { return v; }
+inline const void* test_output_impl(char* v) { return v; }
+inline const void* test_output_impl(unsigned char* v) { return v; }
+inline const void* test_output_impl(signed char* v) { return v; }
+template<class T> inline const void* test_output_impl(T volatile* v) { return const_cast<T*>(v); }
+
+#if !defined( BOOST_NO_CXX11_NULLPTR )
+inline const void* test_output_impl(std::nullptr_t) { return nullptr; }
+#endif
+
+struct lw_test_eq {
+    template <typename T, typename U>
+    bool operator()(const T& t, const U& u) const { return t == u; }
+    static const char* op() { return "=="; }
+};
+
+struct lw_test_ne {
+    template <typename T, typename U>
+    bool operator()(const T& t, const U& u) const { return t != u; }
+    static const char* op() { return "!="; }
+};
+
+struct lw_test_lt {
+    template <typename T, typename U>
+    bool operator()(const T& t, const U& u) const { return t < u; }
+    static const char* op() { return "<"; }
+};
+
+struct lw_test_le {
+    template <typename T, typename U>
+    bool operator()(const T& t, const U& u) const { return t <= u; }
+    static const char* op() { return "<="; }
+};
+
+struct lw_test_gt {
+    template <typename T, typename U>
+    bool operator()(const T& t, const U& u) const { return t > u; }
+    static const char* op() { return ">"; }
+};
+
+struct lw_test_ge {
+    template <typename T, typename U>
+    bool operator()(const T& t, const U& u) const { return t >= u; }
+    static const char* op() { return ">="; }
+};
+
+template<class BinaryPredicate, class T, class U>
+inline void test_with_impl(BinaryPredicate pred, char const * expr1, char const * expr2,
+                           char const * file, int line, char const * function,
+                           T const & t, U const & u)
 {
-    if( t == u )
+    if( pred(t, u) )
     {
-        report_errors_remind();
+        test_results();
     }
     else
     {
         BOOST_LIGHTWEIGHT_TEST_OSTREAM
-            << file << "(" << line << "): test '" << expr1 << " == " << expr2
-            << "' failed in function '" << function << "': "
-            << "'" << t << "' != '" << u << "'" << std::endl;
-        ++test_errors();
+            << file << "(" << line << "): test '" << expr1 << " " << pred.op() << " " << expr2
+            << "' ('" << test_output_impl(t) << "' " << pred.op() << " '" << test_output_impl(u)
+            << "') failed in function '" << function << "'" << std::endl;
+        ++test_results().errors();
     }
 }
 
-template<class T, class U> inline void test_ne_impl( char const * expr1, char const * expr2,
-  char const * file, int line, char const * function, T const & t, U const & u )
+inline void test_cstr_eq_impl( char const * expr1, char const * expr2,
+  char const * file, int line, char const * function, char const * const t, char const * const u )
 {
-    if( t != u )
+    if( std::strcmp(t, u) == 0 )
     {
-        report_errors_remind();
+        test_results();
     }
     else
     {
         BOOST_LIGHTWEIGHT_TEST_OSTREAM
-            << file << "(" << line << "): test '" << expr1 << " != " << expr2
-            << "' failed in function '" << function << "': "
-            << "'" << t << "' == '" << u << "'" << std::endl;
-        ++test_errors();
+            << file << "(" << line << "): test '" << expr1 << " == " << expr2 << "' ('" << t
+            << "' == '" << u << "') failed in function '" << function << "'" << std::endl;
+        ++test_results().errors();
     }
 }
 
+inline void test_cstr_ne_impl( char const * expr1, char const * expr2,
+  char const * file, int line, char const * function, char const * const t, char const * const u )
+{
+    if( std::strcmp(t, u) != 0 )
+    {
+        test_results();
+    }
+    else
+    {
+        BOOST_LIGHTWEIGHT_TEST_OSTREAM
+            << file << "(" << line << "): test '" << expr1 << " != " << expr2 << "' ('" << t
+            << "' != '" << u << "') failed in function '" << function << "'" << std::endl;
+        ++test_results().errors();
+    }
+}
+
+template<class FormattedOutputFunction, class InputIterator1, class InputIterator2>
+void test_all_eq_impl(FormattedOutputFunction& output,
+                      char const * file, int line, char const * function,
+                      InputIterator1 first_begin, InputIterator1 first_end,
+                      InputIterator2 second_begin, InputIterator2 second_end)
+{
+    InputIterator1 first_it = first_begin;
+    InputIterator2 second_it = second_begin;
+    typename std::iterator_traits<InputIterator1>::difference_type first_index = 0;
+    typename std::iterator_traits<InputIterator2>::difference_type second_index = 0;
+    std::size_t error_count = 0;
+    const std::size_t max_count = 8;
+    do
+    {
+        while ((first_it != first_end) && (second_it != second_end) && (*first_it == *second_it))
+        {
+            ++first_it;
+            ++second_it;
+            ++first_index;
+            ++second_index;
+        }
+        if ((first_it == first_end) || (second_it == second_end))
+        {
+            break; // do-while
+        }
+        if (error_count == 0)
+        {
+            output << file << "(" << line << "): Container contents differ in function '" << function << "':";
+        }
+        else if (error_count >= max_count)
+        {
+            output << " ...";
+            break;
+        }
+        output << " [" << first_index << "] '" << test_output_impl(*first_it) << "' != '" << test_output_impl(*second_it) << "'";
+        ++first_it;
+        ++second_it;
+        ++first_index;
+        ++second_index;
+        ++error_count;
+    } while (first_it != first_end);
+
+    first_index += std::distance(first_it, first_end);
+    second_index += std::distance(second_it, second_end);
+    if (first_index != second_index)
+    {
+        if (error_count == 0)
+        {
+            output << file << "(" << line << "): Container sizes differ in function '" << function << "': size(" << first_index << ") != size(" << second_index << ")";
+        }
+        else
+        {
+            output << " [*] size(" << first_index << ") != size(" << second_index << ")";
+        }
+        ++error_count;
+    }
+
+    if (error_count == 0)
+    {
+        test_results();
+    }
+    else
+    {
+        output << std::endl;
+        ++test_results().errors();
+    }
+}
+
+template<class FormattedOutputFunction, class InputIterator1, class InputIterator2, typename BinaryPredicate>
+void test_all_with_impl(FormattedOutputFunction& output,
+                        char const * file, int line, char const * function,
+                        InputIterator1 first_begin, InputIterator1 first_end,
+                        InputIterator2 second_begin, InputIterator2 second_end,
+                        BinaryPredicate predicate)
+{
+    InputIterator1 first_it = first_begin;
+    InputIterator2 second_it = second_begin;
+    typename std::iterator_traits<InputIterator1>::difference_type first_index = 0;
+    typename std::iterator_traits<InputIterator2>::difference_type second_index = 0;
+    std::size_t error_count = 0;
+    const std::size_t max_count = 8;
+    do
+    {
+        while ((first_it != first_end) && (second_it != second_end) && predicate(*first_it, *second_it))
+        {
+            ++first_it;
+            ++second_it;
+            ++first_index;
+            ++second_index;
+        }
+        if ((first_it == first_end) || (second_it == second_end))
+        {
+            break; // do-while
+        }
+        if (error_count == 0)
+        {
+            output << file << "(" << line << "): Container contents differ in function '" << function << "':";
+        }
+        else if (error_count >= max_count)
+        {
+            output << " ...";
+            break;
+        }
+        output << " [" << first_index << "]";
+        ++first_it;
+        ++second_it;
+        ++first_index;
+        ++second_index;
+        ++error_count;
+    } while (first_it != first_end);
+
+    first_index += std::distance(first_it, first_end);
+    second_index += std::distance(second_it, second_end);
+    if (first_index != second_index)
+    {
+        if (error_count == 0)
+        {
+            output << file << "(" << line << "): Container sizes differ in function '" << function << "': size(" << first_index << ") != size(" << second_index << ")";
+        }
+        else
+        {
+            output << " [*] size(" << first_index << ") != size(" << second_index << ")";
+        }
+        ++error_count;
+    }
+
+    if (error_count == 0)
+    {
+        test_results();
+    }
+    else
+    {
+        output << std::endl;
+        ++test_results().errors();
+    }
+}
+
+#if defined(_MSC_VER)
+# pragma warning(pop)
+#elif defined(__clang__) && defined(__has_warning)
+# if __has_warning("-Wsign-compare")
+#  pragma clang diagnostic pop
+# endif
+#elif defined(__GNUC__) && !(defined(__INTEL_COMPILER) || defined(__ICL) || defined(__ICC) || defined(__ECC)) && (__GNUC__ * 100 + __GNUC_MINOR__) >= 406
+# pragma GCC diagnostic pop
+#endif
+
 } // namespace detail
 
 inline int report_errors()
 {
-    boost::detail::report_errors_remind().called_report_errors_function = true;
-
-    int errors = boost::detail::test_errors();
+    boost::detail::test_result& result = boost::detail::test_results();
+    result.done();
 
+    int errors = result.errors();
     if( errors == 0 )
     {
         BOOST_LIGHTWEIGHT_TEST_OSTREAM
@@ -143,12 +402,24 @@ inline int report_errors()
 
 } // namespace boost
 
-#define BOOST_TEST(expr) ((expr)? (void)0: ::boost::detail::test_failed_impl(#expr, __FILE__, __LINE__, BOOST_CURRENT_FUNCTION))
+#define BOOST_TEST(expr) ((expr)? (void)::boost::detail::test_results(): ::boost::detail::test_failed_impl(#expr, __FILE__, __LINE__, BOOST_CURRENT_FUNCTION))
+#define BOOST_TEST_NOT(expr) BOOST_TEST(!(expr))
 
 #define BOOST_ERROR(msg) ( ::boost::detail::error_impl(msg, __FILE__, __LINE__, BOOST_CURRENT_FUNCTION) )
 
-#define BOOST_TEST_EQ(expr1,expr2) ( ::boost::detail::test_eq_impl(#expr1, #expr2, __FILE__, __LINE__, BOOST_CURRENT_FUNCTION, expr1, expr2) )
-#define BOOST_TEST_NE(expr1,expr2) ( ::boost::detail::test_ne_impl(#expr1, #expr2, __FILE__, __LINE__, BOOST_CURRENT_FUNCTION, expr1, expr2) )
+#define BOOST_TEST_EQ(expr1,expr2) ( ::boost::detail::test_with_impl(::boost::detail::lw_test_eq(), #expr1, #expr2, __FILE__, __LINE__, BOOST_CURRENT_FUNCTION, expr1, expr2) )
+#define BOOST_TEST_NE(expr1,expr2) ( ::boost::detail::test_with_impl(::boost::detail::lw_test_ne(), #expr1, #expr2, __FILE__, __LINE__, BOOST_CURRENT_FUNCTION, expr1, expr2) )
+
+#define BOOST_TEST_LT(expr1,expr2) ( ::boost::detail::test_with_impl(::boost::detail::lw_test_lt(), #expr1, #expr2, __FILE__, __LINE__, BOOST_CURRENT_FUNCTION, expr1, expr2) )
+#define BOOST_TEST_LE(expr1,expr2) ( ::boost::detail::test_with_impl(::boost::detail::lw_test_le(), #expr1, #expr2, __FILE__, __LINE__, BOOST_CURRENT_FUNCTION, expr1, expr2) )
+#define BOOST_TEST_GT(expr1,expr2) ( ::boost::detail::test_with_impl(::boost::detail::lw_test_gt(), #expr1, #expr2, __FILE__, __LINE__, BOOST_CURRENT_FUNCTION, expr1, expr2) )
+#define BOOST_TEST_GE(expr1,expr2) ( ::boost::detail::test_with_impl(::boost::detail::lw_test_ge(), #expr1, #expr2, __FILE__, __LINE__, BOOST_CURRENT_FUNCTION, expr1, expr2) )
+
+#define BOOST_TEST_CSTR_EQ(expr1,expr2) ( ::boost::detail::test_cstr_eq_impl(#expr1, #expr2, __FILE__, __LINE__, BOOST_CURRENT_FUNCTION, expr1, expr2) )
+#define BOOST_TEST_CSTR_NE(expr1,expr2) ( ::boost::detail::test_cstr_ne_impl(#expr1, #expr2, __FILE__, __LINE__, BOOST_CURRENT_FUNCTION, expr1, expr2) )
+
+#define BOOST_TEST_ALL_EQ(begin1, end1, begin2, end2) ( ::boost::detail::test_all_eq_impl(BOOST_LIGHTWEIGHT_TEST_OSTREAM, __FILE__, __LINE__, BOOST_CURRENT_FUNCTION, begin1, end1, begin2, end2) )
+#define BOOST_TEST_ALL_WITH(begin1, end1, begin2, end2, predicate) ( ::boost::detail::test_all_with_impl(BOOST_LIGHTWEIGHT_TEST_OSTREAM, __FILE__, __LINE__, BOOST_CURRENT_FUNCTION, begin1, end1, begin2, end2, predicate) )
 
 #ifndef BOOST_NO_EXCEPTIONS
    #define BOOST_TEST_THROWS( EXPR, EXCEP )                    \

include/boost/core/lightweight_test_trait.hpp

@@ -31,7 +31,7 @@ template< class T > inline void test_trait_impl( char const * trait, void (*)( T
 {
     if( T::value == expected )
     {
-        report_errors_remind();
+        test_results();
     }
     else
     {
@@ -42,7 +42,7 @@ template< class T > inline void test_trait_impl( char const * trait, void (*)( T
             << "' (should have been " << ( expected? "true": "false" ) << ")"
             << std::endl;
 
-        ++test_errors();
+        ++test_results().errors();
     }
 }
 

include/boost/core/no_exceptions_support.hpp

@@ -21,7 +21,7 @@
 //----------------------------------------------------------------------
 
 #include <boost/config.hpp>
-#include <boost/detail/workaround.hpp>
+#include <boost/config/workaround.hpp>
 
 #if !(defined BOOST_NO_EXCEPTIONS)
 #    define BOOST_TRY { try

include/boost/core/noncopyable.hpp

@@ -20,7 +20,22 @@ namespace boost {
 
 namespace noncopyable_  // protection from unintended ADL
 {
-  class noncopyable
+#ifndef BOOST_NONCOPYABLE_BASE_TOKEN_DEFINED
+#define BOOST_NONCOPYABLE_BASE_TOKEN_DEFINED
+
+// noncopyable derives from base_token to enable Type Traits to detect
+// whether a type derives from noncopyable without needing the definition
+// of noncopyable itself.
+//
+// The definition of base_token is macro-guarded so that Type Trais can
+// define it locally without including this header, to avoid a dependency
+// on Core.
+
+  struct base_token {};
+
+#endif // #ifndef BOOST_NONCOPYABLE_BASE_TOKEN_DEFINED
+
+  class noncopyable: base_token
   {
   protected:
 #if !defined(BOOST_NO_CXX11_DEFAULTED_FUNCTIONS) && !defined(BOOST_NO_CXX11_NON_PUBLIC_DEFAULTED_FUNCTIONS)

include/boost/core/pointer_traits.hpp

@@ -0,0 +1,233 @@
+/*
+Copyright 2017-2018 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_POINTER_TRAITS_HPP
+#define BOOST_CORE_POINTER_TRAITS_HPP
+
+#include <boost/config.hpp>
+#if !defined(BOOST_NO_CXX11_POINTER_TRAITS)
+#include <memory>
+#else
+#include <boost/core/addressof.hpp>
+#endif
+
+namespace boost {
+
+#if !defined(BOOST_NO_CXX11_POINTER_TRAITS)
+template<class T>
+struct pointer_traits
+    : std::pointer_traits<T> {
+    template<class U>
+    struct rebind_to {
+        typedef typename std::pointer_traits<T>::template rebind<U> type;
+    };
+};
+
+template<class T>
+struct pointer_traits<T*>
+    : std::pointer_traits<T*> {
+    template<class U>
+    struct rebind_to {
+        typedef U* type;
+    };
+};
+#else
+namespace detail {
+
+template<class>
+struct ptr_void {
+    typedef void type;
+};
+
+template<class T>
+struct ptr_first;
+
+#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+template<template<class, class...> class T, class U, class... Args>
+struct ptr_first<T<U, Args...> > {
+    typedef U type;
+};
+#else
+template<template<class> class T, class U>
+struct ptr_first<T<U> > {
+    typedef U type;
+};
+
+template<template<class, class> class T, class U1, class U2>
+struct ptr_first<T<U1, U2> > {
+    typedef U1 type;
+};
+
+template<template<class, class, class> class T, class U1, class U2, class U3>
+struct ptr_first<T<U1, U2, U3> > {
+    typedef U1 type;
+};
+#endif
+
+template<class T, class = void>
+struct ptr_element {
+    typedef typename ptr_first<T>::type type;
+};
+
+template<class T>
+struct ptr_element<T, typename ptr_void<typename T::element_type>::type> {
+    typedef typename T::element_type type;
+};
+
+template<class, class = void>
+struct ptr_difference {
+    typedef std::ptrdiff_t type;
+};
+
+template<class T>
+struct ptr_difference<T,
+    typename ptr_void<typename T::difference_type>::type> {
+    typedef typename T::difference_type type;
+};
+
+template<class T, class V>
+struct ptr_transform;
+
+#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+template<template<class, class...> class T, class U, class... Args, class V>
+struct ptr_transform<T<U, Args...>, V> {
+    typedef T<V, Args...> type;
+};
+#else
+template<template<class> class T, class U, class V>
+struct ptr_transform<T<U>, V> {
+    typedef T<V> type;
+};
+
+template<template<class, class> class T, class U1, class U2, class V>
+struct ptr_transform<T<U1, U2>, V> {
+    typedef T<V, U2> type;
+};
+
+template<template<class, class, class> class T,
+    class U1, class U2, class U3, class V>
+struct ptr_transform<T<U1, U2, U3>, V> {
+    typedef T<V, U2, U3> type;
+};
+#endif
+
+template<class T, class U, class = void>
+struct ptr_rebind {
+    typedef typename ptr_transform<T, U>::type type;
+};
+
+#if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
+template<class T, class U>
+struct ptr_rebind<T, U,
+    typename ptr_void<typename T::template rebind<U> >::type> {
+    typedef typename T::template rebind<U> type;
+};
+#endif
+
+template<class T>
+struct ptr_value {
+    typedef T type;
+};
+
+template<>
+struct ptr_value<void> {
+    typedef struct { } type;
+};
+
+} /* detail */
+
+template<class T>
+struct pointer_traits {
+    typedef T pointer;
+    typedef typename detail::ptr_element<T>::type element_type;
+    typedef typename detail::ptr_difference<T>::type difference_type;
+    template<class U>
+    struct rebind_to {
+        typedef typename detail::ptr_rebind<T, U>::type type;
+    };
+#if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
+    template<class U>
+    using rebind = typename detail::ptr_rebind<T, U>::type;
+#endif
+    static pointer
+    pointer_to(typename detail::ptr_value<element_type>::type& v) {
+        return pointer::pointer_to(v);
+    }
+};
+
+template<class T>
+struct pointer_traits<T*> {
+    typedef T* pointer;
+    typedef T element_type;
+    typedef std::ptrdiff_t difference_type;
+    template<class U>
+    struct rebind_to {
+        typedef U* type;
+    };
+#if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
+    template<class U>
+    using rebind = U*;
+#endif
+    static T*
+    pointer_to(typename detail::ptr_value<T>::type& v) BOOST_NOEXCEPT {
+        return boost::addressof(v);
+    }
+};
+#endif
+
+template<class T>
+BOOST_CONSTEXPR inline T*
+to_address(T* v) BOOST_NOEXCEPT
+{
+    return v;
+}
+
+#if !defined(BOOST_NO_CXX14_RETURN_TYPE_DEDUCTION)
+namespace detail {
+
+template<class T>
+inline T*
+ptr_address(T* v, int) BOOST_NOEXCEPT
+{
+    return v;
+}
+
+template<class T>
+inline auto
+ptr_address(const T& v, int) BOOST_NOEXCEPT
+-> decltype(boost::pointer_traits<T>::to_address(v))
+{
+    return boost::pointer_traits<T>::to_address(v);
+}
+
+template<class T>
+inline auto
+ptr_address(const T& v, long) BOOST_NOEXCEPT
+{
+    return boost::detail::ptr_address(v.operator->(), 0);
+}
+
+} /* detail */
+
+template<class T>
+inline auto
+to_address(const T& v) BOOST_NOEXCEPT
+{
+    return boost::detail::ptr_address(v, 0);
+}
+#else
+template<class T>
+inline typename pointer_traits<T>::element_type*
+to_address(const T& v) BOOST_NOEXCEPT
+{
+    return boost::to_address(v.operator->());
+}
+#endif
+
+} /* boost */
+
+#endif

include/boost/core/ref.hpp

@@ -8,8 +8,8 @@
 #endif
 
 #include <boost/config.hpp>
-#include <boost/utility/addressof.hpp>
-#include <boost/detail/workaround.hpp>
+#include <boost/config/workaround.hpp>
+#include <boost/core/addressof.hpp>
 
 //
 //  ref.hpp - ref/cref, useful helper functions

include/boost/core/scoped_enum.hpp

@@ -43,7 +43,8 @@ namespace boost
    * @throws No-throws.
    */
   template <typename UnderlyingType, typename EnumType>
-  UnderlyingType underlying_cast(EnumType v)
+  inline
+  BOOST_CONSTEXPR UnderlyingType underlying_cast(EnumType v) BOOST_NOEXCEPT
   {
     return v.get_underlying_value_();
   }
@@ -61,7 +62,7 @@ namespace boost
    */
   template <typename EnumType>
   inline
-  typename EnumType::enum_type native_value(EnumType e)
+  BOOST_CONSTEXPR typename EnumType::enum_type native_value(EnumType e) BOOST_NOEXCEPT
   {
     return e.get_native_value_();
   }
@@ -75,14 +76,15 @@ namespace boost
   };
 
   template <typename UnderlyingType, typename EnumType>
-  UnderlyingType underlying_cast(EnumType v)
+  inline
+  BOOST_CONSTEXPR UnderlyingType underlying_cast(EnumType v) BOOST_NOEXCEPT
   {
     return static_cast<UnderlyingType>(v);
   }
 
   template <typename EnumType>
   inline
-  EnumType native_value(EnumType e)
+  BOOST_CONSTEXPR EnumType native_value(EnumType e) BOOST_NOEXCEPT
   {
     return e;
   }
@@ -96,7 +98,7 @@ namespace boost
 #ifndef BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS
 
 #define BOOST_SCOPED_ENUM_UT_DECLARE_CONVERSION_OPERATOR \
-     explicit operator underlying_type() const BOOST_NOEXCEPT { return get_underlying_value_(); }
+     explicit BOOST_CONSTEXPR operator underlying_type() const BOOST_NOEXCEPT { return get_underlying_value_(); }
 
 #else
 
@@ -115,8 +117,8 @@ namespace boost
         typedef void is_boost_scoped_enum_tag;                          \
         typedef UnderlyingType underlying_type;                         \
         EnumType() BOOST_NOEXCEPT {}                                    \
-        explicit EnumType(underlying_type v) BOOST_NOEXCEPT : v_(v) {}                 \
-        underlying_type get_underlying_value_() const BOOST_NOEXCEPT { return v_; }    \
+        explicit BOOST_CONSTEXPR EnumType(underlying_type v) BOOST_NOEXCEPT : v_(v) {}                 \
+        BOOST_CONSTEXPR underlying_type get_underlying_value_() const BOOST_NOEXCEPT { return v_; }    \
         BOOST_SCOPED_ENUM_UT_DECLARE_CONVERSION_OPERATOR                \
     private:                                                            \
         underlying_type v_;                                             \
@@ -125,30 +127,30 @@ namespace boost
         enum enum_type
 
 #define BOOST_SCOPED_ENUM_DECLARE_END2() \
-        enum_type get_native_value_() const BOOST_NOEXCEPT { return enum_type(v_); } \
-        friend bool operator ==(self_type lhs, self_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)==enum_type(rhs.v_); } \
-        friend bool operator ==(self_type lhs, enum_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)==rhs; } \
-        friend bool operator ==(enum_type lhs, self_type rhs) BOOST_NOEXCEPT { return lhs==enum_type(rhs.v_); } \
-        friend bool operator !=(self_type lhs, self_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)!=enum_type(rhs.v_); } \
-        friend bool operator !=(self_type lhs, enum_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)!=rhs; } \
-        friend bool operator !=(enum_type lhs, self_type rhs) BOOST_NOEXCEPT { return lhs!=enum_type(rhs.v_); } \
-        friend bool operator <(self_type lhs, self_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)<enum_type(rhs.v_); } \
-        friend bool operator <(self_type lhs, enum_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)<rhs; } \
-        friend bool operator <(enum_type lhs, self_type rhs) BOOST_NOEXCEPT { return lhs<enum_type(rhs.v_); } \
-        friend bool operator <=(self_type lhs, self_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)<=enum_type(rhs.v_); } \
-        friend bool operator <=(self_type lhs, enum_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)<=rhs; } \
-        friend bool operator <=(enum_type lhs, self_type rhs) BOOST_NOEXCEPT { return lhs<=enum_type(rhs.v_); } \
-        friend bool operator >(self_type lhs, self_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)>enum_type(rhs.v_); } \
-        friend bool operator >(self_type lhs, enum_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)>rhs; } \
-        friend bool operator >(enum_type lhs, self_type rhs) BOOST_NOEXCEPT { return lhs>enum_type(rhs.v_); } \
-        friend bool operator >=(self_type lhs, self_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)>=enum_type(rhs.v_); } \
-        friend bool operator >=(self_type lhs, enum_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)>=rhs; } \
-        friend bool operator >=(enum_type lhs, self_type rhs) BOOST_NOEXCEPT { return lhs>=enum_type(rhs.v_); } \
+        BOOST_CONSTEXPR enum_type get_native_value_() const BOOST_NOEXCEPT { return enum_type(v_); } \
+        friend BOOST_CONSTEXPR bool operator ==(self_type lhs, self_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)==enum_type(rhs.v_); } \
+        friend BOOST_CONSTEXPR bool operator ==(self_type lhs, enum_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)==rhs; } \
+        friend BOOST_CONSTEXPR bool operator ==(enum_type lhs, self_type rhs) BOOST_NOEXCEPT { return lhs==enum_type(rhs.v_); } \
+        friend BOOST_CONSTEXPR bool operator !=(self_type lhs, self_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)!=enum_type(rhs.v_); } \
+        friend BOOST_CONSTEXPR bool operator !=(self_type lhs, enum_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)!=rhs; } \
+        friend BOOST_CONSTEXPR bool operator !=(enum_type lhs, self_type rhs) BOOST_NOEXCEPT { return lhs!=enum_type(rhs.v_); } \
+        friend BOOST_CONSTEXPR bool operator <(self_type lhs, self_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)<enum_type(rhs.v_); } \
+        friend BOOST_CONSTEXPR bool operator <(self_type lhs, enum_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)<rhs; } \
+        friend BOOST_CONSTEXPR bool operator <(enum_type lhs, self_type rhs) BOOST_NOEXCEPT { return lhs<enum_type(rhs.v_); } \
+        friend BOOST_CONSTEXPR bool operator <=(self_type lhs, self_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)<=enum_type(rhs.v_); } \
+        friend BOOST_CONSTEXPR bool operator <=(self_type lhs, enum_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)<=rhs; } \
+        friend BOOST_CONSTEXPR bool operator <=(enum_type lhs, self_type rhs) BOOST_NOEXCEPT { return lhs<=enum_type(rhs.v_); } \
+        friend BOOST_CONSTEXPR bool operator >(self_type lhs, self_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)>enum_type(rhs.v_); } \
+        friend BOOST_CONSTEXPR bool operator >(self_type lhs, enum_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)>rhs; } \
+        friend BOOST_CONSTEXPR bool operator >(enum_type lhs, self_type rhs) BOOST_NOEXCEPT { return lhs>enum_type(rhs.v_); } \
+        friend BOOST_CONSTEXPR bool operator >=(self_type lhs, self_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)>=enum_type(rhs.v_); } \
+        friend BOOST_CONSTEXPR bool operator >=(self_type lhs, enum_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)>=rhs; } \
+        friend BOOST_CONSTEXPR bool operator >=(enum_type lhs, self_type rhs) BOOST_NOEXCEPT { return lhs>=enum_type(rhs.v_); } \
     };
 
 #define BOOST_SCOPED_ENUM_DECLARE_END(EnumType) \
     ; \
-    EnumType(enum_type v) BOOST_NOEXCEPT : v_(v) {}                 \
+    BOOST_CONSTEXPR EnumType(enum_type v) BOOST_NOEXCEPT : v_(v) {}                 \
     BOOST_SCOPED_ENUM_DECLARE_END2()
 
 /**

include/boost/detail/iterator.hpp

@@ -9,6 +9,9 @@
 // This header is obsolete and will be deprecated.
 
 #include <iterator>
+#if defined(__SUNPRO_CC) && (defined(__SGI_STL_PORT) || defined(_STLPORT_VERSION))
+#include <cstddef>
+#endif
 
 namespace boost
 {
@@ -19,6 +22,16 @@ namespace detail
 using std::iterator_traits;
 using std::distance;
 
+#if defined(__SUNPRO_CC) && (defined(__SGI_STL_PORT) || defined(_STLPORT_VERSION))
+// std::distance from stlport with Oracle compiler 12.4 and 12.5 fails to deduce template parameters
+// when one of the arguments is an array and the other one is a pointer.
+template< typename T, std::size_t N >
+inline typename std::iterator_traits< T* >::difference_type distance(T (&left)[N], T* right)
+{
+    return std::distance(static_cast< T* >(left), right);
+}
+#endif
+
 } // namespace detail
 
 } // namespace boost

include/boost/utility/empty_deleter.hpp

@@ -1,43 +0,0 @@
-/*
- *          Copyright Andrey Semashev 2007 - 2013.
- * 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   empty_deleter.hpp
- * \author Andrey Semashev
- * \date   22.04.2007
- *
- * This header contains an \c empty_deleter implementation. This is an empty
- * function object that receives a pointer and does nothing with it.
- * Such empty deletion strategy may be convenient, for example, when
- * constructing <tt>shared_ptr</tt>s that point to some object that should not be
- * deleted (i.e. a variable on the stack or some global singleton, like <tt>std::cout</tt>).
- */
-
-#ifndef BOOST_UTILITY_EMPTY_DELETER_HPP
-#define BOOST_UTILITY_EMPTY_DELETER_HPP
-
-#include <boost/config.hpp>
-#include <boost/core/null_deleter.hpp>
-
-#ifdef BOOST_HAS_PRAGMA_ONCE
-#pragma once
-#endif
-
-#if defined(__GNUC__)
-#pragma message "This header is deprecated, use boost/core/null_deleter.hpp instead."
-#elif defined(_MSC_VER)
-#pragma message("This header is deprecated, use boost/core/null_deleter.hpp instead.")
-#endif
-
-namespace boost {
-
-//! A deprecated name for \c null_deleter
-typedef null_deleter empty_deleter;
-
-} // namespace boost
-
-#endif // BOOST_UTILITY_EMPTY_DELETER_HPP

test/Jamfile.v2

@@ -1,17 +1,24 @@
 #  Boost.Core Library test Jamfile
 #
-#  Copyright (c) 2014 Peter Dimov
+#  Copyright (c) 2014, 2017 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
 
+import modules ;
 import testing ;
 
+# quick test (for CI)
+run quick.cpp ;
+
+# full test suite
 run addressof_test.cpp ;
 run addressof_test2.cpp ;
 run addressof_np_test.cpp ;
 run addressof_fn_test.cpp ;
+compile addressof_constexpr_test.cpp ;
+compile-fail addressof_fail_rvalue.cpp ;
 
 run checked_delete_test.cpp ;
 compile-fail checked_delete_fail.cpp ;
@@ -28,6 +35,7 @@ compile-fail ref_rv_fail4.cpp ;
 compile-fail ref_rv_fail5.cpp ;
 compile-fail ref_implicit_fail.cpp ;
 compile-fail ref_implicit_fail2.cpp ;
+run ref_cv_test.cpp ;
 
 run eif_constructors.cpp ;
 run eif_dummy_arg_disambiguation.cpp ;
@@ -60,8 +68,14 @@ 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-fail lightweight_test_fail.cpp ;
 run-fail lightweight_test_fail2.cpp ;
@@ -73,6 +87,13 @@ run-fail lightweight_test_fail7.cpp ;
 run-fail lightweight_test_fail7.cpp : : : <rtti>off : lightweight_test_fail7_no_rtti ;
 run-fail lightweight_test_fail8.cpp ;
 run-fail lightweight_test_fail8.cpp : : : <rtti>off : lightweight_test_fail8_no_rtti ;
+run-fail lightweight_test_fail9.cpp ;
+run-fail lightweight_test_fail10.cpp ;
+run-fail lightweight_test_fail11.cpp ;
+run-fail lightweight_test_lt_fail.cpp ;
+run-fail lightweight_test_le_fail.cpp ;
+run-fail lightweight_test_gt_fail.cpp ;
+run-fail lightweight_test_ge_fail.cpp ;
 
 run is_same_test.cpp ;
 
@@ -92,3 +113,19 @@ compile-fail scoped_enum_compile_fail_conv_from_int.cpp ;
 compile-fail scoped_enum_compile_fail_conv_to_int.cpp ;
 
 run underlying_type.cpp ;
+
+run pointer_traits_pointer_test.cpp ;
+run pointer_traits_element_type_test.cpp ;
+run pointer_traits_difference_type_test.cpp ;
+run pointer_traits_rebind_test.cpp ;
+run pointer_traits_pointer_to_test.cpp ;
+run to_address_test.cpp ;
+
+run exchange_test.cpp ;
+run exchange_move_test.cpp ;
+
+run empty_value_test.cpp ;
+run empty_value_size_test.cpp ;
+
+use-project /boost/core/swap : ./swap ;
+build-project ./swap ;

test/addressof_constexpr_test.cpp

@@ -0,0 +1,20 @@
+/*
+Copyright 2017 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/addressof.hpp>
+#include <boost/static_assert.hpp>
+
+#if !defined(BOOST_CORE_NO_CONSTEXPR_ADDRESSOF)
+struct Type { };
+
+static int v1 = 0;
+static Type v2 = { };
+
+BOOST_STATIC_ASSERT(boost::addressof(v1) == &v1);
+BOOST_STATIC_ASSERT(boost::addressof(v2) == &v2);
+#endif

test/addressof_fail_rvalue.cpp

@@ -0,0 +1,26 @@
+/*
+Copyright 2017 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/addressof.hpp>
+
+#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && \
+    !defined(BOOST_NO_CXX11_DELETED_FUNCTIONS)
+struct type { };
+
+inline const type function()
+{
+    return type();
+}
+
+int main()
+{
+    (void)boost::addressof(function());
+}
+#else
+#error Requires rvalue references and deleted functions
+#endif

test/eif_namespace_disambiguation.cpp

@@ -10,16 +10,19 @@
 //             Jeremiah Willcock (jewillco at osl.iu.edu)
 //             Andrew Lumsdaine (lums at osl.iu.edu)
 
-#include <boost/mpl/not.hpp>
-
+#include <boost/config.hpp>
 #include <boost/utility/enable_if.hpp>
 #include <boost/type_traits/is_arithmetic.hpp>
 #include <boost/detail/lightweight_test.hpp>
 
 using boost::enable_if;
-using boost::mpl::not_;
 using boost::is_arithmetic;
 
+template<class T> struct not_
+{
+  BOOST_STATIC_CONSTANT( bool, value = !T::value );
+};
+
 namespace A {
   template<class T>
   typename enable_if<is_arithmetic<T>, bool>::type

test/eif_no_disambiguation.cpp

@@ -10,16 +10,19 @@
 //             Jeremiah Willcock (jewillco at osl.iu.edu)
 //             Andrew Lumsdaine (lums at osl.iu.edu)
 
-#include <boost/mpl/not.hpp>
-
+#include <boost/config.hpp>
 #include <boost/utility/enable_if.hpp>
 #include <boost/type_traits/is_arithmetic.hpp>
 #include <boost/detail/lightweight_test.hpp>
 
-using boost::mpl::not_;
 using boost::enable_if;
 using boost::is_arithmetic;
 
+template<class T> struct not_
+{
+  BOOST_STATIC_CONSTANT( bool, value = !T::value );
+};
+
 template<class T>
 typename enable_if<is_arithmetic<T>, bool>::type
 arithmetic_object(T t) { return true; }

test/empty_value_size_test.cpp

@@ -0,0 +1,60 @@
+/*
+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/config.hpp>
+#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
+#include <boost/core/empty_value.hpp>
+#include <boost/core/lightweight_test.hpp>
+
+struct T1 { };
+
+struct S1
+    : boost::empty_value<T1, 0, true> { };
+
+struct T2 {
+    int value;
+};
+
+struct S2
+    : boost::empty_value<T1, 0, true>
+    , boost::empty_value<T2, 1, true> { };
+
+struct S3
+    : boost::empty_value<T1, 0, false>
+    , boost::empty_value<T2, 1, true> { };
+
+struct T3 { };
+
+struct S4
+    : boost::empty_value<T1, 0, true>
+    , boost::empty_value<T3, 1, true> { };
+
+struct S5
+    : boost::empty_value<T1, 0, false>
+    , boost::empty_value<T3, 1, false> { };
+
+struct S6
+    : boost::empty_value<T1, 0, true>
+    , boost::empty_value<T2, 1, true>
+    , boost::empty_value<T3, 2, true> { };
+
+int main()
+{
+    BOOST_TEST(sizeof(S1) == sizeof(T1));
+    BOOST_TEST(sizeof(S2) == sizeof(T2));
+    BOOST_TEST(sizeof(S3) > sizeof(T2));
+    BOOST_TEST(sizeof(S4) == sizeof(T1));
+    BOOST_TEST(sizeof(S5) > sizeof(T1));
+    BOOST_TEST(sizeof(S6) == sizeof(T2));
+    return boost::report_errors();
+}
+#else
+int main()
+{
+    return 0;
+}
+#endif

test/empty_value_test.cpp

@@ -0,0 +1,76 @@
+/*
+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>
+
+struct empty {
+    operator bool() const {
+        return false;
+    }
+    operator bool() {
+        return true;
+    }
+};
+
+class type {
+public:
+    type()
+        : value_(false) { }
+    explicit type(bool value)
+        : value_(value) { }
+    operator bool() const {
+        return value_;
+    }
+private:
+    bool value_;
+};
+
+void test_bool()
+{
+    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());
+    v2.get() = false;
+    BOOST_TEST(!v2.get());
+}
+
+void test_empty()
+{
+    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());
+    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(), true);
+    BOOST_TEST(v1.get());
+    boost::empty_value<type> v2;
+    BOOST_TEST(!v2.get());
+    v2 = v1;
+    BOOST_TEST(v2.get());
+    v2.get() = type();
+    BOOST_TEST(!v2.get());
+}
+
+int main()
+{
+    test_bool();
+    test_empty();
+    test_type();
+    return boost::report_errors();
+}

test/exchange_move_test.cpp

@@ -0,0 +1,100 @@
+/*
+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/config.hpp>
+#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+#include <boost/core/exchange.hpp>
+#include <boost/core/lightweight_test.hpp>
+
+class C1 {
+public:
+    explicit C1(int i)
+        : i_(i) { }
+    C1(C1&& c)
+        : i_(c.i_) { }
+    C1& operator=(C1&& c) {
+        i_ = c.i_;
+        return *this;
+    }
+    int i() const {
+        return i_;
+    }
+private:
+    C1(const C1&);
+    C1& operator=(const C1&);
+    int i_;
+};
+
+void test1()
+{
+    C1 x(1);
+    BOOST_TEST(boost::exchange(x, C1(2)).i() == 1);
+    BOOST_TEST(x.i() == 2);
+}
+
+class C2 {
+public:
+    explicit C2(int i)
+        : i_(i) { }
+    operator C1() const {
+        return C1(i_);
+    }
+    int i() const {
+        return i_;
+    }
+private:
+    C2(const C2&);
+    C2& operator=(const C2&);
+    int i_;
+};
+
+void test2()
+{
+    C1 x(1);
+    BOOST_TEST(boost::exchange(x, C2(2)).i() == 1);
+    BOOST_TEST(x.i() == 2);
+}
+
+class C3 {
+public:
+    explicit C3(int i)
+        : i_(i) { }
+    C3(C3&& c)
+        : i_(c.i_) { }
+    C3& operator=(C1&& c) {
+        i_ = c.i();
+        return *this;
+    }
+    int i() const {
+        return i_;
+    }
+private:
+    C3(const C3&);
+    C3& operator=(const C3&);
+    int i_;
+};
+
+void test3()
+{
+    C3 x(1);
+    BOOST_TEST(boost::exchange(x, C1(2)).i() == 1);
+    BOOST_TEST(x.i() == 2);
+}
+
+int main()
+{
+    test1();
+    test2();
+    test3();
+    return boost::report_errors();
+}
+#else
+int main()
+{
+    return 0;
+}
+#endif

test/exchange_test.cpp

@@ -0,0 +1,89 @@
+/*
+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/exchange.hpp>
+#include <boost/core/lightweight_test.hpp>
+
+void test1()
+{
+    int i = 1;
+    BOOST_TEST(boost::exchange(i, 2) == 1);
+    BOOST_TEST(i == 2);
+}
+
+class C1 {
+public:
+    explicit C1(int i)
+        : i_(i) { }
+    int i() const {
+        return i_;
+    }
+private:
+    int i_;
+};
+
+void test2()
+{
+    C1 x(1);
+    BOOST_TEST(boost::exchange(x, C1(2)).i() == 1);
+    BOOST_TEST(x.i() == 2);
+}
+
+class C2 {
+public:
+    explicit C2(int i)
+        : i_(i) { }
+    operator C1() const {
+        return C1(i_);
+    }
+    int i() const {
+        return i_;
+    }
+private:
+    int i_;
+};
+
+void test3()
+{
+    C1 x(1);
+    BOOST_TEST(boost::exchange(x, C2(2)).i() == 1);
+    BOOST_TEST(x.i() == 2);
+}
+
+class C3 {
+public:
+    explicit C3(int i)
+        : i_(i) { }
+    C3(const C3& c)
+        : i_(c.i_) { }
+    C3& operator=(const C1& c) {
+        i_ = c.i();
+        return *this;
+    }
+    int i() const {
+        return i_;
+    }
+private:
+    C3& operator=(const C3&);
+    int i_;
+};
+
+void test4()
+{
+    C3 x(1);
+    BOOST_TEST(boost::exchange(x, C1(2)).i() == 1);
+    BOOST_TEST(x.i() == 2);
+}
+
+int main()
+{
+    test1();
+    test2();
+    test3();
+    test4();
+    return boost::report_errors();
+}

test/explicit_operator_bool_compile_fail_conv_int.cpp

@@ -35,6 +35,7 @@ int main(int, char*[])
 {
     checkable val;
     int n = val;
+    (void)n;
 
     return 0;
 }

test/explicit_operator_bool_compile_fail_conv_pvoid.cpp

@@ -35,6 +35,7 @@ int main(int, char*[])
 {
     checkable val;
     void* p = val;
+    (void)p;
 
     return 0;
 }

test/get_pointer_test.cpp

@@ -1,7 +1,7 @@
 //
 // get_pointer_test.cpp
 //
-// Copyright 2014 Peter Dimov
+// Copyright 2014, 2017 Peter Dimov
 //
 // Distributed under the Boost Software License, Version 1.0.
 // See accompanying file LICENSE_1_0.txt or copy at
@@ -27,11 +27,25 @@ int main()
         delete p;
     }
 
+    {
+        X * p = 0;
+        BOOST_TEST( get_pointer( p ) == 0 );
+    }
+
+#if !defined( BOOST_NO_AUTO_PTR )
+
     {
         std::auto_ptr< X > p( new X );
         BOOST_TEST( get_pointer( p ) == p.get() );
     }
 
+    {
+        std::auto_ptr< X > p;
+        BOOST_TEST( get_pointer( p ) == 0 );
+    }
+
+#endif
+
 #if !defined( BOOST_NO_CXX11_SMART_PTR )
 
     {
@@ -39,11 +53,21 @@ int main()
         BOOST_TEST( get_pointer( p ) == p.get() );
     }
 
+    {
+        std::unique_ptr< X > p;
+        BOOST_TEST( get_pointer( p ) == 0 );
+    }
+
     {
         std::shared_ptr< X > p( new X );
         BOOST_TEST( get_pointer( p ) == p.get() );
     }
 
+    {
+        std::shared_ptr< X > p;
+        BOOST_TEST( get_pointer( p ) == 0 );
+    }
+
 #endif
 
     return boost::report_errors();

test/lightweight_test_all_eq_test.cpp

@@ -0,0 +1,124 @@
+//
+// Negative test for BOOST_TEST_ALL_EQ
+//
+// Copyright (c) 2017 Bjorn Reese
+//
+// 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 <vector>
+#include <set>
+#include <boost/core/lightweight_test.hpp>
+
+int main()
+{
+    int test_cases = 0;
+
+    // Array
+
+    {
+        int x[] = { 1 };
+        int y[] = { 1, 2 };
+        BOOST_TEST_ALL_EQ( x, x + sizeof(x)/sizeof(x[0]), y, y + sizeof(y)/sizeof(y[0]) );
+        ++test_cases;
+    }
+
+    {
+        int x[] = { 1, 2 };
+        int y[] = { 1 };
+        BOOST_TEST_ALL_EQ( x, x + sizeof(x)/sizeof(x[0]), y, y + sizeof(y)/sizeof(y[0]) );
+        ++test_cases;
+    }
+
+    {
+        int x[] = { 2 };
+        int y[] = { 1, 2 };
+        BOOST_TEST_ALL_EQ( x, x + sizeof(x)/sizeof(x[0]), y, y + sizeof(y)/sizeof(y[0]) );
+        ++test_cases;
+    }
+
+    {
+        int x[] = { 1, 2, 3, 4 };
+        int y[] = { 1, 3, 2, 4 };
+        BOOST_TEST_ALL_EQ( x, x + sizeof(x)/sizeof(x[0]), y, y + sizeof(y)/sizeof(y[0]) );
+        ++test_cases;
+    }
+
+    // Vector
+
+    {
+        std::vector<int> x, y;
+        x.push_back( 1 );
+        BOOST_TEST_ALL_EQ( x.begin(), x.end(), y.begin(), y.end() );
+        ++test_cases;
+    }
+
+    {
+        std::vector<int> x, y;
+        y.push_back( 1 );
+        BOOST_TEST_ALL_EQ( x.begin(), x.end(), y.begin(), y.end() );
+        ++test_cases;
+    }
+
+    {
+        std::vector<int> x, y;
+        x.push_back( 1 ); x.push_back( 2 ); x.push_back( 3 ); x.push_back( 4 );
+        y.push_back( 1 ); y.push_back( 3 ); y.push_back( 2 ); y.push_back( 4 );
+        BOOST_TEST_ALL_EQ( x.begin(), x.end(), y.begin(), y.end() );
+        ++test_cases;
+    }
+
+    {
+        std::vector<float> x, y;
+        x.push_back( 1.0f ); x.push_back( 2.0f ); x.push_back( 3.0f ); x.push_back( 4.0f );
+        y.push_back( 4.0f ); y.push_back( 2.0f ); y.push_back( 3.0f ); y.push_back( 1.0f );
+        BOOST_TEST_ALL_EQ( x.begin(), x.end(), y.begin(), y.end() );
+        ++test_cases;
+    }
+
+    {
+        std::vector<int> x, y;
+        x.push_back( 1 ); x.push_back( 2 ); x.push_back( 3 );
+        y.push_back( 1 ); y.push_back( 3 ); y.push_back( 2 ); y.push_back( 4 );
+        BOOST_TEST_ALL_EQ( x.begin(), x.end(), y.begin(), y.end() );
+        ++test_cases;
+    }
+
+    {
+        std::vector<int> x, y;
+        x.push_back( 1 ); x.push_back( 2 ); x.push_back( 3 ); x.push_back( 4 );
+        y.push_back( 1 ); y.push_back( 3 ); y.push_back( 2 );;
+        BOOST_TEST_ALL_EQ( x.begin(), x.end(), y.begin(), y.end() );
+        ++test_cases;
+    }
+
+    // Set
+
+    {
+        std::set<int> x, y;
+        x.insert(1);
+        y.insert(1); y.insert(3);
+        BOOST_TEST_ALL_EQ( x.begin(), x.end(), y.begin(), y.end() );
+        ++test_cases;
+    }
+
+    {
+        std::set<int> x, y;
+        x.insert(1); x.insert(2);
+        y.insert(1);
+        BOOST_TEST_ALL_EQ( x.begin(), x.end(), y.begin(), y.end() );
+        ++test_cases;
+    }
+
+    {
+        std::set<int> x, y;
+        x.insert(1); x.insert(2);
+        y.insert(1); y.insert(3);
+        BOOST_TEST_ALL_EQ( x.begin(), x.end(), y.begin(), y.end() );
+        ++test_cases;
+    }
+
+    return !boost::report_errors();
+}

test/lightweight_test_all_with_fail.cpp

@@ -0,0 +1,105 @@
+//
+// Negative est for BOOST_TEST_ALL_WITH
+//
+// Copyright (c) 2017 Bjorn Reese
+//
+// 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 <cmath>
+#include <functional>
+#include <vector>
+#include <boost/core/lightweight_test.hpp>
+
+int fail_vector()
+{
+    int test_cases = 0;
+
+    {
+        std::vector<int> x, y;
+        x.push_back( 1 );
+        BOOST_TEST_ALL_WITH( x.begin(), x.end(), y.begin(), y.end(), std::equal_to<int>() );
+        ++test_cases;
+    }
+
+    {
+        std::vector<int> x, y;
+        y.push_back( 1 );
+        BOOST_TEST_ALL_WITH( x.begin(), x.end(), y.begin(), y.end(), std::equal_to<int>() );
+        ++test_cases;
+    }
+
+    {
+        std::vector<int> x, y;
+        x.push_back( 1 ); x.push_back( 2 ); x.push_back( 3 ); x.push_back( 4 );
+        y.push_back( 1 ); y.push_back( 2 ); y.push_back( 3 );
+        BOOST_TEST_ALL_WITH( x.begin(), x.end(), y.begin(), y.end(), std::equal_to<int>() );
+        ++test_cases;
+    }
+
+    {
+        std::vector<int> x, y;
+        x.push_back( 1 ); x.push_back( 2 ); x.push_back( 3 );
+        y.push_back( 1 ); y.push_back( 2 ); y.push_back( 3 ); y.push_back( 4 );
+        BOOST_TEST_ALL_WITH( x.begin(), x.end(), y.begin(), y.end(), std::equal_to<int>() );
+        ++test_cases;
+    }
+
+    {
+        std::vector<int> x, y;
+        x.push_back( 1 ); x.push_back( 2 ); x.push_back( 3 ); x.push_back( 4 );
+        y.push_back( 1 ); y.push_back( 3 ); y.push_back( 2 ); y.push_back( 4 );
+        BOOST_TEST_ALL_WITH( x.begin(), x.end(), y.begin(), y.end(), std::equal_to<int>() );
+        ++test_cases;
+    }
+
+    {
+        std::vector<int> x, y;
+        x.push_back( 1 ); x.push_back( 2 ); x.push_back( 3 ); x.push_back( 4 );
+        y.push_back( 1 ); y.push_back( 3 ); y.push_back( 2 ); y.push_back( 4 );
+        BOOST_TEST_ALL_WITH( x.begin(), x.end(), y.begin(), y.end(), std::less<int>() );
+        ++test_cases;
+    }
+
+    return test_cases;
+}
+
+template <typename T>
+struct with_tolerance
+{
+    with_tolerance(T tolerance) : tolerance(tolerance) {}
+    bool operator()(T lhs, T rhs)
+    {
+        return (std::abs(lhs - rhs) <= tolerance);
+    }
+
+private:
+    T tolerance;
+};
+
+int fail_tolerance_predicate()
+{
+    int test_cases = 0;
+
+    {
+        std::vector<double> x, y;
+        x.push_back( 1.0 ); x.push_back( 1.0 );
+        y.push_back( 1.0 - 1e-4 ); y.push_back( 1.0 + 1e-4 );
+        BOOST_TEST_ALL_WITH( x.begin(), x.end(), y.begin(), y.end(), with_tolerance<double>(1e-5) );
+        ++test_cases;
+    }
+
+    return test_cases;
+}
+
+int main()
+{
+    int test_cases = 0;
+
+    test_cases += fail_vector();
+    test_cases += fail_tolerance_predicate();
+
+    return !boost::report_errors();
+}

test/lightweight_test_all_with_test.cpp

@@ -0,0 +1,76 @@
+//
+// Test for BOOST_TEST_ALL_WITH
+//
+// Copyright (c) 2017 Bjorn Reese
+//
+// 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 <cmath>
+#include <functional>
+#include <vector>
+#include <boost/core/lightweight_test.hpp>
+
+void test_vector()
+{
+    {
+        std::vector<int> x, y;
+        x.push_back( 1 ); x.push_back( 2 ); x.push_back( 3 ); x.push_back( 4 );
+        y.push_back( 1 ); y.push_back( 2 ); y.push_back( 3 ); y.push_back( 4 );
+        BOOST_TEST_ALL_WITH( x.begin(), x.end(), y.begin(), y.end(), std::equal_to<int>() );
+    }
+
+    {
+        std::vector<int> x, y;
+        x.push_back( 1 ); x.push_back( 2 ); x.push_back( 3 ); x.push_back( 4 );
+        y.push_back( 2 ); y.push_back( 3 ); y.push_back( 4 ); y.push_back( 5 );
+        BOOST_TEST_ALL_WITH( x.begin(), x.end(), y.begin(), y.end(), std::not_equal_to<int>() );
+    }
+
+    {
+        std::vector<int> x, y;
+        x.push_back( 1 ); x.push_back( 2 ); x.push_back( 3 ); x.push_back( 4 );
+        y.push_back( 2 ); y.push_back( 3 ); y.push_back( 4 ); y.push_back( 5 );
+        BOOST_TEST_ALL_WITH( x.begin(), x.end(), y.begin(), y.end(), std::less<int>() );
+    }
+}
+
+template <typename T>
+struct with_tolerance
+{
+    with_tolerance(T tolerance) : tolerance(tolerance) {}
+    bool operator()(T lhs, T rhs)
+    {
+        return (std::abs(lhs - rhs) <= tolerance);
+    }
+
+private:
+    T tolerance;
+};
+
+void test_tolerance_predicate()
+{
+    {
+        std::vector<double> x, y;
+        x.push_back( 1.0 ); x.push_back( 2.0 ); x.push_back( 3.0 ); x.push_back( 4.0 );
+        y.push_back( 1.0 ); y.push_back( 2.0 ); y.push_back( 3.0 ); y.push_back( 4.0 );
+        BOOST_TEST_ALL_WITH( x.begin(), x.end(), y.begin(), y.end(), with_tolerance<double>(1e-5) );
+    }
+
+    {
+        std::vector<double> x, y;
+        x.push_back( 1.0 ); x.push_back( 1.0 );
+        y.push_back( 1.0 - 1e-6 ); y.push_back( 1.0 + 1e-6 );
+        BOOST_TEST_ALL_WITH( x.begin(), x.end(), y.begin(), y.end(), with_tolerance<double>(1e-5) );
+    }
+}
+
+int main()
+{
+    test_vector();
+    test_tolerance_predicate();
+
+    return boost::report_errors();
+}

test/lightweight_test_eq_nullptr.cpp

@@ -0,0 +1,31 @@
+//
+// Test BOOST_TEST_EQ( p, nullptr )
+//
+// Copyright 2017 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>
+#include <boost/core/lightweight_test.hpp>
+
+int main()
+{
+#if !defined( BOOST_NO_CXX11_NULLPTR )
+
+    int x = 0;
+    int* p1 = 0;
+    int* p2 = &x;
+
+    BOOST_TEST_EQ( p1, nullptr );
+    BOOST_TEST_NE( p2, nullptr );
+
+    BOOST_TEST_EQ( nullptr, p1 );
+    BOOST_TEST_NE( nullptr, p2 );
+
+#endif
+
+    return boost::report_errors();
+}

test/lightweight_test_fail10.cpp

@@ -0,0 +1,18 @@
+//
+// Negative test for BOOST_TEST_EQ on const char*
+//
+// Copyright (c) 2017 Hans Dembinski
+//
+// 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>
+
+int main()
+{
+    BOOST_TEST_EQ("xab"+1 , "yab"+1); // compares addresses, not cstrings
+
+    return boost::report_errors();
+}

test/lightweight_test_fail11.cpp

@@ -0,0 +1,14 @@
+/*
+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/lightweight_test.hpp>
+
+int main()
+{
+    BOOST_TEST(true);
+    return 0;
+}

test/lightweight_test_fail9.cpp

@@ -0,0 +1,18 @@
+//
+// Negative test for BOOST_TEST_CSTR_EQ
+//
+// Copyright (c) 2017 Hans Dembinski
+//
+// 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>
+
+int main()
+{
+    BOOST_TEST_CSTR_EQ("x" , "y");
+
+    return boost::report_errors();
+}

test/lightweight_test_ge_fail.cpp

@@ -0,0 +1,20 @@
+//
+// Negative test for BOOST_TEST_GE
+//
+// Copyright 2017 Kohei Takahashi
+//
+// 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>
+
+int main()
+{
+    int x = 0;
+
+    BOOST_TEST_GE( x, 1 );
+
+    return boost::report_errors();
+}

test/lightweight_test_gt_fail.cpp

@@ -0,0 +1,20 @@
+//
+// Negative test for BOOST_TEST_GT
+//
+// Copyright 2017 Kohei Takahashi
+//
+// 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>
+
+int main()
+{
+    int x = 0;
+
+    BOOST_TEST_GT( x, 0 );
+
+    return boost::report_errors();
+}

test/lightweight_test_gt_ge_test.cpp

@@ -0,0 +1,34 @@
+//
+// Test for BOOST_TEST_GT, BOOST_TEST_GE
+//
+// Copyright 2017 Kohei Takahashi
+//
+// 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>
+
+int main()
+{
+    int x = 0;
+
+    BOOST_TEST_GT( x, -1 );
+    BOOST_TEST_GT( ++x, 0 );
+    BOOST_TEST_GT( x++, 0 );
+
+    BOOST_TEST_GE( x, 2 );
+    BOOST_TEST_GE( ++x, 3 );
+    BOOST_TEST_GE( x++, 3 );
+
+    int y = 5;
+
+    BOOST_TEST_GT( ++y, ++x );
+    BOOST_TEST_GT( y++, x++ );
+
+    BOOST_TEST_GE( ++y, x );
+    BOOST_TEST_GE( y++, x++ );
+
+    return boost::report_errors();
+}

test/lightweight_test_le_fail.cpp

@@ -0,0 +1,20 @@
+//
+// Negative test for BOOST_TEST_LE
+//
+// Copyright 2017 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.hpp>
+
+int main()
+{
+    int x = 1;
+
+    BOOST_TEST_LE( x, 0 );
+
+    return boost::report_errors();
+}

test/lightweight_test_lt_fail.cpp

@@ -0,0 +1,20 @@
+//
+// Negative test for BOOST_TEST_LT
+//
+// Copyright 2014, 2017 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.hpp>
+
+int main()
+{
+    int x = 0;
+
+    BOOST_TEST_LT( x, 0 );
+
+    return boost::report_errors();
+}

test/lightweight_test_lt_le_test.cpp

@@ -0,0 +1,34 @@
+//
+// Test for BOOST_TEST_LT, BOOST_TEST_LE
+//
+// Copyright 2014, 2017 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.hpp>
+
+int main()
+{
+    int x = 0;
+
+    BOOST_TEST_LT( x, 1 );
+    BOOST_TEST_LT( ++x, 2 );
+    BOOST_TEST_LT( x++, 3 );
+
+    BOOST_TEST_LE( x, 2 );
+    BOOST_TEST_LE( ++x, 3 );
+    BOOST_TEST_LE( x++, 4 );
+
+    int y = 3;
+
+    BOOST_TEST_LT( ++y, ++x );
+    BOOST_TEST_LT( y++, x++ );
+
+    BOOST_TEST_LE( ++y, x );
+    BOOST_TEST_LE( y++, x++ );
+
+    return boost::report_errors();
+}

test/lightweight_test_test.cpp

@@ -8,6 +8,7 @@
 // http://www.boost.org/LICENSE_1_0.txt
 //
 
+#include <vector>
 #include <boost/detail/lightweight_test.hpp>
 
 struct X
@@ -43,6 +44,16 @@ int main()
     BOOST_TEST( x++ == 1 );
     BOOST_TEST( x == 2? true: false );
     BOOST_TEST( x == 2? &x: 0 );
+    
+    // BOOST_TEST_NOT
+    
+    BOOST_TEST_NOT( x == 1 );
+    BOOST_TEST_NOT( ++x == 2 );
+    BOOST_TEST_NOT( x++ == 2 );
+    BOOST_TEST_NOT( --x == 2 );
+    BOOST_TEST_NOT( x-- == 2 );
+    BOOST_TEST_NOT( x == 2? false: true );
+    BOOST_TEST_NOT( x == 2? 0: &x );
 
     // BOOST_TEST_EQ
 
@@ -54,11 +65,24 @@ int main()
 
     BOOST_TEST_EQ( ++x, ++y );
     BOOST_TEST_EQ( x++, y++ );
+    BOOST_TEST_CSTR_EQ("xabc"+1, "yabc"+1); // equal cstrings, different addresses
+    BOOST_TEST_EQ( &y, &y );
 
     // BOOST_TEST_NE
 
     BOOST_TEST_NE( ++x, y );
     BOOST_TEST_NE( &x, &y );
+    BOOST_TEST_NE("xabc"+1, "yabc"+1); // equal cstrings, different addresses
+    BOOST_TEST_CSTR_NE("x", "y");
+
+    // BOOST_TEST_ALL_EQ
+    {
+        std::vector<int> xarray;
+        xarray.push_back(1);
+        xarray.push_back(2);
+        std::vector<int> yarray(xarray);
+        BOOST_TEST_ALL_EQ(xarray.begin(), xarray.end(), yarray.begin(), yarray.end());
+    }
 
     // BOOST_TEST_THROWS
 

test/lightweight_test_test3.cpp

@@ -0,0 +1,147 @@
+//
+// Test for lightweight_test.hpp
+//
+// Copyright (c) 2014, 2018 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.hpp>
+#include <boost/core/noncopyable.hpp>
+#include <ostream>
+
+// EQ
+
+struct eq1: private boost::noncopyable {};
+struct eq2: private boost::noncopyable {};
+
+std::ostream& operator<<( std::ostream& os, eq1 const& )
+{
+    return os << "eq1()";
+}
+
+std::ostream& operator<<( std::ostream& os, eq2 const& )
+{
+    return os << "eq2()";
+}
+
+bool operator==( eq1 const&, eq2 const& )
+{
+    return true;
+}
+
+// NE
+
+struct ne1: private boost::noncopyable {};
+struct ne2: private boost::noncopyable {};
+
+std::ostream& operator<<( std::ostream& os, ne1 const& )
+{
+    return os << "ne1()";
+}
+
+std::ostream& operator<<( std::ostream& os, ne2 const& )
+{
+    return os << "ne2()";
+}
+
+bool operator!=( ne1 const&, ne2 const& )
+{
+    return true;
+}
+
+// LT
+
+struct lt1: private boost::noncopyable {};
+struct lt2: private boost::noncopyable {};
+
+std::ostream& operator<<( std::ostream& os, lt1 const& )
+{
+    return os << "lt1()";
+}
+
+std::ostream& operator<<( std::ostream& os, lt2 const& )
+{
+    return os << "lt2()";
+}
+
+bool operator<( lt1 const&, lt2 const& )
+{
+    return true;
+}
+
+// LE
+
+struct le1: private boost::noncopyable {};
+struct le2: private boost::noncopyable {};
+
+std::ostream& operator<<( std::ostream& os, le1 const& )
+{
+    return os << "le1()";
+}
+
+std::ostream& operator<<( std::ostream& os, le2 const& )
+{
+    return os << "le2()";
+}
+
+bool operator<=( le1 const&, le2 const& )
+{
+    return true;
+}
+
+// GT
+
+struct gt1: private boost::noncopyable {};
+struct gt2: private boost::noncopyable {};
+
+std::ostream& operator<<( std::ostream& os, gt1 const& )
+{
+    return os << "gt1()";
+}
+
+std::ostream& operator<<( std::ostream& os, gt2 const& )
+{
+    return os << "gt2()";
+}
+
+bool operator>( gt1 const&, gt2 const& )
+{
+    return true;
+}
+
+// GE
+
+struct ge1: private boost::noncopyable {};
+struct ge2: private boost::noncopyable {};
+
+std::ostream& operator<<( std::ostream& os, ge1 const& )
+{
+    return os << "ge1()";
+}
+
+std::ostream& operator<<( std::ostream& os, ge2 const& )
+{
+    return os << "ge2()";
+}
+
+bool operator>=( ge1 const&, ge2 const& )
+{
+    return true;
+}
+
+//
+
+int main()
+{
+    BOOST_TEST_EQ( eq1(), eq2() );
+    BOOST_TEST_NE( ne1(), ne2() );
+    BOOST_TEST_LT( lt1(), lt2() );
+    BOOST_TEST_LE( le1(), le2() );
+    BOOST_TEST_GT( gt1(), gt2() );
+    BOOST_TEST_GE( ge1(), ge2() );
+
+    return boost::report_errors();
+}

test/pointer_traits_difference_type_test.cpp

@@ -0,0 +1,41 @@
+/*
+Copyright 2017 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/pointer_traits.hpp>
+#include <boost/core/is_same.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+
+template<class T>
+struct P { };
+
+template<class T>
+struct E {
+    typedef long difference_type;
+};
+
+int main()
+{
+    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<std::ptrdiff_t,
+        boost::pointer_traits<int*>::difference_type>));
+    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<std::ptrdiff_t,
+        boost::pointer_traits<P<int> >::difference_type>));
+    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<long,
+        boost::pointer_traits<E<int> >::difference_type>));
+    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<std::ptrdiff_t,
+        boost::pointer_traits<void*>::difference_type>));
+    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<std::ptrdiff_t,
+        boost::pointer_traits<P<void> >::difference_type>));
+    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<long,
+        boost::pointer_traits<E<void> >::difference_type>));
+    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<std::ptrdiff_t,
+        boost::pointer_traits<const int*>::difference_type>));
+    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<std::ptrdiff_t,
+        boost::pointer_traits<P<const int> >::difference_type>));
+    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<long,
+        boost::pointer_traits<E<const int> >::difference_type>));
+    return boost::report_errors();
+}

test/pointer_traits_element_type_test.cpp

@@ -0,0 +1,83 @@
+/*
+Copyright 2017 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/pointer_traits.hpp>
+#include <boost/core/is_same.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+
+template<class T>
+struct P1 { };
+
+template<class T1, class T2>
+struct P2 { };
+
+template<class T1, class T2, class T3>
+struct P3 { };
+
+template<class T>
+struct E1 {
+    typedef bool element_type;
+};
+
+template<class T1, class T2>
+struct E2 {
+    typedef bool element_type;
+};
+
+template<class T1, class T2, class T3>
+struct E3 {
+    typedef bool element_type;
+};
+
+#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+template<class T, class... U>
+struct P { };
+
+template<class T, class... U>
+struct E {
+    typedef bool element_type;
+};
+#endif
+
+int main()
+{
+    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<int,
+        boost::pointer_traits<int*>::element_type>));
+    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<int,
+        boost::pointer_traits<P1<int> >::element_type>));
+    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<int,
+        boost::pointer_traits<P2<int, char> >::element_type>));
+    BOOST_TEST_TRAIT_TRUE((boost::core::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::pointer_traits<P<int, char, char, char> >::element_type>));
+#endif
+    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<bool,
+        boost::pointer_traits<E1<int> >::element_type>));
+    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<bool,
+        boost::pointer_traits<E2<int, int> >::element_type>));
+    BOOST_TEST_TRAIT_TRUE((boost::core::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::pointer_traits<E<int, int, int, int> >::element_type>));
+#endif
+    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<void,
+        boost::pointer_traits<void*>::element_type>));
+    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<void,
+        boost::pointer_traits<P1<void> >::element_type>));
+    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<bool,
+        boost::pointer_traits<E1<void> >::element_type>));
+    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<const int,
+        boost::pointer_traits<const int*>::element_type>));
+    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<const int,
+        boost::pointer_traits<P1<const int> >::element_type>));
+    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<bool,
+        boost::pointer_traits<E1<const int> >::element_type>));
+    return boost::report_errors();
+}

test/pointer_traits_pointer_test.cpp

@@ -0,0 +1,30 @@
+/*
+Copyright 2017 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/pointer_traits.hpp>
+#include <boost/core/is_same.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+
+template<class T>
+struct P { };
+
+int main()
+{
+    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<int*,
+        boost::pointer_traits<int*>::pointer>));
+    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<P<int>,
+        boost::pointer_traits<P<int> >::pointer>));
+    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<void*,
+        boost::pointer_traits<void*>::pointer>));
+    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<P<void>,
+        boost::pointer_traits<P<void> >::pointer>));
+    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<const int*,
+        boost::pointer_traits<const int*>::pointer>));
+    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<P<const int>,
+        boost::pointer_traits<P<const int> >::pointer>));
+    return boost::report_errors();
+}

test/pointer_traits_pointer_to_test.cpp

@@ -0,0 +1,63 @@
+/*
+Copyright 2017 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/pointer_traits.hpp>
+#include <boost/core/lightweight_test.hpp>
+
+template<class T>
+class pointer {
+public:
+    typedef typename boost::pointer_traits<T>::element_type element_type;
+    pointer(T value)
+        : value_(value) { }
+    T get() const BOOST_NOEXCEPT {
+        return value_;
+    }
+    static pointer<T> pointer_to(element_type& value) {
+        return pointer<T>(&value);
+    }
+private:
+    T value_;
+};
+
+template<class T>
+inline bool
+operator==(const pointer<T>& lhs, const pointer<T>& rhs) BOOST_NOEXCEPT
+{
+    return lhs.get() == rhs.get();
+}
+
+int main()
+{
+    int i = 0;
+    {
+        typedef int* type;
+        type p = &i;
+        BOOST_TEST(boost::pointer_traits<type>::pointer_to(i) == p);
+    }
+    {
+        typedef pointer<int*> type;
+        type p(&i);
+        BOOST_TEST(boost::pointer_traits<type>::pointer_to(i) == p);
+    }
+    {
+        typedef pointer<pointer<int*> > type;
+        type p(&i);
+        BOOST_TEST(boost::pointer_traits<type>::pointer_to(i) == p);
+    }
+    {
+        typedef const int* type;
+        type p = &i;
+        BOOST_TEST(boost::pointer_traits<type>::pointer_to(i) == p);
+    }
+    {
+        typedef pointer<const int*> type;
+        type p(&i);
+        BOOST_TEST(boost::pointer_traits<type>::pointer_to(i) == p);
+    }
+    return boost::report_errors();
+}

test/pointer_traits_rebind_test.cpp

@@ -0,0 +1,107 @@
+/*
+Copyright 2017 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/pointer_traits.hpp>
+#include <boost/core/is_same.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+
+template<class T>
+struct P1 { };
+
+template<class T1, class T2>
+struct P2 { };
+
+template<class T1, class T2, class T3>
+struct P3 { };
+
+#if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
+template<class T>
+struct E1 {
+    template<class U>
+    using rebind = E1<bool>;
+};
+
+template<class T1, class T2>
+struct E2 {
+    template<class U>
+    using rebind = E2<bool, T2>;
+};
+
+template<class T1, class T2, class T3>
+struct E3 {
+    template<class U>
+    using rebind = E3<bool, T2, T3>;
+};
+#endif
+
+#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+template<class T, class... U>
+struct P { };
+
+#if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
+template<class T, class... U>
+struct E {
+    template<class V>
+    using rebind = E<bool, U...>;
+};
+#endif
+#endif
+
+struct R { };
+
+int main()
+{
+    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<char*,
+        boost::pointer_traits<R*>::rebind_to<char>::type>));
+    BOOST_TEST_TRAIT_TRUE((boost::core::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::pointer_traits<P2<R, R> >::rebind_to<char>::type>));
+    BOOST_TEST_TRAIT_TRUE((boost::core::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::pointer_traits<P<R, R, R, R> >::rebind_to<char>::type>));
+#endif
+    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<void*,
+        boost::pointer_traits<R*>::rebind_to<void>::type>));
+    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<P1<void>,
+        boost::pointer_traits<P1<R> >::rebind_to<void>::type>));
+    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<R*,
+        boost::pointer_traits<void*>::rebind_to<R>::type>));
+    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<P1<R>,
+        boost::pointer_traits<P1<void> >::rebind_to<R>::type>));
+    BOOST_TEST_TRAIT_TRUE((boost::core::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::pointer_traits<P1<R> >::rebind_to<const int>::type>));
+    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<int*,
+        boost::pointer_traits<const R*>::rebind_to<int>::type>));
+    BOOST_TEST_TRAIT_TRUE((boost::core::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<E1<bool>,
+        boost::pointer_traits<E1<R> >::rebind_to<char>::type>));
+    BOOST_TEST_TRAIT_TRUE((boost::core::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::pointer_traits<E3<R, R, R> >::rebind_to<char>::type>));
+#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<E<bool, R, R, R>,
+        boost::pointer_traits<E<R, R, R, R> >::rebind_to<char>::type>));
+#endif
+    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<E1<bool>,
+        boost::pointer_traits<E1<R> >::rebind_to<void>::type>));
+    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<E1<bool>,
+        boost::pointer_traits<E1<void> >::rebind_to<R>::type>));
+    BOOST_TEST_TRAIT_TRUE((boost::core::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::pointer_traits<E1<const R> >::rebind_to<int>::type>));
+#endif
+    return boost::report_errors();
+}

test/quick.cpp

@@ -0,0 +1,34 @@
+//
+// quick.cpp - a quick (CI) test for Boost.Core
+//
+// Copyright 2017 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/addressof.hpp>
+#include <boost/core/checked_delete.hpp>
+#include <boost/core/demangle.hpp>
+#include <boost/detail/iterator.hpp>
+#include <boost/core/enable_if.hpp>
+#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/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>
+
+int main()
+{
+}

test/ref_cv_test.cpp

@@ -0,0 +1,35 @@
+//  ref_cv_test.cpp: ref( x ) where x is of a cv-qualified type
+//
+//  Copyright (c) 2017 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/ref.hpp>
+#include <boost/core/lightweight_test.hpp>
+
+#define BOOST_TEST_REF( x ) BOOST_TEST( &boost::ref( x ).get() == &x )
+#define BOOST_TEST_CREF( x ) BOOST_TEST( &boost::cref( x ).get() == &x )
+
+int main()
+{
+    int x1 = 1;
+    int const x2 = 2;
+    int volatile x3 = 3;
+    int const volatile x4 = 4;
+
+    BOOST_TEST_REF( x1 );
+    BOOST_TEST_CREF( x1 );
+
+    BOOST_TEST_REF( x2 );
+    BOOST_TEST_CREF( x2 );
+
+    BOOST_TEST_REF( x3 );
+    BOOST_TEST_CREF( x3 );
+
+    BOOST_TEST_REF( x4 );
+    BOOST_TEST_CREF( x4 );
+
+    return boost::report_errors();
+}

test/ref_rv_fail1.cpp

@@ -15,6 +15,7 @@
 int main()
 {
     boost::reference_wrapper<int const> r( 1 ); // this should produce an ERROR
+    (void)r;
 }
 
 #else

test/ref_rv_fail2.cpp

@@ -13,4 +13,5 @@
 int main()
 {
     boost::reference_wrapper<int> r = boost::ref( 2 ); // this should produce an ERROR
+    (void)r;
 }

test/ref_rv_fail3.cpp

@@ -19,6 +19,7 @@ X const crv() { return X(); }
 int main()
 {
     boost::reference_wrapper<X const> r = boost::ref( crv() ); // this should produce an ERROR
+    (void)r;
 }
 
 #else

test/ref_rv_fail4.cpp

@@ -16,6 +16,7 @@
 int main()
 {
     boost::reference_wrapper<int const> r = boost::cref( 2 ); // should fail
+    (void)r;
 }
 
 #else

test/ref_rv_fail5.cpp

@@ -20,6 +20,7 @@ X const crv() { return X(); }
 int main()
 {
     boost::reference_wrapper<X const> r = boost::cref( crv() ); // must fail
+    (void)r;
 }
 
 #else

test/to_address_test.cpp

@@ -0,0 +1,158 @@
+/*
+Copyright 2017-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/pointer_traits.hpp>
+#include <boost/core/lightweight_test.hpp>
+
+template<class T>
+class P1 {
+public:
+    explicit P1(T* p)
+        : p_(p) { }
+    T* operator->() const BOOST_NOEXCEPT {
+        return p_;
+    }
+private:
+    T* p_;
+};
+
+template<class T>
+class P2 {
+public:
+    explicit P2(T* p)
+        : p_(p) { }
+    P1<T> operator->() const BOOST_NOEXCEPT {
+        return p_;
+    }
+private:
+    P1<T> p_;
+};
+
+#if !defined(BOOST_NO_CXX14_RETURN_TYPE_DEDUCTION)
+template<class T>
+class P3 {
+public:
+    explicit P3(T* p)
+        : p_(p) { }
+    T* get() const BOOST_NOEXCEPT {
+        return p_;
+    }
+private:
+    T* p_;
+};
+
+namespace boost {
+template<class T>
+struct pointer_traits<P3<T> > {
+    static T* to_address(const P3<T>& p) BOOST_NOEXCEPT {
+        return p.get();
+    }
+};
+} /* boost */
+
+template<class T>
+class P4 {
+public:
+    explicit P4(T* p)
+        : p_(p) { }
+    T* operator->() const BOOST_NOEXCEPT {
+        return 0;
+    }
+    T* get() const BOOST_NOEXCEPT {
+        return p_;
+    }
+private:
+    int* p_;
+};
+
+namespace boost {
+template<class T>
+struct pointer_traits<P4<T> > {
+    static T* to_address(const P4<T>& p) BOOST_NOEXCEPT {
+        return p.get();
+    }
+};
+} /* boost */
+
+#if !defined(BOOST_NO_CXX11_POINTER_TRAITS)
+template<class T>
+class P5 {
+public:
+    explicit P5(T* p)
+        : p_(p) { }
+    T* get() const BOOST_NOEXCEPT {
+        return p_;
+    }
+private:
+    T* p_;
+};
+
+namespace std {
+template<class T>
+struct pointer_traits<P5<T> > {
+    static T* to_address(const P5<T>& p) BOOST_NOEXCEPT {
+        return p.get();
+    }
+};
+} /* std */
+
+template<class T>
+class P6 {
+public:
+    explicit P6(T* p)
+        : p_(p) { }
+    T* get() const BOOST_NOEXCEPT {
+        return p_;
+    }
+private:
+    T* p_;
+};
+
+namespace boost {
+template<class T>
+struct pointer_traits<P6<T> > {
+    static T* to_address(const P6<T>& p) BOOST_NOEXCEPT {
+        return p.get();
+    }
+};
+} /* boost */
+
+namespace std {
+template<class T>
+struct pointer_traits<P6<T> > {
+    static T* to_address(const P6<T>& p) BOOST_NOEXCEPT {
+        return 0;
+    }
+};
+} /* std */
+#endif
+#endif
+
+int main()
+{
+    int i = 0;
+    BOOST_TEST(boost::to_address(&i) == &i);
+    int* p = &i;
+    BOOST_TEST(boost::to_address(p) == &i);
+    P1<int> p1(&i);
+    BOOST_TEST(boost::to_address(p1) == &i);
+    P2<int> p2(&i);
+    BOOST_TEST(boost::to_address(p2) == &i);
+#if !defined(BOOST_NO_CXX14_RETURN_TYPE_DEDUCTION)
+    P3<int> p3(&i);
+    BOOST_TEST(boost::to_address(p3) == &i);
+    P4<int> p4(&i);
+    BOOST_TEST(boost::to_address(p4) == &i);
+#if !defined(BOOST_NO_CXX11_POINTER_TRAITS)
+    P5<int> p5(&i);
+    BOOST_TEST(boost::to_address(p5) == &i);
+    P6<int> p6(&i);
+    BOOST_TEST(boost::to_address(p6) == &i);
+#endif
+#endif
+    return boost::report_errors();
+}