Changed http to https in URLs in readme.

_set_abort_behavior not supported in old MSVC

.travis.yml

@@ -1,4 +1,4 @@
-# Copyright 2016, 2017 Peter Dimov
+# Copyright 2016-2018 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)
 
@@ -119,6 +119,16 @@ matrix:
           sources:
             - ubuntu-toolchain-r-test
 
+    - os: linux
+      compiler: g++-8
+      env: UBSAN=1 TOOLSET=gcc COMPILER=g++-8 CXXSTD=03,11,14,17 UBSAN_OPTIONS=print_stacktrace=1 LINKFLAGS=-fuse-ld=gold
+      addons:
+        apt:
+          packages:
+            - g++-8
+          sources:
+            - ubuntu-toolchain-r-test
+
     - os: linux
       compiler: clang++
       env: TOOLSET=clang COMPILER=clang++ CXXSTD=03,11
@@ -133,7 +143,6 @@ matrix:
             - libstdc++-4.9-dev
           sources:
             - ubuntu-toolchain-r-test
-            - llvm-toolchain-precise-3.5
 
     - os: linux
       compiler: clang++-3.6
@@ -142,20 +151,9 @@ matrix:
         apt:
           packages:
             - clang-3.6
+            - libstdc++-4.9-dev
           sources:
             - ubuntu-toolchain-r-test
-            - llvm-toolchain-precise-3.6
-
-    - os: linux
-      compiler: clang++-3.7
-      env: TOOLSET=clang COMPILER=clang++-3.7 CXXSTD=03,11,14,1z
-      addons:
-        apt:
-          packages:
-            - clang-3.7
-          sources:
-            - ubuntu-toolchain-r-test
-            - llvm-toolchain-precise-3.7
 
     - os: linux
       compiler: clang++-3.8
@@ -167,7 +165,6 @@ matrix:
             - libstdc++-4.9-dev
           sources:
             - ubuntu-toolchain-r-test
-            - llvm-toolchain-precise-3.8
 
     - os: linux
       compiler: clang++-3.9
@@ -179,7 +176,6 @@ matrix:
             - libstdc++-4.9-dev
           sources:
             - ubuntu-toolchain-r-test
-            - llvm-toolchain-precise-3.9
 
     - os: linux
       compiler: clang++-4.0
@@ -214,6 +210,29 @@ matrix:
             - ubuntu-toolchain-r-test
             - llvm-toolchain-trusty-6.0
 
+    - os: linux
+      compiler: clang++-7
+      env: TOOLSET=clang COMPILER=clang++-7 CXXSTD=03,11,14,17
+      addons:
+        apt:
+          packages:
+            - clang-7
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-trusty-7
+
+    - os: linux
+      compiler: clang++-6.0
+      env: UBSAN=1 TOOLSET=clang COMPILER=clang++-6.0 CXXSTD=03,11,14,1z UBSAN_OPTIONS=print_stacktrace=1
+      addons:
+        apt:
+          packages:
+            - clang-6.0
+            - libstdc++-5-dev
+          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
@@ -222,6 +241,14 @@ matrix:
           packages:
             - libc++-dev
 
+    - os: linux
+      compiler: clang++-libc++
+      env: UBSAN=1 TOOLSET=clang COMPILER=clang++-libc++ CXXSTD=03,11,14,1z UBSAN_OPTIONS=print_stacktrace=1
+      addons:
+        apt:
+          packages:
+            - libc++-dev
+
     - os: osx
       compiler: clang++
       env: TOOLSET=clang COMPILER=clang++ CXXSTD=03,11,14,1z
@@ -245,7 +272,7 @@ install:
 script:
   - |-
     echo "using $TOOLSET : : $COMPILER ;" > ~/user-config.jam
-  - ./b2 -j 3 libs/core/test toolset=$TOOLSET cxxstd=$CXXSTD
+  - ./b2 -j 3 libs/core/test toolset=$TOOLSET cxxstd=$CXXSTD variant=debug,release ${UBSAN:+cxxflags=-fsanitize=undefined cxxflags=-fno-sanitize-recover=undefined linkflags=-fsanitize=undefined define=UBSAN=1 debug-symbols=on} ${LINKFLAGS:+linkflags=$LINKFLAGS}
 
 notifications:
   email:

CMakeLists.txt

