Remove _Addr assignment from the constructor of std_category. Fixes #98.

.drone.jsonnet

@@ -173,12 +173,19 @@ local windows_pipeline(name, image, environment, arch = "amd64") =
     ),
 
     linux_pipeline(
-        "Linux 20.04 GCC 9 ARM64 32/64",
+        "Linux 20.04 GCC 9* ARM64",
         "cppalliance/droneubuntu2004:multiarch",
-        { TOOLSET: 'gcc', COMPILER: 'g++', CXXSTD: '03,11,14,17,2a', ADDRMD: '32,64' },
+        { TOOLSET: 'gcc', COMPILER: 'g++', CXXSTD: '03,11,14,17,2a' },
         arch="arm64",
     ),
 
+    linux_pipeline(
+        "Linux 20.04 GCC 9* S390x",
+        "cppalliance/droneubuntu2004:multiarch",
+        { TOOLSET: 'gcc', COMPILER: 'g++', CXXSTD: '03,11,14,17,2a' },
+        arch="s390x",
+    ),
+
     linux_pipeline(
         "Linux 20.04 GCC 10 32 ASAN",
         "cppalliance/droneubuntu2004:1",
@@ -193,6 +200,25 @@ local windows_pipeline(name, image, environment, arch = "amd64") =
         "g++-10-multilib",
     ),
 
+    linux_pipeline(
+        "Linux 22.04 GCC 11* 32",
+        "cppalliance/droneubuntu2204:1",
+        { TOOLSET: 'gcc', COMPILER: 'g++', CXXSTD: '03,11,14,17,2a', ADDRMD: '32' },
+    ),
+
+    linux_pipeline(
+        "Linux 22.04 GCC 11* 64",
+        "cppalliance/droneubuntu2204:1",
+        { TOOLSET: 'gcc', COMPILER: 'g++', CXXSTD: '03,11,14,17,2a', ADDRMD: '64' },
+    ),
+
+    linux_pipeline(
+        "Linux 22.04 GCC 12",
+        "cppalliance/droneubuntu2204:1",
+        { TOOLSET: 'gcc', COMPILER: 'g++-12', CXXSTD: '03,11,14,17,20,2b' },
+        "g++-12",
+    ),
+
     linux_pipeline(
         "Linux 20.04 Clang 13",
         "cppalliance/droneubuntu2004:1",
@@ -217,6 +243,14 @@ local windows_pipeline(name, image, environment, arch = "amd64") =
         ["deb http://apt.llvm.org/focal/ llvm-toolchain-focal-14 main"],
     ),
 
