Update .drone.jsonnet

Fixes -Wnonnull warnings when calling message with a nullptr buffer

.drone.jsonnet

@@ -189,16 +189,16 @@ local windows_pipeline(name, image, environment, arch = "amd64") =
     ),
 
     linux_pipeline(
-        "Linux 22.04 GCC 12 32 ASAN",
+        "Linux 22.04 GCC 12 32",
         "cppalliance/droneubuntu2204:1",
-        { TOOLSET: 'gcc', COMPILER: 'g++-12', CXXSTD: '11,14,17,20,2b', ADDRMD: '32' } + asan,
+        { TOOLSET: 'gcc', COMPILER: 'g++-12', CXXSTD: '11,14,17,20,2b', ADDRMD: '32' },
         "g++-12-multilib",
     ),
 
     linux_pipeline(
-        "Linux 22.04 GCC 12 64 ASAN",
+        "Linux 22.04 GCC 12 64",
         "cppalliance/droneubuntu2204:1",
-        { TOOLSET: 'gcc', COMPILER: 'g++-12', CXXSTD: '11,14,17,20,2b', ADDRMD: '64' } + asan,
+        { TOOLSET: 'gcc', COMPILER: 'g++-12', CXXSTD: '11,14,17,20,2b', ADDRMD: '64' },
         "g++-12-multilib",
     ),
 
@@ -216,6 +216,34 @@ local windows_pipeline(name, image, environment, arch = "amd64") =
         "g++-13-multilib",
     ),
 