@@ -0,0 +1,21 @@
+# Copyright 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
+
+# Partial (add_subdirectory only) and experimental CMake support
+# Subject to change; please do not rely on the contents of this file yet
+
+cmake_minimum_required(VERSION 3.5)
+
+project(BoostCore LANGUAGES CXX)
+
+add_library(boost_core INTERFACE)
+add_library(Boost::core ALIAS boost_core)
+
+target_include_directories(boost_core INTERFACE include)
+
+target_link_libraries(boost_core
+    INTERFACE
+        Boost::assert
+        Boost::config
+)

README.md

@@ -1,7 +1,7 @@
 Boost.Core
 ==========
 
-Boost.Core, part of collection of the [Boost C++ Libraries](http://github.com/boostorg), is a collection of core utilities used by other Boost libraries.
+Boost.Core, part of collection of the [Boost C++ Libraries](https://github.com/boostorg), is a collection of core utilities used by other Boost libraries.
 The criteria for inclusion is that the utility component be:
 
 * simple,
@@ -23,10 +23,10 @@ Master   | [![Build Status](https://travis-ci.org/boostorg/core.svg?branch=maste
 
 ### More information
 
-* [Documentation](http://boost.org/libs/core)
+* [Documentation](https://boost.org/libs/core)
 * [Report bugs](https://svn.boost.org/trac/boost/newticket?component=core;version=Boost%20Release%20Branch). Be sure to mention Boost version, platform and compiler you're using. A small compilable code sample to reproduce the problem is always good as well.
-* Submit your patches as pull requests against **develop** branch. Note that by submitting patches you agree to license your modifications under the [Boost Software License, Version 1.0](http://www.boost.org/LICENSE_1_0.txt).
+* Submit your patches as pull requests against **develop** branch. Note that by submitting patches you agree to license your modifications under the [Boost Software License, Version 1.0](https://www.boost.org/LICENSE_1_0.txt).
 
 ### License
 
-Distributed under the [Boost Software License, Version 1.0](http://boost.org/LICENSE_1_0.txt).
+Distributed under the [Boost Software License, Version 1.0](https://boost.org/LICENSE_1_0.txt).

appveyor.yml

@@ -17,21 +17,6 @@ environment:
     - 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
 
@@ -39,6 +24,31 @@ environment:
       TOOLSET: msvc-14.1
       CXXSTD: 14,17
 
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2013
+      ADDPATH: C:\cygwin\bin;
+      TOOLSET: gcc
+      CXXSTD: 03,11,14,1z
+
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2013
+      ADDPATH: C:\cygwin64\bin;
+      TOOLSET: gcc
+      CXXSTD: 03,11,14,1z
+
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2013
+      ADDPATH: C:\mingw\bin;
+      TOOLSET: gcc
+      CXXSTD: 03,11,14,1z
+
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2013
+      ADDPATH: C:\mingw-w64\x86_64-6.3.0-posix-seh-rt_v5-rev1\mingw64\bin;
+      TOOLSET: gcc
+      CXXSTD: 03,11,14,1z
+
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2013
+      ADDPATH: C:\mingw-w64\x86_64-7.2.0-posix-seh-rt_v5-rev1\mingw64\bin;
+      TOOLSET: gcc
+      CXXSTD: 03,11,14,1z
+
 install:
   - set BOOST_BRANCH=develop
   - if "%APPVEYOR_REPO_BRANCH%" == "master" set BOOST_BRANCH=master

doc/.gitignore

@@ -0,0 +1,3 @@
+/html/
+/pdf/
+ref_reference.xml

doc/Jamfile.v2

@@ -1,5 +1,5 @@
-# Copyright (c) 2014 Glen Joseph Fernandes
-# glenfe at live dot com
+# Copyright 2014 Glen Joseph Fernandes
+# (glenjofe@gmail.com)
 #
 # Distributed under the Boost Software License,
 # Version 1.0. (See accompanying file LICENSE_1_0.txt

doc/core.qbk

@@ -1,10 +1,10 @@
 [/
-  Copyright (c) 2014 Glen Joseph Fernandes
-  glenfe at live dot com
+Copyright 2014 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://boost.org/LICENSE_1_0.txt)
+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)
 ]
 
 [library Boost.Core
@@ -41,6 +41,7 @@ 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]
@@ -51,6 +52,7 @@ criteria for inclusion is that the utility component be:
 [include noncopyable.qbk]
 [include null_deleter.qbk]
 [include pointer_traits.qbk]
+[include quick_exit.qbk]
 [include ref.qbk]
 [include scoped_enum.qbk]
 [include swap.qbk]

doc/empty_value.qbk

@@ -0,0 +1,137 @@
+[/
+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:
+    typedef T type;
+
+    empty_value() = default;
+
+    template<class... Args>
+    explicit empty_value(empty_init_t, Args&&... args);
+
+    const T& get() const noexcept;
+
+    T& get() noexcept;
+};
+
+} /* 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 Member types]
+
+[variablelist [[`type`][The template parameter `T`]]]
+
+[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 noexcept;`][Returns the value]]
+[[`T& get() noexcept;`][Returns the value]]]
+
+[endsect]
+
+[endsect]
+
+[endsect]

doc/quick_exit.qbk

@@ -0,0 +1,40 @@
+[/
+  Copyright 2018 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
+]
+
+[section:quick_exit quick_exit]
+
+[simplesect Authors]
+
+* Peter Dimov
+
+[endsimplesect]
+
+[section Header <boost/core/quick_exit.hpp>]
+
+The header `<boost/core/quick_exit.hpp>` defines the function
+`void boost::quick_exit(int code)`. It calls the standard C++11 function
+[@https://en.cppreference.com/w/cpp/utility/program/quick_exit
+ `std::quick_exit(code)`], if that is available, and otherwise exits the
+ process via [@https://en.cppreference.com/w/cpp/utility/program/_Exit
+ `std::_Exit(code)`] or equivalent.
+
+[section Synopsis]
+
+``
+namespace boost
+{
+    [[noreturn]] void quick_exit(int code) noexcept;
+}
+``
+
+[endsect]
+
+[endsect]
+
+[endsect]

include/boost/core/empty_value.hpp

@@ -0,0 +1,136 @@
+/*
+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 { };
+
+namespace empty_ {
+
+template<class T, unsigned N = 0,
+    bool E = boost::use_empty_value_base<T>::value>
+class empty_value {
+public:
+    typedef T type;
+
+#if !defined(BOOST_NO_CXX11_DEFAULTED_FUNCTIONS)
+    empty_value() = default;
+#else
+    empty_value() { }
+#endif
+
+    empty_value(boost::empty_init_t)
+        : value_() { }
+
+#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+    template<class... Args>
+    explicit empty_value(boost::empty_init_t, Args&&... args)
+        : value_(std::forward<Args>(args)...) { }
+#else
+    template<class U>
+    empty_value(boost::empty_init_t, U&& value)
+        : value_(std::forward<U>(value)) { }
+#endif
+#else
+    template<class U>
+    empty_value(boost::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:
+    typedef T type;
+
+#if !defined(BOOST_NO_CXX11_DEFAULTED_FUNCTIONS)
+    empty_value() = default;
+#else
+    empty_value() { }
+#endif
+
+    empty_value(boost::empty_init_t)
+        : T() { }
+
+#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+    template<class... Args>
+    explicit empty_value(boost::empty_init_t, Args&&... args)
+        : T(std::forward<Args>(args)...) { }
+#else
+    template<class U>
+    empty_value(boost::empty_init_t, U&& value)
+        : T(std::forward<U>(value)) { }
+#endif
+#else
+    template<class U>
+    empty_value(boost::empty_init_t, const U& value)
+        : T(value) { }
+#endif
+
+    const T& get() const BOOST_NOEXCEPT {
+        return *this;
+    }
+
+    T& get() BOOST_NOEXCEPT {
+        return *this;
+    }
+};
+#endif
+
+} /* empty_ */
+
+using empty_::empty_value;
+
+} /* boost */
+
+#endif

include/boost/core/lightweight_test.hpp

@@ -14,16 +14,19 @@
 //  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/core/no_exceptions_support.hpp>
-#include <boost/assert.hpp>
 #include <boost/current_function.hpp>
 #include <iostream>
 #include <iterator>
+#include <cstdlib>
 #include <cstring>
 #include <cstddef>
 
@@ -39,29 +42,45 @@ 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) && (_MSC_VER > 1310)
+        ::_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;
+            std::abort();
+        }
+    }
+
+    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)
@@ -69,7 +88,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)
@@ -77,7 +96,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)
@@ -85,7 +104,7 @@ 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();
 }
 
 // In the comparisons below, it is possible that T and U are signed and unsigned integer types, which generates warnings in some compilers.
@@ -118,105 +137,58 @@ template<class T> inline const void* test_output_impl(T volatile* v) { return co
 inline const void* test_output_impl(std::nullptr_t) { return nullptr; }
 #endif
 
-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 )
-{
-    if( t == u )
-    {
-        report_errors_remind();
-    }
-    else
-    {
-        BOOST_LIGHTWEIGHT_TEST_OSTREAM
-            << file << "(" << line << "): test '" << expr1 << " == " << expr2
-            << "' failed in function '" << function << "': "
-            << "'" << test_output_impl(t) << "' != '" << test_output_impl(u) << "'" << std::endl;
-        ++test_errors();
-    }
-}
+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 "=="; }
+};
 