+    linux_pipeline(
+        "Linux 20.04 Clang 15",
+        "cppalliance/droneubuntu2004:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-15', CXXSTD: '03,11,14,17,20,2b' },
+        "clang-15",
+        ["deb http://apt.llvm.org/focal/ llvm-toolchain-focal-15 main"],
+    ),
+
     macos_pipeline(
         "MacOS 10.15 Xcode 12.2 UBSAN",
         { TOOLSET: 'clang', COMPILER: 'clang++', CXXSTD: '03,11,14,1z' } + ubsan,

.github/workflows/ci.yml

@@ -19,22 +19,26 @@ jobs:
         include:
           - toolset: gcc-4.8
             cxxstd: "03,11"
-            os: ubuntu-18.04
+            os: ubuntu-latest
+            container: ubuntu:18.04
             install: g++-4.8
           - toolset: gcc-5
             cxxstd: "03,11,14,1z"
-            os: ubuntu-18.04
+            os: ubuntu-latest
+            container: ubuntu:18.04
             install: g++-5
           - toolset: gcc-6
             cxxstd: "03,11,14,1z"
-            os: ubuntu-18.04
+            os: ubuntu-latest
+            container: ubuntu:18.04
             install: g++-6
           - toolset: gcc-7
             cxxstd: "03,11,14,17"
-            os: ubuntu-18.04
+            os: ubuntu-latest
+            container: ubuntu:18.04
           - toolset: gcc-8
             cxxstd: "03,11,14,17,2a"
-            os: ubuntu-18.04
+            os: ubuntu-20.04
             install: g++-8
           - toolset: gcc-9
             cxxstd: "03,11,14,17,2a"
@@ -48,33 +52,36 @@ jobs:
             os: ubuntu-20.04
             install: g++-11
           - toolset: gcc-12
-            cxxstd: "03,11,14,17,20"
+            cxxstd: "03,11,14,17,20,2b"
             os: ubuntu-22.04
             install: g++-12
           - toolset: clang
             compiler: clang++-3.9
             cxxstd: "03,11,14"
-            os: ubuntu-18.04
+            os: ubuntu-latest
+            container: ubuntu:18.04
             install: clang-3.9
           - toolset: clang
             compiler: clang++-4.0
             cxxstd: "03,11,14"
-            os: ubuntu-18.04
+            os: ubuntu-latest
+            container: ubuntu:18.04
             install: clang-4.0
           - toolset: clang
             compiler: clang++-5.0
             cxxstd: "03,11,14,1z"
-            os: ubuntu-18.04
+            os: ubuntu-latest
+            container: ubuntu:18.04
             install: clang-5.0
           - toolset: clang
             compiler: clang++-6.0
             cxxstd: "03,11,14,17"
-            os: ubuntu-18.04
+            os: ubuntu-20.04
             install: clang-6.0
           - toolset: clang
             compiler: clang++-7
             cxxstd: "03,11,14,17"
-            os: ubuntu-18.04
+            os: ubuntu-20.04
             install: clang-7
           - toolset: clang
             compiler: clang++-8
@@ -100,12 +107,12 @@ jobs:
             os: ubuntu-20.04
           - toolset: clang
             compiler: clang++-13
-            cxxstd: "03,11,14,17,20"
+            cxxstd: "03,11,14,17,20,2b"
             os: ubuntu-22.04
             install: clang-13
           - toolset: clang
             compiler: clang++-14
-            cxxstd: "03,11,14,17,20"
+            cxxstd: "03,11,14,17,20,2b"
             os: ubuntu-22.04
             install: clang-14
           - toolset: clang
@@ -113,13 +120,24 @@ jobs:
             os: macos-11
 
     runs-on: ${{matrix.os}}
+    container: ${{matrix.container}}
+
+    defaults:
+      run:
+        shell: bash
 
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
+
+      - name: Setup container environment
+        if: matrix.container
+        run: |
+          apt-get update
+          apt-get -y install sudo python git g++
 
       - name: Install packages
         if: matrix.install
-        run: sudo apt install ${{matrix.install}}
+        run: sudo apt-get -y install ${{matrix.install}}
 
       - name: Setup Boost
         run: |
@@ -182,7 +200,7 @@ jobs:
     runs-on: ${{matrix.os}}
 
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
 
       - name: Setup Boost
         shell: cmd
@@ -217,7 +235,6 @@ jobs:
       fail-fast: false
       matrix:
         include:
-          - os: ubuntu-18.04
           - os: ubuntu-20.04
           - os: ubuntu-22.04
           - os: macos-11
@@ -225,11 +242,11 @@ jobs:
     runs-on: ${{matrix.os}}
 
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
 
       - name: Install packages
         if: matrix.install
-        run: sudo apt install ${{matrix.install}}
+        run: sudo apt-get -y install ${{matrix.install}}
 
       - name: Setup Boost
         run: |
@@ -264,7 +281,6 @@ jobs:
       fail-fast: false
       matrix:
         include:
-          - os: ubuntu-18.04
           - os: ubuntu-20.04
           - os: ubuntu-22.04
           - os: macos-11
@@ -272,11 +288,11 @@ jobs:
     runs-on: ${{matrix.os}}
 
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
 
       - name: Install packages
         if: matrix.install
-        run: sudo apt install ${{matrix.install}}
+        run: sudo apt-get -y install ${{matrix.install}}
 
       - name: Setup Boost
         run: |
@@ -321,7 +337,6 @@ jobs:
       fail-fast: false
       matrix:
         include:
-          - os: ubuntu-18.04
           - os: ubuntu-20.04
           - os: ubuntu-22.04
           - os: macos-11
@@ -329,11 +344,11 @@ jobs:
     runs-on: ${{matrix.os}}
 
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
 
       - name: Install packages
         if: matrix.install
-        run: sudo apt install ${{matrix.install}}
+        run: sudo apt-get -y install ${{matrix.install}}
 
       - name: Setup Boost
         run: |

doc/system/changes.adoc

@@ -8,6 +8,14 @@ https://www.boost.org/LICENSE_1_0.txt
 # Revision History
 :idprefix:
 
+## Changes in Boost 1.81
+
+* The macro `BOOST_SYSTEM_DISABLE_THREADS` can now be defined to disable
+  the use of `<mutex>` (e.g. on single-threaded libstdc++).
+* Added `value_type`, `error_type`, `in_place_value`, `in_place_error`
+  to `result<>`.
+* Added `emplace` to `result<>`.
+
 ## Changes in Boost 1.80
 
 * When an `error_code` is converted to `std::error_code` and then back

doc/system/reference.adoc

@@ -29,6 +29,11 @@ When `BOOST_SYSTEM_USE_UTF8` is defined, on Windows the library returns
 UTF-8 messages using code page `CP_UTF8` instead of the default `CP_ACP`.
 This macro has no effect on POSIX.
 
+When `BOOST_SYSTEM_DISABLE_THREADS` is defined, the library assumes that
+the current platform doesn't support multiple threads and disables the use
+of the standard header `<mutex>`, eliminating the mutex locks. The single
+threaded `libstdc++` is one such platform.
+
 ## Deprecated Names
 
 In the process of adding Boost.System to the {cpp}11 standard library, the
@@ -1595,6 +1600,12 @@ template<class T, class E = error_code> class result
 {
 public:
 
+    using value_type = T;
+    using error_type = E;
+
+    static constexpr in_place_value_t in_place_value{};
+    static constexpr in_place_error_t in_place_error{};
+
     // constructors
 
     constexpr result();
@@ -1648,6 +1659,11 @@ public:
 
     constexpr E error() const;
 
+    // emplace
+
+    template<class... A>
+      constexpr T& emplace( A&&... a );
+
     // swap
 
     constexpr void swap( result& r );
@@ -1843,6 +1859,20 @@ constexpr E error() const;
 Effects: ::
   If `*this` holds an error, returns it. Otherwise, returns `E()`.
 
+#### emplace
+
+```
+template<class... A>
+  constexpr T& emplace( A&&... a );
+```
+[none]
+* {blank}
++
+Ensures: ::
+  `*this` holds the value `T( std::forward<A>(a)... )`.
+Returns: ::
+  A reference to the contained value.
+
 #### swap
 
 ```
@@ -1911,6 +1941,12 @@ template<class E> class result<void, E>
 {
 public:
 
+    using value_type = void;
+    using error_type = E;
+
+    static constexpr in_place_value_t in_place_value{};
+    static constexpr in_place_error_t in_place_error{};
+
     // constructors
 
     constexpr result() noexcept;
@@ -1945,6 +1981,10 @@ public:
 
     constexpr E error() const;
 
+    // emplace
+
+    constexpr void emplace();
+
     // swap
 
     constexpr void swap( result& r );
@@ -2088,6 +2128,17 @@ constexpr E error() const;
 Effects: ::
   If `*this` holds an error, returns it. Otherwise, returns `E()`.
 
+#### emplace
+
+```
+constexpr void emplace();
+```
+[none]
+* {blank}
++
+Ensures: ::
+  `*this` holds an unspecified value.
+
 #### swap
 
 ```

include/boost/system/detail/error_category.hpp

@@ -48,7 +48,7 @@ class std_category;
 #pragma GCC diagnostic ignored "-Wnon-virtual-dtor"
 #endif
 
-#if defined(BOOST_MSVC)
+#if defined(BOOST_MSVC) && BOOST_MSVC < 1900
 #pragma warning(push)
 #pragma warning(disable: 4351) //  new behavior: elements of array will be default initialized
 #endif
@@ -183,7 +183,7 @@ public:
 #endif
 };
 
-#if defined(BOOST_MSVC)
+#if defined(BOOST_MSVC) && BOOST_MSVC < 1900
 #pragma warning(pop)
 #endif
 

include/boost/system/detail/error_category_impl.hpp

@@ -143,7 +143,7 @@ inline void error_category::init_stdcat() const
 
     if( sc_init_.load( std::memory_order_acquire ) == 0 )
     {
-        ::new( static_cast<void*>( stdcat_ ) ) boost::system::detail::std_category( this, 0 );
+        ::new( static_cast<void*>( stdcat_ ) ) boost::system::detail::std_category( this, system::detail::id_wrapper<0>() );
         sc_init_.store( 1, std::memory_order_release );
     }
 }