+    linux_pipeline(
+        "Linux 23.04 GCC 13 32 ASAN",
+        "cppalliance/droneubuntu2304:1",
+        { TOOLSET: 'gcc', COMPILER: 'g++-13', CXXSTD: '11,14,17,20,2b', ADDRMD: '32' } + asan,
+        "g++-13-multilib",
+    ),
+
+    linux_pipeline(
+        "Linux 23.04 GCC 13 64 ASAN",
+        "cppalliance/droneubuntu2304:1",
+        { TOOLSET: 'gcc', COMPILER: 'g++-13', CXXSTD: '11,14,17,20,2b', ADDRMD: '64' } + asan,
+        "g++-13-multilib",
+    ),
+
+    linux_pipeline(
+        "Linux 24.04 GCC 14 32",
+        "cppalliance/droneubuntu2404:1",
+        { TOOLSET: 'gcc', COMPILER: 'g++-14', CXXSTD: '11,14,17,20,2b', ADDRMD: '32' },
+        "g++-14-multilib",
+    ),
+
+    linux_pipeline(
+        "Linux 24.04 GCC 14 64",
+        "cppalliance/droneubuntu2404:1",
+        { TOOLSET: 'gcc', COMPILER: 'g++-14', CXXSTD: '11,14,17,20,2b', ADDRMD: '64' },
+        "g++-14-multilib",
+    ),
+
     linux_pipeline(
         "Linux 16.04 Clang 3.5",
         "cppalliance/droneubuntu1604:1",
@@ -273,17 +301,24 @@ local windows_pipeline(name, image, environment, arch = "amd64") =
     ),
 
     linux_pipeline(
-        "Linux 23.10 Clang 17 UBSAN",
+        "Linux 23.10 Clang 17",
         "cppalliance/droneubuntu2310:1",
-        { TOOLSET: 'clang', COMPILER: 'clang++-17', CXXSTD: '11,14,17,20,2b' } + ubsan,
+        { TOOLSET: 'clang', COMPILER: 'clang++-17', CXXSTD: '11,14,17,20,2b' },
         "clang-17",
     ),
 
     linux_pipeline(
-        "Linux 23.10 Clang 17 ASAN",
-        "cppalliance/droneubuntu2310:1",
-        { TOOLSET: 'clang', COMPILER: 'clang++-17', CXXSTD: '11,14,17,20,2b' } + asan,
-        "clang-17",
+        "Linux 24.04 Clang 18 UBSAN",
+        "cppalliance/droneubuntu2404:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-18', CXXSTD: '11,14,17,20,2b' } + ubsan,
+        "clang-18",
+    ),
+
+    linux_pipeline(
+        "Linux 24.04 Clang 18 ASAN",
+        "cppalliance/droneubuntu2404:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-18', CXXSTD: '11,14,17,20,2b' } + asan,
+        "clang-18",
     ),
 
     macos_pipeline(

.github/workflows/ci.yml

@@ -49,8 +49,7 @@ jobs:
             install: g++-10
           - toolset: gcc-11
             cxxstd: "11,14,17,2a"
-            os: ubuntu-20.04
-            install: g++-11
+            os: ubuntu-22.04
           - toolset: gcc-12
             cxxstd: "11,14,17,20,2b"
             os: ubuntu-22.04
@@ -60,6 +59,11 @@ jobs:
             os: ubuntu-latest
             container: ubuntu:23.04
             install: g++-13
+          - toolset: gcc-14
+            cxxstd: "11,14,17,20,2b"
+            os: ubuntu-latest
+            container: ubuntu:24.04
+            install: g++-14
           - toolset: clang
             compiler: clang++-3.9
             cxxstd: "11,14"
@@ -141,14 +145,20 @@ jobs:
             os: ubuntu-latest
             install: clang-17
           - toolset: clang
-            cxxstd: "11,14,17,2a"
-            os: macos-11
+            compiler: clang++-18
+            cxxstd: "11,14,17,20,2b"
+            container: ubuntu:24.04
+            os: ubuntu-latest
+            install: clang-18
           - toolset: clang
             cxxstd: "11,14,17,20,2b"
             os: macos-12
           - toolset: clang
             cxxstd: "11,14,17,20,2b"
             os: macos-13
+          - toolset: clang
+            cxxstd: "11,14,17,20,2b"
+            os: macos-14
 
     runs-on: ${{matrix.os}}
     container: ${{matrix.container}}
@@ -270,9 +280,9 @@ jobs:
         include:
           - os: ubuntu-20.04
           - os: ubuntu-22.04
-          - os: macos-11
           - os: macos-12
           - os: macos-13
+          - os: macos-14
 
     runs-on: ${{matrix.os}}
 
@@ -318,9 +328,9 @@ jobs:
         include:
           - os: ubuntu-20.04
           - os: ubuntu-22.04
-          - os: macos-11
           - os: macos-12
           - os: macos-13
+          - os: macos-14
 
     runs-on: ${{matrix.os}}
 
@@ -376,9 +386,9 @@ jobs:
         include:
           - os: ubuntu-20.04
           - os: ubuntu-22.04
-          - os: macos-11
           - os: macos-12
           - os: macos-13
+          - os: macos-14
 
     runs-on: ${{matrix.os}}
 

doc/system/changes.adoc

@@ -8,6 +8,11 @@ https://www.boost.org/LICENSE_1_0.txt
 # Revision History
 :idprefix:
 
+## Changes in Boost 1.86
+
+* Support `result<T> & fv`, where `fv` returns `void`.
+* Support `result<void> &= fv;`, where `fv` returns `void`.
+
 ## Changes in Boost 1.85
 
 * {cpp}03 is no longer supported; a {cpp}11 compiler is required. (This includes GCC 4.8 or later, and MSVC 14.0 (VS 2015) or later.)

include/boost/system/detail/generic_category_message.hpp

@@ -39,7 +39,19 @@ inline char const * strerror_r_helper( int r, char const * buffer ) noexcept
 
 inline char const * generic_error_category_message( int ev, char * buffer, std::size_t len ) noexcept
 {
-    return strerror_r_helper( strerror_r( ev, buffer, len ), buffer );
+    if( buffer != nullptr )
+    {
+        return strerror_r_helper( strerror_r( ev, buffer, len ), buffer );
+    }
+    else
+    {
+        // strerror_r requires non-null buffer pointer
+
+        char tmp[ 1 ] = {};
+        char const* r = strerror_r_helper( strerror_r( ev, tmp, 0 ), buffer );
+
+        return r == tmp? nullptr: r;
+    }
 }
 
 inline std::string generic_error_category_message( int ev )

include/boost/system/result.hpp

@@ -1296,6 +1296,20 @@ result<T, E>& operator&=( result<T, E>& r, F&& f )
     return r;
 }
 
+template<class E, class F,
+    class U = decltype( std::declval<F>()() ),
+    class En = typename std::enable_if<!detail::is_result<U>::value>::type
+>
+result<void, E>& operator&=( result<void, E>& r, F&& f )
+{
+    if( r )
+    {
+        std::forward<F>( f )();
+    }
+
+    return r;
+}
+
 // result &= unary-returning-result
 
 template<class T, class E, class F,