-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 )
-{
-    if( t != u )
-    {
-        report_errors_remind();
-    }
-    else
-    {
-        BOOST_LIGHTWEIGHT_TEST_OSTREAM
-            << file << "(" << line << "): test '" << expr1 << " != " << expr2
-            << "' failed in function '" << function << "': "
-            << "'" << test_output_impl(t) << "' == '" << test_output_impl(u) << "'" << std::endl;
-        ++test_errors();
-    }
-}
+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 "!="; }
+};
 
-template<class T, class U> inline void test_lt_impl( char const * expr1, char const * expr2,
-  char const * file, int line, char const * function, T const & t, U const & u )
-{
-    if( t < u )
-    {
-        report_errors_remind();
-    }
-    else
-    {
-        BOOST_LIGHTWEIGHT_TEST_OSTREAM
-            << file << "(" << line << "): test '" << expr1 << " < " << expr2
-            << "' failed in function '" << function << "': "
-            << "'" << test_output_impl(t) << "' >= '" << test_output_impl(u) << "'" << std::endl;
-        ++test_errors();
-    }
-}
+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 "<"; }
+};
 
-template<class T, class U> inline void test_le_impl( char const * expr1, char const * expr2,
-  char const * file, int line, char const * function, T const & t, U const & u )
-{
-    if( t <= u )
-    {
-        report_errors_remind();
-    }
-    else
-    {
-        BOOST_LIGHTWEIGHT_TEST_OSTREAM
-            << file << "(" << line << "): test '" << expr1 << " <= " << expr2
-            << "' failed in function '" << function << "': "
-            << "'" << test_output_impl(t) << "' > '" << test_output_impl(u) << "'" << std::endl;
-        ++test_errors();
-    }
-}
+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 "<="; }
+};
 