@@ -160,7 +160,7 @@ inline BOOST_NOINLINE error_category::operator std::error_category const & () co
 // This condition must be the same as the one in error_condition.hpp
 #if defined(BOOST_SYSTEM_AVOID_STD_GENERIC_CATEGORY)
 
-        static const boost::system::detail::std_category generic_instance( this, 0x1F4D3 );
+        static const boost::system::detail::std_category generic_instance( this, system::detail::id_wrapper<0x1F4D3>() );
         return generic_instance;
 
 #else
@@ -175,7 +175,7 @@ inline BOOST_NOINLINE error_category::operator std::error_category const & () co
 // This condition must be the same as the one in error_code.hpp
 #if defined(BOOST_SYSTEM_AVOID_STD_SYSTEM_CATEGORY)
 
-        static const boost::system::detail::std_category system_instance( this, 0x1F4D7 );
+        static const boost::system::detail::std_category system_instance( this, system::detail::id_wrapper<0x1F4D7>() );
         return system_instance;
 
 #else

include/boost/system/detail/std_category.hpp

@@ -11,6 +11,7 @@
 // See library home page at http://www.boost.org/libs/system
 
 #include <boost/system/detail/error_category.hpp>
+#include <boost/config.hpp>
 #include <system_error>
 
 //
@@ -24,6 +25,8 @@ namespace system
 namespace detail
 {
 
+template<unsigned Id> struct id_wrapper {};
+
 class BOOST_SYMBOL_VISIBLE std_category: public std::error_category
 {
 private:
@@ -39,20 +42,22 @@ public:
 
 public:
 
-    explicit std_category( boost::system::error_category const * pc, unsigned id ): pc_( pc )
+    template<unsigned Id>
+    explicit std_category( boost::system::error_category const * pc, id_wrapper<Id> ): pc_( pc )
     {
-        if( id != 0 )
-        {
 #if defined(_MSC_VER) && defined(_CPPLIB_VER) && _MSC_VER >= 1900 && _MSC_VER < 2000
 
-            // Poking into the protected _Addr member of std::error_category
-            // is not a particularly good programming practice, but what can
-            // you do
+        // We used to assign to the protected _Addr member of std::error_category
+        // here when Id != 0, but this should never happen now because this code
+        // path is no longer used
 
-            _Addr = id;
+#if !defined(BOOST_NO_CXX11_STATIC_ASSERT)
+
+        static_assert( Id == 0, "This constructor should only be called with Id == 0 under MS STL 14.0+" );
+
+#endif
 
 #endif
-        }
     }
 
     const char * name() const BOOST_NOEXCEPT BOOST_OVERRIDE

include/boost/system/detail/system_category_condition_win32.hpp

@@ -59,6 +59,7 @@ inline int system_category_condition_win32( int ev ) BOOST_NOEXCEPT
     case ERROR_ACCESS_DENIED_: return permission_denied;
     case ERROR_ALREADY_EXISTS_: return file_exists;
     case ERROR_BAD_NETPATH_: return no_such_file_or_directory;
+    case ERROR_BAD_NET_NAME_: return no_such_file_or_directory;
     case ERROR_BAD_UNIT_: return no_such_device;
     case ERROR_BROKEN_PIPE_: return broken_pipe;
     case ERROR_BUFFER_OVERFLOW_: return filename_too_long;
@@ -75,6 +76,7 @@ inline int system_category_condition_win32( int ev ) BOOST_NOEXCEPT
     case ERROR_DIR_NOT_EMPTY_: return directory_not_empty;
     case ERROR_DIRECTORY_: return invalid_argument; // WinError.h: "The directory name is invalid"
     case ERROR_DISK_FULL_: return no_space_on_device;
+    case ERROR_FILENAME_EXCED_RANGE_: return filename_too_long;
     case ERROR_FILE_EXISTS_: return file_exists;
     case ERROR_FILE_NOT_FOUND_: return no_such_file_or_directory;
     case ERROR_HANDLE_DISK_FULL_: return no_space_on_device;
@@ -100,12 +102,16 @@ inline int system_category_condition_win32( int ev ) BOOST_NOEXCEPT
     case ERROR_REPARSE_TAG_INVALID_: return invalid_argument;
     case ERROR_RETRY_: return resource_unavailable_try_again;
     case ERROR_SEEK_: return io_error;
+    case ERROR_SEM_TIMEOUT_: return timed_out;
     case ERROR_SHARING_VIOLATION_: return permission_denied;
     case ERROR_NOT_SUPPORTED_: return not_supported; // WinError.h: "The request is not supported."
+    case ERROR_TIMEOUT_: return timed_out;
     case ERROR_TOO_MANY_OPEN_FILES_: return too_many_files_open;
     case ERROR_WRITE_FAULT_: return io_error;
     case ERROR_WRITE_PROTECT_: return permission_denied;
 
+    case 258: return timed_out; // WAIT_TIMEOUT
+
     case WSAEACCES_: return permission_denied;
     case WSAEADDRINUSE_: return address_in_use;
     case WSAEADDRNOTAVAIL_: return address_not_available;

include/boost/system/result.hpp

@@ -95,6 +95,14 @@ private:
 
     variant2::variant<T, E> v_;
 
+public:
+
+    using value_type = T;
+    using error_type = E;
+
+    static constexpr in_place_value_t in_place_value{};
+    static constexpr in_place_error_t in_place_error{};
+
 public:
 
     // constructors
@@ -393,6 +401,14 @@ public:
         return has_error()? variant2::unsafe_get<1>( v_ ): E();
     }
 
+    // emplace
+
+    template<class... A>
+    BOOST_CXX14_CONSTEXPR T& emplace( A&&... a )
+    {
+        return v_.template emplace<0>( std::forward<A>(a)... );
+    }
+
     // swap
 
     BOOST_CXX14_CONSTEXPR void swap( result& r )
@@ -444,6 +460,14 @@ private:
 
     variant2::variant<variant2::monostate, E> v_;
 
+public:
+
+    using value_type = void;
+    using error_type = E;
+
+    static constexpr in_place_value_t in_place_value{};
+    static constexpr in_place_error_t in_place_error{};
+
 public:
 
     // constructors
@@ -557,6 +581,13 @@ public:
         return has_error()? variant2::unsafe_get<1>( v_ ): E();
     }
 