test/error_code_test2.cpp

@@ -11,26 +11,53 @@ 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" ) );
+    char buffer[ 4096 ], buffer2[ 4096 ];
 
     {
+        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(), buffer2, sizeof( buffer2 ) ) );
+        BOOST_TEST_CSTR_EQ( ec.message( buffer, sizeof( buffer ) ), ec.message().c_str() );
+
+        {
+            char const* msg = ec.message( nullptr, 0 );
+
+            if( msg != nullptr )
+            {
+                BOOST_TEST_CSTR_EQ( msg, ec.message().c_str() );
+            }
+        }
+
+        BOOST_TEST( !ec.failed() );
+        BOOST_TEST( !ec );
+
+        BOOST_TEST_EQ( ec.to_string(), std::string( "system:0" ) );
+    }
+
+    {
+        sys::error_code ec;
         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_CSTR_EQ( ec2.message( buffer, sizeof( buffer ) ), ec2.category().message( ec2.value(), buffer2, sizeof( buffer2 ) ) );
+        BOOST_TEST_CSTR_EQ( ec2.message( buffer, sizeof( buffer ) ), ec2.message().c_str() );
+
+        {
+            char const* msg = ec2.message( nullptr, 0 );
+
+            if( msg != nullptr )
+            {
+                BOOST_TEST_CSTR_EQ( msg, ec2.message().c_str() );
+            }
+        }
+
         BOOST_TEST( !ec2.failed() );
         BOOST_TEST( !ec2 );
 
@@ -41,12 +68,25 @@ int main()
     }
 
     {
+        sys::error_code ec;
         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_CSTR_EQ( ec2.message( buffer, sizeof( buffer ) ), ec2.category().message( ec2.value(), buffer2, sizeof( buffer2 ) ) );
+        BOOST_TEST_CSTR_EQ( ec2.message( buffer, sizeof( buffer ) ), ec2.message().c_str() );
+
+        {
+            char const* msg = ec2.message( nullptr, 0 );
+
+            if( msg != nullptr )
+            {
+                BOOST_TEST_CSTR_EQ( msg, ec2.message().c_str() );
+            }
+        }
+
         BOOST_TEST( !ec2.failed() );
         BOOST_TEST( !ec2 );
 
@@ -61,34 +101,124 @@ int main()
 
         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_CSTR_EQ( ec2.message( buffer, sizeof( buffer ) ), ec2.category().message( ec2.value(), buffer2, sizeof( buffer2 ) ) );
+        BOOST_TEST_CSTR_EQ( ec2.message( buffer, sizeof( buffer ) ), ec2.message().c_str() );
+
+        {
+            char const* msg = ec2.message( nullptr, 0 );
+
+            if( msg != nullptr )
+            {
+                BOOST_TEST_CSTR_EQ( msg, ec2.message().c_str() );
+            }
+        }
+
         BOOST_TEST( ec2.failed() );
         BOOST_TEST( ec2 );
         BOOST_TEST_NOT( !ec2 );
 
+        sys::error_code ec;
+
         BOOST_TEST_NE( ec, ec2 );
         BOOST_TEST_NOT( ec == ec2 );
 
         BOOST_TEST_EQ( ec2.to_string(), std::string( "generic:5" ) );
     }
 
