Merge branch 'develop' into feature/std-category-2

.github/workflows/ci.yml

@@ -189,3 +189,159 @@ jobs:
         run: |
           cd ../boost-root
           b2 -j3 libs/%LIBRARY%/test toolset=${{matrix.toolset}} cxxstd=${{matrix.cxxstd}} address-model=${{matrix.addrmd}} variant=debug,release
+
+  posix-cmake-subdir:
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - os: ubuntu-18.04
+          - os: ubuntu-20.04
+          - os: macos-10.15
+
+    runs-on: ${{matrix.os}}
+
+    steps:
+      - uses: actions/checkout@v2
+
+      - name: Install packages
+        if: matrix.install
+        run: sudo apt install ${{matrix.install}}
+
+      - name: Setup Boost
+        run: |
+          echo GITHUB_REPOSITORY: $GITHUB_REPOSITORY
+          LIBRARY=${GITHUB_REPOSITORY#*/}
+          echo LIBRARY: $LIBRARY
+          echo "LIBRARY=$LIBRARY" >> $GITHUB_ENV
+          echo GITHUB_BASE_REF: $GITHUB_BASE_REF
+          echo GITHUB_REF: $GITHUB_REF
+          REF=${GITHUB_BASE_REF:-$GITHUB_REF}
+          REF=${REF#refs/heads/}
+          echo REF: $REF
+          BOOST_BRANCH=develop && [ "$REF" == "master" ] && BOOST_BRANCH=master || true
+          echo BOOST_BRANCH: $BOOST_BRANCH
+          cd ..
+          git clone -b $BOOST_BRANCH --depth 1 https://github.com/boostorg/boost.git boost-root
+          cd boost-root
+          cp -r $GITHUB_WORKSPACE/* libs/$LIBRARY
+          git submodule update --init tools/boostdep
+          python tools/boostdep/depinst/depinst.py --git_args "--jobs 3" $LIBRARY
+
+      - name: Use library with add_subdirectory
+        run: |
+          cd ../boost-root/libs/$LIBRARY/test/cmake_subdir_test
+          mkdir __build__ && cd __build__
+          cmake ..
+          cmake --build .
+          ctest --output-on-failure --no-tests=error
+
+  posix-cmake-install:
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - os: ubuntu-18.04
+          - os: ubuntu-20.04
+          - os: macos-10.15
+
+    runs-on: ${{matrix.os}}
+
+    steps:
+      - uses: actions/checkout@v2
+
+      - name: Install packages
+        if: matrix.install
+        run: sudo apt install ${{matrix.install}}
+
+      - name: Setup Boost
+        run: |
+          echo GITHUB_REPOSITORY: $GITHUB_REPOSITORY
+          LIBRARY=${GITHUB_REPOSITORY#*/}
+          echo LIBRARY: $LIBRARY
+          echo "LIBRARY=$LIBRARY" >> $GITHUB_ENV
+          echo GITHUB_BASE_REF: $GITHUB_BASE_REF
+          echo GITHUB_REF: $GITHUB_REF
+          REF=${GITHUB_BASE_REF:-$GITHUB_REF}
+          REF=${REF#refs/heads/}
+          echo REF: $REF
+          BOOST_BRANCH=develop && [ "$REF" == "master" ] && BOOST_BRANCH=master || true
+          echo BOOST_BRANCH: $BOOST_BRANCH
+          cd ..
+          git clone -b $BOOST_BRANCH --depth 1 https://github.com/boostorg/boost.git boost-root
+          cd boost-root
+          cp -r $GITHUB_WORKSPACE/* libs/$LIBRARY
+          git submodule update --init tools/boostdep
+          python tools/boostdep/depinst/depinst.py --git_args "--jobs 3" $LIBRARY
+
+      - name: Configure
+        run: |
+          cd ../boost-root
+          mkdir __build__ && cd __build__
+          cmake -DBOOST_INCLUDE_LIBRARIES=$LIBRARY -DCMAKE_INSTALL_PREFIX=~/.local ..
+
+      - name: Install
+        run: |
+          cd ../boost-root/__build__
+          cmake --build . --target install
+
+      - name: Use the installed library
+        run: |
+          cd ../boost-root/libs/$LIBRARY/test/cmake_install_test && mkdir __build__ && cd __build__
+          cmake -DCMAKE_INSTALL_PREFIX=~/.local ..
+          cmake --build .
+          ctest --output-on-failure --no-tests=error
+
+  posix-cmake-test:
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - os: ubuntu-18.04
+          - os: ubuntu-20.04
+          - os: macos-10.15
+
+    runs-on: ${{matrix.os}}
+
+    steps:
+      - uses: actions/checkout@v2
+
+      - name: Install packages
+        if: matrix.install
+        run: sudo apt install ${{matrix.install}}
+
+      - name: Setup Boost
+        run: |
+          echo GITHUB_REPOSITORY: $GITHUB_REPOSITORY
+          LIBRARY=${GITHUB_REPOSITORY#*/}
+          echo LIBRARY: $LIBRARY
+          echo "LIBRARY=$LIBRARY" >> $GITHUB_ENV
+          echo GITHUB_BASE_REF: $GITHUB_BASE_REF
+          echo GITHUB_REF: $GITHUB_REF
+          REF=${GITHUB_BASE_REF:-$GITHUB_REF}
+          REF=${REF#refs/heads/}
+          echo REF: $REF
+          BOOST_BRANCH=develop && [ "$REF" == "master" ] && BOOST_BRANCH=master || true
+          echo BOOST_BRANCH: $BOOST_BRANCH
+          cd ..
+          git clone -b $BOOST_BRANCH --depth 1 https://github.com/boostorg/boost.git boost-root
+          cd boost-root
+          cp -r $GITHUB_WORKSPACE/* libs/$LIBRARY
+          git submodule update --init tools/boostdep
+          python tools/boostdep/depinst/depinst.py --git_args "--jobs 3" $LIBRARY
+
+      - name: Configure
+        run: |
+          cd ../boost-root
+          mkdir __build__ && cd __build__
+          cmake -DBOOST_INCLUDE_LIBRARIES=$LIBRARY -DBUILD_TESTING=ON ..
+
+      - name: Build tests
+        run: |
+          cd ../boost-root/__build__
+          cmake --build . --target tests
+
+      - name: Run tests
+        run: |
+          cd ../boost-root/__build__
+          ctest --output-on-failure --no-tests=error

CMakeLists.txt

@@ -1,4 +1,4 @@
-# Copyright 2018-2020 Peter Dimov
+# Copyright 2018-2021 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
 
@@ -13,7 +13,10 @@ target_include_directories(boost_system INTERFACE include)
 
 target_link_libraries(boost_system
   INTERFACE
+    Boost::assert
     Boost::config
+    Boost::throw_exception
+    Boost::variant2
     Boost::winapi
 )
 

doc/system/changes.adoc

@@ -11,7 +11,7 @@ https://www.boost.org/LICENSE_1_0.txt
 ## Changes in Boost 1.78
 
 * Added support for source locations to `error_code`.
-* Added `error_code::to_string`.
+* Added `error_code::to_string`, `error_condition::to_string`.
 * `system_error::what()` now contains the source location, if present.
 * Added `result<T, E = error_code>`, a class holding either a value or an
   error, defined in `<boost/system/result.hpp>`.

doc/system/reference.adoc

@@ -725,7 +725,7 @@ constexpr void assign( int val, const error_category & cat ) noexcept;
 [none]
 * {blank}
 +
-Effects: :: `*this = error_code( val, cat );`.
+Effects: :: `*this = error_code( val, cat )`.
 
 ```
 void assign( int val, const error_category & cat,
@@ -734,7 +734,7 @@ void assign( int val, const error_category & cat,
 [none]
 * {blank}
 +
-Effects: :: `*this = error_code( val, cat, loc );`.
+Effects: :: `*this = error_code( val, cat, loc )`.
 
 ```
 template<typename ErrorCodeEnum>
@@ -753,7 +753,7 @@ constexpr void clear() noexcept;
 * {blank}
 +
 Effects: ::
-  `*this = error_code();`.
+  `*this = error_code()`.
 
 #### Observers
 
@@ -1096,6 +1096,10 @@ public:
 
     operator std::error_condition() const;
 
+    // to_string
+
+    std::string to_string() const;
+
     // stream insertion
 
     template <class charT, class traits>
@@ -1284,6 +1288,17 @@ operator std::error_condition() const;
 Returns: ::
   `std::error_condition( value(), category() )`.
 
+#### to_string
+
+```
+std::string to_string() const;
+```
+[none]
+* {blank}
++
+Returns: :: The concatenation of `"cond:"`, `category().name()`, `':'`,
+  and the string representation of `value()`.
+
 #### Stream Insertion
 
 ```
@@ -1294,7 +1309,7 @@ template <class charT, class traits>
 [none]
 * {blank}
 +
-Effects: :: `os << "cond:" << en.category().name() << ':' << en.value()`.
+Effects: :: `os << en.to_string()`.
 Returns: ::
   `os`.
 
@@ -1700,8 +1715,8 @@ template<class Ch, class Tr, class T, class E>
 * {blank}
 +
 Effects: ::
-  - If `*this` holds a value `t`, `os << "value:" << t;`.
-  - If `*this` holds an error `e`, `os << "error:" << e;`.
+  - If `*this` holds a value `t`, `os << "value:" << t`.
+  - If `*this` holds an error `e`, `os << "error:" << e`.
 Returns: ::
   `os`.
 
@@ -1943,8 +1958,8 @@ template<class Ch, class Tr, class E>
 * {blank}
 +
 Effects: ::
-  - If `*this` holds a value, `os << "value:void";`.
-  - If `*this` holds an error `e`, `os << "error:" << e;`.
+  - If `*this` holds a value, `os << "value:void"`.
+  - If `*this` holds an error `e`, `os << "error:" << e`.
 Returns: ::
   `os`.
 

include/boost/system/detail/append_int.hpp

@@ -0,0 +1,32 @@
+#ifndef BOOST_SYSTEM_DETAIL_APPEND_INT_HPP_INCLUDED
+#define BOOST_SYSTEM_DETAIL_APPEND_INT_HPP_INCLUDED
+
+// Copyright 2021 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt)
+
+#include <boost/system/detail/snprintf.hpp>
+#include <string>
+
+//
+
+namespace boost
+{
+namespace system
+{
+namespace detail
+{
+
+inline void append_int( std::string& s, int v )
+{
+    char buffer[ 32 ];
+    detail::snprintf( buffer, sizeof( buffer ), ":%d", v );
+
+    s += buffer;
+}
+
+} // namespace detail
+} // namespace system
+} // namespace boost
+
+#endif // #ifndef BOOST_SYSTEM_DETAIL_APPEND_INT_HPP_INCLUDED

include/boost/system/detail/error_category.hpp

@@ -55,6 +55,9 @@ private:
     friend std::size_t hash_value( error_code const & ec );
     friend BOOST_SYSTEM_CONSTEXPR bool detail::failed_impl( int ev, error_category const & cat );
 
+    friend class error_code;
+    friend class error_condition;
+
 #if !defined(BOOST_NO_CXX11_DELETED_FUNCTIONS)
 public:
 
@@ -170,9 +173,9 @@ public:
 namespace detail
 {
 
-static const boost::ulong_long_type generic_category_id = ( boost::ulong_long_type( 0xB2AB117A ) << 32 ) + 0x257EDF0D;
-static const boost::ulong_long_type system_category_id = ( boost::ulong_long_type( 0x8FAFD21E ) << 32 ) + 0x25C5E09B;
-static const boost::ulong_long_type interop_category_id = ( boost::ulong_long_type( 0x943F2817 ) << 32 ) + 0xFD3A8FAF;
+static const boost::ulong_long_type generic_category_id = ( boost::ulong_long_type( 0xB2AB117A ) << 32 ) + 0x257EDFD0;
+static const boost::ulong_long_type system_category_id = generic_category_id + 1;
+static const boost::ulong_long_type interop_category_id = generic_category_id + 2;
 
 BOOST_SYSTEM_CONSTEXPR inline bool failed_impl( int ev, error_category const & cat )
 {

include/boost/system/detail/error_category_impl.hpp

@@ -20,7 +20,6 @@
 
 namespace boost
 {
-
 namespace system
 {
 
@@ -38,7 +37,7 @@ inline bool error_category::equivalent( int code, const error_condition & condit
 
 inline bool error_category::equivalent( const error_code & code, int condition ) const BOOST_NOEXCEPT
 {
-    return *this == code.category() && code.value() == condition;
+    return code.equals( condition, *this );
 }
 
 inline char const * error_category::message( int ev, char * buffer, std::size_t len ) const BOOST_NOEXCEPT
@@ -91,7 +90,6 @@ inline char const * error_category::message( int ev, char * buffer, std::size_t
 }
 
 } // namespace system
-
 } // namespace boost
 
 // interoperability with std::error_code, std::error_condition
@@ -100,28 +98,54 @@ inline char const * error_category::message( int ev, char * buffer, std::size_t
 
 #include <boost/system/detail/std_category.hpp>
 
-inline boost::system::error_category::operator std::error_category const & () const
+namespace boost
 {
-    if( id_ == boost::system::detail::system_category_id )
+namespace system
+{
+
+inline error_category::operator std::error_category const & () const
+{
+    if( id_ == detail::generic_category_id )
     {
-        static const boost::system::detail::std_category system_instance( this, 0x1F4D7 );
-        return system_instance;
+// This condition must be the same as the one in error_condition.hpp
+#if defined(BOOST_GCC) && BOOST_GCC < 50000
+
+    static const boost::system::detail::std_category generic_instance( this, 0x1F4D3 );
+    return generic_instance;
+
+#else
+
+    return std::generic_category();
+
+#endif
     }
 
-    if( id_ == boost::system::detail::generic_category_id )
+    if( id_ == detail::system_category_id )
     {
-        static const boost::system::detail::std_category generic_instance( this, 0x1F4D3 );
-        return generic_instance;
+// This condition must be the same as the one in error_code.hpp
+#if defined(__CYGWIN__) || defined(__MINGW32__) || (defined(_MSC_VER) && _MSC_VER == 1800) || (defined(BOOST_GCC) && BOOST_GCC < 50000)
+
+    // Under Cygwin (and MinGW!), std::system_category() is POSIX
+    // Under VS2013, std::system_category() isn't quite right
+
+    static const boost::system::detail::std_category system_instance( this, 0x1F4D7 );
+    return system_instance;
+
+#else
+
+    return std::system_category();
+
+#endif
     }
 
-    boost::system::detail::std_category* p = ps_.load( std::memory_order_acquire );
+    detail::std_category* p = ps_.load( std::memory_order_acquire );
 
     if( p != 0 )
     {
         return *p;
     }
 
-    boost::system::detail::std_category* q = new detail::std_category( this, 0 );
+    detail::std_category* q = new detail::std_category( this, 0 );
 
     if( ps_.compare_exchange_strong( p, q, std::memory_order_release, std::memory_order_acquire ) )
     {
@@ -134,6 +158,9 @@ inline boost::system::error_category::operator std::error_category const & () co
     }
 }
 
+} // namespace system
+} // namespace boost
+
 #endif // #if defined(BOOST_SYSTEM_HAS_SYSTEM_ERROR)
 
 #endif // #ifndef BOOST_SYSTEM_DETAIL_ERROR_CATEGORY_IMPL_HPP_INCLUDED

include/boost/system/detail/error_code.hpp

@@ -18,6 +18,7 @@
 #include <boost/system/detail/interop_category.hpp>
 #include <boost/system/detail/enable_if.hpp>
 #include <boost/system/detail/is_same.hpp>
+#include <boost/system/detail/append_int.hpp>
 #include <boost/system/detail/snprintf.hpp>
 #include <boost/system/detail/config.hpp>
 #include <boost/assert/source_location.hpp>
@@ -285,6 +286,30 @@ public:
 
     // relationals:
 
+private:
+
+    // private equality for use in error_category::equivalent
+
+    friend class error_category;
+
+    BOOST_SYSTEM_CONSTEXPR bool equals( int val, error_category const& cat ) const BOOST_NOEXCEPT
+    {
+        if( lc_flags_ == 0 )
+        {
+            return val == 0 && cat.id_ == detail::system_category_id;
+        }
+        else if( lc_flags_ == 1 )
+        {
+            return cat.id_ == detail::interop_category_id && val == value();
+        }
+        else
+        {
+            return val == d1_.val_ && cat == *d1_.cat_;
+        }
+    }
+
+public:
+
     //  the more symmetrical non-member syntax allows enum
     //  conversions work for both rhs and lhs.
 
@@ -479,8 +504,16 @@ public:
         }
         else if( lc_flags_ == 0 )
         {
-            //return std::error_code();
+// This condition must be the same as the one in error_category_impl.hpp
+#if defined(__CYGWIN__) || defined(__MINGW32__) || (defined(_MSC_VER) && _MSC_VER == 1800) || (defined(BOOST_GCC) && BOOST_GCC < 50000)
+
             return std::error_code( 0, boost::system::system_category() );
+
+#else
+
+            return std::error_code();
+
+#endif
         }
         else
         {
@@ -525,18 +558,18 @@ public:
         {
             std::error_code const& e2 = *reinterpret_cast<std::error_code const*>( d2_ );
 
-            char buffer[ 32 ];
-            detail::snprintf( buffer, sizeof( buffer ), "%d", e2.value() );
+            std::string r( "std:" );
+            r += e2.category().name();
+            detail::append_int( r, e2.value() );
 
-            return std::string( "std:" ) + e2.category().name() + ":" + buffer;
+            return r;
         }
         else
 #endif
         {
-            char buffer[ 32 ];
-            detail::snprintf( buffer, sizeof( buffer ), "%d", value() );
-
-            return std::string( category().name() ) + ":" + buffer;
+            std::string r = category().name();
+            detail::append_int( r, value() );
+            return r;
         }
     }
 

include/boost/system/detail/error_condition.hpp

@@ -15,6 +15,7 @@
 #include <boost/system/detail/enable_if.hpp>
 #include <boost/system/detail/is_same.hpp>
 #include <boost/system/detail/errc.hpp>
+#include <boost/system/detail/append_int.hpp>
 #include <boost/system/is_error_condition_enum.hpp>
 #include <boost/system/detail/config.hpp>
 #include <boost/config.hpp>
@@ -47,6 +48,13 @@ private:
     int val_;
     error_category const * cat_;
 
+private:
+
+    boost::ulong_long_type cat_id() const BOOST_NOEXCEPT
+    {
+        return cat_? cat_->id_: detail::generic_category_id;
+    }
+
 public:
 
     // constructors:
@@ -122,7 +130,7 @@ public:
         }
         else
         {
-            return generic_category().message( value() );
+            return detail::generic_error_category_message( value() );
         }
     }
 
@@ -134,7 +142,7 @@ public:
         }
         else
         {
-            return generic_category().message( value(), buffer, len );
+            return detail::generic_error_category_message( value(), buffer, len );
         }
     }
 
@@ -180,7 +188,22 @@ public:
 
     BOOST_SYSTEM_CONSTEXPR inline friend bool operator==( const error_condition & lhs, const error_condition & rhs ) BOOST_NOEXCEPT
     {
-        return lhs.val_ == rhs.val_ && lhs.category() == rhs.category();
+        if( lhs.val_ != rhs.val_ )
+        {
+            return false;
+        }
+        else if( lhs.cat_ == 0 )
+        {
+            return rhs.cat_id() == detail::generic_category_id;
+        }
+        else if( rhs.cat_ == 0 )
+        {
+            return lhs.cat_id() == detail::generic_category_id;
+        }
+        else
+        {
+            return *lhs.cat_ == *rhs.cat_;
+        }
     }
 
     BOOST_SYSTEM_CONSTEXPR inline friend bool operator<( const error_condition & lhs, const error_condition & rhs ) BOOST_NOEXCEPT
@@ -199,7 +222,23 @@ public:
 
     operator std::error_condition () const
     {
+// This condition must be the same as the one in error_category_impl.hpp
+#if defined(BOOST_GCC) && BOOST_GCC < 50000
+
         return std::error_condition( value(), category() );
+
+#else
+
+        if( cat_ )
+        {
+            return std::error_condition( val_, *cat_ );
+        }
+        else
+        {
+            return std::error_condition( val_, std::generic_category() );
+        }
+
+#endif
     }
 
     inline friend bool operator==( std::error_code const & lhs, error_condition const & rhs ) BOOST_NOEXCEPT
@@ -224,14 +263,29 @@ public:
 
 #endif
 
+    std::string to_string() const
+    {
+        std::string r( "cond:" );
+
+        if( cat_ )
+        {
+            r += cat_->name();
+        }
+        else
+        {
+            r += "generic";
+        }
+
+        detail::append_int( r, value() );
+
+        return r;
+    }
+
     template<class Ch, class Tr>
         inline friend std::basic_ostream<Ch, Tr>&
         operator<< (std::basic_ostream<Ch, Tr>& os, error_condition const & en)
     {
-        {
-            os << "cond:" << en.category().name() << ':' << en.value();
-        }
-
+        os << en.to_string();
         return os;
     }
 };

include/boost/system/system_error.hpp

@@ -6,9 +6,8 @@
 // Distributed under the Boost Software License, Version 1.0.
 // https://www.boost.org/LICENSE_1_0.txt
 
+#include <boost/system/errc.hpp>
 #include <boost/system/detail/error_code.hpp>
-#include <boost/system/detail/error_category_impl.hpp>
-#include <boost/system/detail/snprintf.hpp>
 #include <string>
 #include <stdexcept>
 #include <cassert>
@@ -26,14 +25,6 @@ private:
 
 private:
 
-    static std::string to_string( int v )
-    {
-        char buffer[ 32 ];
-        detail::snprintf( buffer, sizeof( buffer ), "%d", v );
-
-        return buffer;
-    }
-
     static std::string build_message( char const * prefix, error_code const & ec )
     {
         std::string r;
@@ -51,23 +42,8 @@ private:
             r += " [";
             r += ec.to_string();
             r += " at ";
-
-            boost::source_location loc = ec.location();
-
-            r += loc.file_name();
-
-            r += ':';
-            r += to_string( loc.line() );
-
-            if( loc.column() != 0 )
-            {
-                r += ':';
-                r += to_string( loc.column() );
-            }
-
-            r += " in function '";
-            r += loc.function_name();
-            r += "\']";
+            r += ec.location().to_string();
+            r += "]";
         }
 
         return r;

test/CMakeLists.txt

@@ -98,3 +98,26 @@ boost_test(TYPE run SOURCES std_interop_test6.cpp)
 boost_test(TYPE run SOURCES std_interop_test7.cpp)
 boost_test(TYPE run SOURCES std_interop_test8.cpp)
 boost_test(TYPE run SOURCES std_interop_test9.cpp)
+
+boost_test(TYPE run SOURCES ec_location_test.cpp)
+
+boost_test(TYPE run SOURCES error_condition_test3.cpp)
+boost_test(TYPE run SOURCES error_code_test2.cpp)
+boost_test(TYPE run SOURCES system_error_test2.cpp)
+boost_test(TYPE run SOURCES std_interop_test10.cpp)
+
+# result
+
+set(BOOST_TEST_COMPILE_FEATURES cxx_std_11)
+
+boost_test(TYPE run SOURCES result_default_construct.cpp)
+boost_test(TYPE run SOURCES result_value_construct.cpp)
+boost_test(TYPE run SOURCES result_error_construct.cpp)
+boost_test(TYPE run SOURCES result_copy_construct.cpp)
+boost_test(TYPE run SOURCES result_move_construct.cpp)
+boost_test(TYPE run SOURCES result_copy_assign.cpp)
+boost_test(TYPE run SOURCES result_move_assign.cpp)
+boost_test(TYPE run SOURCES result_value_access.cpp)
+boost_test(TYPE run SOURCES result_error_access.cpp)
+boost_test(TYPE run SOURCES result_swap.cpp)
+boost_test(TYPE run SOURCES result_eq.cpp)

test/Jamfile.v2

@@ -123,6 +123,11 @@ run std_interop_test9.cpp ;
 
 run ec_location_test.cpp ;
 
+run error_condition_test3.cpp ;
+run error_code_test2.cpp ;
+run system_error_test2.cpp ;
+run std_interop_test10.cpp ;
+
 # result
 
 import ../../config/checks/config : requires ;

test/cmake_subdir_test/CMakeLists.txt

@@ -1,8 +1,8 @@
-# Copyright 2018, 2019 Peter Dimov
+# Copyright 2018-2021 Peter Dimov
 # Distributed under the Boost Software License, Version 1.0.
 # See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt
 
-cmake_minimum_required(VERSION 3.5...3.16)
+cmake_minimum_required(VERSION 3.5...3.20)
 
 project(cmake_subdir_test LANGUAGES CXX)
 
@@ -10,7 +10,10 @@ add_subdirectory(../.. boostorg/system)
 add_subdirectory(../../../assert boostorg/assert)
 add_subdirectory(../../../config boostorg/config)
 add_subdirectory(../../../core boostorg/core)
+add_subdirectory(../../../mp11 boostorg/mp11)
 add_subdirectory(../../../predef boostorg/predef)
+add_subdirectory(../../../throw_exception boostorg/throw_exception)
+add_subdirectory(../../../variant2 boostorg/variant2)
 add_subdirectory(../../../winapi boostorg/winapi)
 
 add_executable(quick ../quick.cpp)
@@ -19,4 +22,4 @@ target_link_libraries(quick Boost::system Boost::core)
 enable_testing()
 add_test(quick quick)
 
-add_custom_target(check COMMAND ${CMAKE_CTEST_COMMAND} --output-on-failure -C $<CONFIG>)
+add_custom_target(check COMMAND ${CMAKE_CTEST_COMMAND} --output-on-failure --no-tests=error -C $<CONFIG>)

test/error_code_test2.cpp

@@ -0,0 +1,94 @@
+// Copyright 2020, 2021 Peter Dimov.
+// Distributed under the Boost Software License, Version 1.0.
+// http://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/system/error_code.hpp>
+#include <boost/system/generic_category.hpp>
+#include <boost/system/system_category.hpp>
+#include <boost/core/lightweight_test.hpp>
+
+namespace sys = boost::system;
+
+int main()
+{
+    char buffer[ 1024 ];
+
+    sys::error_code ec;
+
+    BOOST_TEST_EQ( ec.value(), 0 );
+    BOOST_TEST( ec.category() == sys::system_category() );
+    BOOST_TEST_EQ( ec.message(), ec.category().message( ec.value() ) );
+    BOOST_TEST_CSTR_EQ( ec.message( buffer, sizeof( buffer ) ), ec.category().message( ec.value(), buffer, sizeof( buffer ) ) );
+    BOOST_TEST( !ec.failed() );
+    BOOST_TEST( !ec );
+
+    BOOST_TEST_EQ( ec.to_string(), std::string( "system:0" ) );
+
+    {
+        sys::error_code ec2( ec );
+
+        BOOST_TEST_EQ( ec2.value(), 0 );
+        BOOST_TEST( ec2.category() == sys::system_category() );
+        BOOST_TEST_EQ( ec2.message(), ec2.category().message( ec2.value() ) );
+        BOOST_TEST_CSTR_EQ( ec2.message( buffer, sizeof( buffer ) ), ec2.category().message( ec2.value(), buffer, sizeof( buffer ) ) );
+        BOOST_TEST( !ec2.failed() );
+        BOOST_TEST( !ec2 );
+
+        BOOST_TEST_EQ( ec, ec2 );
+        BOOST_TEST_NOT( ec != ec2 );
+
+        BOOST_TEST_EQ( ec2.to_string(), std::string( "system:0" ) );
+    }
+
+    {
+        sys::error_code ec2( ec.value(), ec.category() );
+
+        BOOST_TEST_EQ( ec2.value(), 0 );
+        BOOST_TEST( ec2.category() == sys::system_category() );
+        BOOST_TEST_EQ( ec2.message(), ec2.category().message( ec2.value() ) );
+        BOOST_TEST_CSTR_EQ( ec2.message( buffer, sizeof( buffer ) ), ec2.category().message( ec2.value(), buffer, sizeof( buffer ) ) );
+        BOOST_TEST( !ec2.failed() );
+        BOOST_TEST( !ec2 );
+
+        BOOST_TEST_EQ( ec, ec2 );
+        BOOST_TEST_NOT( ec != ec2 );
+
+        BOOST_TEST_EQ( ec2.to_string(), std::string( "system:0" ) );
+    }
+
+    {
+        sys::error_code ec2( 5, sys::generic_category() );
+
+        BOOST_TEST_EQ( ec2.value(), 5 );
+        BOOST_TEST( ec2.category() == sys::generic_category() );
+        BOOST_TEST_EQ( ec2.message(), ec2.category().message( ec2.value() ) );
+        BOOST_TEST_CSTR_EQ( ec2.message( buffer, sizeof( buffer ) ), ec2.category().message( ec2.value(), buffer, sizeof( buffer ) ) );
+        BOOST_TEST( ec2.failed() );
+        BOOST_TEST( ec2 );
+        BOOST_TEST_NOT( !ec2 );
+
+        BOOST_TEST_NE( ec, ec2 );
+        BOOST_TEST_NOT( ec == ec2 );
+
+        BOOST_TEST_EQ( ec2.to_string(), std::string( "generic:5" ) );
+    }
+
+    {
+        sys::error_code ec2( 5, sys::system_category() );
+
+        BOOST_TEST_EQ( ec2.value(), 5 );
+        BOOST_TEST( ec2.category() == sys::system_category() );
+        BOOST_TEST_EQ( ec2.message(), ec2.category().message( ec2.value() ) );
+        BOOST_TEST_CSTR_EQ( ec2.message( buffer, sizeof( buffer ) ), ec2.category().message( ec2.value(), buffer, sizeof( buffer ) ) );
+        BOOST_TEST( ec2.failed() );
+        BOOST_TEST( ec2 );
+        BOOST_TEST_NOT( !ec2 );
+
+        BOOST_TEST_NE( ec, ec2 );
+        BOOST_TEST_NOT( ec == ec2 );
+
+        BOOST_TEST_EQ( ec2.to_string(), std::string( "system:5" ) );
+    }
+
+    return boost::report_errors();
+}

test/error_condition_test3.cpp

@@ -0,0 +1,94 @@
+// Copyright 2020, 2021 Peter Dimov.
+// Distributed under the Boost Software License, Version 1.0.
+// http://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/system/error_condition.hpp>
+#include <boost/system/generic_category.hpp>
+#include <boost/system/system_category.hpp>
+#include <boost/core/lightweight_test.hpp>
+
+namespace sys = boost::system;
+
+int main()
+{
+    char buffer[ 1024 ];
+
+    sys::error_condition en;
+
+    BOOST_TEST_EQ( en.value(), 0 );
+    BOOST_TEST( en.category() == sys::generic_category() );
+    BOOST_TEST_EQ( en.message(), en.category().message( en.value() ) );
+    BOOST_TEST_CSTR_EQ( en.message( buffer, sizeof( buffer ) ), en.category().message( en.value(), buffer, sizeof( buffer ) ) );
+    BOOST_TEST( !en.failed() );
+    BOOST_TEST( !en );
+
+    BOOST_TEST_EQ( en.to_string(), std::string( "cond:generic:0" ) );
+
+    {
+        sys::error_condition en2( en );
+
+        BOOST_TEST_EQ( en2.value(), 0 );
+        BOOST_TEST( en2.category() == sys::generic_category() );
+        BOOST_TEST_EQ( en2.message(), en2.category().message( en2.value() ) );
+        BOOST_TEST_CSTR_EQ( en2.message( buffer, sizeof( buffer ) ), en2.category().message( en2.value(), buffer, sizeof( buffer ) ) );
+        BOOST_TEST( !en2.failed() );
+        BOOST_TEST( !en2 );
+
+        BOOST_TEST_EQ( en, en2 );
+        BOOST_TEST_NOT( en != en2 );
+
+        BOOST_TEST_EQ( en2.to_string(), std::string( "cond:generic:0" ) );
+    }
+
+    {
+        sys::error_condition en2( en.value(), en.category() );
+
+        BOOST_TEST_EQ( en2.value(), 0 );
+        BOOST_TEST( en2.category() == sys::generic_category() );
+        BOOST_TEST_EQ( en2.message(), en2.category().message( en2.value() ) );
+        BOOST_TEST_CSTR_EQ( en2.message( buffer, sizeof( buffer ) ), en2.category().message( en2.value(), buffer, sizeof( buffer ) ) );
+        BOOST_TEST( !en2.failed() );
+        BOOST_TEST( !en2 );
+
+        BOOST_TEST_EQ( en, en2 );
+        BOOST_TEST_NOT( en != en2 );
+
+        BOOST_TEST_EQ( en2.to_string(), std::string( "cond:generic:0" ) );
+    }
+
+    {
+        sys::error_condition en2( 5, sys::generic_category() );
+
+        BOOST_TEST_EQ( en2.value(), 5 );
+        BOOST_TEST( en2.category() == sys::generic_category() );
+        BOOST_TEST_EQ( en2.message(), en2.category().message( en2.value() ) );
+        BOOST_TEST_CSTR_EQ( en2.message( buffer, sizeof( buffer ) ), en2.category().message( en2.value(), buffer, sizeof( buffer ) ) );
+        BOOST_TEST( en2.failed() );
+        BOOST_TEST( en2 );
+        BOOST_TEST_NOT( !en2 );
+
+        BOOST_TEST_NE( en, en2 );
+        BOOST_TEST_NOT( en == en2 );
+
+        BOOST_TEST_EQ( en2.to_string(), std::string( "cond:generic:5" ) );
+    }
+
+    {
+        sys::error_condition en2( 5, sys::system_category() );
+
+        BOOST_TEST_EQ( en2.value(), 5 );
+        BOOST_TEST( en2.category() == sys::system_category() );
+        BOOST_TEST_EQ( en2.message(), en2.category().message( en2.value() ) );
+        BOOST_TEST_CSTR_EQ( en2.message( buffer, sizeof( buffer ) ), en2.category().message( en2.value(), buffer, sizeof( buffer ) ) );
+        BOOST_TEST( en2.failed() );
+        BOOST_TEST( en2 );
+        BOOST_TEST_NOT( !en2 );
+
+        BOOST_TEST_NE( en, en2 );
+        BOOST_TEST_NOT( en == en2 );
+
+        BOOST_TEST_EQ( en2.to_string(), std::string( "cond:system:5" ) );
+    }
+
+    return boost::report_errors();
+}

test/std_interop_test.cpp

@@ -44,7 +44,8 @@ static void test_generic_category()
 
     int ev = ENOENT;
 
-    BOOST_TEST_EQ( bt.message( ev ), st.message( ev ) );
+    // Under MSVC, it's "no such file or directory" instead of "No such file or directory"
+    BOOST_TEST_EQ( bt.message( ev ).substr( 1 ), st.message( ev ).substr( 1 ) );
 
     {
         boost::system::error_code bc( ev, bt );
@@ -82,34 +83,13 @@ static void test_system_category()
 
     BOOST_TEST_CSTR_EQ( bt.name(), st.name() );
 
+    for( int ev = 1; ev < 6; ++ev )
     {
-        int ev = 5;
-        BOOST_TEST_EQ( bt.message( ev ), st.message( ev ) );
+        std::string bm = bt.message( ev );
+        std::string sm = st.message( ev );
 
-        {
-            boost::system::error_code bc( ev, bt );
-
-            BOOST_TEST_EQ( bc.value(), ev );
-            BOOST_TEST_EQ( &bc.category(), &bt );
-
-            std::error_code sc( bc );
-
-            BOOST_TEST_EQ( sc.value(), ev );
-            BOOST_TEST_EQ( &sc.category(), &st );
-        }
-
-        {
-            boost::system::error_condition bn = bt.default_error_condition( ev );
-            BOOST_TEST( bt.equivalent( ev, bn ) );
-
-            std::error_condition sn( bn );
-            BOOST_TEST( st.equivalent( ev, sn ) );
-        }
-    }
-
-    {
-        int ev = 4;
-        BOOST_TEST_EQ( bt.message( ev ), st.message( ev ) );
+        // We strip whitespace and the trailing dot, MSVC not so much
+        BOOST_TEST_EQ( bm, sm.substr( 0, bm.size() ) );
 
         {
             boost::system::error_code bc( ev, bt );

test/std_interop_test10.cpp

@@ -0,0 +1,66 @@
+// Copyright 2021 Peter Dimov.
+// Distributed under the Boost Software License, Version 1.0.
+// http://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/system/error_code.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <boost/config/pragma_message.hpp>
+#include <cerrno>
+
+#if !defined(BOOST_SYSTEM_HAS_SYSTEM_ERROR)
+
+BOOST_PRAGMA_MESSAGE( "BOOST_SYSTEM_HAS_SYSTEM_ERROR not defined, test will be skipped" )
+int main() {}
+
+#else
+
+#include <system_error>
+
+int main()
+{
+    {
+        boost::system::error_code e1;
+        boost::system::error_code e2( 0, boost::system::system_category() );
+
+        BOOST_TEST_EQ( e1, e2 );
+
+        std::error_code e3( e1 );
+        std::error_code e4( e2 );
+
+        BOOST_TEST_EQ( e3, e4 );
+    }
+
+    {
+        boost::system::error_code e1;
+
+        std::error_code e2( e1 );
+        std::error_code e3( e1.value(), e1.category() );
+
+        BOOST_TEST_EQ( e2, e3 );
+    }
+
+    {
+        boost::system::error_condition e1;
+        boost::system::error_condition e2( 0, boost::system::generic_category() );
+
+        BOOST_TEST_EQ( e1, e2 );
+
+        std::error_condition e3( e1 );
+        std::error_condition e4( e2 );
+
+        BOOST_TEST( e3 == e4 );
+    }
+
+    {
+        boost::system::error_condition e1;
+
+        std::error_condition e2( e1 );
+        std::error_condition e3( e1.value(), e1.category() );
+
+        BOOST_TEST( e2 == e3 );
+    }
+
+    return boost::report_errors();
+}
+
+#endif

test/std_interop_test6.cpp

@@ -30,13 +30,20 @@ int main()
         BOOST_TEST_EQ( e2, e1 );
         BOOST_TEST_NOT( e2 != e1 );
 
-        BOOST_TEST( e2 == en );
+#if defined(_LIBCPP_VERSION)
+
+        // Under MS STL and libstdc++, std::error_code() does not compare
+        // equal to std::error_condition(). Go figure.
+
+        BOOST_TEST_EQ( e2, en );
         BOOST_TEST_NOT( e2 != en );
 
         boost::system::error_code e3( e2 );
 
         BOOST_TEST_EQ( e3, en );
         BOOST_TEST_NOT( e3 != en );
+
+#endif
     }
 
     {
@@ -51,13 +58,17 @@ int main()
         BOOST_TEST_EQ( e2, e1 );
         BOOST_TEST_NOT( e2 != e1 );
 
-        BOOST_TEST( e2 == en );
+#if defined(_LIBCPP_VERSION)
+
+        BOOST_TEST_EQ( e2, en );
         BOOST_TEST_NOT( e2 != en );
 
         boost::system::error_code e3( e2 );
 
         BOOST_TEST_EQ( e3, en );
         BOOST_TEST_NOT( e3 != en );
+
+#endif
     }
 
     {
@@ -72,7 +83,7 @@ int main()
         BOOST_TEST_EQ( e2, e1 );
         BOOST_TEST_NOT( e2 != e1 );
 
-        BOOST_TEST( e2 == en );
+        BOOST_TEST_EQ( e2, en );
         BOOST_TEST_NOT( e2 != en );
 
         boost::system::error_code e3( e2 );
@@ -93,7 +104,7 @@ int main()
         BOOST_TEST_EQ( e2, e1 );
         BOOST_TEST_NOT( e2 != e1 );
 
-        BOOST_TEST( e2 == en );
+        BOOST_TEST_EQ( e2, en );
         BOOST_TEST_NOT( e2 != en );
 
         boost::system::error_code e3( e2 );
@@ -114,7 +125,7 @@ int main()
         BOOST_TEST_EQ( e2, e1 );
         BOOST_TEST_NOT( e2 != e1 );
 
-        BOOST_TEST( e2 == en );
+        BOOST_TEST_EQ( e2, en );
         BOOST_TEST_NOT( e2 != en );
 
         boost::system::error_code e3( e2 );

test/system_error_test2.cpp

@@ -0,0 +1,41 @@
+// Copyright 2021 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/system/system_error.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <cerrno>
+
+namespace sys = boost::system;
+
+int main()
+{
+    {
+        sys::error_code ec( 5, sys::generic_category() );
+        sys::system_error x1( ec );
+        (void)x1;
+    }
+
+    {
+        sys::error_code ec( 5, sys::system_category() );
+        sys::system_error x1( ec );
+        (void)x1;
+    }
+
+    {
+        sys::system_error x1( make_error_code( sys::errc::invalid_argument ) );
+        (void)x1;
+    }
+
+    {
+        sys::system_error x1( 5, sys::generic_category() );
+        (void)x1;
+    }
+
+    {
+        sys::system_error x1( 5, sys::system_category() );
+        (void)x1;
+    }
+
+    return boost::report_errors();
+}