+    // emplace
+
+    BOOST_CXX14_CONSTEXPR void emplace()
+    {
+        v_.template emplace<0>();
+    }
+
     // swap
 
     BOOST_CXX14_CONSTEXPR void swap( result& r )

test/CMakeLists.txt

@@ -130,6 +130,8 @@ boost_test(TYPE compile SOURCES constexpr_test2.cpp)
 boost_test(TYPE run SOURCES error_code_test3.cpp)
 boost_test(TYPE run SOURCES std_interop_test15.cpp)
 
+boost_test(TYPE run SOURCES win32_generic_test.cpp)
+
 # result
 
 set(BOOST_TEST_COMPILE_FEATURES cxx_std_11)
@@ -149,3 +151,6 @@ boost_test(TYPE run SOURCES result_range_for.cpp)
 boost_test(TYPE run SOURCES result_value_construct2.cpp)
 boost_test(TYPE run SOURCES result_error_construct2.cpp)
 boost_test(TYPE run SOURCES result_convert_construct.cpp)
+boost_test(TYPE run SOURCES result_typedefs.cpp)
+boost_test(TYPE run SOURCES result_value_construct3.cpp)
+boost_test(TYPE run SOURCES result_error_construct3.cpp)

test/Jamfile.v2

@@ -158,6 +158,8 @@ compile constexpr_test2.cpp ;
 run error_code_test3.cpp ;
 run std_interop_test15.cpp ;
 