+    {
+        sys::error_code ec2( -4, sys::generic_category() );
+
+        BOOST_TEST_EQ( ec2.value(), -4 );
+        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(), buffer2, sizeof( buffer2 ) ) );
+        BOOST_TEST_CSTR_EQ( ec2.message( buffer, sizeof( buffer ) ), ec2.message().c_str() );
+
+        {
+            char const* msg = ec2.message( nullptr, 0 );
+
+            if( msg != nullptr )
+            {
+                BOOST_TEST_CSTR_EQ( msg, ec2.message().c_str() );
+            }
+        }
+
+        BOOST_TEST( ec2.failed() );
+        BOOST_TEST( ec2 );
+        BOOST_TEST_NOT( !ec2 );
+
+        sys::error_code ec;
+
+        BOOST_TEST_NE( ec, ec2 );
+        BOOST_TEST_NOT( ec == ec2 );
+
+        BOOST_TEST_EQ( ec2.to_string(), std::string( "generic:-4" ) );
+    }
+
     {
         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_CSTR_EQ( ec2.message( buffer, sizeof( buffer ) ), ec2.category().message( ec2.value(), buffer2, sizeof( buffer2 ) ) );
+        BOOST_TEST_CSTR_EQ( ec2.message( buffer, sizeof( buffer ) ), ec2.message().c_str() );
+
+        {
+            char const* msg = ec2.message( nullptr, 0 );
+
+            if( msg != nullptr )
+            {
+                BOOST_TEST_CSTR_EQ( msg, ec2.message().c_str() );
+            }
+        }
+
         BOOST_TEST( ec2.failed() );
         BOOST_TEST( ec2 );
         BOOST_TEST_NOT( !ec2 );
 
+        sys::error_code ec;
+
         BOOST_TEST_NE( ec, ec2 );
         BOOST_TEST_NOT( ec == ec2 );
 
         BOOST_TEST_EQ( ec2.to_string(), std::string( "system:5" ) );
     }
 
+    {
+        sys::error_code ec2( -4, sys::system_category() );
+
+        BOOST_TEST_EQ( ec2.value(), -4 );
+        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(), buffer2, sizeof( buffer2 ) ) );
+        BOOST_TEST_CSTR_EQ( ec2.message( buffer, sizeof( buffer ) ), ec2.message().c_str() );
+
+        {
+            char const* msg = ec2.message( nullptr, 0 );
+
+            if( msg != nullptr )
+            {
+                BOOST_TEST_CSTR_EQ( msg, ec2.message().c_str() );
+            }
+        }
+
+        BOOST_TEST( ec2.failed() );
+        BOOST_TEST( ec2 );
+        BOOST_TEST_NOT( !ec2 );
+
+        sys::error_code ec;
+
+        BOOST_TEST_NE( ec, ec2 );
+        BOOST_TEST_NOT( ec == ec2 );
+
+        BOOST_TEST_EQ( ec2.to_string(), std::string( "system:-4" ) );
+    }
+
     return boost::report_errors();
 }

test/error_condition_test3.cpp