-template<class T, class U> inline void test_gt_impl( char const * expr1, char const * expr2,
-  char const * file, int line, char const * function, T const & t, U const & u )
-{
-    if( t > u )
-    {
-        report_errors_remind();
-    }
-    else
-    {
-        BOOST_LIGHTWEIGHT_TEST_OSTREAM
-            << file << "(" << line << "): test '" << expr1 << " > " << expr2
-            << "' failed in function '" << function << "': "
-            << "'" << test_output_impl(t) << "' <= '" << test_output_impl(u) << "'" << std::endl;
-        ++test_errors();
-    }
-}
+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 ">"; }
+};
 
-template<class T, class U> inline void test_ge_impl( char const * expr1, char const * expr2,
-  char const * file, int line, char const * function, T const & t, U const & u )
+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 << "': "
-            << "'" << test_output_impl(t) << "' < '" << test_output_impl(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();
     }
 }
 
@@ -225,15 +197,14 @@ inline void test_cstr_eq_impl( char const * expr1, char const * expr2,
 {
     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();
     }
 }
 
@@ -242,15 +213,14 @@ inline void test_cstr_ne_impl( char const * expr1, char const * expr2,
 {
     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();
     }
 }
 
@@ -313,12 +283,12 @@ void test_all_eq_impl(FormattedOutputFunction& output,
 
     if (error_count == 0)
     {
-        boost::detail::report_errors_remind();
+        test_results();
     }
     else
     {
         output << std::endl;
-        ++boost::detail::test_errors();
+        ++test_results().errors();
     }
 }
 