+run win32_generic_test.cpp ;
+
 # result
 
 import ../../config/checks/config : requires ;
@@ -180,3 +182,7 @@ run result_value_construct2.cpp : : : $(CPP11) ;
 run result_error_construct2.cpp : : : $(CPP11) ;
 run result_errc_construct.cpp : : : $(CPP11) ;
 run result_convert_construct.cpp : : : $(CPP11) ;
+run result_typedefs.cpp : : : $(CPP11) ;
+run result_value_construct3.cpp : : : $(CPP11) ;
+run result_error_construct3.cpp : : : $(CPP11) ;
+run result_emplace.cpp : : : $(CPP11) ;

test/result_emplace.cpp

@@ -0,0 +1,176 @@
+// Copyright 2017, 2021, 2022 Peter Dimov.
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/system/result.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <cerrno>
+
+using namespace boost::system;
+
+struct X
+{
+    static int instances;
+
+    int v_;
+
+    explicit X( int v ): v_( v ) { ++instances; }
+
+    X( int v1, int v2 ): v_( v1+v2 ) { ++instances; }
+    X( int v1, int v2, int v3 ): v_( v1+v2+v3 ) { ++instances; }
+
+    X( X const& ) = delete;
+    X& operator=( X const& ) = delete;
+
+    ~X() { --instances; }
+};
+
+int X::instances = 0;
+
+struct Y
+{
+    static int instances;
+
+    Y() noexcept { ++instances; }
+
+    Y( Y const& ) noexcept { ++instances; }
+
+    Y& operator=( Y const& ) = default;
+
+    ~Y() { --instances; }
+};
+
+int Y::instances = 0;
+
+int main()
+{
+    {
+        result<int> r;
+
+        BOOST_TEST( r.has_value() );
+
+        r.emplace( 1 );
+
+        BOOST_TEST( r.has_value() );
+        BOOST_TEST_EQ( r.value(), 1 );
+    }
+
+    {
+        result<int> r( ENOENT, generic_category() );
+
+        BOOST_TEST( !r.has_value() );
+
+        r.emplace( 1 );
+
+        BOOST_TEST( r.has_value() );
+        BOOST_TEST_EQ( r.value(), 1 );
+    }
+
+    BOOST_TEST_EQ( X::instances, 0 );
+
+    {
+        result<X> r( 0 );
+
+        BOOST_TEST( r.has_value() );
+        BOOST_TEST_EQ( r.value().v_, 0 );
+        BOOST_TEST_EQ( X::instances, 1 );
+
+        r.emplace( 1 );
+        BOOST_TEST( r.has_value() );
+        BOOST_TEST_EQ( r.value().v_, 1 );
+        BOOST_TEST_EQ( X::instances, 1 );
+
+        r.emplace( 1, 2 );
+        BOOST_TEST( r.has_value() );
+        BOOST_TEST_EQ( r.value().v_, 1+2 );
+        BOOST_TEST_EQ( X::instances, 1 );
+
+        r.emplace( 1, 2, 3 );
+        BOOST_TEST( r.has_value() );
+        BOOST_TEST_EQ( r.value().v_, 1+2+3 );
+        BOOST_TEST_EQ( X::instances, 1 );
+    }
+
+    BOOST_TEST_EQ( X::instances, 0 );
+
+    {
+        result<X> r( ENOENT, generic_category() );
+
+        BOOST_TEST( !r.has_value() );
+        BOOST_TEST_EQ( X::instances, 0 );
+
+        r.emplace( 1, 2 );
+        BOOST_TEST( r.has_value() );
+        BOOST_TEST_EQ( r.value().v_, 1+2 );
+        BOOST_TEST_EQ( X::instances, 1 );
+    }
+
+    BOOST_TEST_EQ( X::instances, 0 );
+    BOOST_TEST_EQ( Y::instances, 0 );
+
+    {
+        result<int, Y> r( Y{} );
+
+        BOOST_TEST( !r.has_value() );
+        BOOST_TEST_EQ( Y::instances, 1 );
+
+        r.emplace( 1 );
+        BOOST_TEST( r.has_value() );
+        BOOST_TEST_EQ( *r, 1 );
+        BOOST_TEST_EQ( Y::instances, 0 );
+    }
+
+    BOOST_TEST_EQ( X::instances, 0 );
+    BOOST_TEST_EQ( Y::instances, 0 );
+
+    {
+        result<X, Y> r( in_place_error );
+
+        BOOST_TEST( !r.has_value() );
+        BOOST_TEST_EQ( X::instances, 0 );
+        BOOST_TEST_EQ( Y::instances, 1 );
+
+        r.emplace( 1, 2, 3 );
+
+        BOOST_TEST( r.has_value() );
+        BOOST_TEST_EQ( r->v_, 1+2+3 );
+        BOOST_TEST_EQ( X::instances, 1 );
+        BOOST_TEST_EQ( Y::instances, 0 );
+    }
+
+    BOOST_TEST_EQ( X::instances, 0 );
+    BOOST_TEST_EQ( Y::instances, 0 );
+
+    {
+        result<void> r;
+
+        BOOST_TEST( r.has_value() );
+
+        r.emplace();
+        BOOST_TEST( r.has_value() );
+    }
+
+    {
+        result<void> r( ENOENT, generic_category() );
+
+        BOOST_TEST( !r.has_value() );
+
+        r.emplace();
+        BOOST_TEST( r.has_value() );
+    }
+
+    BOOST_TEST_EQ( Y::instances, 0 );
+
+    {
+        result<void, Y> r( in_place_error );
+
+        BOOST_TEST( !r.has_value() );
+        BOOST_TEST_EQ( Y::instances, 1 );
+
+        r.emplace();
+        BOOST_TEST( r.has_value() );
+        BOOST_TEST_EQ( Y::instances, 0 );
+    }
+
+    return boost::report_errors();
+}

