Excise generic_category() references from error_condition

.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

@@ -38,7 +38,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

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.
 
@@ -525,18 +550,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
@@ -224,14 +247,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;
     }
 };

test/CMakeLists.txt

@@ -98,3 +98,24 @@ 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)
+
+# 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,9 @@ run std_interop_test9.cpp ;
 
 run ec_location_test.cpp ;
 
+run error_condition_test3.cpp ;
+run error_code_test2.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();
+}