@@ -382,12 +352,12 @@ void test_all_with_impl(FormattedOutputFunction& output,
 
     if (error_count == 0)
     {
-        report_errors_remind();
+        test_results();
     }
     else
     {
         output << std::endl;
-        ++test_errors();
+        ++test_results().errors();
     }
 }
 
@@ -405,10 +375,10 @@ void test_all_with_impl(FormattedOutputFunction& output,
 
 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
@@ -425,18 +395,18 @@ 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_lt_impl(#expr1, #expr2, __FILE__, __LINE__, BOOST_CURRENT_FUNCTION, expr1, expr2) )
-#define BOOST_TEST_LE(expr1,expr2) ( ::boost::detail::test_le_impl(#expr1, #expr2, __FILE__, __LINE__, BOOST_CURRENT_FUNCTION, expr1, expr2) )
-#define BOOST_TEST_GT(expr1,expr2) ( ::boost::detail::test_gt_impl(#expr1, #expr2, __FILE__, __LINE__, BOOST_CURRENT_FUNCTION, expr1, expr2) )
-#define BOOST_TEST_GE(expr1,expr2) ( ::boost::detail::test_ge_impl(#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) )
@@ -452,6 +422,7 @@ inline int report_errors()
          (#EXCEP, __FILE__, __LINE__, BOOST_CURRENT_FUNCTION); \
       }                                                        \
       catch(EXCEP const&) {                                    \
+         ::boost::detail::test_results();                      \
       }                                                        \
       catch(...) {                                             \
          ::boost::detail::throw_failed_impl                    \

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/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/quick_exit.hpp

@@ -0,0 +1,59 @@
+#ifndef BOOST_CORE_QUICK_EXIT_HPP_INCLUDED
+#define BOOST_CORE_QUICK_EXIT_HPP_INCLUDED
+
+// MS compatible compilers support #pragma once
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+//  boost/core/quick_exit.hpp
+//
+//  Copyright 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/config.hpp>
+#include <cstdlib>
+
+#if defined(__MINGW32__) && !defined(__MINGW64_VERSION_MAJOR)
+
+extern "C" _CRTIMP __cdecl __MINGW_NOTHROW  void _exit (int) __MINGW_ATTRIB_NORETURN;
+
+#endif
+
+#if defined(__CYGWIN__) && __cplusplus < 201103L
+
+extern "C" _Noreturn void quick_exit(int);
+
+#endif
+
+namespace boost
+{
+
+BOOST_NORETURN void quick_exit( int code ) BOOST_NOEXCEPT
+{
+#if defined(_MSC_VER) && _MSC_VER < 1900
+
+    ::_exit( code );
+
+#elif defined(__MINGW32__)
+
+    ::_exit( code );
+
+#elif defined(__APPLE__)
+
+    ::_Exit( code );
+
+#else
+
+    ::quick_exit( code );
+
+#endif
+}
+
+} // namespace boost
+
+#endif  // #ifndef BOOST_CORE_QUICK_EXIT_HPP_INCLUDED

include/boost/core/ref.hpp

@@ -19,7 +19,8 @@
 //  Copyright (C) 2002 David Abrahams
 //
 //  Copyright (C) 2014 Glen Joseph Fernandes
-//  glenfe at live dot com
+//  (glenjofe@gmail.com)
+//
 //  Copyright (C) 2014 Agustin Berge
 //
 // Distributed under the Boost Software License, Version 1.0. (See

include/boost/core/swap.hpp

@@ -21,13 +21,19 @@
 // avoid ambiguity when swapping objects of a Boost type that does
 // not have its own boost::swap overload.
 
+#include <boost/core/enable_if.hpp>
+#include <boost/config.hpp>
 #include <utility> //for std::swap (C++11)
 #include <algorithm> //for std::swap (C++98)
 #include <cstddef> //for std::size_t
-#include <boost/config.hpp>
 
 namespace boost_swap_impl
 {
+  // we can't use type_traits here
+
+  template<class T> struct is_const { enum _vt { value = 0 }; };
+  template<class T> struct is_const<T const> { enum _vt { value = 1 }; };
+
   template<class T>
   BOOST_GPU_ENABLED
   void swap_impl(T& left, T& right)
@@ -51,7 +57,8 @@ namespace boost
 {
   template<class T1, class T2>
   BOOST_GPU_ENABLED
-  void swap(T1& left, T2& right)
+  typename enable_if_c< !boost_swap_impl::is_const<T1>::value && !boost_swap_impl::is_const<T2>::value >::type
+  swap(T1& left, T2& right)
   {
     ::boost_swap_impl::swap_impl(left, right);
   }

include/boost/core/typeinfo.hpp

@@ -21,6 +21,7 @@
 
 #include <boost/current_function.hpp>
 #include <functional>
+#include <cstring>
 
 namespace boost
 {
@@ -36,26 +37,43 @@ private:
     typeinfo& operator=( typeinfo const& );
 
     char const * name_;
+    void (*lib_id_)();
 
 public:
 
-    explicit typeinfo( char const * name ): name_( name )
+    typeinfo( char const * name, void (*lib_id)() ): name_( name ), lib_id_( lib_id )
     {
     }
 
     bool operator==( typeinfo const& rhs ) const
     {
+#if ( defined(_WIN32) || defined(__CYGWIN__) ) && defined(__GNUC__) && !defined(BOOST_DISABLE_CURRENT_FUNCTION)
+
+        return lib_id_ == rhs.lib_id_? this == &rhs: std::strcmp( name_, rhs.name_ ) == 0;
+
+#else
+
         return this == &rhs;
+
+#endif
     }
 
     bool operator!=( typeinfo const& rhs ) const
     {
-        return this != &rhs;
+        return !( *this == rhs );
     }
 
     bool before( typeinfo const& rhs ) const
     {
+#if ( defined(_WIN32) || defined(__CYGWIN__) ) && defined(__GNUC__) && !defined(BOOST_DISABLE_CURRENT_FUNCTION)
+
+        return lib_id_ == rhs.lib_id_? std::less< typeinfo const* >()( this, &rhs ): std::strcmp( name_, rhs.name_ ) < 0;
+
+#else
+
         return std::less< typeinfo const* >()( this, &rhs );
+
+#endif
     }
 
     char const* name() const
@@ -74,7 +92,7 @@ inline char const * demangled_name( core::typeinfo const & ti )
 namespace detail
 {
 
-template<class T> struct core_typeid_
+template<class T> struct BOOST_SYMBOL_VISIBLE core_typeid_
 {
     static boost::core::typeinfo ti_;
 
@@ -84,13 +102,11 @@ template<class T> struct core_typeid_
     }
 };
 
-#if defined(__SUNPRO_CC)
-// see #4199, the Sun Studio compiler gets confused about static initialization 
-// constructor arguments. But an assignment works just fine. 
-template<class T> boost::core::typeinfo core_typeid_< T >::ti_ = core_typeid_< T >::name();
-#else
-template<class T> boost::core::typeinfo core_typeid_< T >::ti_(core_typeid_< T >::name());
-#endif
+BOOST_SYMBOL_VISIBLE inline void core_typeid_lib_id()
+{
+}
+
+template<class T> boost::core::typeinfo core_typeid_< T >::ti_( core_typeid_< T >::name(), &core_typeid_lib_id );
 
 template<class T> struct core_typeid_< T & >: core_typeid_< T >
 {

meta/libraries.json

@@ -9,7 +9,7 @@
     ],
     "maintainers": [
         "Peter Dimov <pdimov -at- pdimov.com>",
-        "Glen Fernandes <glenfe -at- live.com>",
+        "Glen Fernandes <glenjofe -at- gmail.com>",
         "Andrey Semashev <andrey.semashev -at- gmail.com>"
     ],
     "description": "A collection of simple core utilities with minimal dependencies.",

test/Jamfile.v2

@@ -89,6 +89,7 @@ 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 ;
@@ -123,5 +124,19 @@ 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 ;
+
+run quick_exit_test.cpp ;
+run-fail quick_exit_fail.cpp ;
+
+lib lib_typeid : lib_typeid.cpp : <link>shared:<define>LIB_TYPEID_DYN_LINK=1 ;
+
+run test_lib_typeid.cpp lib_typeid : : : <link>shared : test_lib_typeid_shared ;
+run test_lib_typeid.cpp lib_typeid : : : <link>static : test_lib_typeid_static ;
+
+run test_lib_typeid.cpp lib_typeid : : : <link>shared <rtti>off : test_lib_typeid_shared_no_rtti ;
+run test_lib_typeid.cpp lib_typeid : : : <link>static <rtti>off  : test_lib_typeid_static_no_rtti ;
+
 use-project /boost/core/swap : ./swap ;
 build-project ./swap ;

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/lib_typeid.cpp

@@ -0,0 +1,17 @@
+
+// Copyright 2018 Peter Dimov.
+// Distributed under the Boost Software License, Version 1.0.
+
+#include <boost/core/typeinfo.hpp>
+#include <boost/config.hpp>
+
+#if defined(LIB_TYPEID_DYN_LINK)
+# define EXPORT BOOST_SYMBOL_EXPORT
+#else
+# define EXPORT
+#endif
+
+EXPORT boost::core::typeinfo const & get_typeid_int()
+{
+    return BOOST_CORE_TYPEID( int );
+}

test/lightweight_test_all_eq_test.cpp

@@ -120,7 +120,5 @@ int main()
         ++test_cases;
     }
 
-    boost::report_errors();
-
-    return boost::detail::test_errors() != test_cases;
+    return !boost::report_errors();
 }

test/lightweight_test_all_with_fail.cpp

@@ -101,7 +101,5 @@ int main()
     test_cases += fail_vector();
     test_cases += fail_tolerance_predicate();
 
-    boost::report_errors();
-
-    return boost::detail::test_errors() != test_cases;
+    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/quick_exit_fail.cpp

@@ -0,0 +1,17 @@
+
+// Test for quick_exit.hpp
+//
+// Copyright 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/quick_exit.hpp>
+
+int main()
+{
+    boost::quick_exit( 1 );
+    return 0;
+}

test/quick_exit_test.cpp

@@ -0,0 +1,17 @@
+
+// Test for quick_exit.hpp
+//
+// Copyright 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/quick_exit.hpp>
+
+int main()
+{
+    boost::quick_exit( 0 );
+    return 1;
+}

test/swap/Jamfile.v2

@@ -16,6 +16,9 @@ local compile_tests =
     mixed_headers_2.cpp
     ;
 
+local compile_fail_tests =
+    const_wrapper_fail.cpp ;
+
 local run_tests =
     primitive.cpp
     specialized_in_boost.cpp
@@ -49,6 +52,12 @@ rule test_all
         all_rules += [ compile $(file) : : "swap-$(test_name)" ] ;
     }
 
+    for file in $(compile_fail_tests)
+    {
+        local test_name = [ MATCH "([^.]*).cpp$" : $(file) ] ;
+        all_rules += [ compile-fail $(file) : : "swap-$(test_name)" ] ;
+    }
+
     for file in $(run_tests)
     {
         local test_name = [ MATCH "([^.]*).cpp$" : $(file) ] ;

test/swap/const_wrapper_fail.cpp

@@ -0,0 +1,28 @@
+// Copyright 2018 Andrzej Krzemieński
+// Copyright 2018 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+
+#include <boost/core/swap.hpp>
+
+namespace boost
+{
+  
+template<class T> struct Wrapper
+{
+    T value;
+};
+
+template<class T> inline void swap( Wrapper<T> & w, Wrapper<T> & v )
+{
+    boost::swap( w, v );
+}
+  
+} // namespace boost
+ 
+int main()
+{
+    boost::Wrapper<int> const w = { 2 };
+    boost::Wrapper<int> const v = { 3 };
+
+    swap( w, v );
+}

test/test_lib_typeid.cpp

@@ -0,0 +1,26 @@
+
+// Copyright 2018 Peter Dimov.
+// Distributed under the Boost Software License, Version 1.0.
+
+#include <boost/core/typeinfo.hpp>
+#include <boost/core/lightweight_test.hpp>
+
+boost::core::typeinfo const & get_typeid_int();
+
+int main()
+{
+    boost::core::typeinfo const & ti = BOOST_CORE_TYPEID( int );
+    boost::core::typeinfo const & tf = BOOST_CORE_TYPEID( float );
+
+    boost::core::typeinfo const & ti2 = get_typeid_int();
+
+    BOOST_TEST( ti2 == ti );
+    BOOST_TEST( ti2 != tf );
+
+    BOOST_TEST( !ti2.before( ti ) );
+    BOOST_TEST( !ti.before( ti2 ) );
+
+    BOOST_TEST( ti2.before( tf ) != tf.before( ti2 ) );
+
+    return boost::report_errors();
+}