test/result_error_construct3.cpp

@@ -0,0 +1,161 @@
+// Copyright 2017, 2021, 2022 Peter Dimov.
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/system/result.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <string>
+#include <cerrno>
+
+using namespace boost::system;
+
+struct X
+{
+    static int instances;
+
+    int v_;
+
+    X(): v_() { ++instances; }
+
+    explicit X( int v ): v_( v ) { ++instances; }
+
+    X( int v1, int v2 ): v_( v1+v2 ) { ++instances; }
+    X( int v1, int v2, int v3 ): v_( v1+v2+v3 ) { ++instances; }
+
+    X( X const& r ): v_( r.v_ ) { ++instances; }
+
+    X& operator=( X const& ) = delete;
+
+    ~X() { --instances; }
+};
+
+int X::instances = 0;
+
+int main()
+{
+    {
+        auto ec = make_error_code( errc::invalid_argument );
+
+        using R = result<int>;
+        R r( R::in_place_error, ec );
+
+        BOOST_TEST( !r.has_value() );
+        BOOST_TEST( r.has_error() );
+
+        BOOST_TEST_EQ( r.error(), ec );
+    }
+
+    {
+        using R = result<int>;
+        R r( R::in_place_error, EINVAL, generic_category() );
+
+        BOOST_TEST( !r.has_value() );
+        BOOST_TEST( r.has_error() );
+
+        BOOST_TEST_EQ( r.error(), error_code( EINVAL, generic_category() ) );
+    }
+
+    {
+        auto ec = make_error_code( errc::invalid_argument );
+
+        using R = result<error_code>;
+        R r( R::in_place_error, ec );
+
+        BOOST_TEST( !r.has_value() );
+        BOOST_TEST( r.has_error() );
+
+        BOOST_TEST_EQ( r.error(), ec );
+    }
+
+    {
+        using R = result<error_code>;
+        R r( R::in_place_error, EINVAL, generic_category() );
+
+        BOOST_TEST( !r.has_value() );
+        BOOST_TEST( r.has_error() );
+
+        BOOST_TEST_EQ( r.error(), error_code( EINVAL, generic_category() ) );
+    }
+
+    BOOST_TEST_EQ( X::instances, 0 );
+
+    {
+        using R = result<std::string, X>;
+        R r( R::in_place_error, 1 );
+
+        BOOST_TEST( !r.has_value() );
+        BOOST_TEST( r.has_error() );
+
+        BOOST_TEST_EQ( r.error().v_, 1 );
+
+        BOOST_TEST_EQ( X::instances, 1 );
+    }
+
+    BOOST_TEST_EQ( X::instances, 0 );
+
+    {
+        using R = result<int, X>;
+        R r( R::in_place_error, 1, 2 );
+
+        BOOST_TEST( !r.has_value() );
+        BOOST_TEST( r.has_error() );
+
+        BOOST_TEST_EQ( r.error().v_, 1+2 );
+
+        BOOST_TEST_EQ( X::instances, 1 );
+    }
+
+    BOOST_TEST_EQ( X::instances, 0 );
+
+    {
+        using R = result<int, X>;
+        R r( R::in_place_error, 1, 2, 3 );
+
+        BOOST_TEST( !r.has_value() );
+        BOOST_TEST( r.has_error() );
+
+        BOOST_TEST_EQ( r.error().v_, 1+2+3 );
+
+        BOOST_TEST_EQ( X::instances, 1 );
+    }
+
+    BOOST_TEST_EQ( X::instances, 0 );
+
+    {
+        using R = result<X, X>;
+        R r( R::in_place_error, 1 );
+
+        BOOST_TEST( !r.has_value() );
+        BOOST_TEST( r.has_error() );
+
+        BOOST_TEST_EQ( r.error().v_, 1 );
+
+        BOOST_TEST_EQ( X::instances, 1 );
+    }
+
+    BOOST_TEST_EQ( X::instances, 0 );
+
+    {
+        auto ec = make_error_code( errc::invalid_argument );
+
+        using R = result<void>;
+        R r( R::in_place_error, ec );
+
+        BOOST_TEST( !r.has_value() );
+        BOOST_TEST( r.has_error() );
+
+        BOOST_TEST_EQ( r.error(), ec );
+    }
+
+    {
+        using R = result<void>;
+        R r( R::in_place_error, EINVAL, generic_category() );
+
+        BOOST_TEST( !r.has_value() );
+        BOOST_TEST( r.has_error() );
+
+        BOOST_TEST_EQ( r.error(), error_code( EINVAL, generic_category() ) );
+    }
+
+    return boost::report_errors();
+}