@@ -11,26 +11,53 @@ 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" ) );
+    char buffer[ 4096 ], buffer2[ 4096 ];
 
     {
+        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(), buffer2, sizeof( buffer2 ) ) );
+        BOOST_TEST_CSTR_EQ( en.message( buffer, sizeof( buffer ) ), en.message().c_str() );
+
+        {
+            char const* msg = en.message( nullptr, 0 );
+
+            if( msg != nullptr )
+            {
+                BOOST_TEST_CSTR_EQ( msg, en.message().c_str() );
+            }
+        }
+
+        BOOST_TEST( !en.failed() );
+        BOOST_TEST( !en );
+
+        BOOST_TEST_EQ( en.to_string(), std::string( "cond:generic:0" ) );
+    }
+
+    {
+        sys::error_condition en;
         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_CSTR_EQ( en2.message( buffer, sizeof( buffer ) ), en2.category().message( en2.value(), buffer2, sizeof( buffer2 ) ) );
+        BOOST_TEST_CSTR_EQ( en2.message( buffer, sizeof( buffer ) ), en2.message().c_str() );
+
+        {
+            char const* msg = en2.message( nullptr, 0 );
+
+            if( msg != nullptr )
+            {
+                BOOST_TEST_CSTR_EQ( msg, en2.message().c_str() );
+            }
+        }
+
         BOOST_TEST( !en2.failed() );
         BOOST_TEST( !en2 );
 
@@ -41,12 +68,25 @@ int main()
     }
 
     {
+        sys::error_condition en;
         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_CSTR_EQ( en2.message( buffer, sizeof( buffer ) ), en2.category().message( en2.value(), buffer2, sizeof( buffer2 ) ) );
+        BOOST_TEST_CSTR_EQ( en2.message( buffer, sizeof( buffer ) ), en2.message().c_str() );
+
+        {
+            char const* msg = en2.message( nullptr, 0 );
+
+            if( msg != nullptr )
+            {
+                BOOST_TEST_CSTR_EQ( msg, en2.message().c_str() );
+            }
+        }
+
         BOOST_TEST( !en2.failed() );
         BOOST_TEST( !en2 );
 
@@ -61,34 +101,124 @@ int main()
 
         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_CSTR_EQ( en2.message( buffer, sizeof( buffer ) ), en2.category().message( en2.value(), buffer2, sizeof( buffer2 ) ) );
+        BOOST_TEST_CSTR_EQ( en2.message( buffer, sizeof( buffer ) ), en2.message().c_str() );
+
+        {
+            char const* msg = en2.message( nullptr, 0 );
+
+            if( msg != nullptr )
+            {
+                BOOST_TEST_CSTR_EQ( msg, en2.message().c_str() );
+            }
+        }
+
         BOOST_TEST( en2.failed() );
         BOOST_TEST( en2 );
         BOOST_TEST_NOT( !en2 );
 
+        sys::error_condition en;
+
         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( -4, sys::generic_category() );
+
+        BOOST_TEST_EQ( en2.value(), -4 );
+        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(), buffer2, sizeof( buffer2 ) ) );
+        BOOST_TEST_CSTR_EQ( en2.message( buffer, sizeof( buffer ) ), en2.message().c_str() );
+
+        {
+            char const* msg = en2.message( nullptr, 0 );
+
+            if( msg != nullptr )
+            {
+                BOOST_TEST_CSTR_EQ( msg, en2.message().c_str() );
+            }
+        }
+
+        BOOST_TEST( en2.failed() );
+        BOOST_TEST( en2 );
+        BOOST_TEST_NOT( !en2 );
+
+        sys::error_condition en;
+
+        BOOST_TEST_NE( en, en2 );
+        BOOST_TEST_NOT( en == en2 );
+
+        BOOST_TEST_EQ( en2.to_string(), std::string( "cond:generic:-4" ) );
+    }
+
     {
         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_CSTR_EQ( en2.message( buffer, sizeof( buffer ) ), en2.category().message( en2.value(), buffer2, sizeof( buffer2 ) ) );
+        BOOST_TEST_CSTR_EQ( en2.message( buffer, sizeof( buffer ) ), en2.message().c_str() );
+
+        {
+            char const* msg = en2.message( nullptr, 0 );
+
+            if( msg != nullptr )
+            {
+                BOOST_TEST_CSTR_EQ( msg, en2.message().c_str() );
+            }
+        }
+
         BOOST_TEST( en2.failed() );
         BOOST_TEST( en2 );
         BOOST_TEST_NOT( !en2 );
 
+        sys::error_condition en;
+
         BOOST_TEST_NE( en, en2 );
         BOOST_TEST_NOT( en == en2 );
 
         BOOST_TEST_EQ( en2.to_string(), std::string( "cond:system:5" ) );
     }
 
+    {
+        sys::error_condition en2( -4, sys::system_category() );
+
+        BOOST_TEST_EQ( en2.value(), -4 );
+        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(), buffer2, sizeof( buffer2 ) ) );
+        BOOST_TEST_CSTR_EQ( en2.message( buffer, sizeof( buffer ) ), en2.message().c_str() );
+
+        {
+            char const* msg = en2.message( nullptr, 0 );
+
+            if( msg != nullptr )
+            {
+                BOOST_TEST_CSTR_EQ( msg, en2.message().c_str() );
+            }
+        }
+
+        BOOST_TEST( en2.failed() );
+        BOOST_TEST( en2 );
+        BOOST_TEST_NOT( !en2 );
+
+        sys::error_condition en;
+
+        BOOST_TEST_NE( en, en2 );
+        BOOST_TEST_NOT( en == en2 );
+
+        BOOST_TEST_EQ( en2.to_string(), std::string( "cond:system:-4" ) );
+    }
+
     return boost::report_errors();
 }

test/result_and_eq_fn1v.cpp

@@ -59,6 +59,13 @@ int& h( int& )
     return x;
 }
 
+static int fv_called;
+
+void fv()
+{
+    ++fv_called;
+}
+
 int main()
 {
     {
@@ -110,5 +117,25 @@ int main()
         BOOST_TEST( r.has_error() );
     }
 
+    {
+        result<void> r;
+        fv_called = 0;
+
+        r &= fv;
+
+        BOOST_TEST( r.has_value() );
+        BOOST_TEST_EQ( fv_called, 1 );
+    }
+
+    {
+        result<void, E> r( in_place_error );
+        fv_called = 0;
+
+        r &= fv;
+
+        BOOST_TEST( r.has_error() );
+        BOOST_TEST_EQ( fv_called, 0 );
+    }
+
     return boost::report_errors();
 }