test/result_typedefs.cpp

@@ -0,0 +1,22 @@
+// Copyright 2022 Peter Dimov.
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/system/result.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+
+using namespace boost::system;
+
+struct X {};
+
+int main()
+{
+    BOOST_TEST_TRAIT_SAME( result<int>::value_type, int );
+    BOOST_TEST_TRAIT_SAME( result<X>::value_type, X );
+    BOOST_TEST_TRAIT_SAME( result<void>::value_type, void );
+
+    BOOST_TEST_TRAIT_SAME( result<int>::error_type, error_code );
+    BOOST_TEST_TRAIT_SAME( result<int, X>::error_type, X );
+
+    return boost::report_errors();
+}

test/result_value_construct3.cpp

@@ -0,0 +1,118 @@
+// Copyright 2017, 2021, 2022 Peter Dimov.
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/system/result.hpp>
+#include <boost/core/lightweight_test.hpp>
+
+using namespace boost::system;
+
+struct X
+{
+    static int instances;
+
+    int v_;
+
+    explicit X( int v ): v_( v ) { ++instances; }
+
+    X( int v1, int v2 ): v_( v1+v2 ) { ++instances; }
+    X( int v1, int v2, int v3 ): v_( v1+v2+v3 ) { ++instances; }
+
+    X( X const& ) = delete;
+    X& operator=( X const& ) = delete;
+
+    ~X() { --instances; }
+};
+
+int X::instances = 0;
+
+int main()
+{
+    {
+        using R = result<int>;
+        R r( R::in_place_value, 0 );
+
+        BOOST_TEST( r.has_value() );
+        BOOST_TEST( !r.has_error() );
+
+        BOOST_TEST_EQ( r.value(), 0 );
+    }
+
+    {
+        using R = result<int, int>;
+        R r( R::in_place_value, 1 );
+
+        BOOST_TEST( r.has_value() );
+        BOOST_TEST( !r.has_error() );
+
+        BOOST_TEST_EQ( *r, 1 );
+    }
+
+    BOOST_TEST_EQ( X::instances, 0 );
+
+    {
+        using R = result<X>;
+        R r( R::in_place_value, 1 );
+
+        BOOST_TEST( r.has_value() );
+        BOOST_TEST( !r.has_error() );
+
+        BOOST_TEST_EQ( r.value().v_, 1 );
+
+        BOOST_TEST_EQ( X::instances, 1 );
+    }
+
+    BOOST_TEST_EQ( X::instances, 0 );
+
+    {
+        using R = result<X>;
+        R r( R::in_place_value, 1, 2 );
+
+        BOOST_TEST( r.has_value() );
+        BOOST_TEST( !r.has_error() );
+
+        BOOST_TEST_EQ( r.value().v_, 1+2 );
+
+        BOOST_TEST_EQ( X::instances, 1 );
+    }
+
+    BOOST_TEST_EQ( X::instances, 0 );
+
+    {
+        using R = result<X>;
+        R r( R::in_place_value, 1, 2, 3 );
+
+        BOOST_TEST( r.has_value() );
+        BOOST_TEST( !r.has_error() );
+
+        BOOST_TEST_EQ( r.value().v_, 1+2+3 );
+
+        BOOST_TEST_EQ( X::instances, 1 );
+    }
+
+    BOOST_TEST_EQ( X::instances, 0 );
+
+    {
+        using R = result<X, X>;
+        R r( R::in_place_value, 1 );
+
+        BOOST_TEST( r.has_value() );
+        BOOST_TEST( !r.has_error() );
+
+        BOOST_TEST_EQ( r->v_, 1 );
+
+        BOOST_TEST_EQ( X::instances, 1 );
+    }
+
+    BOOST_TEST_EQ( X::instances, 0 );
+
+    {
+        using R = result<void>;
+        R r( R::in_place_value );
+
+        BOOST_TEST( r.has_value() );
+        BOOST_TEST( !r.has_error() );
+    }
+
+    return boost::report_errors();
+}

test/win32_generic_test.cpp

@@ -0,0 +1,52 @@
+// Copyright 2022 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/system.hpp>
+#include <boost/config.hpp>
+#include <boost/config/pragma_message.hpp>
+
+#if !defined(BOOST_SYSTEM_HAS_SYSTEM_ERROR)
+
+BOOST_PRAGMA_MESSAGE( "Skipping test, BOOST_SYSTEM_HAS_SYSTEM_ERROR is not defined" )
+int main() {}
+
+#elif !defined(BOOST_MSSTL_VERSION) || BOOST_MSSTL_VERSION < 140
+
+BOOST_PRAGMA_MESSAGE( "Skipping test, BOOST_MSSTL_VERSION is not defined or is less than 140" )
+int main() {}
+
+#else
+
+#include <system_error>
+#include <iostream>
+
+int main()
+{
+    namespace sys = boost::system;
+
+    int n = 0;
+
+    for( int i = 0; i < 65000; ++i )
+    {
+        sys::error_code ec1( i, sys::system_category() );
+        sys::error_condition en1 = ec1.default_error_condition();
+
+        std::error_code ec2( i, std::system_category() );
+        std::error_condition en2 = ec2.default_error_condition();
+
+        if( en1 != en2 )
+        {
+            std::cout << i << ": " << en1 << " (" << en1.message() << ") != cond:" << en2.category().name() << ":" << en2.value() << " (" << en2.message() << ")\n";
+
+            if( en2.category() == std::generic_category() && i != 123 ) // msvc-14.0, msvc-14.1 disagree with us on ERROR_INVALID_NAME
+            {
+                ++n;
+            }
+        }
+    }
+
+    return n < 256 ? n: 255;
+}
+
+#endif