test/result_and_fn1v.cpp

@@ -55,12 +55,18 @@ int k()
     return 7;
 }
 
-void fv1( int /*x*/ )
+static int fv1_called_with;
+
+void fv1( int x )
 {
+    fv1_called_with = x;
 }
 
+static int fv2_called;
+
 void fv2()
 {
+    ++fv2_called;
 }
 
 int main()
@@ -208,10 +214,13 @@ int main()
     }
 
     {
+        fv1_called_with = 0;
+
         result<int> r( 1 );
         result<void> r2 = r & fv1;
 
         BOOST_TEST( r2.has_value() );
+        BOOST_TEST_EQ( fv1_called_with, 1 );
     }
 
     {
@@ -219,72 +228,103 @@ int main()
         result<void> r2 = r & fv1;
 
         BOOST_TEST( r2.has_value() );
+        BOOST_TEST_EQ( fv1_called_with, 1 );
     }
 
     {
+        fv1_called_with = 0;
+
         result<void> r2 = result<int>( 1 ) & fv1;
 
         BOOST_TEST( r2.has_value() );
+        BOOST_TEST_EQ( fv1_called_with, 1 );
     }
 
     {
+        fv1_called_with = 0;
+
         result<int, E> r( in_place_error );
         result<void, E> r2 = r & fv1;
 
         BOOST_TEST( r2.has_error() );
+        BOOST_TEST_EQ( fv1_called_with, 0 );
     }
 
     {
+        fv1_called_with = 0;
+
         result<int, E> const r( in_place_error );
         result<void, E> r2 = r & fv1;
 
         BOOST_TEST( r2.has_error() );
+        BOOST_TEST_EQ( fv1_called_with, 0 );
     }
 
     {
+        fv1_called_with = 0;
+
         result<void, E> r2 = result<int, E>( in_place_error ) & fv1;
 
         BOOST_TEST( r2.has_error() );
+        BOOST_TEST_EQ( fv1_called_with, 0 );
     }
 
     {
         result<void> r;
+        fv2_called = 0;
+
         result<void> r2 = r & fv2;
 
         BOOST_TEST( r2.has_value() );
+        BOOST_TEST_EQ( fv2_called, 1 );
     }
 
     {
         result<void> const r;
+        fv2_called = 0;
+
         result<void> r2 = r & fv2;
 
         BOOST_TEST( r2.has_value() );
+        BOOST_TEST_EQ( fv2_called, 1 );
     }
 
     {
+        fv2_called = 0;
+
         result<void> r2 = result<void>() & fv2;
 
         BOOST_TEST( r2.has_value() );
+        BOOST_TEST_EQ( fv2_called, 1 );
     }
 
     {
         result<void, E> r( in_place_error );
+        fv2_called = 0;
+
         result<void, E> r2 = r & fv2;
 
         BOOST_TEST( r2.has_error() );
+        BOOST_TEST_EQ( fv2_called, 0 );
     }
 
     {
         result<void, E> const r( in_place_error );
+        fv2_called = 0;
+
         result<void, E> r2 = r & fv2;
 
         BOOST_TEST( r2.has_error() );
+        BOOST_TEST_EQ( fv2_called, 0 );
     }
 
     {
+        fv2_called = 0;
+
         result<void, E> r2 = result<void, E>( in_place_error ) & fv2;
 
         BOOST_TEST( r2.has_error() );
+        BOOST_TEST_EQ( fv2_called, 0 );
     }
 
     return boost::report_errors();

test/snprintf_test.cpp

@@ -6,6 +6,12 @@
 # pragma GCC diagnostic ignored "-Wformat-truncation"
 #endif
 
+#if defined(__clang__) && defined(__has_warning)
+# if __has_warning( "-Wformat-truncation" )
+#  pragma clang diagnostic ignored "-Wformat-truncation"
+# endif
+#endif
+
 #include <boost/system/detail/snprintf.hpp>
 #include <boost/core/lightweight_test.hpp>