Adding upstream version 14.2.21.upstream/14.2.21 upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
author: Daniel Baumann <daniel.baumann@progress-linux.org> 2024-04-27 18:24:20 +0000
committer: Daniel Baumann <daniel.baumann@progress-linux.org> 2024-04-27 18:24:20 +0000
commit: 483eb2f56657e8e7f419ab1a4fab8dce9ade8609 (patch)
tree: e5d88d25d870d5dedacb6bbdbe2a966086a0a5cf /src/boost/libs/outcome
parent: Initial commit. (diff)
download: ceph-483eb2f56657e8e7f419ab1a4fab8dce9ade8609.tar.xz
ceph-483eb2f56657e8e7f419ab1a4fab8dce9ade8609.zip
47 files changed, 6366 insertions, 0 deletions
diff --git a/src/boost/libs/outcome/CMakeLists.txt b/src/boost/libs/outcome/CMakeLists.txt
new file mode 100644
index 00000000..cc49eb71
--- /dev/null
+++ b/src/boost/libs/outcome/CMakeLists.txt
@@ -0,0 +1,16 @@
+# Distributed under the Boost Software License, Version 1.0.
+# See accompanying file LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt
+
+cmake_minimum_required(VERSION 3.5)
+project(BoostOutcome LANGUAGES CXX)
+
+add_library(boost_outcome INTERFACE)
+add_library(Boost::outcome ALIAS boost_outcome)
+
+target_include_directories(boost_outcome INTERFACE include)
+
+target_link_libraries(boost_outcome INTERFACE
+  Boost::config
+  Boost::exception
+  Boost::system
+)
diff --git a/src/boost/libs/outcome/Readme.md b/src/boost/libs/outcome/Readme.md
new file mode 100644
index 00000000..163ae900
--- /dev/null
+++ b/src/boost/libs/outcome/Readme.md
@@ -0,0 +1,23 @@
+Build and tests passing: Linux [![Build Status](https://travis-ci.org/boostorg/outcome.svg?branch=master)](https://travis-ci.org/boostorg/outcome)
+
+Documentation generated from the master branch shown below (may be newer than boost.org's): http://boostorg.github.io/outcome
+
+This is the Boost-ified edition of standalone https://github.com/ned14/outcome.
+Every commit made to standalone Outcome (develop and master branches only) gets
+automatically converted and merged to here.
+
+Note that changes made here may not get noticed in a timely fashion.
+Please try to send pull requests to https://github.com/ned14/outcome/pulls instead.
+
+Similarly, please report bugs to https://github.com/ned14/outcome/issues.
+
+This library works well in older Boosts missing Outcome. Installation into an
+older Boost and running the test suite would be as follows:
+
+```
+cd boost/libs
+git clone --depth 1 https://github.com/boostorg/outcome.git outcome
+cd ..
+./b2 headers
+./b2 libs/outcome/test cxxflags=--std=c++14
+```
diff --git a/src/boost/libs/outcome/index.html b/src/boost/libs/outcome/index.html
new file mode 100644
index 00000000..32c29efe
--- /dev/null
+++ b/src/boost/libs/outcome/index.html
@@ -0,0 +1,4 @@
+<html>
+<head><meta http-equiv="refresh" content="0; url=doc/html/index.html" /></head>
+<body>Please go to <a href="doc/index.html">doc/html/index.html</a></body>
+</html>
diff --git a/src/boost/libs/outcome/meta/explicit-failures-markup.xml b/src/boost/libs/outcome/meta/explicit-failures-markup.xml
new file mode 100644
index 00000000..d22f9956
--- /dev/null
+++ b/src/boost/libs/outcome/meta/explicit-failures-markup.xml
@@ -0,0 +1,38 @@
+<?xml version="1.0" encoding="utf-8"?>
+<explicit-failures-markup xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+ xsi:noNamespaceSchemaLocation="https://raw.githubusercontent.com/boostorg/boost/master/status/explicit-failures.xsd">
+    <!-- outcome -->
+    <library name="outcome">
+        <mark-unusable>
+            <toolset name="*c++98"/>
+            <toolset name="*c++11"/>
+            <toolset name="*gnu++98"/>
+            <toolset name="*gnu++11"/>
+            <toolset name="*gnu98"/>
+            <toolset name="*gnu11"/>
+            <toolset name="clang-linux-3*"/>
+            <toolset name="gcc-3*"/>
+            <toolset name="gcc-4*"/>
+            <toolset name="gcc-5*"/>
+            <toolset name="gcc-mngw-3*"/>
+            <toolset name="gcc-mngw-4*"/>
+            <toolset name="gcc-mngw-5*"/>
+            <toolset name="msvc-7*"/>
+            <toolset name="msvc-8*"/>
+            <toolset name="msvc-9*"/>
+            <toolset name="msvc-10*"/>
+            <toolset name="msvc-11*"/>
+            <toolset name="msvc-12*"/>
+            <toolset name="msvc-13*"/>
+            <toolset name="msvc-14.0"/>
+            <toolset name="msvc-14.0*"/>
+            <note author="Niall Douglas">Complete C++14 support is the minimum requirement.</note>
+        </mark-unusable>
+        <mark-unusable>
+            <toolset name="clang-linux-4.0~c++14"/>
+            <toolset name="clang-linux-5.0~c++14"/>
+            <toolset name="clang-linux-6.0~c++17"/>
+            <note author="Niall Douglas">libstdc++ 6 is the minimum version which works.</note>
+        </mark-unusable>
+    </library>
+</explicit-failures-markup>
+\ No newline at end of file
diff --git a/src/boost/libs/outcome/meta/libraries.json b/src/boost/libs/outcome/meta/libraries.json
new file mode 100644
index 00000000..de6460ec
--- /dev/null
+++ b/src/boost/libs/outcome/meta/libraries.json
@@ -0,0 +1,13 @@
+{
+  "key": "outcome",
+  "name": "Outcome",
+  "authors": [ "Niall Douglas" ],
+  "maintainers": [ "Niall Douglas" ],
+  "description": "A deterministic failure handling library partially simulating lightweight exceptions.",
+  "std": [ "proposal" ],
+  "category": [
+    "Patterns",
+    "Emulation",
+    "Programming"
+  ]
+}
diff --git a/src/boost/libs/outcome/test/Jamfile.v2 b/src/boost/libs/outcome/test/Jamfile.v2
new file mode 100644
index 00000000..4b11a380
--- /dev/null
+++ b/src/boost/libs/outcome/test/Jamfile.v2
@@ -0,0 +1,67 @@
+# Boost.Outcome Library test Jamfile
+#
+# Copyright (C) 2017-2019 Niall Douglas
+#
+# Use, modification, and distribution is subject to 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)
+#
+# See http://www.boost.org/libs/outcome for documentation.
+
+import testing ;
+import ../../config/checks/config : requires ;
+import ../../predef/tools/check/predef : check require : predef-check predef-require ;
+
+project
+    : requirements
+      [ requires cxx14_variable_templates cxx14_constexpr ]
+      [ predef-require "!BOOST_COMP_GNUC" or "BOOST_COMP_GNUC >= 6.0" ]
+      [ predef-require "!BOOST_COMP_CLANG" or "BOOST_COMP_CLANG >= 4.0" ]
+      <define>BOOST_TEST_MODULE=Outcome
+      <library>../../test/build//boost_unit_test_framework
+    ;
+
+{
+  test-suite outcome :
+
+    [ compile-fail compile-fail/outcome-int-int-1.cpp ]
+    [ compile-fail compile-fail/result-int-int-1.cpp ]
+    [ compile-fail compile-fail/result-int-int-2.cpp ]
+
+    [ run tests/comparison.cpp ]
+    [ run tests/constexpr.cpp ]
+    [ run tests/containers.cpp ]
+    [ run tests/core-outcome.cpp ]
+    [ run tests/core-result.cpp ]
+    [ run tests/default-construction.cpp ]
+    [ run tests/experimental-core-outcome-status.cpp ]
+    [ run tests/experimental-core-result-status.cpp ]
+    [ run tests/experimental-p0709a.cpp ]
+    [ run tests/fileopen.cpp ]
+    [ run tests/hooks.cpp ]
+    [ run tests/issue0007.cpp ]
+    [ run tests/issue0009.cpp ]
+    [ run tests/issue0010.cpp ]
+    [ run tests/issue0012.cpp ]
+    [ run tests/issue0016.cpp ]
+    [ run tests/issue0059.cpp ]
+    [ run tests/issue0061.cpp ]
+    [ run tests/issue0064.cpp ]
+    [ run tests/issue0065.cpp ]
+    [ run tests/issue0071.cpp ]
+    [ run tests/issue0095.cpp ]
+    [ run tests/issue0115.cpp ]
+    [ run tests/issue0116.cpp ]
+    [ run tests/issue0140.cpp ]
+    [ run tests/noexcept-propagation.cpp ]
+    [ run tests/propagate.cpp ]
+    [ run tests/serialisation.cpp ]
+    [ run tests/success-failure.cpp ]
+    [ run tests/swap.cpp ]
+    [ run tests/udts.cpp ]
+    [ run tests/value-or-error.cpp ]
+
+    [ run expected-pass.cpp ]
+
+  ;
+}
diff --git a/src/boost/libs/outcome/test/compile-fail/issue0071-fail.cpp b/src/boost/libs/outcome/test/compile-fail/issue0071-fail.cpp
new file mode 100644
index 00000000..ac94c713
--- /dev/null
+++ b/src/boost/libs/outcome/test/compile-fail/issue0071-fail.cpp
@@ -0,0 +1,37 @@
+/* clang-format off
+(error: no matching function for call to .+::basic_result|error: no matching constructor for initialization of 'result<udt>'|cannot convert argument 1 from 'int')
+clang-format on
+
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License in the accompanying file
+Licence.txt or at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file Licence.txt or copy at
+http://www.boost.org/LICENSE_1_0.txt)
+*/
+
+#include "../../include/boost/outcome/result.hpp"
+
+int main()
+{
+  using namespace BOOST_OUTCOME_V2_NAMESPACE;
+  struct udt
+  {
+    explicit udt(int /*unused*/) {}
+  };
+  // Must not be possible to implicitly initialise a result<udt>
+  result<udt> m(5);
+  return 0;
+}
diff --git a/src/boost/libs/outcome/test/compile-fail/outcome-int-int-1.cpp b/src/boost/libs/outcome/test/compile-fail/outcome-int-int-1.cpp
new file mode 100644
index 00000000..4ee66b74
--- /dev/null
+++ b/src/boost/libs/outcome/test/compile-fail/outcome-int-int-1.cpp
@@ -0,0 +1,33 @@
+/* clang-format off
+(use of deleted function|call to deleted constructor|attempting to reference a deleted function)
+clang-format on
+
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License in the accompanying file
+Licence.txt or at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file Licence.txt or copy at
+http://www.boost.org/LICENSE_1_0.txt)
+*/
+
+#include "../../include/boost/outcome/outcome.hpp"
+
+int main()
+{
+  using namespace BOOST_OUTCOME_V2_NAMESPACE;
+  // Must not be possible to initialise an outcome with same R, S and P types
+  outcome<int, int, int> m(5);
+  return 0;
+}
diff --git a/src/boost/libs/outcome/test/compile-fail/result-int-int-1.cpp b/src/boost/libs/outcome/test/compile-fail/result-int-int-1.cpp
new file mode 100644
index 00000000..e4eb9203
--- /dev/null
+++ b/src/boost/libs/outcome/test/compile-fail/result-int-int-1.cpp
@@ -0,0 +1,33 @@
+/* clang-format off
+(use of deleted function|call to deleted constructor|attempting to reference a deleted function)
+clang-format on
+
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License in the accompanying file
+Licence.txt or at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file Licence.txt or copy at
+http://www.boost.org/LICENSE_1_0.txt)
+*/
+
+#include "../../include/boost/outcome/result.hpp"
+
+int main()
+{
+  using namespace BOOST_OUTCOME_V2_NAMESPACE;
+  // Must not be possible to initialise a result with same R and S types
+  result<int, int> m(5);
+  return 0;
+}
diff --git a/src/boost/libs/outcome/test/compile-fail/result-int-int-2.cpp b/src/boost/libs/outcome/test/compile-fail/result-int-int-2.cpp
new file mode 100644
index 00000000..35c999d0
--- /dev/null
+++ b/src/boost/libs/outcome/test/compile-fail/result-int-int-2.cpp
@@ -0,0 +1,33 @@
+/* clang-format off
+(use of deleted function|call to deleted constructor|attempting to reference a deleted function)
+clang-format on
+
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License in the accompanying file
+Licence.txt or at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file Licence.txt or copy at
+http://www.boost.org/LICENSE_1_0.txt)
+*/
+
+#include "../../include/boost/outcome/result.hpp"
+
+int main()
+{
+  using namespace BOOST_OUTCOME_V2_NAMESPACE;
+  // Must not be possible to initialise a result with same R and S types
+  result<int, int> m(in_place_type<int>);
+  return 0;
+}
diff --git a/src/boost/libs/outcome/test/expected-pass.cpp b/src/boost/libs/outcome/test/expected-pass.cpp
new file mode 100644
index 00000000..5c63b911
--- /dev/null
+++ b/src/boost/libs/outcome/test/expected-pass.cpp
@@ -0,0 +1,2015 @@
+//! \file test_expected.cpp
+
+// Copyright Pierre Talbot 2013.
+// Copyright Vicente J. Botet Escriba 2013,2014.
+
+// Use, modification and distribution are subject to 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)
+
+
+// Notes by ned:
+// Original is at https://github.com/viboes/std-make/blob/master/test/expected/expected_pass.cpp
+// This edition modified to use result with throw_bad_result_access policy
+// Quite a lot of the test suite I had to disable, not because our Expected implementation is
+// incorrect, but because the reference test suite is testing an Expected quite far away from
+// the latest WG21 proposal paper, and we're implementing that latest edition.
+
+#if !defined(__GNUC__) || defined(__clang__) || __GNUC__ >= 7
+
+#include <utility>
+
+#include <boost/outcome/iostream_support.hpp>
+#include <boost/outcome/std_result.hpp>
+
+#define QUICKCPPLIB_BOOST_UNIT_TEST_CUSTOM_MAIN_DEFINED
+#include <boost/test/unit_test.hpp>
+#include <boost/test/unit_test_monitor.hpp>
+
+#define JASEL_NORETURN
+#ifndef BOOST_TEST
+#define BOOST_TEST(expr) BOOST_CHECK(expr)
+#endif
+#ifndef BOOST_TEST_EQ
+#define BOOST_TEST_EQ(a, b) BOOST_CHECK_EQUAL((a), (b))
+#endif
+#ifndef BOOST_TEST_THROWS
+#define BOOST_TEST_THROWS(expr, ex) BOOST_CHECK_THROW((expr), ex)
+#endif
+#ifndef BOOST_CONSTEXPR
+#define BOOST_CONSTEXPR constexpr
+#endif
+
+#ifdef _MSC_VER
+#pragma warning(disable : 4127)  // conditional expression is constant
+#pragma warning(disable : 4244)  // conversion from int to short
+#endif
+
+namespace stde
+{
+#if __cplusplus >= 201700 || _HAS_CXX17
+  using in_place_t = std::in_place_t;
+  using std::in_place;
+#else
+  struct in_place_t
+  {
+    explicit in_place_t() = default;
+  };
+  constexpr in_place_t in_place{};
+#endif
+
+  //! [expected_implementation]
+  /* Here is a fairly conforming implementation of P0323R3 `expected<T, E>` using `checked<T, E>`.
+  It passes the reference test suite for P0323R3 at
+  https://github.com/viboes/std-make/blob/master/test/expected/expected_pass.cpp with modifications
+  only to move the test much closer to the P0323R3 Expected, as the reference test suite is for a
+  much older proposed Expected.
+
+  Known differences from P0323R3 in this implementation:
+  - `T` and `E` cannot be the same type.
+  - No variant storage is implemented.
+  */
+
+  namespace detail
+  {
+    template <class T, class E> using expected_result = BOOST_OUTCOME_V2_NAMESPACE::checked<T, E>;
+    template <class T, class E> struct enable_default_constructor : public expected_result<T, E>
+    {
+      using base = expected_result<T, E>;
+      using base::base;
+      constexpr enable_default_constructor()
+          : base{BOOST_OUTCOME_V2_NAMESPACE::in_place_type<T>}
+      {
+      }
+    };
+    template <class T, class E> using select_expected_base = std::conditional_t<std::is_default_constructible<T>::value, enable_default_constructor<T, E>, expected_result<T, E>>;
+  }  // namespace detail
+  template <class T, class E> class expected : public detail::select_expected_base<T, E>
+  {
+    static_assert(!std::is_same<T, E>::value, "T and E cannot be the same in this expected implementation");
+    using base = detail::select_expected_base<T, E>;
+
+  public:
+    // Inherit base's constructors
+    using base::base;
+    expected() = default;
+
+    // Expected takes in_place not in_place_type
+    template <class... Args>
+    constexpr explicit expected(in_place_t /*unused*/, Args &&... args)
+        : base{BOOST_OUTCOME_V2_NAMESPACE::in_place_type<T>, std::forward<Args>(args)...}
+    {
+    }
+
+    // Expected always accepts a T even if ambiguous
+    BOOST_OUTCOME_TEMPLATE(class U)
+    BOOST_OUTCOME_TREQUIRES(BOOST_OUTCOME_TPRED(std::is_constructible<T, U>::value))
+    constexpr expected(U &&v)  // NOLINT
+    : base{BOOST_OUTCOME_V2_NAMESPACE::in_place_type<T>, std::forward<U>(v)}
+    {
+    }
+
+    // Expected has an emplace() modifier
+    template <class... Args> void emplace(Args &&... args) { *static_cast<base *>(this) = base{BOOST_OUTCOME_V2_NAMESPACE::in_place_type<T>, std::forward<Args>(args)...}; }
+
+    // Expected has a narrow operator* and operator->
+    constexpr const T &operator*() const & { return base::assume_value(); }
+    constexpr T &operator*() & { return base::assume_value(); }
+    constexpr const T &&operator*() const && { return base::assume_value(); }
+    constexpr T &&operator*() && { return base::assume_value(); }
+    constexpr const T *operator->() const { return &base::assume_value(); }
+    constexpr T *operator->() { return &base::assume_value(); }
+
+    // Expected has a narrow error() observer
+    constexpr const E &error() const & { return base::assume_error(); }
+    constexpr E &error() & { return base::assume_error(); }
+    constexpr const E &&error() const && { return base::assume_error(); }
+    constexpr E &error() && { return base::assume_error(); }
+  };
+  template <class E> class expected<void, E> : public BOOST_OUTCOME_V2_NAMESPACE::result<void, E, BOOST_OUTCOME_V2_NAMESPACE::policy::throw_bad_result_access<E, void>>
+  {
+    using base = BOOST_OUTCOME_V2_NAMESPACE::result<void, E, BOOST_OUTCOME_V2_NAMESPACE::policy::throw_bad_result_access<E, void>>;
+
+  public:
+    // Inherit base constructors
+    using base::base;
+
+    // Expected has a narrow operator* and operator->
+    constexpr void operator*() const { base::assume_value(); }
+    constexpr void operator->() const { base::assume_value(); }
+  };
+  template <class E> using unexpected = BOOST_OUTCOME_V2_NAMESPACE::failure_type<E>;
+  template <class E> unexpected<E> make_unexpected(E &&arg) { return BOOST_OUTCOME_V2_NAMESPACE::failure<E>(std::forward<E>(arg)); }
+  template <class E, class... Args> unexpected<E> make_unexpected(Args &&... args) { return BOOST_OUTCOME_V2_NAMESPACE::failure<E>(std::forward<Args>(args)...); }
+  template <class E> using bad_expected_access = BOOST_OUTCOME_V2_NAMESPACE::bad_result_access_with<E>;
+  //! [expected_implementation]
+
+  // Not actually part of the Expected proposal, but needed to pass the test
+  template <typename T> using exception_or = expected<T, std::exception_ptr>;
+}  // namespace stde
+
+template <class T> using expected_sc = stde::expected<T, std::error_code>;
+
+struct NoDefaultConstructible
+{
+  NoDefaultConstructible() = delete;
+  NoDefaultConstructible(int /*unused*/) {}  // NOLINT
+};
+
+struct NoCopyConstructible
+{
+  NoCopyConstructible() = default;
+  NoCopyConstructible(NoCopyConstructible const &) = delete;
+  NoCopyConstructible(NoCopyConstructible &&) noexcept = default;
+};
+struct NoMoveConstructible
+{
+  NoMoveConstructible() = default;
+  NoMoveConstructible(NoMoveConstructible const &) noexcept = default;
+  NoMoveConstructible(NoMoveConstructible &&) = delete;
+  NoMoveConstructible &operator=(NoMoveConstructible const &) noexcept = default;
+  NoMoveConstructible &operator=(NoMoveConstructible &&) = delete;
+};
+
+enum State
+{
+  sDefaultConstructed,
+  sValueCopyConstructed,
+  sValueMoveConstructed,
+  sCopyConstructed,
+  sMoveConstructed,
+  sMoveAssigned,
+  sCopyAssigned,
+  sValueCopyAssigned,
+  sValueMoveAssigned,
+  sMovedFrom,
+  sValueConstructed
+};
+
+struct OracleVal
+{
+  State s{sValueConstructed};
+  int i;
+  constexpr OracleVal(int i_ = 0)  // NOLINT
+  : i(i_)
+  {
+  }
+};
+
+struct Oracle
+{
+  State s{sDefaultConstructed};
+  OracleVal val;
+
+  Oracle() = default;
+  Oracle(const OracleVal &v)  // NOLINT
+  : s(sValueCopyConstructed),
+    val(v)
+  {
+  }
+  Oracle(OracleVal &&v) noexcept : s(sValueMoveConstructed), val(v) { v.s = sMovedFrom; }  // NOLINT
+  Oracle(const Oracle &o)
+      : s(sCopyConstructed)
+      , val(o.val)
+  {
+  }
+  Oracle(Oracle &&o) noexcept : s(sMoveConstructed), val(std::move(o.val)) { o.s = sMovedFrom; }  // NOLINT
+
+  Oracle &operator=(const OracleVal &v)
+  {
+    s = sValueCopyConstructed;
+    val = v;
+    return *this;
+  }
+  Oracle &operator=(OracleVal &&v) noexcept
+  {
+    s = sValueMoveConstructed;
+    val = std::move(v);  // NOLINT
+    v.s = sMovedFrom;
+    return *this;
+  }
+  Oracle &operator=(const Oracle &o)
+  {
+    s = sCopyConstructed;
+    val = o.val;
+    return *this;
+  }
+  Oracle &operator=(Oracle &&o) noexcept
+  {
+    s = sMoveConstructed;
+    val = std::move(o.val);  // NOLINT
+    o.s = sMovedFrom;
+    return *this;
+  }
+};
+
+struct Guard
+{
+  std::string val;
+  Guard() = default;
+  explicit Guard(std::string s, int /*unused*/ = 0)
+      : val(std::move(s))
+  {
+  }
+  Guard(const Guard &) = delete;
+  Guard(Guard &&) = delete;
+  void operator=(const Guard &) = delete;
+  void operator=(Guard &&) = delete;
+};
+
+struct ExplicitStr
+{
+  std::string s;
+  explicit ExplicitStr(const char *chp)
+      : s(chp)
+  {
+  }
+};
+
+struct Date
+{
+  int i;
+  Date() = delete;
+  Date(int i_) noexcept : i{i_} {}  // NOLINT
+  Date(Date &&d) noexcept : i(d.i) { d.i = 0; }
+  Date(const Date &) = delete;
+  Date &operator=(const Date &) = delete;
+  Date &operator=(Date &&d) noexcept
+  {
+    i = d.i;
+    d.i = 0;
+    return *this;
+  }
+};
+
+struct TExcept
+{
+  int i;
+  TExcept() = delete;
+  TExcept(int i_)  // NOLINT
+  : i{i_}
+  {
+  }
+  TExcept(TExcept &&d)
+      : i(d.i)
+  {
+    d.i = 0;
+  }
+  TExcept(const TExcept &) = delete;
+  TExcept &operator=(const TExcept &) = delete;
+  TExcept &operator=(TExcept &&d)
+  {
+    i = d.i;
+    d.i = 0;
+    return *this;
+  }
+};
+
+template <class T> struct MoveAware
+{
+  T val;
+  bool moved;
+  MoveAware(T val_)  // NOLINT
+  : val(val_),
+    moved(false)
+  {
+  }
+  MoveAware(MoveAware const &) = delete;
+  MoveAware(MoveAware &&rhs)
+      : val(rhs.val)
+      , moved(rhs.moved)
+  {
+    rhs.moved = true;
+  }
+  MoveAware &operator=(MoveAware const &) = delete;
+  MoveAware &operator=(MoveAware &&rhs)
+  {
+    val = (rhs.val);
+    moved = (rhs.moved);
+    rhs.moved = true;
+    return *this;
+  }
+};
+
+struct OverloadedAddressOf
+{
+  OverloadedAddressOf() = default;
+  OverloadedAddressOf *operator&() const { return nullptr; }
+};
+
+// using namespace boost;
+// using namespace boost::functional;
+
+class test_exception : public std::exception
+{
+};
+
+int throwing_fun()
+{
+  throw test_exception();
+}
+int nothrowing_fun()
+{
+  return 4;
+}
+
+JASEL_NORETURN void void_throwing_fun()
+{
+  throw test_exception();
+}
+void do_nothing_fun()
+{
+}
+
+void except_default_constructor()
+{
+  // From value constructor.
+  expected_sc<int> e{};
+  try
+  {
+    int i = e.value();
+    (void) i;
+    BOOST_TEST(true);
+  }
+  catch(...)
+  {
+    BOOST_TEST(false);
+  };
+  BOOST_TEST(e.has_value());
+  BOOST_TEST(e);
+  BOOST_TEST(static_cast<bool>(e));
+}
+
+
+void except_default_constructor_error_code()
+{
+  // From value constructor.
+  stde::expected<int, std::error_code> e;
+  BOOST_TEST(e.has_value());
+  BOOST_TEST(e);
+  BOOST_TEST(static_cast<bool>(e));
+}
+
+void except_default_constructor_constexpr()
+{
+  // From value constructor.
+  BOOST_CONSTEXPR stde::expected<int, long> e;
+  BOOST_TEST(e.has_value());
+}
+
+void expected_from_value()
+{
+  // using T = int;
+  using E = std::error_code;
+
+  // static_assert(noexcept(stde::adl::swap_impl(std::declval<T &>(), std::declval<T &>())), "");
+  static_assert(std::is_nothrow_copy_constructible<E>::value, "");
+  // static_assert(noexcept(stde::adl::swap_impl(std::declval<E &>(), std::declval<E &>())), "");
+
+  static_assert(std::is_nothrow_copy_constructible<expected_sc<int>>::value, "");
+  static_assert(std::is_nothrow_copy_assignable<expected_sc<int>>::value, "");
+  static_assert(std::is_nothrow_move_constructible<expected_sc<int>>::value, "");
+  static_assert(std::is_nothrow_move_assignable<expected_sc<int>>::value, "");
+
+  // From value constructor.
+  expected_sc<int> e(5);
+  // BOOST_REQUIRE_NO_THROW(e.value());
+  BOOST_TEST_EQ(e.value(), 5);
+  BOOST_TEST_EQ(*e, 5);
+  BOOST_TEST(e.has_value());
+  BOOST_TEST(static_cast<bool>(e));
+}
+
+void expected_from_value2()
+{
+  // From value constructor.
+  expected_sc<int> e(5);
+  e = {};
+  BOOST_TEST(e.has_value());
+  BOOST_TEST_EQ(e.value(), 0);
+}
+
+void expected_from_cnv_value()
+{
+  OracleVal v;
+  expected_sc<Oracle> e(v);
+  // BOOST_REQUIRE_NO_THROW(e.value());
+  BOOST_TEST(!!e);
+  BOOST_TEST(e.has_value());
+  BOOST_TEST(bool(e));
+  BOOST_TEST_EQ(e.value().s, sValueCopyConstructed);
+  BOOST_TEST_EQ(v.s, sValueConstructed);
+
+  expected_sc<Oracle> e2(std::move(v));  // NOLINT
+  // BOOST_REQUIRE_NO_THROW(e2.value());
+  BOOST_TEST(!!e2);
+  BOOST_TEST(e2.has_value());
+  BOOST_TEST(bool(e2));
+  BOOST_TEST_EQ(e2.value().s, sValueMoveConstructed);
+  BOOST_TEST_EQ(v.s, sMovedFrom);
+}
+
+struct NDCE  // no default constructor
+{            // (no default date exists)
+  explicit NDCE(int /*unused*/) {}
+};
+
+void except_constructor_NDCE()
+{
+  expected_sc<NDCE> e{NDCE{1}};
+  BOOST_TEST(e.has_value());
+}
+struct NDC                // no default constructor
+{                         // (no default date exists)
+  NDC(int /*unused*/) {}  // NOLINT
+};
+
+void except_constructor_NDC()
+{
+  static_assert(std::is_nothrow_copy_constructible<expected_sc<NDC>>::value, "");
+  static_assert(std::is_nothrow_copy_assignable<expected_sc<NDC>>::value, "");
+  static_assert(std::is_nothrow_move_constructible<expected_sc<NDC>>::value, "");
+  static_assert(std::is_nothrow_move_assignable<expected_sc<NDC>>::value, "");
+  expected_sc<NDC> e{1};
+  BOOST_TEST(e.has_value());
+}
+
+void except_constructor_Date()
+{
+  static_assert(std::is_nothrow_move_constructible<expected_sc<Date>>::value, "");
+  static_assert(std::is_nothrow_move_assignable<expected_sc<Date>>::value, "");
+  expected_sc<Date> e{Date{1}};
+  BOOST_TEST(e.has_value());
+}
+
+void except_constructor_TExcept()
+{
+  static_assert(!std::is_nothrow_move_constructible<expected_sc<TExcept>>::value, "");
+  static_assert(!std::is_nothrow_move_assignable<expected_sc<TExcept>>::value, "");
+  expected_sc<TExcept> e{TExcept{1}};
+  BOOST_TEST(e.has_value());
+}
+
+void expected_from_in_place_value()
+{
+  OracleVal v;
+  expected_sc<Oracle> e{stde::in_place, v};
+  // BOOST_REQUIRE_NO_THROW(e.value());
+  BOOST_TEST(!!e);
+  BOOST_TEST(e.has_value());
+  BOOST_TEST(bool(e));
+  BOOST_TEST_EQ(e.value().s, sValueCopyConstructed);
+  BOOST_TEST_EQ(v.s, sValueConstructed);
+
+  expected_sc<Oracle> e2{stde::in_place, std::move(v)};  // NOLINT
+  // BOOST_REQUIRE_NO_THROW(e2.value());
+  BOOST_TEST(!!e2);
+  BOOST_TEST(e2.has_value());
+  BOOST_TEST(bool(e2));
+  BOOST_TEST_EQ(e2.value().s, sValueMoveConstructed);
+  BOOST_TEST_EQ(v.s, sMovedFrom);
+}
+
+#if 0
+void expected_from_exception()
+{
+  // From stde::unexpected constructor.
+  stde::exception_or<int> e(stde::make_unexpected(test_exception()));
+  BOOST_TEST_THROWS(e.value(), test_exception);
+  BOOST_TEST_EQ(e.has_value(), false);
+  BOOST_TEST_EQ(static_cast<bool>(e), false);
+}
+#endif
+
+void expected_from_copy_value()
+{
+  // From copy constructor.
+  expected_sc<int> ef(5);
+  expected_sc<int> e(ef);
+  // BOOST_REQUIRE_NO_THROW(e.value());
+  BOOST_TEST_EQ(e.value(), 5);
+  BOOST_TEST_EQ(*e, 5);
+  BOOST_TEST(e.has_value());
+  BOOST_TEST(static_cast<bool>(e));
+}
+
+#if 0
+void expected_from_copy_exception()
+{
+  // From stde::unexpected constructor.
+  stde::exception_or<int> ef(stde::make_unexpected(test_exception()));
+  stde::exception_or<int> e(ef);
+  BOOST_TEST_THROWS(e.value(), test_exception);
+  BOOST_TEST_EQ(e.has_value(), false);
+  BOOST_TEST_EQ(static_cast<bool>(e), false);
+}
+#endif
+
+void expected_from_in_place()
+{
+  // From stde::in_place constructor.
+  expected_sc<std::string> e(stde::in_place, "stde::in_place");
+  // BOOST_REQUIRE_NO_THROW(e.value());
+  BOOST_TEST_EQ(e.value(), "stde::in_place");
+  BOOST_TEST_EQ(*e, "stde::in_place");
+  BOOST_TEST(e.has_value());
+  BOOST_TEST(static_cast<bool>(e));
+}
+
+#if 0
+void expected_from_exception_ptr()
+{
+  // From exception_ptr constructor.
+  stde::exception_or<int> e(stde::make_unexpected(std::make_exception_ptr(test_exception())));
+  BOOST_TEST_THROWS(e.value(), test_exception);
+  BOOST_TEST_EQ(e.has_value(), false);
+  BOOST_TEST_EQ(static_cast<bool>(e), false);
+}
+#endif
+
+void expected_from_moved_value()
+{
+  // From move value constructor.
+  std::string value = "my value";
+  expected_sc<std::string> e = std::move(value);
+  // BOOST_REQUIRE_NO_THROW(e.value());
+  BOOST_TEST_EQ(e.value(), "my value");
+  BOOST_TEST_EQ(*e, "my value");
+  BOOST_TEST(e.has_value());
+  BOOST_TEST(static_cast<bool>(e));
+}
+
+void expected_from_catch_block()
+{
+  // From catch block
+  try
+  {
+    throw test_exception();
+  }
+  catch(...)
+  {
+    stde::exception_or<int> e(stde::make_unexpected(std::current_exception()));
+
+    BOOST_TEST_THROWS(e.value(), std::exception);
+    BOOST_TEST_EQ(e.has_value(), false);
+    BOOST_TEST_EQ(static_cast<bool>(e), false);
+  }
+}
+
+
+void make_expected_E_from_value()
+{
+  // auto e = stde::make_expected<std::string>( 5 );
+  // BOOST_TEST_EQ(e.has_value(), false);
+}
+void make_expected_const_from_value()
+{
+#if defined __clang__ && __clang_major__ >= 4 && __cplusplus > 201402L
+  const int i = 0;
+  auto e = expected_sc<const int>(i);
+  (void) e;
+// static_assert(std::is_same<decltype(e), stde::success<const int>>::value, "");
+#endif
+}
+void make_expected_from_U_value()
+{
+  expected_sc<int> e = expected_sc<int>(short(5));
+  static_assert(std::is_same<decltype(e), expected_sc<int>>{}, "");
+  BOOST_TEST_EQ(e.has_value(), true);
+}
+void make_expected_from_U_value2()
+{
+  expected_sc<std::string> e = expected_sc<std::string>("aa");
+  static_assert(std::is_same<decltype(e), expected_sc<std::string>>{}, "");
+  BOOST_TEST_EQ(e.has_value(), true);
+}
+
+void expected_from_value_error_condition()
+{
+  // From value constructor.
+  stde::expected<int, std::error_condition> e(5);
+  // BOOST_REQUIRE_NO_THROW(e.value());
+  BOOST_TEST_EQ(e.value(), 5);
+  BOOST_TEST_EQ(*e, 5);
+  BOOST_TEST(e.has_value());
+  BOOST_TEST(static_cast<bool>(e));
+}
+
+void expected_from_error_error_condition()
+{
+  // From stde::unexpected constructor.
+  stde::expected<int, std::error_condition> e(stde::make_unexpected<std::error_condition>(std::make_error_condition(std::errc::invalid_argument)));
+  auto error_from_except_check = [](const stde::bad_expected_access<std::error_condition> &except) { return std::errc(except.error().value()) == std::errc::invalid_argument; };
+  try
+  {
+    (void) e.value();
+  }
+  catch(stde::bad_expected_access<std::error_condition> &ex)
+  {
+    BOOST_TEST(error_from_except_check(ex));
+  }
+  BOOST_TEST_EQ(e.has_value(), false);
+  BOOST_TEST_EQ(static_cast<bool>(e), false);
+}
+
+
+void expected_from_error_convertible()
+{
+  {
+    stde::expected<int, short> e1 = stde::make_unexpected<short>(1);
+    stde::expected<int, long> e2(e1);
+    BOOST_TEST_EQ(e2.has_value(), false);
+    BOOST_TEST_EQ(static_cast<bool>(e2), false);
+    BOOST_TEST_EQ(e2.error(), 1);
+  }
+  {
+    stde::expected<void, short> e1 = stde::make_unexpected<short>(1);
+    stde::expected<void, int> e2(e1);
+    BOOST_TEST_EQ(e2.has_value(), false);
+    BOOST_TEST_EQ(static_cast<bool>(e2), false);
+    BOOST_TEST_EQ(e2.error(), 1);
+  }
+}
+
+void except_valid_constexpr_int()
+{
+  // From value constructor.
+  BOOST_CONSTEXPR stde::expected<int, long> e;
+  BOOST_CONSTEXPR bool b = e.has_value();
+  BOOST_TEST(b);
+}
+void except_value_constexpr_int()
+{
+  // From value constructor.
+  BOOST_CONSTEXPR stde::expected<int, long> e(1);
+  BOOST_CONSTEXPR int x = e.value();
+  BOOST_TEST_EQ(x, 1);
+}
+
+void expected_from_value3()
+{
+  expected_sc<int> e(5);
+  BOOST_TEST_EQ(e.value(), 5);
+
+  // From value assignment.
+  e = 8;
+  // BOOST_REQUIRE_NO_THROW(e.value());
+  BOOST_TEST_EQ(e.value(), 8);
+  BOOST_TEST_EQ(*e, 8);
+  BOOST_TEST(e.has_value());
+  BOOST_TEST(static_cast<bool>(e));
+}
+
+void expected_from_copy_expected()
+{
+  expected_sc<int> e(5);
+  expected_sc<int> e2(8);
+
+  // From value assignment.
+  e = e2;
+  // BOOST_REQUIRE_NO_THROW(e.value());
+  BOOST_TEST_EQ(e.value(), 8);
+  BOOST_TEST_EQ(*e, 8);
+  BOOST_TEST(e.has_value());
+  BOOST_TEST(static_cast<bool>(e));
+}
+
+void expected_from_moved_expected()
+{
+  expected_sc<std::string> e("e");
+  expected_sc<std::string> e2("e2");
+
+  // From value assignment.
+  e = std::move(e2);
+  // BOOST_REQUIRE_NO_THROW(e.value());
+  BOOST_TEST_EQ(e.value(), "e2");
+  BOOST_TEST_EQ(*e, "e2");
+  BOOST_TEST(e.has_value());
+  BOOST_TEST(static_cast<bool>(e));
+
+// BOOST_REQUIRE_NO_THROW(e2.value());
+#ifndef __GLIBBOOST_OUTCOME_C__
+  BOOST_TEST_EQ(e2.value(), "");
+  BOOST_TEST_EQ(*e2, "");
+#endif
+  BOOST_TEST(e2.has_value());
+  BOOST_TEST(static_cast<bool>(e2));
+}
+
+void expected_from_in_place2()
+{
+  // From stde::in_place constructor.
+  expected_sc<std::string> e(stde::in_place, "stde::in_place");
+  BOOST_TEST_EQ(e.value(), "stde::in_place");
+
+  // From emplace method.
+  e.emplace("emplace method");
+  // BOOST_REQUIRE_NO_THROW(e.value());
+  BOOST_TEST_EQ(e.value(), "emplace method");
+  BOOST_TEST_EQ(*e, "emplace method");
+  BOOST_TEST(e.has_value());
+  BOOST_TEST(static_cast<bool>(e));
+}
+
+void expected_from_move_value()
+{
+  expected_sc<std::string> e("v");
+
+  std::string value = "my value";
+  // From assignment operator.
+  e = std::move(value);
+  // BOOST_REQUIRE_NO_THROW(e.value());
+  BOOST_TEST_EQ(e.value(), "my value");
+  BOOST_TEST_EQ(*e, "my value");
+  BOOST_TEST(e.has_value());
+  BOOST_TEST(static_cast<bool>(e));
+}
+
+
+void expected_from_in_place3()
+{
+  // From stde::in_place factory.
+  // auto e = stde::make_expected<std::string>("stde::in_place");
+  auto e = expected_sc<std::string>("stde::in_place");
+  // BOOST_REQUIRE_NO_THROW(e.value());
+  BOOST_TEST_EQ(e.value(), "stde::in_place");
+  BOOST_TEST_EQ(*e, "stde::in_place");
+  BOOST_TEST(e.has_value());
+  BOOST_TEST(static_cast<bool>(e));
+}
+void expected_from_in_place_error()
+{
+  // From stde::in_place factory.
+  auto e = stde::expected<std::string, std::error_condition>("stde::in_place");
+  // BOOST_REQUIRE_NO_THROW(e.value());
+  BOOST_TEST_EQ(e.value(), "stde::in_place");
+  BOOST_TEST_EQ(*e, "stde::in_place");
+  BOOST_TEST(e.has_value());
+  BOOST_TEST(static_cast<bool>(e));
+}
+
+void expected_from_exception_catch()
+{
+  // From catch block
+  try
+  {
+    throw test_exception();
+  }
+  catch(...)
+  {
+    stde::exception_or<int> e = stde::make_unexpected(std::current_exception());
+
+    BOOST_TEST_THROWS(e.value(), std::exception);
+    BOOST_TEST_EQ(e.has_value(), false);
+    BOOST_TEST_EQ(static_cast<bool>(e), false);
+  }
+}
+
+#if 0
+void expected_from_error()
+{
+  // From stde::unexpected constructor.
+  auto e = stde::make_expected_from_error<int>(std::make_error_condition(std::errc::invalid_argument));
+  auto error_from_except_check = [](const stde::bad_expected_access<std::error_condition> &except) { return std::errc(except.error().value()) == std::errc::invalid_argument; };
+  try
+  {
+    (void) e.value();
+  }
+  catch(stde::bad_expected_access<std::error_condition> &ex)
+  {
+    BOOST_TEST(error_from_except_check(ex));
+  }
+  BOOST_TEST_EQ(e.has_value(), false);
+  BOOST_TEST_EQ(static_cast<bool>(e), false);
+}
+
+void expected_from_error_U()
+{
+  // From stde::unexpected constructor.
+  auto e = stde::make_expected_from_error<int, short>(42);
+  static_assert(std::is_same<decltype(e), stde::expected<int, short>>{}, "");
+  BOOST_TEST_EQ(e.has_value(), false);
+  BOOST_TEST_EQ(static_cast<bool>(e), false);
+}
+
+void expected_from_exception2()
+{
+  // From stde::unexpected constructor.
+  auto e = stde::make_expected_from_exception<int>(test_exception());
+  // auto e = expected_sc<int>(stde::unexpected<>(test_exception()));
+  BOOST_TEST_THROWS(e.value(),  test_exception );
+  BOOST_TEST_EQ(e.has_value(), false);
+  BOOST_TEST_EQ(static_cast<bool>(e), false);
+}
+
+void expected_from_exception_ptr2()
+{
+  // From exception_ptr constructor.
+  auto e = stde::exception_or<int>(stde::make_unexpected(test_exception()));
+  BOOST_TEST_THROWS(e.value(),  test_exception );
+  BOOST_TEST_EQ(e.has_value(), false);
+  BOOST_TEST_EQ(static_cast<bool>(e), false);
+}
+
+void make_expected_from_call_fun()
+{
+  try
+  {
+    stde::make_expected_from_call(throwing_fun);
+    BOOST_TEST(true);
+  }
+  catch(...)
+  {
+    BOOST_TEST(false);
+  }
+  stde::exception_or<int> e = stde::make_expected_from_call(throwing_fun);
+  BOOST_TEST_THROWS(e.value(),  std::exception );
+  BOOST_TEST_EQ(e.has_value(), false);
+  BOOST_TEST_EQ(static_cast<bool>(e), false);
+
+  e = stde::make_expected_from_call(nothrowing_fun);
+  try
+  {
+    (void) e.value();
+    BOOST_TEST(true);
+  }
+  catch(...)
+  {
+    BOOST_TEST(false);
+  }
+  BOOST_TEST_EQ(e.value(), 4);
+  BOOST_TEST_EQ(*e, 4);
+  BOOST_TEST_EQ(e.has_value(), true);
+  BOOST_TEST_EQ(static_cast<bool>(e), true);
+
+#if 0
+  BOOST_TEST_THROWS(stde::make_expected_from_call<std::error_condition>(throwing_fun), test_exception);
+
+  BOOST_TEST_NO_THROW(stde::make_expected_from_call<std::error_condition>(nothrowing_fun));
+  stde::expected<int, std::error_condition> e2 = stde::make_expected_from_call<std::error_condition>(nothrowing_fun);
+  BOOST_TEST_NO_THROW(e2.value());
+  BOOST_TEST_EQ(e2.value(), 4);
+  BOOST_TEST_EQ(*e2, 4);
+  BOOST_TEST_EQ(e2.has_value(), true);
+  BOOST_TEST_EQ(static_cast<bool>(e2), true);
+#endif
+}
+
+void make_expected_from_call_void_fun()
+{
+#if 0
+  BOOST_TEST_NO_THROW(stde::make_expected_from_call(void_throwing_fun));
+  expected_sc<void> e = stde::make_expected_from_call(void_throwing_fun);
+  BOOST_TEST_THROWS(e.value(), std::exception);
+  BOOST_TEST_EQ(e.has_value(), false);
+  BOOST_TEST_EQ(static_cast<bool>(e), false);
+
+  e = stde::make_expected_from_call(do_nothing_fun);
+  BOOST_TEST_NO_THROW(e.value());
+  BOOST_TEST_EQ(e.has_value(), true);
+  BOOST_TEST_EQ(static_cast<bool>(e), true);
+
+  BOOST_TEST_THROWS(stde::make_expected_from_call<std::error_condition>(void_throwing_fun), test_exception);
+
+  try {
+    stde::make_expected_from_call<std::error_condition>(do_nothing_fun);
+    BOOST_TEST(true);
+  }
+  catch (...)
+  {
+    BOOST_TEST(false);
+  }
+  stde::expected<void, std::error_condition> e2 = stde::make_expected_from_call<std::error_condition>(do_nothing_fun);
+  try {
+    (void)e2.value();
+    BOOST_TEST(true);
+  }
+  catch (...)
+  {
+    BOOST_TEST(false);
+  }
+  //BOOST_TEST_NO_THROW(e2.value());
+  BOOST_TEST_EQ(e2.has_value(), true);
+  BOOST_TEST_EQ(static_cast<bool>(e2), true);
+#endif
+}
+#endif
+
+void expected_swap_value()
+{
+  // From value constructor.
+  expected_sc<int> e(5);
+  expected_sc<int> e2(8);
+
+  e.swap(e2);
+
+  BOOST_TEST_EQ(e.value(), 8);
+  BOOST_TEST_EQ(e2.value(), 5);
+
+  e2.swap(e);
+
+  BOOST_TEST_EQ(e.value(), 5);
+  BOOST_TEST_EQ(e2.value(), 8);
+}
+
+#if 0
+void expected_swap_exception()
+{
+  // From value constructor.
+  stde::exception_or<int> e = stde::make_unexpected(std::invalid_argument("e"));
+  stde::exception_or<int> e2 = stde::make_unexpected(std::invalid_argument("e2"));
+
+  e.swap(e2);
+
+  auto equal_to_e = [](const std::invalid_argument &except) { return std::string(except.what()) == "e"; };
+  auto equal_to_e2 = [](const std::invalid_argument &except) { return std::string(except.what()) == "e2"; };
+
+  try
+  {
+    (void) e.value();
+    BOOST_TEST(true);
+  }
+  catch(std::invalid_argument &ex)
+  {
+    BOOST_TEST(equal_to_e2(ex));
+  }
+  try
+  {
+    (void) e2.value();
+    BOOST_TEST(true);
+  }
+  catch(std::invalid_argument &ex)
+  {
+    BOOST_TEST(equal_to_e(ex));
+  }
+
+  e2.swap(e);
+
+  try
+  {
+    (void) e.value();
+    BOOST_TEST(true);
+  }
+  catch(std::invalid_argument &ex)
+  {
+    BOOST_TEST(equal_to_e(ex));
+  }
+  try
+  {
+    (void) e2.value();
+    BOOST_TEST(true);
+  }
+  catch(std::invalid_argument &ex)
+  {
+    BOOST_TEST(equal_to_e2(ex));
+  }
+}
+#endif
+
+void expected_swap_function_value()
+{
+  // From value constructor.
+  expected_sc<int> e(5);
+  expected_sc<int> e2(8);
+
+  swap(e, e2);
+
+  BOOST_TEST_EQ(e.value(), 8);
+  BOOST_TEST_EQ(e2.value(), 5);
+
+  swap(e, e2);
+
+  BOOST_TEST_EQ(e.value(), 5);
+  BOOST_TEST_EQ(e2.value(), 8);
+}
+
+
+#ifdef QUICKCPPLIB_BOOST_UNIT_TEST_HPP
+int main()
+#else
+BOOST_AUTO_TEST_CASE(expected_pass)
+#endif
+{
+
+  static_assert(!std::is_default_constructible<NoDefaultConstructible>::value, "");
+  static_assert(!std::is_default_constructible<expected_sc<NoDefaultConstructible>>::value, "");
+
+  static_assert(!std::is_copy_constructible<NoCopyConstructible>::value, "");
+  static_assert(!std::is_constructible<expected_sc<NoCopyConstructible>, NoCopyConstructible const &>::value, "");
+  static_assert(!std::is_constructible<stde::exception_or<NoCopyConstructible>, stde::exception_or<NoCopyConstructible> const &>::value, "");
+  static_assert(!std::is_copy_constructible<stde::exception_or<NoCopyConstructible>>::value, "");
+
+#if 0
+  // fixme
+  {
+    NoMoveConstructible nmc;
+    // NoMoveConstructible nmc2 = std::move(nmc); // FAILS as expected
+
+    expected_sc<NoMoveConstructible> x{std::move(nmc)};  // DOESN'T FAIL as copy is selected instead
+    (void) x;
+  }
+// fixme
+#if defined __clang__ && __clang_major__ >= 4 && __cplusplus > 201402L
+  {
+    NoMoveConstructible nmc;
+    // NoMoveConstructible nmc2 = std::move(nmc); // FAILS as expected
+
+    expected_sc<NoMoveConstructible> x = std::move(nmc);  // DOESN'T FAIL as copy is selected instead
+    (void) x;
+  }
+#endif
+#endif
+
+  static_assert(!std::is_move_constructible<NoMoveConstructible>::value, "");
+  static_assert(!std::is_constructible<expected_sc<NoMoveConstructible>, NoMoveConstructible &&>::value, "");
+  static_assert(std::is_move_constructible<expected_sc<NoMoveConstructible>>::value, "");
+
+  except_default_constructor();
+  except_default_constructor_error_code();
+  except_default_constructor_constexpr();
+  expected_from_value();
+  expected_from_value2();
+  expected_from_cnv_value();
+  except_constructor_NDCE();
+  except_constructor_NDC();
+  except_constructor_Date();
+  expected_from_in_place_value();
+  // expected_from_exception();
+  expected_from_copy_value();
+  // expected_from_copy_exception();
+  expected_from_in_place();
+  // expected_from_exception_ptr();
+  expected_from_moved_value();
+  expected_from_catch_block();
+  make_expected_E_from_value();
+  make_expected_const_from_value();
+  make_expected_from_U_value2();
+  expected_from_value_error_condition();
+  expected_from_error_error_condition();
+  expected_from_error_convertible();
+  except_valid_constexpr_int();
+  except_value_constexpr_int();
+  expected_from_value3();
+  expected_from_copy_expected();
+  expected_from_moved_expected();
+  expected_from_in_place2();
+  expected_from_move_value();
+  expected_from_in_place3();
+  expected_from_in_place_error();
+  expected_from_exception_catch();
+  // expected_from_error();
+  // expected_from_error_U();
+  // expected_from_exception2();
+  // expected_from_exception_ptr2();
+  // make_expected_from_call_fun();
+  // make_expected_from_call_void_fun();
+  expected_swap_value();
+  // expected_swap_exception();
+  expected_swap_function_value();
+
+#ifdef QUICKCPPLIB_BOOST_UNIT_TEST_HPP
+  return QUICKCPPLIB_NAMESPACE::unit_test::current_test_case()->fails != 0;
+#endif
+}
+
+#if 0
+///////////////////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////////////////////
+
+
+//void expected_from_error_catch_exception)
+//{
+//  // From catch block
+//  try
+//  {
+//    throw test_exception();
+//  }
+//  catch(...)
+//  {
+//    auto throw_lambda = [](){ return stde::make_expected_from_error<int,std::error_condition>();};
+//
+//    //BOOST_TEST_THROWS(throw_lambda(), test_exception);
+//  }
+//}
+
+
+
+////////////////////////////////////
+BOOST_AUTO_TEST_SUITE(expected_map)
+
+void expected_map()
+{
+  auto fun = [](bool b) -> expected_sc<int>
+  {
+    if (b)
+      return stde::make_expected(5);
+    else
+      return stde::make_unexpected(test_exception());
+  };
+
+  auto add_five = [](int sum) -> int
+  {
+    return sum + 5;
+  };
+
+  auto launch_except = [](int sum) -> int
+  {
+    throw test_exception();
+  };
+
+  expected_sc<int> e = fun(true).map(add_five);
+  BOOST_TEST_NO_THROW(e.value());
+  BOOST_TEST_EQ(*e, 10);
+
+  e = fun(true).map(add_five).map(add_five);
+  BOOST_TEST_NO_THROW(e.value());
+  BOOST_TEST_EQ(*e, 15);
+
+  e = fun(false).map(add_five).map(add_five);
+  BOOST_TEST_THROWS(e.value(), test_exception);
+
+  BOOST_TEST_THROWS(fun(true).map(launch_except), test_exception);
+
+}
+
+void expected_void_map()
+{
+  auto fun = [](bool b)
+  {
+    if (b)
+      return stde::make_expected();
+    else
+      return expected_sc<void>(stde::make_unexpected(test_exception()));
+  };
+
+  auto launch_except = []() -> void
+  {
+    throw test_exception();
+  };
+
+  auto do_nothing = []() {};
+
+  expected_sc<void> e = fun(true).map(do_nothing);
+  BOOST_TEST_NO_THROW(e.value());
+
+  e = fun(false).map(do_nothing);
+  BOOST_TEST_THROWS(e.value(), test_exception);
+
+  BOOST_TEST_THROWS(fun(true).map(launch_except), test_exception);
+
+}
+
+BOOST_AUTO_TEST_SUITE_END()
+
+////////////////////////////////////
+BOOST_AUTO_TEST_SUITE(expected_bind)
+
+void expected_bind()
+{
+  auto fun = [](bool b) -> expected_sc<int>
+  {
+    if (b)
+      return stde::make_expected(5);
+    else
+      return stde::make_unexpected(test_exception());
+  };
+
+  auto add_five = [](int sum) -> expected_sc<int>
+  {
+    return stde::make_expected(sum + 5);
+  };
+
+  auto launch_except = [](int sum) -> expected_sc<int>
+  {
+    throw test_exception();
+  };
+
+  expected_sc<int> e = fun(true).bind(add_five);
+  BOOST_TEST_NO_THROW(e.value());
+  BOOST_TEST_EQ(*e, 10);
+
+  e = fun(true).bind(add_five).bind(add_five);
+  BOOST_TEST_NO_THROW(e.value());
+  BOOST_TEST_EQ(*e, 15);
+
+  e = fun(false).bind(add_five).bind(add_five);
+  BOOST_TEST_THROWS(e.value(), test_exception);
+
+  BOOST_TEST_THROWS(fun(true).bind(launch_except), test_exception);
+
+}
+
+void expected_void_bind()
+{
+  auto fun = [](bool b)
+  {
+    if (b)
+      return stde::make_expected();
+    else
+      return expected_sc<void>(stde::make_unexpected(test_exception()));
+  };
+
+  auto launch_except = []() -> expected_sc<void>
+  {
+    throw test_exception();
+  };
+
+  auto do_nothing = []() {
+    return stde::make_expected();
+  };
+
+  expected_sc<void> e = fun(true).bind(do_nothing);
+  BOOST_TEST_NO_THROW(e.value());
+
+  e = fun(false).bind(do_nothing);
+  BOOST_TEST_THROWS(e.value(), test_exception);
+
+  BOOST_TEST_THROWS(fun(true).bind(launch_except), test_exception);
+
+}
+
+BOOST_AUTO_TEST_SUITE_END()
+
+
+////////////////////////////////////
+BOOST_AUTO_TEST_SUITE(expected_then)
+
+void expected_non_void_then()
+{
+  auto fun = [](bool b) -> expected_sc<int>
+  {
+    if (b)
+      return stde::make_expected(5);
+    else
+      return stde::make_unexpected(test_exception());
+  };
+
+
+  auto add_five = [](int sum) -> int
+  {
+    return sum + 5;
+  };
+  auto six = []() -> int
+  {
+    return 6;
+  };
+
+  auto pair = [](int a) -> bool
+  {
+    return (a % 2) == 0;
+  };
+
+  auto launch_except = [](int sum) -> int
+  {
+    throw test_exception();
+  };
+
+  auto then_launch_except = [](expected<int>) -> int
+  {
+    throw test_exception();
+  };
+
+  expected_sc<int> e = fun(true).then(if_valued(add_five));
+  BOOST_TEST_NO_THROW(e.value());
+  BOOST_TEST_EQ(*e, 10);
+
+  e = fun(true).then(if_valued(ident(six)));
+  BOOST_TEST_NO_THROW(e.value());
+  BOOST_TEST_EQ(*e, 6);
+
+  e = fun(false).then(if_unexpected(ident(six)));
+  BOOST_TEST_NO_THROW(e.value());
+  BOOST_TEST_EQ(*e, 6);
+
+  expected_sc<bool> e1 = fun(true).then(if_valued(pair));
+  BOOST_TEST_NO_THROW(e1.value());
+  BOOST_TEST_EQ(*e1, false);
+
+
+
+  e = fun(true).then(if_valued(add_five)).then(if_valued(add_five));
+  BOOST_TEST_NO_THROW(e.value());
+  BOOST_TEST_EQ(*e, 15);
+
+  e = fun(false).then(if_valued(add_five)).then(if_valued(add_five));
+  BOOST_TEST_THROWS(e.value(), test_exception);
+
+  BOOST_TEST_THROWS(fun(true).then(if_valued(launch_except)), test_exception);
+
+  e = fun(false).then(catch_all(then_launch_except));
+  BOOST_TEST_THROWS(e.value(), test_exception);
+
+}
+
+void expected_void_then()
+{
+  auto fun = [](bool b) -> expected_sc<void>
+  {
+    if (b)
+      return stde::make_expected();
+    else
+      return stde::make_unexpected(test_exception());
+  };
+
+  auto launch_except = []()
+  {
+    throw test_exception();
+  };
+
+  auto do_nothing = []() {};
+
+  BOOST_TEST(true);
+  expected_sc<void> e = fun(true).then(if_valued(do_nothing));
+  BOOST_TEST_NO_THROW(e.value());
+
+  e = fun(false).then(if_valued(do_nothing));
+  BOOST_TEST_THROWS(e.value(), test_exception);
+
+  BOOST_TEST_THROWS(fun(true).then(if_valued(launch_except)), test_exception);
+
+}
+
+BOOST_AUTO_TEST_SUITE_END()
+
+BOOST_AUTO_TEST_SUITE(expected_recover)
+
+void expected_recover()
+{
+  auto fun = [](bool b)
+  {
+    if (b)
+      return expected_sc<int>(5);
+    else
+      return expected_sc<int>(stde::make_unexpected(test_exception()));
+  };
+
+  auto add_five = [](int sum) -> expected_sc<int>
+  {
+    return stde::make_expected(sum + 5);
+  };
+
+  auto recover_error = [](std::exception_ptr p)
+  {
+    return stde::make_expected(0);
+  };
+
+  auto recover_error_silent_failure = [](std::exception_ptr p)
+  {
+    return expected_sc<int>(stde::make_unexpected(p));
+  };
+
+  auto recover_error_failure = [](std::exception_ptr p) -> expected_sc<int>
+  {
+    return expected_sc<int>(stde::make_unexpected(test_exception()));
+  };
+
+  auto recover_error_throws = [](std::exception_ptr p) -> expected_sc<int>
+  {
+    throw test_exception();
+  };
+
+  BOOST_TEST_EQ(fun(false).catch_error(recover_error).has_value(), true);
+  BOOST_TEST_EQ(fun(false).catch_error(recover_error).value(), 0);
+  BOOST_TEST_EQ(fun(true).catch_error(recover_error).value(), 5);
+  BOOST_TEST_EQ(fun(false).catch_error(recover_error_silent_failure).has_value(), false);
+  BOOST_TEST_EQ(fun(false).catch_error(recover_error_failure).has_value(), false);
+
+  BOOST_TEST_EQ(fun(true).bind(add_five).value(), 10);
+  BOOST_TEST_EQ(fun(true).bind(add_five).catch_error(recover_error).value(), 10);
+  BOOST_TEST_EQ(fun(true).bind(add_five).catch_error(recover_error_silent_failure).value(), 10);
+  BOOST_TEST_EQ(fun(true).bind(add_five).catch_error(recover_error_failure).value(), 10);
+
+  BOOST_TEST_EQ(fun(false).catch_error(recover_error).bind(add_five).value(), 5);
+  BOOST_TEST_EQ(fun(false).catch_error(recover_error).bind(add_five).bind(add_five).value(), 10);
+  BOOST_TEST_EQ(fun(false).catch_error(recover_error_failure).bind(add_five).has_value(), false);
+  BOOST_TEST_EQ(fun(false).bind(add_five).catch_error(recover_error_failure).bind(add_five).has_value(), false);
+  BOOST_TEST_EQ(fun(false).bind(add_five).catch_error(recover_error_silent_failure).bind(add_five).has_value(), false);
+
+  BOOST_TEST_THROWS(fun(false).catch_error(recover_error_throws), test_exception);
+
+}
+
+void expected_void_recover()
+{
+  auto fun = [](bool b)
+  {
+    if (b)
+      return stde::make_expected();
+    else
+      return expected_sc<void>(boost::stde::make_unexpected(test_exception()));
+  };
+
+  auto do_nothing = []() {
+    return stde::make_expected();
+  };
+
+  auto recover_error = [](std::exception_ptr p)
+  {
+    return stde::make_expected();
+  };
+
+  auto recover_error_silent_failure = [](std::exception_ptr p)
+  {
+    return expected_sc<void>(boost::stde::make_unexpected(p));
+  };
+
+  auto recover_error_failure = [](std::exception_ptr p) -> expected_sc<void>
+  {
+    throw test_exception();
+  };
+
+  // The catch_error doesn't alter the stde::expected if it's valid.
+  BOOST_TEST_EQ(fun(true).catch_error(recover_error_failure).has_value(), true);
+
+  // Simple catch_error tests.
+  BOOST_TEST_EQ(fun(false).catch_error(recover_error).has_value(), true);
+  BOOST_TEST_THROWS(fun(false).catch_error(recover_error_failure), test_exception);
+  BOOST_TEST_EQ(fun(false).catch_error(recover_error_silent_failure).has_value(), false);
+
+  // With a bind between.
+  BOOST_TEST_THROWS(fun(false).bind(do_nothing).catch_error(recover_error_failure), test_exception);
+
+}
+BOOST_AUTO_TEST_SUITE_END()
+
+BOOST_AUTO_TEST_SUITE(proposal)
+
+void proposal_concept()
+{
+  using namespace std;
+
+  {
+    stde::expected<int, string> ei = 0;
+    stde::expected<int, string> ej = 1;
+    stde::expected<int, string> ek = stde::make_unexpected(string());
+
+    ei = 1;
+    ej = stde::make_unexpected(string());;
+    ek = 0;
+
+    ei = stde::make_unexpected(string());;
+    ej = 0;
+    ek = 1;
+  }
+}
+void proposal_init()
+{
+  using namespace std;
+  {
+    string s{ "STR" };
+
+    stde::expected<string, int> ep{ stde::make_unexpected(-1) };              // unexpected value, requires Movable<E>
+    stde::expected<string, int> eq = { stde::make_unexpected(-1) };           // unexpected value, requires Movable<E>
+
+    expected_sc<string> es{ s };                    // requires Copyable<T>
+    expected_sc<string> et = s;                   // requires Copyable<T>
+    expected_sc<string> ev = string{ "STR" };       // requires Movable<T>
+
+    expected_sc<string> ew;                       // unexpected value
+    expected_sc<string> ex{};                     // unexpected value
+    expected_sc<string> ey = {};                  // unexpected value
+    expected_sc<string> ez = expected_sc<string>{};  // unexpected value
+  }
+
+  {
+    stde::expected<Guard, int> eg;                        // unexpected value
+    stde::expected<Guard, int> eh{};                      // unexpected value
+    stde::expected<Guard, int> ei{ stde::in_place };               // calls Guard{} in place
+    stde::expected<Guard, int> ej{ stde::in_place, "arg" };        // calls Guard{"arg"} in place
+  }
+
+  {
+    stde::expected<int, string> ei{ unexpect };               // unexpected value, calls string{} in place
+    stde::expected<int, string> ej{ unexpect, "arg" };        // unexpected value, calls string{"arg"} in place
+  }
+}
+void proposal_make_unexpected_fact()
+{
+  using namespace std;
+  {
+    stde::expected<string, int> opt1 = stde::make_unexpected(1);
+    stde::expected<string, int> opt2 = { unexpect, 1 };
+
+    opt1 = stde::make_unexpected(1);
+    opt2 = { unexpect, 1 };
+  }
+}
+void proposal_error_exception_ts()
+{
+  using namespace std;
+  {
+    stde::expected<int, error_exception<std::error_code, std::system_error> > e =
+      stde::make_unexpected(make_error_code(errc::invalid_argument));
+#if !defined BOOST_MSVC || BOOST_MSVC >= 1900
+    BOOST_TEST(e.error() == make_error_code(errc::invalid_argument));
+#else
+    // VS2013 doesn't match operator==(boost::error_exception<std::error_code,std::system_error>, std::error_code)
+    BOOST_TEST(e.error() == (error_exception<std::error_code, std::system_error>(make_error_code(errc::invalid_argument))));
+#endif
+    try {
+      e.value();
+      BOOST_TEST(false);
+    }
+    catch (std::system_error const& ex) {
+
+    }
+    catch (...) {
+      BOOST_TEST(false);
+    }
+    stde::expected<int, error_exception<std::error_code, std::system_error> > e2 = stde::make_unexpected(e.error());
+#if !defined BOOST_MSVC || BOOST_MSVC >= 1900
+    BOOST_TEST(e2.error() == make_error_code(errc::invalid_argument));
+#else
+    // VS2013 doesn't match operator==(boost::error_exception<std::error_code,std::system_error>, std::error_code)
+    BOOST_TEST(e2.error() == (error_exception<std::error_code, std::system_error>(make_error_code(errc::invalid_argument))));
+#endif
+    try {
+      e2.value();
+      BOOST_TEST(false);
+    }
+    catch (std::system_error const& ex) {
+
+    }
+    catch (...) {
+      BOOST_TEST(false);
+    }
+
+  }
+}
+void proposal_ensured_read_ts()
+{
+  using namespace std;
+  {
+    ensured_read<int> e = make_ensured_read(1);
+    BOOST_TEST(e == 1);
+  }
+  {
+    ensured_read<int> e = make_ensured_read(1);
+    stde::unexpected<ensured_read<int>> ue1 = stde::make_unexpected(std::move(e));
+    BOOST_TEST(ue1.value() == 1);
+  }
+  //  {
+  //    stde::make_unexpected(make_ensured_read(1));
+  //    // calls to terminate.
+  //  }
+  //  {
+  //    stde::expected<int, ensured_read<int> > e = stde::make_unexpected(make_ensured_read(1));
+  //    // calls to terminate.
+  //  }
+  {
+    stde::expected<int, ensured_read<int> > e{ 1 };
+    BOOST_TEST(e.value() == 1);
+  }
+  {
+    stde::expected<int, ensured_read<int> > e = stde::make_unexpected(make_ensured_read(1));
+    BOOST_TEST(e.error() == 1);
+  }
+  {
+    stde::expected<int, ensured_read<int> > e{ unexpect, 1 };
+    BOOST_TEST(e.error() == 1);
+  }
+  {
+    ensured_read<std::exception_ptr> e = make_ensured_read(std::make_exception_ptr(1));
+    BOOST_TEST_THROWS(std::rethrow_exception(e.value()), int);
+  }
+  {
+    stde::expected<int, ensured_read<std::exception_ptr> > e = stde::make_unexpected(make_ensured_read(std::make_exception_ptr(1)));
+    BOOST_TEST_THROWS(std::rethrow_exception(e.error().value()), int);
+  }
+}
+void proposal_relational_operators()
+{
+  using namespace std;
+  {
+    stde::expected<unsigned, int> e0{ 0 };
+    stde::expected<unsigned, int> e1{ 1 };
+    stde::expected<unsigned, int> eN{ unexpect, -1 };
+
+    BOOST_TEST(eN < e0);
+    BOOST_TEST(e0 < e1);
+    BOOST_TEST(!(e0 < eN));
+    BOOST_TEST(eN <= e0);
+    BOOST_TEST(e0 <= e1);
+
+    BOOST_TEST(e0 > eN);
+    BOOST_TEST(e1 > e0);
+    BOOST_TEST(e0 >= eN);
+    BOOST_TEST(e1 >= e0);
+
+    BOOST_TEST(!(eN  < eN));
+    BOOST_TEST(!(e1 < e1));
+    BOOST_TEST(eN <= eN);
+    BOOST_TEST(e1 <= e1);
+
+    BOOST_TEST(eN != e0);
+    BOOST_TEST(e0 != e1);
+    BOOST_TEST(eN == eN);
+    BOOST_TEST(e0 == e0);
+
+    //////
+
+    BOOST_TEST(eN == stde::make_unexpected(-1));
+    BOOST_TEST(e0 != stde::make_unexpected(1));
+    BOOST_TEST(eN != 1u);
+    BOOST_TEST(e1 == 1u);
+
+    BOOST_TEST(eN < 1u);
+    BOOST_TEST(eN <= 1u);
+    BOOST_TEST(1u > eN);
+    BOOST_TEST(!(1u < eN));
+    BOOST_TEST(1u >= eN);
+    BOOST_TEST(stde::make_unexpected(1) < e0);
+    BOOST_TEST(stde::make_unexpected(1) <= e0);
+    BOOST_TEST(!(stde::make_unexpected(1) > e0));
+    BOOST_TEST(!(stde::make_unexpected(1) >= e0));
+
+
+    BOOST_TEST(!(e0 < stde::make_unexpected(1)));
+    BOOST_TEST(!(e0 <= stde::make_unexpected(1)));
+    BOOST_TEST(e0 > stde::make_unexpected(1));
+    BOOST_TEST(e0 >= stde::make_unexpected(1));
+  }
+  {
+    stde::expected<void, int> e0{ boost::expect };
+    stde::expected<void, int> eN{ unexpect, -1 };
+
+    BOOST_TEST(!(e0 < e0));
+    BOOST_TEST(eN < e0);
+    BOOST_TEST(!(e0 < eN));
+    BOOST_TEST(!(eN < eN));
+    BOOST_TEST(e0 <= e0);
+    BOOST_TEST(eN <= e0);
+    BOOST_TEST(!(e0 <= eN));
+    BOOST_TEST(eN <= eN);
+
+    BOOST_TEST(!(e0 > e0));
+    BOOST_TEST(e0 > eN);
+    BOOST_TEST(!(eN > e0));
+    BOOST_TEST(!(eN > eN));
+    BOOST_TEST(e0 >= e0);
+    BOOST_TEST(e0 >= eN);
+    BOOST_TEST(!(eN >= e0));
+    BOOST_TEST(eN >= eN);
+
+    BOOST_TEST(!(e0 != e0));
+    BOOST_TEST(eN != e0);
+    BOOST_TEST(e0 != eN);
+    BOOST_TEST(!(eN != eN));
+    BOOST_TEST(e0 == e0);
+    BOOST_TEST(!(eN == e0));
+    BOOST_TEST(!(e0 == eN));
+    BOOST_TEST(eN == eN);
+
+    //////
+
+    BOOST_TEST(eN == stde::make_unexpected(-1));
+    BOOST_TEST(e0 != stde::make_unexpected(1));
+
+    BOOST_TEST(stde::make_unexpected(1) < e0);
+    BOOST_TEST(stde::make_unexpected(1) <= e0);
+    BOOST_TEST(!(stde::make_unexpected(1) > e0));
+    BOOST_TEST(!(stde::make_unexpected(1) >= e0));
+
+    BOOST_TEST(!(stde::make_unexpected(1) < eN));
+    BOOST_TEST(!(stde::make_unexpected(1) <= eN));
+    BOOST_TEST(stde::make_unexpected(1) > eN);
+    BOOST_TEST(stde::make_unexpected(1) >= eN);
+
+    BOOST_TEST(!(eN < stde::make_unexpected(-1)));
+    BOOST_TEST(eN <= stde::make_unexpected(-1));
+    BOOST_TEST(!(eN > stde::make_unexpected(-1)));
+    BOOST_TEST(eN >= stde::make_unexpected(-1));
+  }
+}
+void proposal_dereference_operators()
+{
+  using namespace std;
+  {
+    const string s{ "STR" };
+
+    expected_sc<string> e0{ s };
+    const expected_sc<string> e1{ s };
+    BOOST_TEST(*e0.operator->() == s);
+    BOOST_TEST(*e1.operator->() == s);
+
+    // Test with class which has operator&() overloaded
+    const OverloadedAddressOf o{};
+    BOOST_TEST(&o == nullptr);
+
+    expected_sc<OverloadedAddressOf> e2{ o };
+    const expected_sc<OverloadedAddressOf> e3{ o };
+    BOOST_TEST(e2.operator->() != nullptr);
+    BOOST_TEST(e3.operator->() != nullptr);
+  }
+}
+BOOST_AUTO_TEST_SUITE_END()
+
+BOOST_AUTO_TEST_SUITE(movesem)
+//////////////////////////////
+void movesem_moved_from_state()
+{
+  // first, test mock:
+  MoveAware<int> i{ 1 }, j{ 2 };
+  BOOST_TEST(i.val == 1);
+  BOOST_TEST(!i.moved);
+  BOOST_TEST(j.val == 2);
+  BOOST_TEST(!j.moved);
+
+  MoveAware<int> k = std::move(i);
+  BOOST_TEST(k.val == 1);
+  BOOST_TEST(!k.moved);
+  BOOST_TEST(i.val == 1);
+  BOOST_TEST(i.moved);
+
+  k = std::move(j);
+  BOOST_TEST(k.val == 2);
+  BOOST_TEST(!k.moved);
+  BOOST_TEST(j.val == 2);
+  BOOST_TEST(j.moved);
+
+  // now, test stde::expected
+  expected_sc<MoveAware<int>> oi{ 1 }, oj{ 2 };
+  BOOST_TEST(oi);
+  BOOST_TEST(!oi->moved);
+  BOOST_TEST(oj);
+  BOOST_TEST(!oj->moved);
+
+  expected_sc<MoveAware<int>> ok{ std::move(oi) };
+  BOOST_TEST(ok);
+  BOOST_TEST(!ok->moved);
+  BOOST_TEST(oi);
+  BOOST_TEST(oi->moved);
+
+  ok = std::move(oj);
+  BOOST_TEST(ok);
+  BOOST_TEST(!ok->moved);
+  BOOST_TEST(oj);
+  BOOST_TEST(oj->moved);
+
+}
+void movesem_move_only_value()
+{
+  const auto make_int = []() {
+    std::unique_ptr<int> value{ new int };
+    *value = 100;
+    return value;
+  };
+  const auto return_void = [](std::unique_ptr<int> value) {
+    BOOST_TEST(value != nullptr);
+    BOOST_TEST(*value == 100);
+  };
+  const auto return_expected = [](std::unique_ptr<int> value) {
+    BOOST_TEST(value != nullptr);
+    BOOST_TEST(*value == 100);
+    return expected_sc<void>{boost::expect};
+  };
+  const auto return_int = [](std::unique_ptr<int> value) {
+    BOOST_TEST(value != nullptr);
+    BOOST_TEST(*value == 100);
+    return 200;
+  };
+
+  BOOST_TEST(expected<std::unique_ptr<int>>{make_int()}.map(return_void));
+  BOOST_TEST(expected<std::unique_ptr<int>>{make_int()}.map(return_expected));
+  BOOST_TEST(expected<std::unique_ptr<int>>{make_int()}.map(return_int));
+}
+void movesem_move_only_value2()
+{
+  const auto make_int = []() {
+    std::unique_ptr<int> value{ new int };
+    *value = 100;
+    return value;
+  };
+  const auto return_expected_void = [](std::unique_ptr<int> value) {
+    BOOST_TEST(value != nullptr);
+    BOOST_TEST(*value == 100);
+    return stde::make_expected();
+  };
+  const auto return_expected = [](std::unique_ptr<int> value) {
+    BOOST_TEST(value != nullptr);
+    BOOST_TEST(*value == 100);
+    return expected_sc<void>{boost::expect};
+  };
+  BOOST_TEST(expected<std::unique_ptr<int>>{make_int()}.bind(return_expected_void));
+  BOOST_TEST(expected<std::unique_ptr<int>>{make_int()}.bind(return_expected));
+}
+void movesem_copy_move_ctor_optional_int()
+{
+  expected_sc<int> oi;
+  expected_sc<int> oj = oi;
+
+  BOOST_TEST(oj);
+  BOOST_TEST(oj == oi);
+  BOOST_TEST(bool(oj));
+
+  oi = 1;
+  expected_sc<int> ok = oi;
+  BOOST_TEST(!!ok);
+  BOOST_TEST(bool(ok));
+  BOOST_TEST(ok == oi);
+  BOOST_TEST(ok != oj);
+  BOOST_TEST(*ok == 1);
+
+  expected_sc<int> ol = std::move(oi);
+  BOOST_TEST(!!ol);
+  BOOST_TEST(bool(ol));
+  BOOST_TEST(ol == oi);
+  BOOST_TEST(ol != oj);
+  BOOST_TEST(*ol == 1);
+}
+void movesem_expected_expected()
+{
+  expected_sc<stde::expected<int, int>> oi1 = stde::make_unexpected(-1);
+  BOOST_TEST(!oi1);
+
+  {
+    expected_sc<expected_sc<int>> oi2{ stde::expect };
+    BOOST_TEST(bool(oi2));
+    BOOST_TEST((*oi2));
+    //std::cout << typeid(**oi2).name() << std::endl;
+  }
+
+  {
+    expected_sc<stde::expected<int, int>> oi2{ stde::expect, stde::make_unexpected(-1) };
+    BOOST_TEST(bool(oi2));
+    BOOST_TEST(!*oi2);
+  }
+
+  {
+    stde::expected<stde::expected<int>> oi2{ stde::expected<int>{} };
+    BOOST_TEST(bool(oi2));
+    BOOST_TEST(*oi2);
+  }
+
+  stde::expected<int> oi;
+  auto ooi = stde::make_expected(oi);
+  static_assert(std::is_same<expected<expected<int>>, decltype(ooi)>::value, "");
+
+}
+BOOST_AUTO_TEST_SUITE_END()
+
+void process() {}
+void process(int) {}
+void processNil() {}
+
+BOOST_AUTO_TEST_SUITE(Examples)
+//////////////////////////////
+
+void example1()
+{
+  stde::expected<int> oi; // create disengaged object
+  stde::expected<int> oj = { unexpect }; // alternative syntax
+  oi = oj; // assign disengaged object
+  stde::expected<int> ok = oj; // ok is disengaged
+
+  if (oi) BOOST_TEST(false); // 'if oi is engaged...'
+  if (!oi) BOOST_TEST(true); // 'if oi is disengaged...'
+
+  BOOST_TEST(oi == ok); // two disengaged optionals compare equal
+
+                        ///////////////////////////////////////////////////////////////////////////
+  stde::expected<int> ol{ 1 }; // ol is engaged; its contained value is 1
+  ok = 2; // ok becomes engaged; its contained value is 2
+  oj = ol; // oj becomes engaged; its contained value is 1
+
+  BOOST_TEST(oi != ol); // disengaged != engaged
+  BOOST_TEST(ok != ol); // different contained values
+  BOOST_TEST(oj == ol); // same contained value
+                        //BOOST_TEST(oi < ol); // disengaged < engaged
+                        //BOOST_TEST(ol < ok); // less by contained value
+
+                        /////////////////////////////////////////////////////////////////////////////
+  stde::expected<int> om{ 1 }; // om is engaged; its contained value is 1
+  stde::expected<int> on = om; // on is engaged; its contained value is 1
+  om = 2; // om is engaged; its contained value is 2
+  BOOST_TEST(on != om); // on still contains 3. They are not pointers
+
+                        /////////////////////////////////////////////////////////////////////////////
+  int i = *ol; // i obtains the value contained in ol
+  BOOST_TEST(i == 1);
+  *ol = 9; // the object contained in ol becomes 9
+  BOOST_TEST(*ol == 9);
+  BOOST_TEST(ol == stde::make_expected(9));
+
+  ///////////////////////////////////
+  int p = 1;
+  stde::expected<int> op = p;
+  BOOST_TEST(*op == 1);
+  p = 2;
+  BOOST_TEST(*op == 1); // value contained in op is separated from p
+
+                        ////////////////////////////////
+  if (ol)
+    process(*ol); // use contained value if present
+  else
+    process(); // proceed without contained value
+
+  if (!om)
+    processNil();
+  else
+    process(*om);
+
+  /////////////////////////////////////////
+  process(ol.value_or(0)); // use 0 if ol is disengaged
+
+                           ////////////////////////////////////////////
+  ok = { unexpect }; // if ok was engaged calls T's dtor
+  oj = {}; // assigns a temporary disengaged stde::expected
+}
+//////////////////////////////////////////////////
+void ValueOr()
+{
+  stde::expected<int> oi = 1;
+  int i = oi.value_or(0);
+  BOOST_TEST(i == 1);
+
+  oi = { unexpect };
+  BOOST_TEST(oi.value_or(3) == 3);
+
+  stde::expected<std::string> os{ "AAA" };
+  BOOST_TEST(os.value_or("BBB") == "AAA");
+  os = {};
+  BOOST_TEST(os);
+  BOOST_TEST(os.value() == "");
+
+  BOOST_TEST(os.value_or(std::string("BBB")) == "");
+  {
+    constexpr stde::expected<int> e = 1;
+    static_assert(e.has_value(), "");
+    static_assert(*e == 1, "");
+    static_assert(e.value() == 1, "");
+  }
+  {
+    constexpr std::error_code ec = std::make_error_code(std::errc(1));
+    constexpr stde::expected<int> e = stde::make_unexpected(ec);
+    static_assert(!e.has_value(), "");
+    static_assert(e.error() == ec, "");
+  }
+  {
+    constexpr stde::expected<OracleVal> e = 1;
+    static_assert(e.has_value(), "");
+    static_assert(*e == 1, "");
+    static_assert(e.value() == 1, "");
+  }
+  {
+    constexpr std::error_code ec = std::make_error_code(std::errc(1));
+    constexpr stde::expected<OracleVal> e = stde::make_unexpected(ec);
+    static_assert(!e.has_value(), "");
+    static_assert(e.error() == ec, "");
+  }
+}
+
+//////////////////////////////////////////////////
+BOOST_AUTO_TEST_SUITE_END()
+
+#endif
+
+#else
+int main(void)
+{
+  return 0;
+}
+#endif
diff --git a/src/boost/libs/outcome/test/tests/comparison.cpp b/src/boost/libs/outcome/test/tests/comparison.cpp
new file mode 100644
index 00000000..b73a7a28
--- /dev/null
+++ b/src/boost/libs/outcome/test/tests/comparison.cpp
@@ -0,0 +1,102 @@
+/* Unit testing for outcomes
+(C) 2013-2019 Niall Douglas <http://www.nedproductions.biz/> (6 commits)
+
+
+Boost Software License - Version 1.0 - August 17th, 2003
+
+Permission is hereby granted, free of charge, to any person or organization
+obtaining a copy of the software and accompanying documentation covered by
+this license (the "Software") to use, reproduce, display, distribute,
+execute, and transmit the Software, and to prepare derivative works of the
+Software, and to permit third-parties to whom the Software is furnished to
+do so, all subject to the following:
+
+The copyright notices in the Software and this entire statement, including
+the above license grant, this restriction and the following disclaimer,
+must be included in all copies of the Software, in whole or in part, and
+all derivative works of the Software, unless such copies or derivative
+works are solely in the form of machine-executable object code generated by
+a source language processor.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
+SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
+FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
+*/
+
+#ifdef _MSC_VER
+#pragma warning(disable : 4127)  // conditional expression is constant
+#pragma warning(disable : 4244)  // conversion from int to short
+#endif
+
+#include <boost/outcome/outcome.hpp>
+#include <boost/test/unit_test.hpp>
+#include <boost/test/unit_test_monitor.hpp>
+
+BOOST_OUTCOME_AUTO_TEST_CASE(works_outcome_comparison, "Tests that the outcome can compare to compatible outcomes")
+{
+#if !defined(__APPLE__) || defined(__cpp_exceptions)
+  using namespace BOOST_OUTCOME_V2_NAMESPACE;
+  auto p = boost::copy_exception(std::runtime_error("hi"));
+  // value comparison
+  {
+    outcome<int> a(1), b(2), c(2);
+    BOOST_CHECK(a == a);
+    BOOST_CHECK(b == b);
+    BOOST_CHECK(c == c);
+    BOOST_CHECK(a != b);
+    BOOST_CHECK(b == c);
+  }
+  // homogeneous outcome comparison
+  {
+    outcome<int> a(1), b(2), c(boost::system::errc::invalid_argument), d(p);
+    BOOST_CHECK(a == a);
+    BOOST_CHECK(a != b);
+    BOOST_CHECK(a != c);
+    BOOST_CHECK(a != d);
+    BOOST_CHECK(b == b);
+    BOOST_CHECK(b != c);
+    BOOST_CHECK(b != d);
+    BOOST_CHECK(c == c);
+    BOOST_CHECK(c != d);
+    BOOST_CHECK(d == d);
+    outcome<int> e(boost::system::errc::invalid_argument), f(p);
+    BOOST_CHECK(c == e);
+    BOOST_CHECK(d == f);
+  }
+  // heterogeneous outcome comparison, so outcome<int> to outcome<double> etc
+  {
+    outcome<int> a(1);
+    outcome<double> b(1);
+    outcome<unsigned short> c(1);
+    BOOST_CHECK(a == b);
+    BOOST_CHECK(a == c);
+    BOOST_CHECK(b == a);
+    BOOST_CHECK(b == c);
+    BOOST_CHECK(c == a);
+    BOOST_CHECK(c == b);
+    // outcome<void> e(in_place_type<void>);
+    outcome<unsigned short> f(boost::system::errc::invalid_argument);
+    outcome<double> g(p);
+    // BOOST_CHECK(a != e);
+    BOOST_CHECK(a != f);
+    BOOST_CHECK(a != g);
+    // BOOST_CHECK(e != f);
+    BOOST_CHECK(f != g);
+  }
+  // upconverting outcome comparison, so outcome<int>==result<int> etc
+  {
+    outcome<int> a(1);
+    result<int> b(1);
+    BOOST_CHECK(a == b);
+    BOOST_CHECK(b == a);
+    // result<void> e(in_place_type<void>), f(boost::system::errc::invalid_argument);
+    // BOOST_CHECK(a != e);
+    // BOOST_CHECK(a != f);
+  }
+  // Should I do outcome<int>(5) == 5? Unsure if it's wise
+#endif
+}
diff --git a/src/boost/libs/outcome/test/tests/constexpr.cpp b/src/boost/libs/outcome/test/tests/constexpr.cpp
new file mode 100644
index 00000000..d29faeb3
--- /dev/null
+++ b/src/boost/libs/outcome/test/tests/constexpr.cpp
@@ -0,0 +1,99 @@
+/* Unit testing for outcomes
+(C) 2013-2019 Niall Douglas <http://www.nedproductions.biz/> (9 commits)
+
+
+Boost Software License - Version 1.0 - August 17th, 2003
+
+Permission is hereby granted, free of charge, to any person or organization
+obtaining a copy of the software and accompanying documentation covered by
+this license (the "Software") to use, reproduce, display, distribute,
+execute, and transmit the Software, and to prepare derivative works of the
+Software, and to permit third-parties to whom the Software is furnished to
+do so, all subject to the following:
+
+The copyright notices in the Software and this entire statement, including
+the above license grant, this restriction and the following disclaimer,
+must be included in all copies of the Software, in whole or in part, and
+all derivative works of the Software, unless such copies or derivative
+works are solely in the form of machine-executable object code generated by
+a source language processor.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
+SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
+FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
+*/
+
+#include <boost/outcome/outcome.hpp>
+#include <boost/test/unit_test.hpp>
+#include <boost/test/unit_test_monitor.hpp>
+
+BOOST_OUTCOME_AUTO_TEST_CASE(works_outcome_constexpr, "Tests that outcome works as intended in a constexpr evaluation context")
+{
+  using namespace BOOST_OUTCOME_V2_NAMESPACE;
+
+  static_assert(std::is_literal_type<result<int, void, void>>::value, "result<int, void, void> is not a literal type!");
+  static_assert(std::is_literal_type<outcome<int, void, void>>::value, "outcome<int, void, void> is not a literal type!");
+
+  // Unfortunately result<T> can never be a literal type as error_code can never be literal
+  //
+  // It can however be trivially destructible as error_code is trivially destructible. That
+  // makes possible lots of compiler optimisations
+  static_assert(std::is_trivially_destructible<result<int>>::value, "result<int> is not trivially destructible!");
+  static_assert(std::is_trivially_destructible<result<void>>::value, "result<void> is not trivially destructible!");
+
+  // outcome<T> default has no trivial operations, but if configured it can become so
+  static_assert(std::is_trivially_destructible<outcome<int, boost::system::error_code, void>>::value, "outcome<int, boost::system::error_code, void> is not trivially destructible!");
+
+  {
+    // Test compatible results can be constructed from one another
+    constexpr result<int, long> g(in_place_type<int>, 5);
+    constexpr result<long, int> g2(g);
+    static_assert(g.has_value(), "");
+    static_assert(!g.has_error(), "");
+    static_assert(g.assume_value() == 5, "");  // value() with UDT E won't compile
+    static_assert(g2.has_value(), "");
+    static_assert(!g2.has_error(), "");
+    static_assert(g2.assume_value() == 5, "");  // value() with UDT E won't compile
+    constexpr result<void, int> g3(in_place_type<void>);
+    constexpr result<long, int> g4(g3);
+    constexpr result<int, void> g5(in_place_type<void>);
+    constexpr result<long, int> g6(g5);
+    (void) g4;
+    (void) g6;
+
+    // Test void
+    constexpr result<void, int> h(in_place_type<void>);
+    static_assert(h.has_value(), "");
+    constexpr result<int, void> h2(in_place_type<void>);
+    static_assert(!h2.has_value(), "");
+    static_assert(h2.has_error(), "");
+
+    // Test const
+    constexpr result<const int, void> i(5);
+    constexpr result<const int, void> i2(i);
+    (void) i2;
+  }
+  {
+    // Test compatible outcomes can be constructed from one another
+    constexpr outcome<int, long, char *> g(in_place_type<int>, 5);
+    constexpr outcome<long, int, const char *> g2(g);
+    static_assert(g.has_value(), "");
+    static_assert(!g.has_error(), "");
+    static_assert(!g.has_exception(), "");
+    static_assert(g.assume_value() == 5, "");  // value() with UDT E won't compile
+    static_assert(g2.has_value(), "");
+    static_assert(!g2.has_error(), "");
+    static_assert(!g2.has_exception(), "");
+    static_assert(g2.assume_value() == 5, "");  // value() with UDT E won't compile
+    constexpr outcome<void, int, char *> g3(in_place_type<void>);
+    constexpr outcome<long, int, const char *> g4(g3);
+    constexpr outcome<int, void, char *> g5(in_place_type<void>);
+    constexpr outcome<long, int, const char *> g6(g5);
+    (void) g4;
+    (void) g6;
+  }
+}
diff --git a/src/boost/libs/outcome/test/tests/containers.cpp b/src/boost/libs/outcome/test/tests/containers.cpp
new file mode 100644
index 00000000..4c3d8116
--- /dev/null
+++ b/src/boost/libs/outcome/test/tests/containers.cpp
@@ -0,0 +1,58 @@
+/* Unit testing for outcomes
+(C) 2013-2019 Niall Douglas <http://www.nedproductions.biz/> (7 commits)
+
+
+Boost Software License - Version 1.0 - August 17th, 2003
+
+Permission is hereby granted, free of charge, to any person or organization
+obtaining a copy of the software and accompanying documentation covered by
+this license (the "Software") to use, reproduce, display, distribute,
+execute, and transmit the Software, and to prepare derivative works of the
+Software, and to permit third-parties to whom the Software is furnished to
+do so, all subject to the following:
+
+The copyright notices in the Software and this entire statement, including
+the above license grant, this restriction and the following disclaimer,
+must be included in all copies of the Software, in whole or in part, and
+all derivative works of the Software, unless such copies or derivative
+works are solely in the form of machine-executable object code generated by
+a source language processor.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
+SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
+FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
+*/
+
+#include <boost/outcome/outcome.hpp>
+#include <boost/test/unit_test.hpp>
+#include <boost/test/unit_test_monitor.hpp>
+
+BOOST_OUTCOME_AUTO_TEST_CASE(works_outcome_containers, "Tests that outcome works as intended inside containers")
+{
+  using namespace BOOST_OUTCOME_V2_NAMESPACE;
+  outcome<std::vector<int>> a(std::vector<int>{5, 6, 7, 8});
+  BOOST_CHECK(a.has_value());
+  BOOST_CHECK(a.value().size() == 4U);
+  auto b(a);
+  BOOST_CHECK(a.has_value());
+  BOOST_CHECK(a.value().size() == 4U);
+  BOOST_CHECK(b.has_value());
+  BOOST_CHECK(b.value().size() == 4U);
+
+  std::vector<outcome<std::vector<int>>> vect;
+  vect.push_back(std::vector<int>{5, 6, 7, 8});
+  vect.push_back(std::vector<int>{1, 2, 3, 4});
+  BOOST_REQUIRE(vect.size() == 2U);  // NOLINT
+  BOOST_CHECK(vect[0].has_value());
+  BOOST_CHECK(vect[1].has_value());
+  BOOST_CHECK(vect[0].value().size() == 4U);
+  BOOST_CHECK(vect[1].value().size() == 4U);
+  BOOST_CHECK(vect[0].value().front() == 5);
+  BOOST_CHECK(vect[0].value().back() == 8);
+  BOOST_CHECK(vect[1].value().front() == 1);
+  BOOST_CHECK(vect[1].value().back() == 4);
+}
diff --git a/src/boost/libs/outcome/test/tests/core-outcome.cpp b/src/boost/libs/outcome/test/tests/core-outcome.cpp
new file mode 100644
index 00000000..aba8aa68
--- /dev/null
+++ b/src/boost/libs/outcome/test/tests/core-outcome.cpp
@@ -0,0 +1,258 @@
+/* Unit testing for outcomes
+(C) 2013-2019 Niall Douglas <http://www.nedproductions.biz/> (18 commits)
+
+
+Boost Software License - Version 1.0 - August 17th, 2003
+
+Permission is hereby granted, free of charge, to any person or organization
+obtaining a copy of the software and accompanying documentation covered by
+this license (the "Software") to use, reproduce, display, distribute,
+execute, and transmit the Software, and to prepare derivative works of the
+Software, and to permit third-parties to whom the Software is furnished to
+do so, all subject to the following:
+
+The copyright notices in the Software and this entire statement, including
+the above license grant, this restriction and the following disclaimer,
+must be included in all copies of the Software, in whole or in part, and
+all derivative works of the Software, unless such copies or derivative
+works are solely in the form of machine-executable object code generated by
+a source language processor.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
+SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
+FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
+*/
+
+#include <boost/outcome/outcome.hpp>
+#include <boost/test/unit_test.hpp>
+#include <boost/test/unit_test_monitor.hpp>
+
+#include <iostream>
+
+#ifdef _MSC_VER
+#pragma warning(disable : 4702)  // unreachable code
+#endif
+
+BOOST_OUTCOME_AUTO_TEST_CASE(works_outcome, "Tests that the outcome works as intended")
+{
+  using namespace BOOST_OUTCOME_V2_NAMESPACE;
+
+  static_assert(std::is_constructible<outcome<long>, int>::value, "Sanity check that monad can be constructed from a value_type");
+  static_assert(!std::is_constructible<outcome<outcome<long>>, int>::value, "Sanity check that outer monad can be constructed from an inner monad's value_type");
+  static_assert(!std::is_constructible<outcome<outcome<outcome<long>>>, int>::value, "Sanity check that outer monad can be constructed from an inner inner monad's value_type");
+  static_assert(!std::is_constructible<outcome<outcome<outcome<outcome<long>>>>, int>::value, "Sanity check that outer monad can be constructed from an inner inner monad's value_type");
+
+  static_assert(std::is_constructible<outcome<int>, outcome<long>>::value, "Sanity check that compatible monads can be constructed from one another");
+  static_assert(std::is_constructible<outcome<outcome<int>>, outcome<long>>::value, "Sanity check that outer monad can be constructed from a compatible monad");
+  static_assert(!std::is_constructible<outcome<outcome<outcome<int>>>, outcome<long>>::value, "Sanity check that outer monad can be constructed from a compatible monad up to two nestings deep");
+  static_assert(!std::is_constructible<outcome<outcome<outcome<outcome<int>>>>, outcome<long>>::value, "Sanity check that outer monad can be constructed from a compatible monad three or more nestings deep");
+  static_assert(!std::is_constructible<outcome<std::string>, outcome<int>>::value, "Sanity check that incompatible monads cannot be constructed from one another");
+
+  static_assert(std::is_constructible<outcome<int>, outcome<void>>::value, "Sanity check that all monads can be constructed from a void monad");
+  static_assert(std::is_constructible<outcome<outcome<int>>, outcome<void>>::value, "Sanity check that outer monad can be constructed from a compatible monad");
+  static_assert(std::is_constructible<outcome<outcome<outcome<int>>>, outcome<void>>::value, "Sanity check that outer monad can be constructed from a compatible monad up to two nestings deep");
+  static_assert(!std::is_constructible<outcome<void>, outcome<int>>::value, "Sanity check that incompatible monads cannot be constructed from one another");
+
+  static_assert(std::is_void<result<void>::value_type>::value, "Sanity check that result<void> has a void value_type");
+  static_assert(std::is_void<result<void, void>::error_type>::value, "Sanity check that result<void, void> has a void error_type");
+  // static_assert(std::is_void<outcome<void, void, void>::exception_type>::value, "Sanity check that outcome<void, void, void> has a void exception_type");
+
+  static_assert(std::is_same<outcome<int>::value_type, int>::value, "Sanity check that outcome<int> has a int value_type");
+  static_assert(std::is_same<outcome<int>::error_type, boost::system::error_code>::value, "Sanity check that outcome<int> has a error_code error_type");
+  static_assert(std::is_same<outcome<int>::exception_type, boost::exception_ptr>::value, "Sanity check that outcome<int> has a exception_ptr exception_type");
+
+
+  {  // errored int
+    outcome<int> m(boost::system::errc::bad_address);
+    BOOST_CHECK(!m);
+    BOOST_CHECK(!m.has_value());
+    BOOST_CHECK(m.has_error());
+    BOOST_CHECK(!m.has_exception());
+    BOOST_CHECK_THROW(m.value(), boost::system::system_error);
+    BOOST_CHECK_NO_THROW(m.error());
+    BOOST_CHECK_THROW(m.exception(), bad_outcome_access);
+    BOOST_CHECK_THROW(boost::rethrow_exception(m.failure()), boost::system::system_error);
+  }
+  {  // errored void
+    outcome<void> m(boost::system::errc::bad_address);
+    BOOST_CHECK(!m);
+    BOOST_CHECK(!m.has_value());
+    BOOST_CHECK(m.has_error());
+    BOOST_CHECK(!m.has_exception());
+    BOOST_CHECK_THROW(([&m]() -> void { return m.value(); }()), boost::system::system_error);
+    BOOST_CHECK_NO_THROW(m.error());
+    BOOST_CHECK_THROW(m.exception(), bad_outcome_access);
+    BOOST_CHECK_THROW(boost::rethrow_exception(m.failure()), boost::system::system_error);
+  }
+  {  // valued int
+    outcome<int> m(5);
+    BOOST_CHECK(m);
+    BOOST_CHECK(m.has_value());
+    BOOST_CHECK(!m.has_error());
+    BOOST_CHECK(!m.has_exception());
+    BOOST_CHECK(m.value() == 5);
+    m.value() = 6;
+    BOOST_CHECK(m.value() == 6);
+    BOOST_CHECK_THROW(m.error(), bad_outcome_access);
+    BOOST_CHECK_THROW(m.exception(), bad_outcome_access);
+    BOOST_CHECK(!m.failure());
+  }
+  {  // moves do not clear state
+    outcome<std::string> m("niall");
+    BOOST_CHECK(m);
+    BOOST_CHECK(m.has_value());
+    BOOST_CHECK(!m.has_error());
+    BOOST_CHECK(!m.has_exception());
+    BOOST_CHECK(m.value() == "niall");
+    m.value() = "NIALL";
+    BOOST_CHECK(m.value() == "NIALL");
+    auto temp(std::move(m).value());
+    BOOST_CHECK(temp == "NIALL");
+    BOOST_CHECK(m.value().empty());  // NOLINT
+  }
+  {  // valued void
+    outcome<void> m(in_place_type<void>);
+    BOOST_CHECK(m);
+    BOOST_CHECK(m.has_value());
+    BOOST_CHECK(!m.has_error());
+    BOOST_CHECK(!m.has_exception());
+    BOOST_CHECK_NO_THROW(m.value());  // works, but type returned is unusable
+    BOOST_CHECK_THROW(m.error(), bad_outcome_access);
+    BOOST_CHECK_THROW(m.exception(), bad_outcome_access);
+    BOOST_CHECK(!m.failure());
+  }
+  {  // errored
+    boost::system::error_code ec(5, boost::system::system_category());
+    outcome<int> m(ec);
+    BOOST_CHECK(!m);
+    BOOST_CHECK(!m.has_value());
+    BOOST_CHECK(m.has_error());
+    BOOST_CHECK(!m.has_exception());
+    BOOST_CHECK_THROW(m.value(), boost::system::system_error);
+    BOOST_CHECK(m.error() == ec);
+    BOOST_CHECK_THROW(m.exception(), bad_outcome_access);
+#ifndef BOOST_NO_EXCEPTIONS
+    BOOST_CHECK(m.failure());
+    try
+    {
+      boost::rethrow_exception(m.failure());
+    }
+    catch(const boost::system::system_error &ex)
+    {
+      BOOST_CHECK(ex.code() == ec);
+      BOOST_CHECK(ex.code().value() == 5);
+    }
+#endif
+  }
+#if !defined(__APPLE__) || defined(__cpp_exceptions)
+  {  // excepted
+    boost::system::error_code ec(5, boost::system::system_category());
+    auto e = boost::copy_exception(boost::system::system_error(ec));  // NOLINT
+    outcome<int> m(e);
+    BOOST_CHECK(!m);
+    BOOST_CHECK(!m.has_value());
+    BOOST_CHECK(!m.has_error());
+    BOOST_CHECK(m.has_exception());
+    BOOST_CHECK_THROW(m.value(), boost::system::system_error);
+    BOOST_CHECK_THROW(m.error(), bad_outcome_access);
+    BOOST_CHECK(m.exception() == e);
+#ifndef BOOST_NO_EXCEPTIONS
+    BOOST_CHECK(m.failure());
+    try
+    {
+      boost::rethrow_exception(m.failure());
+    }
+    catch(const boost::system::system_error &ex)
+    {
+      BOOST_CHECK(ex.code() == ec);
+      BOOST_CHECK(ex.code().value() == 5);
+    }
+#endif
+  }
+  {  // custom error type
+    struct Foo
+    {
+    };
+    auto e = boost::copy_exception(Foo());
+    outcome<int> m(e);
+    BOOST_CHECK(!m);
+    BOOST_CHECK(!m.has_value());
+    BOOST_CHECK(!m.has_error());
+    BOOST_CHECK(m.has_exception());
+    BOOST_CHECK_THROW(m.value(), Foo);
+    BOOST_CHECK_THROW(m.error(), bad_outcome_access);
+    BOOST_CHECK(m.exception() == e);
+  }
+  {  // outcome<void, void> should work
+    boost::system::error_code ec(5, boost::system::system_category());
+    auto e = boost::copy_exception(boost::system::system_error(ec));
+    outcome<void, void> m(e);
+    BOOST_CHECK(!m);
+    BOOST_CHECK(!m.has_value());
+    BOOST_CHECK(!m.has_error());
+    BOOST_CHECK(m.has_exception());
+  }
+#endif
+
+
+  {
+    outcome<int> a(5);
+    outcome<int> b(make_error_code(boost::system::errc::invalid_argument));
+    std::cout << sizeof(a) << std::endl;  // 40 bytes
+    a.assume_value();
+    b.assume_error();
+#ifndef BOOST_NO_EXCEPTIONS
+    try
+    {
+      b.value();
+      std::cerr << "fail" << std::endl;
+      std::terminate();
+    }
+    catch(const boost::system::system_error & /*unused*/)
+    {
+    }
+#endif
+    static_assert(!std::is_default_constructible<decltype(a)>::value, "");
+    static_assert(!std::is_nothrow_default_constructible<decltype(a)>::value, "");
+    static_assert(std::is_copy_constructible<decltype(a)>::value, "");
+    static_assert(!std::is_trivially_copy_constructible<decltype(a)>::value, "");
+    static_assert(std::is_nothrow_copy_constructible<decltype(a)>::value, "");
+    static_assert(std::is_copy_assignable<decltype(a)>::value, "");
+    static_assert(!std::is_trivially_copy_assignable<decltype(a)>::value, "");
+    static_assert(std::is_nothrow_copy_assignable<decltype(a)>::value, "");
+    static_assert(!std::is_trivially_destructible<decltype(a)>::value, "");
+    static_assert(std::is_nothrow_destructible<decltype(a)>::value, "");
+
+    // Test void compiles
+    outcome<void> c(in_place_type<void>);
+    outcome<void> c2(c);
+    (void) c2;
+    // Test int, void compiles
+    outcome<int, void> d(in_place_type<boost::exception_ptr>);
+  }
+
+  {
+    // Can only be constructed via multiple args
+    struct udt3
+    {
+      udt3() = delete;
+      udt3(udt3 &&) = delete;
+      udt3(const udt3 &) = delete;
+      udt3 &operator=(udt3 &&) = delete;
+      udt3 &operator=(const udt3 &) = delete;
+      explicit udt3(int /*unused*/, const char * /*unused*/, std::nullptr_t /*unused*/) {}
+      ~udt3() = default;
+    };
+    // Test a udt which can only be constructed in place compiles
+    outcome<udt3> g(in_place_type<udt3>, 5, static_cast<const char *>("niall"), nullptr);
+    // Does converting inplace construction also work?
+    outcome<udt3> h(5, static_cast<const char *>("niall"), nullptr);
+    outcome<udt3> i(ENOMEM, boost::system::generic_category());
+    BOOST_CHECK(h.has_value());
+    BOOST_CHECK(i.has_error());
+  }
+}
diff --git a/src/boost/libs/outcome/test/tests/core-result.cpp b/src/boost/libs/outcome/test/tests/core-result.cpp
new file mode 100644
index 00000000..7f1d84bd
--- /dev/null
+++ b/src/boost/libs/outcome/test/tests/core-result.cpp
@@ -0,0 +1,370 @@
+/* Unit testing for outcomes
+(C) 2013-2019 Niall Douglas <http://www.nedproductions.biz/> (30 commits)
+
+
+Boost Software License - Version 1.0 - August 17th, 2003
+
+Permission is hereby granted, free of charge, to any person or organization
+obtaining a copy of the software and accompanying documentation covered by
+this license (the "Software") to use, reproduce, display, distribute,
+execute, and transmit the Software, and to prepare derivative works of the
+Software, and to permit third-parties to whom the Software is furnished to
+do so, all subject to the following:
+
+The copyright notices in the Software and this entire statement, including
+the above license grant, this restriction and the following disclaimer,
+must be included in all copies of the Software, in whole or in part, and
+all derivative works of the Software, unless such copies or derivative
+works are solely in the form of machine-executable object code generated by
+a source language processor.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
+SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
+FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
+*/
+
+#ifdef TESTING_WG21_EXPERIMENTAL_RESULT
+#include <boost/outcome/experimental/result.hpp>
+#define BOOST_OUTCOME_AUTO_TEST_CASE(...) BOOST_AUTO_TEST_CASE(__VA_ARGS__)
+#else
+#include <boost/outcome/result.hpp>
+#endif
+#include <boost/test/unit_test.hpp>
+#include <boost/test/unit_test_monitor.hpp>
+
+#include <iostream>
+
+#ifndef BOOST_NO_EXCEPTIONS
+// Custom error type with payload
+struct payload
+{
+  boost::system::error_code ec;
+  const char *str{nullptr};
+  payload() = default;
+  payload(boost::system::errc::errc_t _ec, const char *_str)
+      : ec(make_error_code(_ec))
+      , str(_str)
+  {
+  }
+};
+struct payload_exception : std::runtime_error
+{
+  explicit payload_exception(const char *what)
+      : std::runtime_error(what)
+  {
+  }
+};
+inline const boost::system::error_code &make_error_code(const payload &p)
+{
+  return p.ec;
+}
+inline void outcome_throw_as_system_error_with_payload(const payload &p)
+{
+  throw payload_exception(p.str);
+}
+#endif
+
+BOOST_OUTCOME_AUTO_TEST_CASE(works_result, "Tests that the result works as intended")
+{
+#ifdef TESTING_WG21_EXPERIMENTAL_RESULT
+  using namespace std::experimental;
+  using std::in_place_type;
+#else
+  using namespace BOOST_OUTCOME_V2_NAMESPACE;
+#endif
+
+  static_assert(std::is_constructible<result<long>, int>::value, "Sanity check that monad can be constructed from a value_type");
+  static_assert(!std::is_constructible<result<result<long>>, int>::value, "Sanity check that outer monad can be constructed from an inner monad's value_type");
+  static_assert(!std::is_constructible<result<result<result<long>>>, int>::value, "Sanity check that outer monad can be constructed from an inner inner monad's value_type");
+  static_assert(!std::is_constructible<result<result<result<result<long>>>>, int>::value, "Sanity check that outer monad can be constructed from an inner inner monad's value_type");
+
+  static_assert(std::is_constructible<result<int>, result<long>>::value, "Sanity check that compatible monads can be constructed from one another");
+  static_assert(std::is_constructible<result<result<int>>, result<long>>::value, "Sanity check that outer monad can be constructed from a compatible monad");
+  static_assert(!std::is_constructible<result<result<result<int>>>, result<long>>::value, "Sanity check that outer monad can be constructed from a compatible monad up to two nestings deep");
+  static_assert(!std::is_constructible<result<result<result<result<int>>>>, result<long>>::value, "Sanity check that outer monad can be constructed from a compatible monad three or more nestings deep");
+  static_assert(!std::is_constructible<result<std::string>, result<int>>::value, "Sanity check that incompatible monads cannot be constructed from one another");
+
+#ifndef TESTING_WG21_EXPERIMENTAL_RESULT
+  static_assert(std::is_constructible<result<int>, result<void>>::value, "Sanity check that all monads can be constructed from a void monad");
+  static_assert(std::is_constructible<result<result<int>>, result<void>>::value, "Sanity check that outer monad can be constructed from a compatible monad");
+  static_assert(std::is_constructible<result<result<result<int>>>, result<void>>::value, "Sanity check that outer monad can be constructed from a compatible monad up to two nestings deep");
+  static_assert(!std::is_constructible<result<void>, result<int>>::value, "Sanity check that incompatible monads cannot be constructed from one another");
+#endif
+  static_assert(std::is_void<result<void>::value_type>::value, "Sanity check that result<void> has a void value_type");
+#ifndef TESTING_WG21_EXPERIMENTAL_RESULT
+  static_assert(std::is_void<result<void, void>::error_type>::value, "Sanity check that result<void, void> has a void error_type");
+#endif
+
+  static_assert(std::is_same<result<int>::value_type, int>::value, "Sanity check that result<int> has a int value_type");
+  static_assert(std::is_same<result<int>::error_type, boost::system::error_code>::value, "Sanity check that result<int> has a error_code error_type");
+
+
+  {  // errored int
+    result<int> m(boost::system::errc::bad_address);
+    BOOST_CHECK(!m);
+    BOOST_CHECK(!m.has_value());
+    BOOST_CHECK(m.has_error());
+    // BOOST_CHECK(!m.has_exception());
+    BOOST_CHECK_THROW(m.value(), boost::system::system_error);
+    BOOST_CHECK_NO_THROW(m.error());
+  }
+  {  // errored void
+    result<void> m(boost::system::errc::bad_address);
+    BOOST_CHECK(!m);
+    BOOST_CHECK(!m.has_value());
+    BOOST_CHECK(m.has_error());
+// BOOST_CHECK(!m.has_exception());
+#ifndef TESTING_WG21_EXPERIMENTAL_RESULT
+    BOOST_CHECK_THROW(([&m]() -> void { return m.value(); }()), boost::system::system_error);
+#endif
+    BOOST_CHECK_NO_THROW(m.error());
+  }
+  {  // valued int
+    result<int> m(5);
+    BOOST_CHECK(m);
+    BOOST_CHECK(m.has_value());
+    BOOST_CHECK(!m.has_error());
+    // BOOST_CHECK(!m.has_exception());
+    BOOST_CHECK(m.value() == 5);
+    m.value() = 6;
+    BOOST_CHECK(m.value() == 6);
+    BOOST_CHECK_THROW(m.error(), bad_result_access);
+  }
+  {  // valued bool
+    result<bool> m(false);
+    BOOST_CHECK(m);
+    BOOST_CHECK(m.has_value());
+    BOOST_CHECK(!m.has_error());
+    // BOOST_CHECK(!m.has_exception());
+    BOOST_CHECK(m.value() == false);
+    m.value() = true;
+    BOOST_CHECK(m.value() == true);
+    BOOST_CHECK_THROW(m.error(), bad_result_access);
+  }
+  {  // moves do not clear state
+    result<std::string> m("niall");
+    BOOST_CHECK(m);
+    BOOST_CHECK(m.has_value());
+    BOOST_CHECK(!m.has_error());
+    // BOOST_CHECK(!m.has_exception());
+    BOOST_CHECK(m.value() == "niall");
+    m.value() = "NIALL";
+    BOOST_CHECK(m.value() == "NIALL");
+    auto temp(std::move(m).value());
+    BOOST_CHECK(temp == "NIALL");
+    BOOST_CHECK(m.value().empty());  // NOLINT
+  }
+  {  // valued void
+    result<void> m(in_place_type<void>);
+    BOOST_CHECK(m);
+    BOOST_CHECK(m.has_value());
+    BOOST_CHECK(!m.has_error());
+    // BOOST_CHECK(!m.has_exception());
+    BOOST_CHECK_NO_THROW(m.value());  // works, but type returned is unusable
+    BOOST_CHECK_THROW(m.error(), bad_result_access);
+  }
+  {  // errored
+    boost::system::error_code ec(5, boost::system::system_category());
+    result<int> m(ec);
+    BOOST_CHECK(!m);
+    BOOST_CHECK(!m.has_value());
+    BOOST_CHECK(m.has_error());
+    // BOOST_CHECK(!m.has_exception());
+    BOOST_CHECK_THROW(m.value(), boost::system::system_error);
+    BOOST_CHECK(m.error() == ec);
+  }
+#if !defined(__APPLE__) || defined(__cpp_exceptions)
+  {  // errored, custom
+    boost::system::error_code ec(5, boost::system::system_category());
+    auto e = boost::copy_exception(boost::system::system_error(ec));  // NOLINT
+    result<int, boost::exception_ptr> m(e);
+    BOOST_CHECK(!m);
+    BOOST_CHECK(!m.has_value());
+    BOOST_CHECK(m.has_error());
+    // BOOST_CHECK(!m.has_exception());
+    BOOST_CHECK_THROW(m.value(), boost::system::system_error);
+    BOOST_CHECK(m.error() == e);
+  }
+#endif
+#ifndef TESTING_WG21_EXPERIMENTAL_RESULT
+  {  // custom error type
+    struct Foo
+    {
+    };
+    result<int, Foo> m(in_place_type<Foo>);
+    BOOST_CHECK(!m);
+    BOOST_CHECK(!m.has_value());
+    BOOST_CHECK(m.has_error());
+    // BOOST_CHECK(!m.has_exception());
+    // BOOST_CHECK_NO_THROW(m.value());
+    // BOOST_CHECK_NO_THROW(m.error());
+  }
+  if(false)  // NOLINT
+  {          // void, void is permitted, but is not constructible
+    result<void, void> *m = nullptr;
+    m->value();
+    m->error();
+  }
+#endif
+
+  {
+    // Deliberately define non-trivial operations
+    struct udt
+    {
+      int _v{0};
+      udt() = default;
+      udt(udt &&o) noexcept : _v(o._v) {}
+      udt(const udt &o)  // NOLINT
+      : _v(o._v)
+      {
+      }
+      udt &operator=(udt &&o) noexcept
+      {
+        _v = o._v;
+        return *this;
+      }
+      udt &operator=(const udt &o)  // NOLINT
+      {
+        _v = o._v;
+        return *this;
+      }
+      ~udt() { _v = 0; }
+    };
+    // No default construction, no copy nor move
+    struct udt2
+    {
+      udt2() = delete;
+      udt2(udt2 &&) = delete;
+      udt2(const udt2 &) = delete;
+      udt2 &operator=(udt2 &&) = delete;
+      udt2 &operator=(const udt2 &) = delete;
+      explicit udt2(int /*unused*/) {}
+      ~udt2() = default;
+    };
+    // Can only be constructed via multiple args
+    struct udt3
+    {
+      udt3() = delete;
+      udt3(udt3 &&) = delete;
+      udt3(const udt3 &) = delete;
+      udt3 &operator=(udt3 &&) = delete;
+      udt3 &operator=(const udt3 &) = delete;
+      explicit udt3(int /*unused*/, const char * /*unused*/, std::nullptr_t /*unused*/) {}
+      ~udt3() = default;
+    };
+
+
+    result<int> a(5);
+    result<int> b(make_error_code(boost::system::errc::invalid_argument));
+    std::cout << sizeof(a) << std::endl;  // 32 bytes
+    if(false)                             // NOLINT
+    {
+      b.assume_value();
+      a.assume_error();
+    }
+#ifndef BOOST_NO_EXCEPTIONS
+    try
+    {
+      b.value();
+      std::cerr << "fail" << std::endl;
+      std::terminate();
+    }
+    catch(const boost::system::system_error & /*unused*/)
+    {
+    }
+#endif
+    static_assert(!std::is_default_constructible<decltype(a)>::value, "");
+    static_assert(!std::is_nothrow_default_constructible<decltype(a)>::value, "");
+    static_assert(std::is_copy_constructible<decltype(a)>::value, "");
+// Quality of implementation of std::optional is poor :(
+#ifndef TESTING_WG21_EXPERIMENTAL_RESULT
+    static_assert(std::is_trivially_copy_constructible<decltype(a)>::value, "");
+    static_assert(std::is_nothrow_copy_constructible<decltype(a)>::value, "");
+    static_assert(std::is_copy_assignable<decltype(a)>::value, "");
+    static_assert(std::is_trivially_copy_assignable<decltype(a)>::value, "");
+    static_assert(std::is_nothrow_copy_assignable<decltype(a)>::value, "");
+#endif
+    static_assert(std::is_trivially_destructible<decltype(a)>::value, "");
+    static_assert(std::is_nothrow_destructible<decltype(a)>::value, "");
+
+    // Test void compiles
+    result<void> c(in_place_type<void>);
+    result<void> c2(c);
+    (void) c2;
+
+    // Test a standard udt compiles
+    result<udt> d(in_place_type<udt>);
+    result<udt> d2(d);
+    static_assert(!std::is_default_constructible<decltype(d)>::value, "");
+    static_assert(!std::is_nothrow_default_constructible<decltype(d)>::value, "");
+    static_assert(std::is_copy_constructible<decltype(d)>::value, "");
+    static_assert(!std::is_trivially_copy_constructible<decltype(d)>::value, "");
+    static_assert(!std::is_nothrow_copy_constructible<decltype(d)>::value, "");
+    static_assert(std::is_copy_assignable<decltype(d)>::value, "");
+    static_assert(!std::is_trivially_copy_assignable<decltype(d)>::value, "");
+    static_assert(!std::is_nothrow_copy_assignable<decltype(d)>::value, "");
+    static_assert(std::is_move_assignable<decltype(d)>::value, "");
+    static_assert(!std::is_trivially_move_assignable<decltype(d)>::value, "");
+    static_assert(std::is_nothrow_move_assignable<decltype(d)>::value, "");
+    static_assert(!std::is_trivially_destructible<decltype(d)>::value, "");
+    static_assert(std::is_nothrow_destructible<decltype(d)>::value, "");
+
+    // Test a highly pathological udt compiles
+    result<udt2> e(in_place_type<udt2>, 5);
+    // result<udt2> e2(e);
+    static_assert(!std::is_default_constructible<decltype(e)>::value, "");
+    static_assert(!std::is_nothrow_default_constructible<decltype(e)>::value, "");
+    static_assert(!std::is_copy_constructible<decltype(e)>::value, "");
+    static_assert(!std::is_trivially_copy_constructible<decltype(e)>::value, "");
+    static_assert(!std::is_nothrow_copy_constructible<decltype(e)>::value, "");
+    static_assert(!std::is_copy_assignable<decltype(e)>::value, "");
+    static_assert(!std::is_trivially_copy_assignable<decltype(e)>::value, "");
+    static_assert(!std::is_nothrow_copy_assignable<decltype(e)>::value, "");
+    static_assert(!std::is_move_assignable<decltype(e)>::value, "");
+    static_assert(!std::is_trivially_move_assignable<decltype(e)>::value, "");
+    static_assert(!std::is_nothrow_move_assignable<decltype(e)>::value, "");
+
+    // Test a udt which can only be constructed in place compiles
+    result<udt3> g(in_place_type<udt3>, 5, static_cast<const char *>("niall"), nullptr);
+    // Does converting inplace construction also work?
+    result<udt3> h(5, static_cast<const char *>("niall"), nullptr);
+    result<udt3> i(ENOMEM, boost::system::generic_category());
+    BOOST_CHECK(h.has_value());
+    BOOST_CHECK(i.has_error());
+  }
+
+  // Test direct use of error code enum works
+  {
+    constexpr result<int, boost::system::errc::errc_t> a(5), b(boost::system::errc::invalid_argument);
+    static_assert(a.value() == 5, "a is not 5");
+    static_assert(b.error() == boost::system::errc::invalid_argument, "b is not errored");
+    BOOST_CHECK_THROW(b.value(), boost::system::system_error);
+  }
+
+#ifndef TESTING_WG21_EXPERIMENTAL_RESULT
+#ifndef BOOST_NO_EXCEPTIONS
+  // Test payload facility
+  {
+    const char *niall = "niall";
+    result<int, payload> b{boost::system::errc::invalid_argument, niall};
+    try
+    {
+      b.value();
+      BOOST_CHECK(false);
+    }
+    catch(const payload_exception &e)
+    {
+      BOOST_CHECK(!strcmp(e.what(), niall));
+    }
+    catch(...)
+    {
+      BOOST_CHECK(false);
+    }
+  }
+#endif
+#endif
+}
diff --git a/src/boost/libs/outcome/test/tests/coroutine-support.cpp b/src/boost/libs/outcome/test/tests/coroutine-support.cpp
new file mode 100644
index 00000000..0c8d8d05
--- /dev/null
+++ b/src/boost/libs/outcome/test/tests/coroutine-support.cpp
@@ -0,0 +1,120 @@
+/* Unit testing for outcomes
+(C) 2013-2019 Niall Douglas <http://www.nedproductions.biz/> (6 commits)
+
+
+Boost Software License - Version 1.0 - August 17th, 2003
+
+Permission is hereby granted, free of charge, to any person or organization
+obtaining a copy of the software and accompanying documentation covered by
+this license (the "Software") to use, reproduce, display, distribute,
+execute, and transmit the Software, and to prepare derivative works of the
+Software, and to permit third-parties to whom the Software is furnished to
+do so, all subject to the following:
+
+The copyright notices in the Software and this entire statement, including
+the above license grant, this restriction and the following disclaimer,
+must be included in all copies of the Software, in whole or in part, and
+all derivative works of the Software, unless such copies or derivative
+works are solely in the form of machine-executable object code generated by
+a source language processor.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
+SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
+FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
+*/
+
+#if defined(__cpp_coroutines)
+
+#include <boost/outcome/coroutine_support.hpp>
+#include <boost/outcome/outcome.hpp>
+#include <boost/outcome/try.hpp>
+#include <boost/test/unit_test.hpp>
+#include <boost/test/unit_test_monitor.hpp>
+
+namespace coroutines
+{
+  template <class T> using eager = BOOST_OUTCOME_V2_NAMESPACE::awaitables::eager<T>;
+  template <class T> using lazy = BOOST_OUTCOME_V2_NAMESPACE::awaitables::lazy<T>;
+  template <class T, class E = boost::system::error_code> using result = BOOST_OUTCOME_V2_NAMESPACE::result<T, E>;
+
+  inline eager<result<int>> eager_int(int x) { co_return x + 1; }
+  inline lazy<result<int>> lazy_int(int x) { co_return x + 1; }
+  inline eager<result<int>> eager_error() { co_return boost::system::errc::not_enough_memory; }
+  inline lazy<result<int>> lazy_error() { co_return boost::system::errc::not_enough_memory; }
+  inline eager<result<void>> eager_void() { co_return boost::system::errc::not_enough_memory; }
+  inline lazy<result<void>> lazy_void() { co_return boost::system::errc::not_enough_memory; }
+
+  template <class U, class... Args> inline eager<result<std::string>> eager_coawait(U &&f, Args... args)
+  {
+    BOOST_OUTCOME_CO_TRY(co_await f(args...));
+    co_return "hi";
+  }
+  template <class U, class... Args> inline lazy<result<std::string>> lazy_coawait(U &&f, Args... args)
+  {
+    BOOST_OUTCOME_CO_TRY(co_await f(args...));
+    co_return "hi";
+  }
+
+#ifndef BOOST_NO_EXCEPTIONS
+  struct custom_exception_type
+  {
+  };
+  inline lazy<result<int, boost::exception_ptr>> result_exception(boost::exception_ptr e)
+  {
+    boost::rethrow_exception(e);
+    co_return 5;
+  }
+
+  inline lazy<BOOST_OUTCOME_V2_NAMESPACE::outcome<int>> outcome_exception(boost::exception_ptr e)
+  {
+    boost::rethrow_exception(e);
+    co_return 5;
+  }
+#endif
+
+  inline eager<int> eager_int2(int x) { co_return x + 1; }
+  inline lazy<int> lazy_int2(int x) { co_return x + 1; }
+  inline eager<void> eager_void2() { co_return; }
+  inline lazy<void> lazy_void2() { co_return; }
+}  // namespace coroutines
+
+BOOST_OUTCOME_AUTO_TEST_CASE(works_result_coroutine, "Tests that results are eager and lazy awaitable")
+{
+  using namespace coroutines;
+  auto eager_await = [](auto t) { return t.await_resume(); };
+  auto lazy_await = [](auto t) {
+    t.await_suspend({});
+    return t.await_resume();
+  };
+
+  BOOST_CHECK(eager_await(eager_int(5)).value() == 6);
+  BOOST_CHECK(lazy_await(lazy_int(5)).value() == 6);
+  BOOST_CHECK(eager_await(eager_error()).error() == boost::system::errc::not_enough_memory);
+  BOOST_CHECK(lazy_await(lazy_error()).error() == boost::system::errc::not_enough_memory);
+  BOOST_CHECK(eager_await(eager_void()).error() == boost::system::errc::not_enough_memory);
+  BOOST_CHECK(lazy_await(lazy_void()).error() == boost::system::errc::not_enough_memory);
+
+  BOOST_CHECK(eager_await(eager_coawait(eager_int, 5)).value() == "hi");
+  BOOST_CHECK(lazy_await(lazy_coawait(lazy_int, 5)).value() == "hi");
+
+#ifndef BOOST_NO_EXCEPTIONS
+  auto e = boost::copy_exception(custom_exception_type());
+  BOOST_CHECK_THROW(lazy_await(result_exception(e)).value(), custom_exception_type);
+  BOOST_CHECK_THROW(lazy_await(outcome_exception(e)).value(), custom_exception_type);
+#endif
+
+  BOOST_CHECK(eager_await(eager_int2(5)) == 6);
+  BOOST_CHECK(lazy_await(lazy_int2(5)) == 6);
+  eager_await(eager_void2());
+  lazy_await(lazy_void2());
+}
+#else
+int main(void)
+{
+  return 0;
+}
+#endif
diff --git a/src/boost/libs/outcome/test/tests/default-construction.cpp b/src/boost/libs/outcome/test/tests/default-construction.cpp
new file mode 100644
index 00000000..bda01116
--- /dev/null
+++ b/src/boost/libs/outcome/test/tests/default-construction.cpp
@@ -0,0 +1,57 @@
+/* Unit testing for outcomes
+(C) 2013-2019 Niall Douglas <http://www.nedproductions.biz/> (4 commits)
+
+
+Boost Software License - Version 1.0 - August 17th, 2003
+
+Permission is hereby granted, free of charge, to any person or organization
+obtaining a copy of the software and accompanying documentation covered by
+this license (the "Software") to use, reproduce, display, distribute,
+execute, and transmit the Software, and to prepare derivative works of the
+Software, and to permit third-parties to whom the Software is furnished to
+do so, all subject to the following:
+
+The copyright notices in the Software and this entire statement, including
+the above license grant, this restriction and the following disclaimer,
+must be included in all copies of the Software, in whole or in part, and
+all derivative works of the Software, unless such copies or derivative
+works are solely in the form of machine-executable object code generated by
+a source language processor.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
+SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
+FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
+*/
+
+#include <boost/outcome/outcome.hpp>
+#include <boost/test/unit_test.hpp>
+#include <boost/test/unit_test_monitor.hpp>
+
+BOOST_OUTCOME_AUTO_TEST_CASE(works_outcome_default_construction, "Tests that outcome default constructs when it ought to")
+{
+  using namespace BOOST_OUTCOME_V2_NAMESPACE;
+  struct udt
+  {
+    int _v{78};
+    udt() = default;
+    constexpr explicit udt(int v) noexcept : _v(v) {}
+    udt(udt &&o) = delete;
+    udt(const udt &) = delete;
+    udt &operator=(udt &&o) = delete;
+    udt &operator=(const udt &) = delete;
+    ~udt() = default;
+    constexpr int operator*() const noexcept { return _v; }
+  };
+  // One path is via success_type<void>
+  outcome<udt> a(success());
+  BOOST_CHECK(*a.value() == 78);
+
+  // Other path is via explicit conversion from void
+  outcome<void> c = success();
+  outcome<udt> d(c);
+  BOOST_CHECK(*d.value() == 78);
+}
diff --git a/src/boost/libs/outcome/test/tests/experimental-core-outcome-status.cpp b/src/boost/libs/outcome/test/tests/experimental-core-outcome-status.cpp
new file mode 100644
index 00000000..3b10814c
--- /dev/null
+++ b/src/boost/libs/outcome/test/tests/experimental-core-outcome-status.cpp
@@ -0,0 +1,225 @@
+/* Unit testing for outcomes
+(C) 2013-2019 Niall Douglas <http://www.nedproductions.biz/> (4 commits)
+
+
+Boost Software License - Version 1.0 - August 17th, 2003
+
+Permission is hereby granted, free of charge, to any person or organization
+obtaining a copy of the software and accompanying documentation covered by
+this license (the "Software") to use, reproduce, display, distribute,
+execute, and transmit the Software, and to prepare derivative works of the
+Software, and to permit third-parties to whom the Software is furnished to
+do so, all subject to the following:
+
+The copyright notices in the Software and this entire statement, including
+the above license grant, this restriction and the following disclaimer,
+must be included in all copies of the Software, in whole or in part, and
+all derivative works of the Software, unless such copies or derivative
+works are solely in the form of machine-executable object code generated by
+a source language processor.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
+SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
+FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
+*/
+
+#include <boost/outcome/experimental/status_outcome.hpp>
+
+#define BOOST_OUTCOME_PREVENT_CONVERSION_WORKAROUND std
+template <class T, class S = BOOST_OUTCOME_SYSTEM_ERROR2_NAMESPACE::system_code, class P = BOOST_OUTCOME_PREVENT_CONVERSION_WORKAROUND::exception_ptr> using outcome = BOOST_OUTCOME_V2_NAMESPACE::experimental::status_outcome<T, S, P>;
+using BOOST_OUTCOME_V2_NAMESPACE::in_place_type;
+
+#include <boost/test/unit_test.hpp>
+#include <boost/test/unit_test_monitor.hpp>
+
+#include <iostream>
+
+#ifdef _MSC_VER
+#pragma warning(disable : 4702)  // unreachable code
+#endif
+
+BOOST_OUTCOME_AUTO_TEST_CASE(works_status_code_outcome, "Tests that the outcome with status_code works as intended")
+{
+  using namespace BOOST_OUTCOME_SYSTEM_ERROR2_NAMESPACE;
+
+  {  // errored int
+    outcome<int> m(generic_code{errc::bad_address});
+    BOOST_CHECK(!m);
+    BOOST_CHECK(!m.has_value());
+    BOOST_CHECK(m.has_error());
+    BOOST_CHECK(!m.has_exception());
+    BOOST_CHECK_THROW(m.value(), status_error<void>);
+    BOOST_CHECK_NO_THROW(m.error());
+    BOOST_CHECK_THROW(BOOST_OUTCOME_PREVENT_CONVERSION_WORKAROUND::rethrow_exception(m.failure()), generic_error);
+  }
+  {  // errored void
+    outcome<void> m(generic_code{errc::bad_address});
+    BOOST_CHECK(!m);
+    BOOST_CHECK(!m.has_value());
+    BOOST_CHECK(m.has_error());
+    BOOST_CHECK(!m.has_exception());
+    BOOST_CHECK_THROW(([&m]() -> void { return m.value(); }()), generic_error);
+    BOOST_CHECK_NO_THROW(m.error());
+    BOOST_CHECK_THROW(BOOST_OUTCOME_PREVENT_CONVERSION_WORKAROUND::rethrow_exception(m.failure()), generic_error);
+  }
+  {  // valued int
+    outcome<int> m(5);
+    BOOST_CHECK(m);
+    BOOST_CHECK(m.has_value());
+    BOOST_CHECK(!m.has_error());
+    BOOST_CHECK(!m.has_exception());
+    BOOST_CHECK(m.value() == 5);
+    m.value() = 6;
+    BOOST_CHECK(m.value() == 6);
+    BOOST_CHECK(!m.failure());
+  }
+  {  // moves do not clear state
+    outcome<std::string> m("niall");
+    BOOST_CHECK(m);
+    BOOST_CHECK(m.has_value());
+    BOOST_CHECK(!m.has_error());
+    BOOST_CHECK(!m.has_exception());
+    BOOST_CHECK(m.value() == "niall");
+    m.value() = "NIALL";
+    BOOST_CHECK(m.value() == "NIALL");
+    auto temp(std::move(m).value());
+    BOOST_CHECK(temp == "NIALL");
+    BOOST_CHECK(m.value().empty());  // NOLINT
+  }
+  {  // valued void
+    outcome<void> m(in_place_type<void>);
+    BOOST_CHECK(m);
+    BOOST_CHECK(m.has_value());
+    BOOST_CHECK(!m.has_error());
+    BOOST_CHECK(!m.has_exception());
+    BOOST_CHECK_NO_THROW(m.value());  // works, but type returned is unusable
+    BOOST_CHECK(!m.failure());
+  }
+  {  // errored
+    error ec(errc::no_link);
+    outcome<int> m(ec.clone());
+    BOOST_CHECK(!m);
+    BOOST_CHECK(!m.has_value());
+    BOOST_CHECK(m.has_error());
+    BOOST_CHECK(!m.has_exception());
+    BOOST_CHECK_THROW(m.value(), generic_error);
+    BOOST_CHECK(m.error() == ec);
+#ifndef BOOST_NO_EXCEPTIONS
+    BOOST_CHECK(m.failure());
+    try
+    {
+      BOOST_OUTCOME_PREVENT_CONVERSION_WORKAROUND::rethrow_exception(m.failure());
+    }
+    catch(const generic_error &ex)
+    {
+      BOOST_CHECK(ex.code() == ec);
+      BOOST_CHECK(ex.code().value() == errc::no_link);
+    }
+#endif
+  }
+#if !defined(__APPLE__) || defined(__cpp_exceptions)
+  {  // excepted
+    BOOST_OUTCOME_PREVENT_CONVERSION_WORKAROUND::error_code ec(5, BOOST_OUTCOME_PREVENT_CONVERSION_WORKAROUND::system_category());
+    auto e = BOOST_OUTCOME_PREVENT_CONVERSION_WORKAROUND::make_exception_ptr(BOOST_OUTCOME_PREVENT_CONVERSION_WORKAROUND::system_error(ec));  // NOLINT
+    outcome<int> m(e);
+    BOOST_CHECK(!m);
+    BOOST_CHECK(!m.has_value());
+    BOOST_CHECK(!m.has_error());
+    BOOST_CHECK(m.has_exception());
+    BOOST_CHECK_THROW(m.value(), BOOST_OUTCOME_PREVENT_CONVERSION_WORKAROUND::system_error);
+    BOOST_CHECK(m.exception() == e);
+#ifndef BOOST_NO_EXCEPTIONS
+    BOOST_CHECK(m.failure());
+    try
+    {
+      BOOST_OUTCOME_PREVENT_CONVERSION_WORKAROUND::rethrow_exception(m.failure());
+    }
+    catch(const BOOST_OUTCOME_PREVENT_CONVERSION_WORKAROUND::system_error &ex)
+    {
+      BOOST_CHECK(ex.code() == ec);
+      BOOST_CHECK(ex.code().value() == 5);
+    }
+#endif
+  }
+  {  // custom error type
+    struct Foo
+    {
+    };
+    auto e = BOOST_OUTCOME_PREVENT_CONVERSION_WORKAROUND::make_exception_ptr(Foo());
+    outcome<int> m(e);
+    BOOST_CHECK(!m);
+    BOOST_CHECK(!m.has_value());
+    BOOST_CHECK(!m.has_error());
+    BOOST_CHECK(m.has_exception());
+    BOOST_CHECK_THROW(m.value(), Foo);
+    BOOST_CHECK(m.exception() == e);
+  }
+  {  // outcome<void, void> should work
+    BOOST_OUTCOME_PREVENT_CONVERSION_WORKAROUND::error_code ec(5, BOOST_OUTCOME_PREVENT_CONVERSION_WORKAROUND::system_category());
+    auto e = BOOST_OUTCOME_PREVENT_CONVERSION_WORKAROUND::make_exception_ptr(BOOST_OUTCOME_PREVENT_CONVERSION_WORKAROUND::system_error(ec));
+    outcome<void, void> m(e);
+    BOOST_CHECK(!m);
+    BOOST_CHECK(!m.has_value());
+    BOOST_CHECK(!m.has_error());
+    BOOST_CHECK(m.has_exception());
+  }
+#endif
+
+
+  {
+    outcome<int> a(5);
+    outcome<int> b(generic_code{errc::invalid_argument});
+    std::cout << sizeof(a) << std::endl;  // 40 bytes
+    a.assume_value();
+    b.assume_error();
+#ifndef BOOST_NO_EXCEPTIONS
+    try
+    {
+      b.value();
+      std::cerr << "fail" << std::endl;
+      std::terminate();
+    }
+    catch(const generic_error & /*unused*/)
+    {
+    }
+#endif
+    static_assert(!std::is_default_constructible<decltype(a)>::value, "");
+    static_assert(!std::is_nothrow_default_constructible<decltype(a)>::value, "");
+    static_assert(!std::is_copy_constructible<decltype(a)>::value, "");
+    static_assert(!std::is_trivially_copy_constructible<decltype(a)>::value, "");
+    static_assert(!std::is_nothrow_copy_constructible<decltype(a)>::value, "");
+    static_assert(!std::is_copy_assignable<decltype(a)>::value, "");
+    static_assert(!std::is_trivially_copy_assignable<decltype(a)>::value, "");
+    static_assert(!std::is_nothrow_copy_assignable<decltype(a)>::value, "");
+    static_assert(!std::is_trivially_destructible<decltype(a)>::value, "");
+    static_assert(std::is_nothrow_destructible<decltype(a)>::value, "");
+
+    // Test void compiles
+    outcome<void> c(in_place_type<void>);
+    // Test int, void compiles
+    outcome<int, void> d(in_place_type<BOOST_OUTCOME_PREVENT_CONVERSION_WORKAROUND::exception_ptr>);
+  }
+
+  {
+    // Can only be constructed via multiple args
+    struct udt3
+    {
+      udt3() = delete;
+      udt3(udt3 &&) = delete;
+      udt3(const udt3 &) = delete;
+      udt3 &operator=(udt3 &&) = delete;
+      udt3 &operator=(const udt3 &) = delete;
+      explicit udt3(int /*unused*/, const char * /*unused*/, std::nullptr_t /*unused*/) {}
+      ~udt3() = default;
+    };
+    // Test a udt which can only be constructed in place compiles
+    outcome<udt3> g(in_place_type<udt3>, 5, static_cast<const char *>("niall"), nullptr);
+    // Does converting inplace construction also work?
+    outcome<udt3> h(5, static_cast<const char *>("niall"), nullptr);
+    BOOST_CHECK(h.has_value());
+  }
+}
diff --git a/src/boost/libs/outcome/test/tests/experimental-core-result-status.cpp b/src/boost/libs/outcome/test/tests/experimental-core-result-status.cpp
new file mode 100644
index 00000000..99decf08
--- /dev/null
+++ b/src/boost/libs/outcome/test/tests/experimental-core-result-status.cpp
@@ -0,0 +1,357 @@
+/* Unit testing for outcomes
+(C) 2013-2019 Niall Douglas <http://www.nedproductions.biz/> (8 commits)
+
+
+Boost Software License - Version 1.0 - August 17th, 2003
+
+Permission is hereby granted, free of charge, to any person or organization
+obtaining a copy of the software and accompanying documentation covered by
+this license (the "Software") to use, reproduce, display, distribute,
+execute, and transmit the Software, and to prepare derivative works of the
+Software, and to permit third-parties to whom the Software is furnished to
+do so, all subject to the following:
+
+The copyright notices in the Software and this entire statement, including
+the above license grant, this restriction and the following disclaimer,
+must be included in all copies of the Software, in whole or in part, and
+all derivative works of the Software, unless such copies or derivative
+works are solely in the form of machine-executable object code generated by
+a source language processor.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
+SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
+FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
+*/
+
+#include <boost/outcome/experimental/status_result.hpp>
+
+template <class T, class S = BOOST_OUTCOME_SYSTEM_ERROR2_NAMESPACE::system_code, class NoValuePolicy = BOOST_OUTCOME_V2_NAMESPACE::experimental::policy::default_status_result_policy<T, S>> using result = BOOST_OUTCOME_V2_NAMESPACE::experimental::status_result<T, S, NoValuePolicy>;
+using BOOST_OUTCOME_V2_NAMESPACE::in_place_type;
+
+#include <boost/test/unit_test.hpp>
+#include <boost/test/unit_test_monitor.hpp>
+
+#include <exception>
+#include <iostream>
+
+#ifndef BOOST_NO_EXCEPTIONS
+// Custom error type with payload
+struct payload
+{
+  BOOST_OUTCOME_SYSTEM_ERROR2_NAMESPACE::errc ec{BOOST_OUTCOME_SYSTEM_ERROR2_NAMESPACE::errc::success};
+  const char *str{nullptr};
+  payload() = default;
+  payload(BOOST_OUTCOME_SYSTEM_ERROR2_NAMESPACE::errc _ec, const char *_str)
+      : ec(_ec)
+      , str(_str)
+  {
+  }
+};
+struct payload_exception : std::exception
+{
+  const char *_what{nullptr};
+  explicit payload_exception(const char *what)
+      : _what(what)
+  {
+  }
+  virtual const char *what() const noexcept override final { return _what; }  // NOLINT
+};
+
+class _payload_domain;
+using status_code_payload = BOOST_OUTCOME_SYSTEM_ERROR2_NAMESPACE::status_code<_payload_domain>;
+class _payload_domain : public BOOST_OUTCOME_SYSTEM_ERROR2_NAMESPACE::status_code_domain
+{
+  template <class> friend class status_code;
+  using _base = BOOST_OUTCOME_SYSTEM_ERROR2_NAMESPACE::status_code_domain;
+
+public:
+  using value_type = payload;
+  using string_ref = _base::string_ref;
+
+public:
+  constexpr _payload_domain() noexcept : _base(0x7b782c8f935e34ba) {}
+
+  static inline constexpr const _payload_domain &get();
+
+  virtual _base::string_ref name() const noexcept override final { return string_ref("payload domain"); }  // NOLINT
+protected:
+  virtual bool _do_failure(const BOOST_OUTCOME_SYSTEM_ERROR2_NAMESPACE::status_code<void> &code) const noexcept override final  // NOLINT
+  {
+    assert(code.domain() == *this);                                                                              // NOLINT
+    return static_cast<const status_code_payload &>(code).value().ec != BOOST_OUTCOME_SYSTEM_ERROR2_NAMESPACE::errc::success;  // NOLINT
+  }
+  virtual bool _do_equivalent(const BOOST_OUTCOME_SYSTEM_ERROR2_NAMESPACE::status_code<void> &code1, const BOOST_OUTCOME_SYSTEM_ERROR2_NAMESPACE::status_code<void> &code2) const noexcept override final  // NOLINT
+  {
+    assert(code1.domain() == *this);                                   // NOLINT
+    const auto &c1 = static_cast<const status_code_payload &>(code1);  // NOLINT
+    if(code2.domain() == *this)
+    {
+      const auto &c2 = static_cast<const status_code_payload &>(code2);  // NOLINT
+      return c1.value().ec == c2.value().ec;
+    }
+    return false;
+  }
+  virtual BOOST_OUTCOME_SYSTEM_ERROR2_NAMESPACE::generic_code _generic_code(const BOOST_OUTCOME_SYSTEM_ERROR2_NAMESPACE::status_code<void> &code) const noexcept override final  // NOLINT
+  {
+    assert(code.domain() == *this);                                    // NOLINT
+    return static_cast<const status_code_payload &>(code).value().ec;  // NOLINT
+  }
+  virtual _base::string_ref _do_message(const BOOST_OUTCOME_SYSTEM_ERROR2_NAMESPACE::status_code<void> &code) const noexcept override final  // NOLINT
+  {
+    assert(code.domain() == *this);                                  // NOLINT
+    const auto &c = static_cast<const status_code_payload &>(code);  // NOLINT
+    return string_ref(BOOST_OUTCOME_SYSTEM_ERROR2_NAMESPACE::detail::generic_code_message(c.value().ec));
+  }
+  virtual void _do_throw_exception(const BOOST_OUTCOME_SYSTEM_ERROR2_NAMESPACE::status_code<void> &code) const override final  // NOLINT
+  {
+    assert(code.domain() == *this);                                  // NOLINT
+    const auto &c = static_cast<const status_code_payload &>(code);  // NOLINT
+    throw payload_exception(c.value().str);
+  }
+};
+constexpr _payload_domain payload_domain;
+inline constexpr const _payload_domain &_payload_domain::get()
+{
+  return payload_domain;
+}
+inline status_code_payload make_status_code(payload c) noexcept
+{
+  return status_code_payload(BOOST_OUTCOME_SYSTEM_ERROR2_NAMESPACE::in_place, c);
+}
+#endif
+
+BOOST_OUTCOME_AUTO_TEST_CASE(works_status_code_result, "Tests that the result with status_code works as intended")
+{
+  using namespace BOOST_OUTCOME_SYSTEM_ERROR2_NAMESPACE;
+
+  {  // errored int
+    result<int> m(generic_code{errc::bad_address});
+    BOOST_CHECK(!m);
+    BOOST_CHECK(!m.has_value());
+    BOOST_CHECK(m.has_error());
+    // BOOST_CHECK(!m.has_exception());
+    BOOST_CHECK_THROW(m.value(), generic_error);
+    BOOST_CHECK_NO_THROW(m.error());
+  }
+  {  // errored void
+    result<void> m(generic_code{errc::bad_address});
+    BOOST_CHECK(!m);
+    BOOST_CHECK(!m.has_value());
+    BOOST_CHECK(m.has_error());
+    // BOOST_CHECK(!m.has_exception());
+    BOOST_CHECK_THROW(([&m]() -> void { return m.value(); }()), generic_error);
+    BOOST_CHECK_NO_THROW(m.error());
+  }
+  {  // valued int
+    result<int> m(5);
+    BOOST_CHECK(m);
+    BOOST_CHECK(m.has_value());
+    BOOST_CHECK(!m.has_error());
+    // BOOST_CHECK(!m.has_exception());
+    BOOST_CHECK(m.value() == 5);
+    m.value() = 6;
+    BOOST_CHECK(m.value() == 6);
+  }
+  {  // valued bool
+    result<bool> m(false);
+    BOOST_CHECK(m);
+    BOOST_CHECK(m.has_value());
+    BOOST_CHECK(!m.has_error());
+    // BOOST_CHECK(!m.has_exception());
+    BOOST_CHECK(m.value() == false);
+    m.value() = true;
+    BOOST_CHECK(m.value() == true);
+  }
+  {  // moves do not clear state
+    result<std::string> m("niall");
+    BOOST_CHECK(m);
+    BOOST_CHECK(m.has_value());
+    BOOST_CHECK(!m.has_error());
+    // BOOST_CHECK(!m.has_exception());
+    BOOST_CHECK(m.value() == "niall");
+    m.value() = "NIALL";
+    BOOST_CHECK(m.value() == "NIALL");
+    auto temp(std::move(m).value());
+    BOOST_CHECK(temp == "NIALL");
+    BOOST_CHECK(m.value().empty());  // NOLINT
+  }
+  {  // valued void
+    result<void> m(in_place_type<void>);
+    BOOST_CHECK(m);
+    BOOST_CHECK(m.has_value());
+    BOOST_CHECK(!m.has_error());
+    // BOOST_CHECK(!m.has_exception());
+    BOOST_CHECK_NO_THROW(m.value());  // works, but type returned is unusable
+  }
+  {  // errored
+    error ec(errc::no_link);
+    result<int> m(ec.clone());
+    BOOST_CHECK(!m);
+    BOOST_CHECK(!m.has_value());
+    BOOST_CHECK(m.has_error());
+    // BOOST_CHECK(!m.has_exception());
+    BOOST_CHECK_THROW(m.value(), generic_error);
+    BOOST_CHECK(m.error() == ec);
+  }
+  if(false)  // NOLINT
+  {          // void, void is permitted, but is not constructible
+    result<void, void> *m = nullptr;
+    m->value();
+    m->error();
+  }
+
+  {
+    // Deliberately define non-trivial operations
+    struct udt
+    {
+      int _v{0};
+      udt() = default;
+      udt(udt &&o) noexcept : _v(o._v) {}
+      udt(const udt &o)  // NOLINT
+      : _v(o._v)
+      {
+      }
+      udt &operator=(udt &&o) noexcept
+      {
+        _v = o._v;
+        return *this;
+      }
+      udt &operator=(const udt &o)  // NOLINT
+      {
+        _v = o._v;
+        return *this;
+      }
+      ~udt() { _v = 0; }
+    };
+    // No default construction, no copy nor move
+    struct udt2
+    {
+      udt2() = delete;
+      udt2(udt2 &&) = delete;
+      udt2(const udt2 &) = delete;
+      udt2 &operator=(udt2 &&) = delete;
+      udt2 &operator=(const udt2 &) = delete;
+      explicit udt2(int /*unused*/) {}
+      ~udt2() = default;
+    };
+    // Can only be constructed via multiple args
+    struct udt3
+    {
+      udt3() = delete;
+      udt3(udt3 &&) = delete;
+      udt3(const udt3 &) = delete;
+      udt3 &operator=(udt3 &&) = delete;
+      udt3 &operator=(const udt3 &) = delete;
+      explicit udt3(int /*unused*/, const char * /*unused*/, std::nullptr_t /*unused*/) {}
+      ~udt3() = default;
+    };
+
+    result<int> a(5);
+    result<int> b(generic_code{errc::invalid_argument});
+    std::cout << sizeof(a) << std::endl;  // 32 bytes
+    if(false)                             // NOLINT
+    {
+      b.assume_value();
+      a.assume_error();
+    }
+#ifndef BOOST_NO_EXCEPTIONS
+    try
+    {
+      b.value();
+      std::cerr << "fail" << std::endl;
+      std::terminate();
+    }
+    catch(const generic_error &e)
+    {
+      BOOST_CHECK(!strcmp(e.what(), b.error().message().c_str()));
+    }
+#endif
+    static_assert(!std::is_default_constructible<decltype(a)>::value, "");
+    static_assert(!std::is_nothrow_default_constructible<decltype(a)>::value, "");
+    static_assert(!std::is_copy_constructible<decltype(a)>::value, "");
+// Quality of implementation of std::optional is poor :(
+#ifndef TESTING_WG21_EXPERIMENTAL_RESULT
+    static_assert(!std::is_trivially_copy_constructible<decltype(a)>::value, "");
+    static_assert(!std::is_nothrow_copy_constructible<decltype(a)>::value, "");
+    static_assert(!std::is_copy_assignable<decltype(a)>::value, "");
+    static_assert(!std::is_trivially_copy_assignable<decltype(a)>::value, "");
+    static_assert(!std::is_nothrow_copy_assignable<decltype(a)>::value, "");
+#endif
+    static_assert(!std::is_trivially_destructible<decltype(a)>::value, "");
+    static_assert(std::is_nothrow_destructible<decltype(a)>::value, "");
+
+    // Test void compiles
+    result<void> c(in_place_type<void>);
+
+    // Test a standard udt compiles
+    result<udt> d(in_place_type<udt>);
+    static_assert(!std::is_default_constructible<decltype(d)>::value, "");
+    static_assert(!std::is_nothrow_default_constructible<decltype(d)>::value, "");
+    static_assert(!std::is_copy_constructible<decltype(d)>::value, "");
+    static_assert(!std::is_trivially_copy_constructible<decltype(d)>::value, "");
+    static_assert(!std::is_nothrow_copy_constructible<decltype(d)>::value, "");
+    static_assert(!std::is_copy_assignable<decltype(d)>::value, "");
+    static_assert(!std::is_trivially_copy_assignable<decltype(d)>::value, "");
+    static_assert(!std::is_nothrow_copy_assignable<decltype(d)>::value, "");
+    static_assert(std::is_move_assignable<decltype(d)>::value, "");
+    static_assert(!std::is_trivially_move_assignable<decltype(d)>::value, "");
+    static_assert(std::is_nothrow_move_assignable<decltype(d)>::value, "");
+    static_assert(!std::is_trivially_destructible<decltype(d)>::value, "");
+    static_assert(std::is_nothrow_destructible<decltype(d)>::value, "");
+
+    // Test a highly pathological udt compiles
+    result<udt2> e(in_place_type<udt2>, 5);
+    // result<udt2> e2(e);
+    static_assert(!std::is_default_constructible<decltype(e)>::value, "");
+    static_assert(!std::is_nothrow_default_constructible<decltype(e)>::value, "");
+    static_assert(!std::is_copy_constructible<decltype(e)>::value, "");
+    static_assert(!std::is_trivially_copy_constructible<decltype(e)>::value, "");
+    static_assert(!std::is_nothrow_copy_constructible<decltype(e)>::value, "");
+    static_assert(!std::is_copy_assignable<decltype(e)>::value, "");
+    static_assert(!std::is_trivially_copy_assignable<decltype(e)>::value, "");
+    static_assert(!std::is_nothrow_copy_assignable<decltype(e)>::value, "");
+    static_assert(!std::is_move_assignable<decltype(e)>::value, "");
+    static_assert(!std::is_trivially_move_assignable<decltype(e)>::value, "");
+    static_assert(!std::is_nothrow_move_assignable<decltype(e)>::value, "");
+
+    // Test a udt which can only be constructed in place compiles
+    result<udt3> g(in_place_type<udt3>, 5, static_cast<const char *>("niall"), nullptr);
+    // Does converting inplace construction also work?
+    result<udt3> h(5, static_cast<const char *>("niall"), nullptr);
+    result<udt3> i(generic_code{errc::not_enough_memory});
+    BOOST_CHECK(h.has_value());
+    BOOST_CHECK(i.has_error());
+  }
+
+  // Test direct use of error code enum works
+  {
+    constexpr result<int, errc, BOOST_OUTCOME_V2_NAMESPACE::policy::all_narrow> a(5), b(errc::invalid_argument);
+    static_assert(a.value() == 5, "a is not 5");
+    static_assert(b.error() == errc::invalid_argument, "b is not errored");
+  }
+
+#ifndef BOOST_NO_EXCEPTIONS
+  // Test payload facility
+  {
+    const char *niall = "niall";
+    result<int, status_code_payload> b{payload{errc::invalid_argument, niall}};
+    try
+    {
+      b.value();
+      BOOST_CHECK(false);
+    }
+    catch(const payload_exception &e)
+    {
+      BOOST_CHECK(!strcmp(e.what(), niall));
+    }
+    catch(...)
+    {
+      BOOST_CHECK(false);
+    }
+  }
+#endif
+}
diff --git a/src/boost/libs/outcome/test/tests/experimental-p0709a.cpp b/src/boost/libs/outcome/test/tests/experimental-p0709a.cpp
new file mode 100644
index 00000000..1b0c3085
--- /dev/null
+++ b/src/boost/libs/outcome/test/tests/experimental-p0709a.cpp
@@ -0,0 +1,169 @@
+/* Unit testing for outcomes
+(C) 2017-2019 Niall Douglas <http://www.nedproductions.biz/> (7 commits)
+
+
+Boost Software License - Version 1.0 - August 17th, 2003
+
+Permission is hereby granted, free of charge, to any person or organization
+obtaining a copy of the software and accompanying documentation covered by
+this license (the "Software") to use, reproduce, display, distribute,
+execute, and transmit the Software, and to prepare derivative works of the
+Software, and to permit third-parties to whom the Software is furnished to
+do so, all subject to the following:
+
+The copyright notices in the Software and this entire statement, including
+the above license grant, this restriction and the following disclaimer,
+must be included in all copies of the Software, in whole or in part, and
+all derivative works of the Software, unless such copies or derivative
+works are solely in the form of machine-executable object code generated by
+a source language processor.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
+SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
+FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
+*/
+
+#include <boost/outcome/experimental/status_result.hpp>
+
+#include <climits>  // for INT_MAX
+#include <cstdio>
+
+// status_code<erased<intptr_t>>
+using error = BOOST_OUTCOME_SYSTEM_ERROR2_NAMESPACE::error;
+// Outcome's result must be told when it is dealing with an erased status code
+template <class T, class E> using result = BOOST_OUTCOME_V2_NAMESPACE::experimental::status_result<T, E, BOOST_OUTCOME_V2_NAMESPACE::policy::all_narrow>;
+
+enum class arithmetic_errc
+{
+  success,
+  divide_by_zero,
+  integer_divide_overflows,
+  not_integer_division
+};
+
+class _arithmetic_errc_domain;
+using arithmetic_errc_error = BOOST_OUTCOME_SYSTEM_ERROR2_NAMESPACE::status_code<_arithmetic_errc_domain>;
+
+class _arithmetic_errc_domain : public BOOST_OUTCOME_SYSTEM_ERROR2_NAMESPACE::status_code_domain
+{
+  using _base = BOOST_OUTCOME_SYSTEM_ERROR2_NAMESPACE::status_code_domain;
+
+public:
+  using value_type = arithmetic_errc;
+
+  constexpr explicit _arithmetic_errc_domain(typename _base::unique_id_type id = 0x290f170194f0c6c7) noexcept : _base(id) {}
+  static inline constexpr const _arithmetic_errc_domain &get();
+
+  virtual _base::string_ref name() const noexcept override final  // NOLINT
+  {
+    static string_ref v("arithmetic error domain");
+    return v;  // NOLINT
+  }
+
+protected:
+  virtual bool _do_failure(const BOOST_OUTCOME_SYSTEM_ERROR2_NAMESPACE::status_code<void> &code) const noexcept override final  // NOLINT
+  {
+    assert(code.domain() == *this);                                     // NOLINT
+    const auto &c1 = static_cast<const arithmetic_errc_error &>(code);  // NOLINT
+    return c1.value() != arithmetic_errc::success;
+  }
+  virtual bool _do_equivalent(const BOOST_OUTCOME_SYSTEM_ERROR2_NAMESPACE::status_code<void> &, const BOOST_OUTCOME_SYSTEM_ERROR2_NAMESPACE::status_code<void> &) const noexcept override final { return false; }  // NOLINT
+  virtual BOOST_OUTCOME_SYSTEM_ERROR2_NAMESPACE::generic_code _generic_code(const BOOST_OUTCOME_SYSTEM_ERROR2_NAMESPACE::status_code<void> &) const noexcept override final { return {}; }                         // NOLINT
+  virtual _base::string_ref _do_message(const BOOST_OUTCOME_SYSTEM_ERROR2_NAMESPACE::status_code<void> &code) const noexcept override final                                                          // NOLINT
+  {
+    assert(code.domain() == *this);                                     // NOLINT
+    const auto &c1 = static_cast<const arithmetic_errc_error &>(code);  // NOLINT
+    switch(c1.value())
+    {
+    case arithmetic_errc::success:
+      return _base::string_ref("success");
+    case arithmetic_errc::divide_by_zero:
+      return _base::string_ref("divide by zero");
+    case arithmetic_errc::integer_divide_overflows:
+      return _base::string_ref("integer divide overflows");
+    case arithmetic_errc::not_integer_division:
+      return _base::string_ref("not integer division");
+    }
+    return _base::string_ref("unknown");
+  }
+  BOOST_OUTCOME_SYSTEM_ERROR2_NORETURN virtual void _do_throw_exception(const BOOST_OUTCOME_SYSTEM_ERROR2_NAMESPACE::status_code<void> &) const override final { abort(); }  // NOLINT
+};
+
+constexpr _arithmetic_errc_domain arithmetic_errc_domain;
+inline constexpr const _arithmetic_errc_domain &_arithmetic_errc_domain::get()
+{
+  return arithmetic_errc_domain;
+}
+
+
+// Tell status code about the available implicit conversion
+inline arithmetic_errc_error make_status_code(arithmetic_errc e)
+{
+  return arithmetic_errc_error(BOOST_OUTCOME_SYSTEM_ERROR2_NAMESPACE::in_place, e);
+}
+
+BOOST_OUTCOME_V2_NAMESPACE_BEGIN
+namespace trait
+{
+  // Tell Outcome that arithmetic_errc is convertible into std::error
+  template <> struct is_error_type_enum<error, arithmetic_errc>
+  {
+    static constexpr bool value = true;
+  };
+}
+BOOST_OUTCOME_V2_NAMESPACE_END
+// And tell Outcome how to perform the implicit conversion
+inline error make_error_code(arithmetic_errc e)
+{
+  return arithmetic_errc_error(BOOST_OUTCOME_SYSTEM_ERROR2_NAMESPACE::in_place, e);
+}
+
+
+result<int, error> safe_divide(int i, int j)
+{
+  if(j == 0)
+  {
+    return arithmetic_errc::divide_by_zero;
+  }
+  if(i == INT_MIN && j == -1)
+  {
+    return arithmetic_errc::integer_divide_overflows;
+  }
+  if(i % j != 0)
+  {
+    return arithmetic_errc::not_integer_division;
+  }
+  return i / j;
+}
+
+int caller2(int i, int j)
+{
+  auto r = safe_divide(i, j);
+  if(r)
+  {
+    return r.value();
+  }
+  if(r.error() == arithmetic_errc::divide_by_zero)
+  {
+    return 0;
+  }
+  if(r.error() == arithmetic_errc::not_integer_division)
+  {
+    return i / j;  // ignore
+  }
+  if(r.error() == arithmetic_errc::integer_divide_overflows)
+  {
+    return INT_MIN;
+  }
+  return 0;
+}
+
+int main()
+{
+  printf("%d\n", caller2(5, 6));  // NOLINT
+  return 0;
+}
diff --git a/src/boost/libs/outcome/test/tests/fileopen.cpp b/src/boost/libs/outcome/test/tests/fileopen.cpp
new file mode 100644
index 00000000..086af781
--- /dev/null
+++ b/src/boost/libs/outcome/test/tests/fileopen.cpp
@@ -0,0 +1,87 @@
+/* Unit testing for outcomes
+(C) 2013-2019 Niall Douglas <http://www.nedproductions.biz/> (7 commits)
+
+
+Boost Software License - Version 1.0 - August 17th, 2003
+
+Permission is hereby granted, free of charge, to any person or organization
+obtaining a copy of the software and accompanying documentation covered by
+this license (the "Software") to use, reproduce, display, distribute,
+execute, and transmit the Software, and to prepare derivative works of the
+Software, and to permit third-parties to whom the Software is furnished to
+do so, all subject to the following:
+
+The copyright notices in the Software and this entire statement, including
+the above license grant, this restriction and the following disclaimer,
+must be included in all copies of the Software, in whole or in part, and
+all derivative works of the Software, unless such copies or derivative
+works are solely in the form of machine-executable object code generated by
+a source language processor.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
+SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
+FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
+*/
+
+#define _CRT_SECURE_NO_WARNINGS
+
+#include <boost/outcome.hpp>
+#include <boost/test/unit_test.hpp>
+#include <boost/test/unit_test_monitor.hpp>
+
+#ifndef BOOST_NO_EXCEPTIONS
+
+#ifdef _MSC_VER
+#define BOOST_OUTCOME_POSIX_OPEN ::_open
+#include <io.h>
+#else
+#define BOOST_OUTCOME_POSIX_OPEN ::open
+#include <fcntl.h>
+#endif
+
+BOOST_OUTCOME_AUTO_TEST_CASE(works_outcome_fileopen, "Tests that the outcome semantically represents opening a file")
+{
+  using namespace BOOST_OUTCOME_V2_NAMESPACE;
+
+  //! [file_open_example]
+  auto openfile = [](std::string path) noexcept->outcome<int>
+  {
+    int fd;
+    do
+    {
+      fd = BOOST_OUTCOME_POSIX_OPEN(path.c_str(), 0);  // NOLINT
+    } while(-1 == fd && EINTR == errno);
+    try
+    {
+      if(-1 == fd)
+      {
+        int code = errno;
+        // If a temporary failure, this is an expected unexpected outcome
+        if(EBUSY == code || EISDIR == code || ELOOP == code || ENOENT == code || ENOTDIR == code || EPERM == code || EACCES == code)
+        {
+          return boost::system::error_code(code, boost::system::generic_category());
+        }
+        // If a non-temporary failure, this is an unexpected outcome
+        return boost::copy_exception(boost::system::system_error(code, boost::system::generic_category(), strerror(code)));
+      }
+      return fd;
+    }
+    catch(...)
+    {
+      // Any exception thrown is truly unexpected
+      return boost::current_exception();
+    }
+  };
+  auto a = openfile("shouldneverexistnotever");
+  BOOST_CHECK(!a);
+  BOOST_CHECK(!a.has_value());
+  BOOST_CHECK(!a.has_exception());
+  BOOST_CHECK(a.has_error());
+  BOOST_CHECK(a.error() == boost::system::error_code(ENOENT, boost::system::generic_category()));
+  //! [file_open_example]
+}
+#endif
diff --git a/src/boost/libs/outcome/test/tests/hooks.cpp b/src/boost/libs/outcome/test/tests/hooks.cpp
new file mode 100644
index 00000000..e5a7bca8
--- /dev/null
+++ b/src/boost/libs/outcome/test/tests/hooks.cpp
@@ -0,0 +1,114 @@
+/* Unit testing for outcomes
+(C) 2013-2019 Niall Douglas <http://www.nedproductions.biz/> (14 commits)
+
+
+Boost Software License - Version 1.0 - August 17th, 2003
+
+Permission is hereby granted, free of charge, to any person or organization
+obtaining a copy of the software and accompanying documentation covered by
+this license (the "Software") to use, reproduce, display, distribute,
+execute, and transmit the Software, and to prepare derivative works of the
+Software, and to permit third-parties to whom the Software is furnished to
+do so, all subject to the following:
+
+The copyright notices in the Software and this entire statement, including
+the above license grant, this restriction and the following disclaimer,
+must be included in all copies of the Software, in whole or in part, and
+all derivative works of the Software, unless such copies or derivative
+works are solely in the form of machine-executable object code generated by
+a source language processor.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
+SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
+FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
+*/
+
+#define _CRT_SECURE_NO_WARNINGS
+
+#include <boost/outcome/outcome.hpp>
+#include <boost/test/unit_test.hpp>
+#include <boost/test/unit_test_monitor.hpp>
+
+#include <iostream>
+
+namespace hook_test
+{
+  using BOOST_OUTCOME_V2_NAMESPACE::in_place_type;
+  // Use static storage to convey extended error info from result construction to outcome conversion
+  static char extended_error_info[256];
+
+  // Use the error_code type as the ADL bridge for the hooks by creating a type here
+  struct error_code : public boost::system::error_code
+  {
+    using boost::system::error_code::error_code;
+    error_code() = default;
+    error_code(boost::system::error_code ec)  // NOLINT
+    : boost::system::error_code(ec)
+    {
+    }
+  };
+  // Localise result to using the local error_code so this namespace gets looked up for the hooks
+  template <class R> using result = BOOST_OUTCOME_V2_NAMESPACE::result<R, error_code>;
+  // Specialise the result construction hook for our localised result
+  template <class U> constexpr inline void hook_result_construction(result<int> *res, U && /*unused*/) noexcept
+  {
+    // Write the value in the result into the static storage
+    snprintf(extended_error_info, sizeof(extended_error_info), "%d", res->assume_value());  // NOLINT
+  }
+  template <class U> constexpr inline void hook_result_construction(result<std::string> *res, U && /*unused*/) noexcept
+  {
+    // Write the value in the result into the static storage
+    snprintf(extended_error_info, sizeof(extended_error_info), "%s", res->assume_value().c_str());  // NOLINT
+  }
+}  // namespace hook_test
+
+BOOST_OUTCOME_AUTO_TEST_CASE(works_result_hooks, "Tests that you can hook result's construction")
+{
+  using namespace hook_test;
+  result<int> a(5);
+  BOOST_CHECK(!strcmp(extended_error_info, "5"));  // NOLINT
+  result<std::string> b("niall");
+  BOOST_CHECK(!strcmp(extended_error_info, "niall"));  // NOLINT
+}
+
+//! [extended_error_coding2]
+namespace hook_test
+{
+  // Localise outcome to using the local error_code so this namespace gets looked up for the hooks
+  template <class R> using outcome = BOOST_OUTCOME_V2_NAMESPACE::outcome<R, error_code, std::string>;
+
+  // Specialise the outcome copy and move conversion hook for our localised result
+  template <class T, class U> constexpr inline void hook_outcome_copy_construction(outcome<T> *res, const result<U> & /*unused*/) noexcept
+  {
+    // when copy constructing from a result<T>, place extended_error_coding::extended_error_info into the payload
+    std::cout << "hook_outcome_copy_construction fires" << std::endl;
+    BOOST_OUTCOME_V2_NAMESPACE::hooks::override_outcome_exception(res, extended_error_info);
+  }
+  template <class T, class U> constexpr inline void hook_outcome_move_construction(outcome<T> *res, result<U> && /*unused*/) noexcept
+  {
+    // when move constructing from a result<T>, place extended_error_coding::extended_error_info into the payload
+    std::cout << "hook_outcome_move_construction fires" << std::endl;
+    BOOST_OUTCOME_V2_NAMESPACE::hooks::override_outcome_exception(res, extended_error_info);
+  }
+}  // namespace hook_test
+
+BOOST_OUTCOME_AUTO_TEST_CASE(works_outcome_hooks, "Tests that you can hook outcome's conversion from a result")
+{
+  using namespace hook_test;
+  outcome<int> a(result<int>(5));
+  BOOST_REQUIRE(a.has_exception());  // NOLINT
+  BOOST_CHECK(a.exception() == "5");
+  outcome<std::string> b(result<std::string>("niall"));
+  BOOST_CHECK(b.exception() == "niall");
+
+  // Make sure hook does not fire for any other kind of outcome copy or move, only when converting from our custom result only
+  outcome<int> c(5);
+  outcome<long> d(c);  // can't be the same type as source, else copy elision takes place and no ADL hook calling
+  BOOST_CHECK(!d.has_exception());
+  outcome<int> e(BOOST_OUTCOME_V2_NAMESPACE::result<int>(5));
+  BOOST_CHECK(!e.has_exception());
+}
diff --git a/src/boost/libs/outcome/test/tests/issue0007.cpp b/src/boost/libs/outcome/test/tests/issue0007.cpp
new file mode 100644
index 00000000..82043632
--- /dev/null
+++ b/src/boost/libs/outcome/test/tests/issue0007.cpp
@@ -0,0 +1,81 @@
+/* Unit testing for outcomes
+(C) 2013-2019 Niall Douglas <http://www.nedproductions.biz/> (5 commits)
+
+
+Boost Software License - Version 1.0 - August 17th, 2003
+
+Permission is hereby granted, free of charge, to any person or organization
+obtaining a copy of the software and accompanying documentation covered by
+this license (the "Software") to use, reproduce, display, distribute,
+execute, and transmit the Software, and to prepare derivative works of the
+Software, and to permit third-parties to whom the Software is furnished to
+do so, all subject to the following:
+
+The copyright notices in the Software and this entire statement, including
+the above license grant, this restriction and the following disclaimer,
+must be included in all copies of the Software, in whole or in part, and
+all derivative works of the Software, unless such copies or derivative
+works are solely in the form of machine-executable object code generated by
+a source language processor.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
+SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
+FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
+*/
+
+#include <boost/outcome/outcome.hpp>
+#include <boost/outcome/try.hpp>
+#include <boost/test/unit_test.hpp>
+#include <boost/test/unit_test_monitor.hpp>
+
+BOOST_OUTCOME_AUTO_TEST_CASE(issues_0007_test, "BOOST_OUTCOME_TRYV(expr) in a function whose return outcome's type has no default constructor fails to compile")
+{
+  using namespace BOOST_OUTCOME_V2_NAMESPACE;
+  struct udt  // NOLINT
+  {
+    explicit udt(int /*unused*/) {}
+    //    udt() = delete;
+    udt(const udt &) = default;
+    udt(udt &&) = default;
+  };
+  {
+    auto f = []() -> result<udt> {
+      auto g = [] { return result<int>(5); };
+      /* This fails because BOOST_OUTCOME_TRYV() returns a result<void>
+      which if it were valued void, would implicitly convert into a
+      default constructed udt which is not possible, hence the compile error.
+      */
+      BOOST_OUTCOME_TRYV(g());
+      return udt(5);
+    };
+    (void) f();
+  }
+  {
+    auto f = []() -> outcome<udt> {
+      auto g = [] { return outcome<int>(5); };
+      /* This fails because BOOST_OUTCOME_TRYV() returns a result<void>
+      which if it were valued void, would implicitly convert into a
+      default constructed udt which is not possible, hence the compile error.
+      */
+      BOOST_OUTCOME_TRYV(g());
+      return udt(5);
+    };
+    (void) f();
+  }
+  {
+    auto f = []() -> outcome<udt> {
+      auto g = [] { return result<int>(5); };
+      /* This fails because BOOST_OUTCOME_TRYV() returns a result<void>
+      which if it were valued void, would implicitly convert into a
+      default constructed udt which is not possible, hence the compile error.
+      */
+      BOOST_OUTCOME_TRYV(g());
+      return udt(5);
+    };
+    (void) f();
+  }
+}
diff --git a/src/boost/libs/outcome/test/tests/issue0009.cpp b/src/boost/libs/outcome/test/tests/issue0009.cpp
new file mode 100644
index 00000000..7fc5e7ab
--- /dev/null
+++ b/src/boost/libs/outcome/test/tests/issue0009.cpp
@@ -0,0 +1,52 @@
+/* Unit testing for outcomes
+(C) 2013-2019 Niall Douglas <http://www.nedproductions.biz/> (5 commits)
+
+
+Boost Software License - Version 1.0 - August 17th, 2003
+
+Permission is hereby granted, free of charge, to any person or organization
+obtaining a copy of the software and accompanying documentation covered by
+this license (the "Software") to use, reproduce, display, distribute,
+execute, and transmit the Software, and to prepare derivative works of the
+Software, and to permit third-parties to whom the Software is furnished to
+do so, all subject to the following:
+
+The copyright notices in the Software and this entire statement, including
+the above license grant, this restriction and the following disclaimer,
+must be included in all copies of the Software, in whole or in part, and
+all derivative works of the Software, unless such copies or derivative
+works are solely in the form of machine-executable object code generated by
+a source language processor.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
+SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
+FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
+*/
+
+#include <boost/outcome/outcome.hpp>
+#include <boost/outcome/try.hpp>
+#include <boost/test/unit_test.hpp>
+#include <boost/test/unit_test_monitor.hpp>
+
+BOOST_OUTCOME_AUTO_TEST_CASE(issues_0009_test, "Alternative TRY macros?")
+{
+#ifdef BOOST_OUTCOME_TRYX
+  using namespace BOOST_OUTCOME_V2_NAMESPACE;
+  struct udt  // NOLINT
+  {
+    explicit udt(int /*unused*/) {}
+    //    udt() = delete;
+    udt(const udt &) = default;
+    udt(udt &&) = default;
+  };
+  auto f = []() -> result<udt> {
+    auto g = [] { return result<int>(5); };
+    return udt(BOOST_OUTCOME_TRYX(g()));
+  };
+  (void) f();
+#endif
+}
diff --git a/src/boost/libs/outcome/test/tests/issue0010.cpp b/src/boost/libs/outcome/test/tests/issue0010.cpp
new file mode 100644
index 00000000..3f7e02ee
--- /dev/null
+++ b/src/boost/libs/outcome/test/tests/issue0010.cpp
@@ -0,0 +1,88 @@
+/* Unit testing for outcomes
+(C) 2013-2019 Niall Douglas <http://www.nedproductions.biz/> (9 commits)
+
+
+Boost Software License - Version 1.0 - August 17th, 2003
+
+Permission is hereby granted, free of charge, to any person or organization
+obtaining a copy of the software and accompanying documentation covered by
+this license (the "Software") to use, reproduce, display, distribute,
+execute, and transmit the Software, and to prepare derivative works of the
+Software, and to permit third-parties to whom the Software is furnished to
+do so, all subject to the following:
+
+The copyright notices in the Software and this entire statement, including
+the above license grant, this restriction and the following disclaimer,
+must be included in all copies of the Software, in whole or in part, and
+all derivative works of the Software, unless such copies or derivative
+works are solely in the form of machine-executable object code generated by
+a source language processor.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
+SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
+FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
+*/
+
+#include <boost/outcome/outcome.hpp>
+#include <boost/test/unit_test.hpp>
+#include <boost/test/unit_test_monitor.hpp>
+
+BOOST_OUTCOME_AUTO_TEST_CASE(issues_0010_test, "Expected's operator->(), operator*() and .error() throw exceptions when they should not")
+{
+  using namespace BOOST_OUTCOME_V2_NAMESPACE;
+  const char *a = "hi", *b = "bye";
+  struct udt1  // NOLINT
+  {
+    const char *_v{nullptr};
+    udt1() = default;
+    constexpr explicit udt1(const char *v) noexcept : _v(v) {}
+    constexpr udt1(udt1 &&o) noexcept : _v(o._v) { o._v = nullptr; }
+    udt1(const udt1 &) = default;
+    constexpr udt1 &operator=(udt1 &&o) noexcept
+    {
+      _v = o._v;
+      o._v = nullptr;
+      return *this;
+    }
+    udt1 &operator=(const udt1 &) = delete;
+    constexpr const char *operator*() const noexcept { return _v; }
+  };
+  struct udt2  // NOLINT
+  {
+    const char *_v{nullptr};
+    udt2() = default;
+    constexpr explicit udt2(const char *v) noexcept : _v(v) {}
+    constexpr udt2(udt2 &&o) noexcept : _v(o._v) { o._v = nullptr; }
+    udt2(const udt2 &) = default;
+    constexpr udt2 &operator=(udt2 &&o) noexcept
+    {
+      _v = o._v;
+      o._v = nullptr;
+      return *this;
+    }
+    udt1 &operator=(const udt1 &) = delete;
+    constexpr const char *operator*() const noexcept { return _v; }
+  };
+  result<udt1, udt2> p(udt1{a});
+  result<udt1, udt2> n(udt2{b});
+  // State check
+  BOOST_CHECK(p.has_value());
+  BOOST_CHECK(!n.has_value());
+  // These should behave as expected (!)
+  // BOOST_CHECK_NO_THROW(p.value());
+  // BOOST_CHECK_NO_THROW(n.value());
+  // And state is not destroyed
+  BOOST_CHECK(p.has_value() && *p.assume_value() == a);
+  BOOST_CHECK(!n.has_value() && *n.assume_error() == b);
+  // LEWG Expected provides rvalue ref semantics for operator*(), error() and error_or()
+  udt1 a1(std::move(p.assume_value()));
+  BOOST_CHECK(*a1 == a);
+  BOOST_CHECK(*p.assume_value() == nullptr);
+  udt2 e2(std::move(n).assume_error());
+  BOOST_CHECK(*e2 == b);
+  BOOST_CHECK(*n.assume_error() == nullptr);  // NOLINT
+}
diff --git a/src/boost/libs/outcome/test/tests/issue0012.cpp b/src/boost/libs/outcome/test/tests/issue0012.cpp
new file mode 100644
index 00000000..5066714f
--- /dev/null
+++ b/src/boost/libs/outcome/test/tests/issue0012.cpp
@@ -0,0 +1,59 @@
+/* Unit testing for outcomes
+(C) 2013-2019 Niall Douglas <http://www.nedproductions.biz/> (5 commits)
+
+
+Boost Software License - Version 1.0 - August 17th, 2003
+
+Permission is hereby granted, free of charge, to any person or organization
+obtaining a copy of the software and accompanying documentation covered by
+this license (the "Software") to use, reproduce, display, distribute,
+execute, and transmit the Software, and to prepare derivative works of the
+Software, and to permit third-parties to whom the Software is furnished to
+do so, all subject to the following:
+
+The copyright notices in the Software and this entire statement, including
+the above license grant, this restriction and the following disclaimer,
+must be included in all copies of the Software, in whole or in part, and
+all derivative works of the Software, unless such copies or derivative
+works are solely in the form of machine-executable object code generated by
+a source language processor.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
+SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
+FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
+*/
+
+#include <boost/outcome/outcome.hpp>
+#include <boost/test/unit_test.hpp>
+#include <boost/test/unit_test_monitor.hpp>
+
+BOOST_OUTCOME_AUTO_TEST_CASE(issues_0012_test, "outcome's copy assignment gets instantiated even when type T cannot be copied")
+{
+  using namespace BOOST_OUTCOME_V2_NAMESPACE;
+  const char *s = "hi";
+  struct udt  // NOLINT
+  {
+    const char *_v{nullptr};
+    udt() = default;
+    constexpr explicit udt(const char *v) noexcept : _v(v) {}
+    constexpr udt(udt &&o) noexcept : _v(o._v) { o._v = nullptr; }
+    udt(const udt &) = delete;
+    constexpr udt &operator=(udt &&o) noexcept
+    {
+      _v = o._v;
+      o._v = nullptr;
+      return *this;
+    }
+    udt &operator=(const udt &) = delete;
+    constexpr const char *operator*() const noexcept { return _v; }
+  };
+  static_assert(std::is_move_constructible<outcome<udt>>::value, "expected<udt> is not move constructible!");
+  static_assert(!std::is_copy_constructible<outcome<udt>>::value, "expected<udt> is copy constructible!");
+  outcome<udt> p(udt{s}), n(boost::system::error_code(ENOMEM, boost::system::generic_category()));
+  n = boost::system::error_code(EINVAL, boost::system::generic_category());
+  BOOST_CHECK(n.error().value() == EINVAL);
+}
diff --git a/src/boost/libs/outcome/test/tests/issue0016.cpp b/src/boost/libs/outcome/test/tests/issue0016.cpp
new file mode 100644
index 00000000..c03e1f37
--- /dev/null
+++ b/src/boost/libs/outcome/test/tests/issue0016.cpp
@@ -0,0 +1,56 @@
+/* Unit testing for outcomes
+(C) 2013-2019 Niall Douglas <http://www.nedproductions.biz/> (5 commits)
+
+
+Boost Software License - Version 1.0 - August 17th, 2003
+
+Permission is hereby granted, free of charge, to any person or organization
+obtaining a copy of the software and accompanying documentation covered by
+this license (the "Software") to use, reproduce, display, distribute,
+execute, and transmit the Software, and to prepare derivative works of the
+Software, and to permit third-parties to whom the Software is furnished to
+do so, all subject to the following:
+
+The copyright notices in the Software and this entire statement, including
+the above license grant, this restriction and the following disclaimer,
+must be included in all copies of the Software, in whole or in part, and
+all derivative works of the Software, unless such copies or derivative
+works are solely in the form of machine-executable object code generated by
+a source language processor.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
+SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
+FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
+*/
+
+#include <boost/outcome/outcome.hpp>
+#include <boost/test/unit_test.hpp>
+#include <boost/test/unit_test_monitor.hpp>
+
+BOOST_OUTCOME_AUTO_TEST_CASE(issues_0016_test, "Default constructor of T is sometimes compiled when T has no default constructor")
+{
+  using namespace BOOST_OUTCOME_V2_NAMESPACE;
+  struct udt
+  {
+    const char *_v{nullptr};
+    udt() = delete;
+    constexpr explicit udt(const char *v) noexcept : _v(v) {}
+    constexpr udt(udt &&o) noexcept : _v(o._v) { o._v = nullptr; }
+    udt(const udt &) = delete;
+    constexpr udt &operator=(udt &&o) noexcept
+    {
+      _v = o._v;
+      o._v = nullptr;
+      return *this;
+    }
+    udt &operator=(const udt &) = delete;
+    ~udt() = default;
+    constexpr const char *operator*() const noexcept { return _v; }
+  };
+  result<udt> n(boost::system::error_code(ENOMEM, boost::system::generic_category()));
+  (void) n;
+}
diff --git a/src/boost/libs/outcome/test/tests/issue0059.cpp b/src/boost/libs/outcome/test/tests/issue0059.cpp
new file mode 100644
index 00000000..9c03e6d4
--- /dev/null
+++ b/src/boost/libs/outcome/test/tests/issue0059.cpp
@@ -0,0 +1,60 @@
+/* Unit testing for outcomes
+(C) 2013-2019 Niall Douglas <http://www.nedproductions.biz/> (8 commits)
+
+
+Boost Software License - Version 1.0 - August 17th, 2003
+
+Permission is hereby granted, free of charge, to any person or organization
+obtaining a copy of the software and accompanying documentation covered by
+this license (the "Software") to use, reproduce, display, distribute,
+execute, and transmit the Software, and to prepare derivative works of the
+Software, and to permit third-parties to whom the Software is furnished to
+do so, all subject to the following:
+
+The copyright notices in the Software and this entire statement, including
+the above license grant, this restriction and the following disclaimer,
+must be included in all copies of the Software, in whole or in part, and
+all derivative works of the Software, unless such copies or derivative
+works are solely in the form of machine-executable object code generated by
+a source language processor.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
+SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
+FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
+*/
+
+#include <boost/outcome/result.hpp>
+#include <boost/outcome/try.hpp>
+#include <boost/test/unit_test.hpp>
+#include <boost/test/unit_test_monitor.hpp>
+
+BOOST_OUTCOME_AUTO_TEST_CASE(issues_0059_test, "result<NonMovable> supported?")
+{
+#if defined(_MSC_VER) || __cplusplus >= 201700
+  using namespace BOOST_OUTCOME_V2_NAMESPACE;
+  struct udt
+  {
+    const char *_v{nullptr};
+    udt() = delete;
+    constexpr udt(const char *v) noexcept : _v(v) {}  // NOLINT
+    udt(udt &&o) = delete;
+    udt(const udt &) = delete;
+    udt &operator=(udt &&o) = delete;
+    udt &operator=(const udt &) = delete;
+    ~udt() = default;
+    constexpr const char *operator*() const noexcept { return _v; }
+  };
+  const char *niall = "niall";
+  auto f = [niall]() -> result<void> {
+    auto g = [niall]() -> result<udt> { return {niall}; };
+    BOOST_OUTCOME_TRY(v, g());  // this must never copy nor move
+    BOOST_CHECK(*v == niall);
+    return success();
+  };
+  (void) f();
+#endif
+}
diff --git a/src/boost/libs/outcome/test/tests/issue0061.cpp b/src/boost/libs/outcome/test/tests/issue0061.cpp
new file mode 100644
index 00000000..3e8d1a6c
--- /dev/null
+++ b/src/boost/libs/outcome/test/tests/issue0061.cpp
@@ -0,0 +1,128 @@
+/* Unit testing for outcomes
+(C) 2013-2019 Niall Douglas <http://www.nedproductions.biz/> (6 commits)
+
+
+Boost Software License - Version 1.0 - August 17th, 2003
+
+Permission is hereby granted, free of charge, to any person or organization
+obtaining a copy of the software and accompanying documentation covered by
+this license (the "Software") to use, reproduce, display, distribute,
+execute, and transmit the Software, and to prepare derivative works of the
+Software, and to permit third-parties to whom the Software is furnished to
+do so, all subject to the following:
+
+The copyright notices in the Software and this entire statement, including
+the above license grant, this restriction and the following disclaimer,
+must be included in all copies of the Software, in whole or in part, and
+all derivative works of the Software, unless such copies or derivative
+works are solely in the form of machine-executable object code generated by
+a source language processor.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
+SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
+FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
+*/
+
+#include <boost/outcome/outcome.hpp>
+#include <boost/test/unit_test.hpp>
+#include <boost/test/unit_test_monitor.hpp>
+
+BOOST_OUTCOME_AUTO_TEST_CASE(issues_0061_result, "result<T1, E1> does not compare to incompatible result<T2, E2>")
+{
+  using namespace BOOST_OUTCOME_V2_NAMESPACE;
+  struct udt1
+  {
+    const char *_v{nullptr};
+    udt1() = default;
+    constexpr udt1(const char *v) noexcept : _v(v) {}  // NOLINT
+    udt1(udt1 &&o) = delete;
+    udt1(const udt1 &) = delete;
+    udt1 &operator=(udt1 &&o) = delete;
+    udt1 &operator=(const udt1 &) = delete;
+    ~udt1() = default;
+    constexpr const char *operator*() const noexcept { return _v; }
+  };
+  struct udt2
+  {
+    const char *_v{nullptr};
+    udt2() = default;
+    constexpr explicit udt2(const char *v) noexcept : _v(v) {}
+    udt2(udt2 &&o) = delete;
+    udt2(const udt2 &) = delete;
+    udt2 &operator=(udt2 &&o) = delete;
+    udt2 &operator=(const udt2 &) = delete;
+    ~udt2() = default;
+    constexpr const char *operator*() const noexcept { return _v; }
+    bool operator==(const udt1 &o) const noexcept { return _v == *o; }
+    bool operator!=(const udt1 &o) const noexcept { return _v != *o; }
+  };
+  using result1 = result<int, udt1>;
+  using result2 = result<int, udt2>;
+
+  result1 a(5);
+  result2 b(5);
+  BOOST_CHECK(b == a);     // udt2 will compare to udt1
+  BOOST_CHECK(!(b != a));  // udt2 will compare to udt1
+
+  result<void> c = success();
+  result<void> d = success();
+  BOOST_CHECK(c == d);
+  BOOST_CHECK(!(c != d));
+
+  BOOST_CHECK(a == success());
+  BOOST_CHECK(success() == a);
+  BOOST_CHECK(b != failure("foo"));
+  BOOST_CHECK(failure("foo") != b);
+}
+
+BOOST_OUTCOME_AUTO_TEST_CASE(issues_0061_outcome, "outcome<T1, E1, P1> does not compare to incompatible outcome<T2, E2, P2>")
+{
+  using namespace BOOST_OUTCOME_V2_NAMESPACE;
+  struct udt1
+  {
+    const char *_v{nullptr};
+    udt1() = default;
+    constexpr udt1(const char *v) noexcept : _v(v) {}  // NOLINT
+    udt1(udt1 &&o) = delete;
+    udt1(const udt1 &) = delete;
+    udt1 &operator=(udt1 &&o) = delete;
+    udt1 &operator=(const udt1 &) = delete;
+    ~udt1() = default;
+    constexpr const char *operator*() const noexcept { return _v; }
+  };
+  struct udt2
+  {
+    const char *_v{nullptr};
+    udt2() = default;
+    constexpr explicit udt2(const char *v) noexcept : _v(v) {}
+    udt2(udt2 &&o) = delete;
+    udt2(const udt2 &) = delete;
+    udt2 &operator=(udt2 &&o) = delete;
+    udt2 &operator=(const udt2 &) = delete;
+    ~udt2() = default;
+    constexpr const char *operator*() const noexcept { return _v; }
+    bool operator==(const udt1 &o) const noexcept { return _v == *o; }
+    bool operator!=(const udt1 &o) const noexcept { return _v != *o; }
+  };
+  using outcome1 = outcome<int, udt1>;
+  using outcome2 = outcome<int, udt2>;
+
+  outcome1 a(5), _a(6);
+  outcome2 b(5);
+  BOOST_CHECK(b == a);     // udt2 will compare to udt1
+  BOOST_CHECK(!(b != a));  // udt2 will compare to udt1
+
+  outcome<void> c = success();
+  outcome<void> d = success();
+  BOOST_CHECK(c == d);
+  BOOST_CHECK(!(c != d));
+
+  BOOST_CHECK(a == success());
+  BOOST_CHECK(success() == a);
+  BOOST_CHECK(b != failure("foo"));
+  BOOST_CHECK(failure("foo") != b);
+}
diff --git a/src/boost/libs/outcome/test/tests/issue0064.cpp b/src/boost/libs/outcome/test/tests/issue0064.cpp
new file mode 100644
index 00000000..6bdbb529
--- /dev/null
+++ b/src/boost/libs/outcome/test/tests/issue0064.cpp
@@ -0,0 +1,50 @@
+/* Unit testing for outcomes
+(C) 2013-2019 Niall Douglas <http://www.nedproductions.biz/> (4 commits)
+
+
+Boost Software License - Version 1.0 - August 17th, 2003
+
+Permission is hereby granted, free of charge, to any person or organization
+obtaining a copy of the software and accompanying documentation covered by
+this license (the "Software") to use, reproduce, display, distribute,
+execute, and transmit the Software, and to prepare derivative works of the
+Software, and to permit third-parties to whom the Software is furnished to
+do so, all subject to the following:
+
+The copyright notices in the Software and this entire statement, including
+the above license grant, this restriction and the following disclaimer,
+must be included in all copies of the Software, in whole or in part, and
+all derivative works of the Software, unless such copies or derivative
+works are solely in the form of machine-executable object code generated by
+a source language processor.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
+SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
+FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
+*/
+
+#include <boost/outcome/iostream_support.hpp>
+#include <boost/outcome/outcome.hpp>
+#include <boost/outcome/try.hpp>
+#include <boost/test/unit_test.hpp>
+#include <boost/test/unit_test_monitor.hpp>
+
+BOOST_OUTCOME_AUTO_TEST_CASE(issues_0064_outcome, "BOOST_OUTCOME_TRY on excepted outcome is propagating a null error rather than just an exception")
+{
+#ifndef BOOST_NO_EXCEPTIONS
+  using namespace BOOST_OUTCOME_V2_NAMESPACE;
+  auto f = []() -> outcome<int> {
+    auto h = []() -> outcome<int> { return boost::copy_exception(std::runtime_error("hello")); };
+    BOOST_OUTCOME_TRY((h()));
+    return 0;
+  }();
+  std::cout << print(f) << std::endl;
+  BOOST_CHECK(!f.has_value());
+  BOOST_CHECK(!f.has_error());
+  BOOST_CHECK(f.has_exception());
+#endif
+}
diff --git a/src/boost/libs/outcome/test/tests/issue0065.cpp b/src/boost/libs/outcome/test/tests/issue0065.cpp
new file mode 100644
index 00000000..6bd61aa1
--- /dev/null
+++ b/src/boost/libs/outcome/test/tests/issue0065.cpp
@@ -0,0 +1,66 @@
+/* Unit testing for outcomes
+(C) 2013-2019 Niall Douglas <http://www.nedproductions.biz/> (3 commits)
+
+
+Boost Software License - Version 1.0 - August 17th, 2003
+
+Permission is hereby granted, free of charge, to any person or organization
+obtaining a copy of the software and accompanying documentation covered by
+this license (the "Software") to use, reproduce, display, distribute,
+execute, and transmit the Software, and to prepare derivative works of the
+Software, and to permit third-parties to whom the Software is furnished to
+do so, all subject to the following:
+
+The copyright notices in the Software and this entire statement, including
+the above license grant, this restriction and the following disclaimer,
+must be included in all copies of the Software, in whole or in part, and
+all derivative works of the Software, unless such copies or derivative
+works are solely in the form of machine-executable object code generated by
+a source language processor.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
+SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
+FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
+*/
+
+#include <boost/outcome/outcome.hpp>
+#include <boost/outcome/try.hpp>
+#include <boost/test/unit_test.hpp>
+#include <boost/test/unit_test_monitor.hpp>
+
+BOOST_OUTCOME_AUTO_TEST_CASE(issues_0065_outcome, "BOOST_OUTCOME_TRY does not preserve the exception_ptr")
+{
+#ifndef BOOST_NO_EXCEPTIONS
+  using namespace BOOST_OUTCOME_V2_NAMESPACE;
+  auto g = []() -> outcome<int> {
+    auto f = []() -> outcome<int> {
+      try
+      {
+        throw std::runtime_error{"XXX"};
+      }
+      catch(...)
+      {
+        return boost::current_exception();
+      }
+    };
+    BOOST_OUTCOME_TRY(ans, (f()));
+    return ans;
+  };
+  outcome<int> o = g();
+  BOOST_CHECK(!o);
+  BOOST_CHECK(o.has_exception());
+  try
+  {
+    o.value();
+    BOOST_CHECK(false);
+  }
+  catch(const std::runtime_error &e)
+  {
+    BOOST_CHECK(!strcmp(e.what(), "XXX"));
+  }
+#endif
+}
diff --git a/src/boost/libs/outcome/test/tests/issue0071.cpp b/src/boost/libs/outcome/test/tests/issue0071.cpp
new file mode 100644
index 00000000..33489d1b
--- /dev/null
+++ b/src/boost/libs/outcome/test/tests/issue0071.cpp
@@ -0,0 +1,45 @@
+/* Unit testing for outcomes
+(C) 2013-2019 Niall Douglas <http://www.nedproductions.biz/> (4 commits)
+
+
+Boost Software License - Version 1.0 - August 17th, 2003
+
+Permission is hereby granted, free of charge, to any person or organization
+obtaining a copy of the software and accompanying documentation covered by
+this license (the "Software") to use, reproduce, display, distribute,
+execute, and transmit the Software, and to prepare derivative works of the
+Software, and to permit third-parties to whom the Software is furnished to
+do so, all subject to the following:
+
+The copyright notices in the Software and this entire statement, including
+the above license grant, this restriction and the following disclaimer,
+must be included in all copies of the Software, in whole or in part, and
+all derivative works of the Software, unless such copies or derivative
+works are solely in the form of machine-executable object code generated by
+a source language processor.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
+SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
+FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
+*/
+
+#include <boost/outcome/result.hpp>
+#include <boost/test/unit_test.hpp>
+#include <boost/test/unit_test_monitor.hpp>
+
+BOOST_OUTCOME_AUTO_TEST_CASE(issues_0071_outcome, "Implicit construction is over eager")
+{
+  using namespace BOOST_OUTCOME_V2_NAMESPACE;
+  struct udt
+  {
+    int v;
+    explicit udt(int a)
+        : v(a){};
+  };
+  result<udt> m = udt{5};
+  BOOST_CHECK(m.value().v == 5);
+}
diff --git a/src/boost/libs/outcome/test/tests/issue0095.cpp b/src/boost/libs/outcome/test/tests/issue0095.cpp
new file mode 100644
index 00000000..f2831e18
--- /dev/null
+++ b/src/boost/libs/outcome/test/tests/issue0095.cpp
@@ -0,0 +1,58 @@
+/* Unit testing for outcomes
+(C) 2013-2019 Niall Douglas <http://www.nedproductions.biz/> (6 commits)
+
+
+Boost Software License - Version 1.0 - August 17th, 2003
+
+Permission is hereby granted, free of charge, to any person or organization
+obtaining a copy of the software and accompanying documentation covered by
+this license (the "Software") to use, reproduce, display, distribute,
+execute, and transmit the Software, and to prepare derivative works of the
+Software, and to permit third-parties to whom the Software is furnished to
+do so, all subject to the following:
+
+The copyright notices in the Software and this entire statement, including
+the above license grant, this restriction and the following disclaimer,
+must be included in all copies of the Software, in whole or in part, and
+all derivative works of the Software, unless such copies or derivative
+works are solely in the form of machine-executable object code generated by
+a source language processor.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
+SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
+FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
+*/
+
+#include <boost/outcome/result.hpp>
+#include <boost/outcome/try.hpp>
+#include <boost/test/unit_test.hpp>
+#include <boost/test/unit_test_monitor.hpp>
+
+namespace issue0095
+{
+  namespace out = BOOST_OUTCOME_V2_NAMESPACE;
+
+  struct E
+  {
+  };
+  // struct F : E {};
+  struct F
+  {
+    operator E() const { return E{}; }  // NOLINT
+  };
+
+  out::result<int, F> f() { return F{}; }
+  out::result<int, E> e()
+  {
+    BOOST_OUTCOME_TRY(i, (f()));
+    return i;
+  }
+}  // namespace issue0095
+BOOST_OUTCOME_AUTO_TEST_CASE(issues_0095_outcome, "operator conversions on E type cause TRY to fail")
+{
+  BOOST_CHECK(issue0095::e().has_error());
+}
diff --git a/src/boost/libs/outcome/test/tests/issue0115.cpp b/src/boost/libs/outcome/test/tests/issue0115.cpp
new file mode 100644
index 00000000..59ba0b9e
--- /dev/null
+++ b/src/boost/libs/outcome/test/tests/issue0115.cpp
@@ -0,0 +1,57 @@
+/* Unit testing for outcomes
+(C) 2013-2019 Niall Douglas <http://www.nedproductions.biz/> (1 commit)
+
+
+Boost Software License - Version 1.0 - August 17th, 2003
+
+Permission is hereby granted, free of charge, to any person or organization
+obtaining a copy of the software and accompanying documentation covered by
+this license (the "Software") to use, reproduce, display, distribute,
+execute, and transmit the Software, and to prepare derivative works of the
+Software, and to permit third-parties to whom the Software is furnished to
+do so, all subject to the following:
+
+The copyright notices in the Software and this entire statement, including
+the above license grant, this restriction and the following disclaimer,
+must be included in all copies of the Software, in whole or in part, and
+all derivative works of the Software, unless such copies or derivative
+works are solely in the form of machine-executable object code generated by
+a source language processor.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
+SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
+FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
+*/
+
+#include <boost/outcome/outcome.hpp>
+#include <boost/test/unit_test.hpp>
+#include <boost/test/unit_test_monitor.hpp>
+
+BOOST_OUTCOME_AUTO_TEST_CASE(issues_0115_outcome, "Initialization from `failure_type` drops default-constructed values")
+{
+  namespace out = BOOST_OUTCOME_V2_NAMESPACE;
+
+  out::outcome<int> o1 = boost::system::error_code{};
+  BOOST_CHECK(o1.has_error());
+  BOOST_CHECK(!o1.has_exception());
+
+  out::outcome<int> o2 = out::failure(boost::system::error_code{});
+  BOOST_CHECK(o2.has_error());
+  BOOST_CHECK(!o2.has_exception());
+
+  out::outcome<int> o3(boost::system::error_code{}, boost::exception_ptr{});
+  BOOST_CHECK(o3.has_error());
+  BOOST_CHECK(o3.has_exception());
+
+  out::outcome<int> o4 = out::failure(boost::system::error_code{}, boost::exception_ptr{});
+  BOOST_CHECK(o4.has_error());
+  BOOST_CHECK(o4.has_exception());
+
+  out::outcome<int> o5 = out::failure(boost::exception_ptr{});
+  BOOST_CHECK(!o5.has_error());
+  BOOST_CHECK(o5.has_exception());
+}
diff --git a/src/boost/libs/outcome/test/tests/issue0116.cpp b/src/boost/libs/outcome/test/tests/issue0116.cpp
new file mode 100644
index 00000000..14875e73
--- /dev/null
+++ b/src/boost/libs/outcome/test/tests/issue0116.cpp
@@ -0,0 +1,45 @@
+/* Unit testing for outcomes
+(C) 2013-2019 Niall Douglas <http://www.nedproductions.biz/> (2 commits)
+
+
+Boost Software License - Version 1.0 - August 17th, 2003
+
+Permission is hereby granted, free of charge, to any person or organization
+obtaining a copy of the software and accompanying documentation covered by
+this license (the "Software") to use, reproduce, display, distribute,
+execute, and transmit the Software, and to prepare derivative works of the
+Software, and to permit third-parties to whom the Software is furnished to
+do so, all subject to the following:
+
+The copyright notices in the Software and this entire statement, including
+the above license grant, this restriction and the following disclaimer,
+must be included in all copies of the Software, in whole or in part, and
+all derivative works of the Software, unless such copies or derivative
+works are solely in the form of machine-executable object code generated by
+a source language processor.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
+SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
+FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
+*/
+
+#include <boost/outcome/outcome.hpp>
+#include <boost/test/unit_test.hpp>
+#include <boost/test/unit_test_monitor.hpp>
+
+BOOST_OUTCOME_AUTO_TEST_CASE(issues_0116_outcome, "Bad implementation of outcome::operator==")
+{
+  namespace out = BOOST_OUTCOME_V2_NAMESPACE;
+
+  out::outcome<int> o1 = 1;
+  BOOST_CHECK(!o1.has_error());
+
+  out::outcome<int> o2 = out::failure(boost::system::error_code{EINVAL, boost::system::generic_category()});
+  BOOST_CHECK(o2.has_error());
+
+  BOOST_CHECK(o1 != o2);
+}
diff --git a/src/boost/libs/outcome/test/tests/issue0140.cpp b/src/boost/libs/outcome/test/tests/issue0140.cpp
new file mode 100644
index 00000000..ef922be5
--- /dev/null
+++ b/src/boost/libs/outcome/test/tests/issue0140.cpp
@@ -0,0 +1,96 @@
+/* Unit testing for outcomes
+(C) 2013-2019 Niall Douglas <http://www.nedproductions.biz/> (2 commits)
+
+
+Boost Software License - Version 1.0 - August 17th, 2003
+
+Permission is hereby granted, free of charge, to any person or organization
+obtaining a copy of the software and accompanying documentation covered by
+this license (the "Software") to use, reproduce, display, distribute,
+execute, and transmit the Software, and to prepare derivative works of the
+Software, and to permit third-parties to whom the Software is furnished to
+do so, all subject to the following:
+
+The copyright notices in the Software and this entire statement, including
+the above license grant, this restriction and the following disclaimer,
+must be included in all copies of the Software, in whole or in part, and
+all derivative works of the Software, unless such copies or derivative
+works are solely in the form of machine-executable object code generated by
+a source language processor.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
+SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
+FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
+*/
+
+#include <boost/outcome/outcome.hpp>
+#include <boost/test/unit_test.hpp>
+#include <boost/test/unit_test_monitor.hpp>
+
+BOOST_OUTCOME_AUTO_TEST_CASE(issues_0140_result, "Construction of non copy constructible value_type fails to not compile")
+{
+  namespace out = BOOST_OUTCOME_V2_NAMESPACE;
+
+  enum op
+  {
+    constructed,
+    moved,
+    copied
+  };
+  struct NotCopyMoveConstructible
+  {
+    op v{op::constructed};
+    NotCopyMoveConstructible() = default;
+    NotCopyMoveConstructible(const NotCopyMoveConstructible &o) = delete;
+    NotCopyMoveConstructible(NotCopyMoveConstructible &&) = delete;
+    NotCopyMoveConstructible &operator=(const NotCopyMoveConstructible &) = delete;
+    NotCopyMoveConstructible &operator=(NotCopyMoveConstructible &&) = delete;
+    ~NotCopyMoveConstructible() = default;
+  };
+  struct NotMoveConstructible
+  {
+    op v{op::constructed};
+    NotMoveConstructible() = default;
+    NotMoveConstructible(const NotMoveConstructible & /*unused*/)
+        : v(op::copied)
+    {
+    }
+    NotMoveConstructible(NotMoveConstructible &&) = delete;
+    NotMoveConstructible &operator=(const NotMoveConstructible &) = delete;
+    NotMoveConstructible &operator=(NotMoveConstructible &&) = delete;
+    ~NotMoveConstructible() = default;
+  };
+  struct NotCopyConstructible
+  {
+    op v{op::constructed};
+    NotCopyConstructible() = default;
+    NotCopyConstructible(NotCopyConstructible && /*unused*/) noexcept : v(op::moved) {}
+    NotCopyConstructible(const NotCopyConstructible & /*unused*/) = delete;
+    NotCopyConstructible &operator=(const NotCopyConstructible &) = delete;
+    NotCopyConstructible &operator=(NotCopyConstructible &&) = delete;
+    ~NotCopyConstructible() = default;
+  };
+
+  // Uncopyable and immovable items should be neither copyable nor moveable
+  static_assert(!std::is_copy_constructible<out::result<NotCopyMoveConstructible>>::value, "result<NotCopyMoveConstructible> is copy constructible!");
+  static_assert(!std::is_move_constructible<out::result<NotCopyMoveConstructible>>::value, "result<NotCopyMoveConstructible> is move constructible!");
+  static_assert(!std::is_convertible<const NotCopyMoveConstructible &, NotCopyMoveConstructible>::value, "");
+  static_assert(!std::is_convertible<NotCopyMoveConstructible &&, NotCopyMoveConstructible>::value, "");
+  static_assert(!std::is_constructible<out::result<NotCopyMoveConstructible>, const NotCopyMoveConstructible &>::value, "result<NotCopyMoveConstructible> is constructible from const NotCopyMoveConstructible&!");
+  static_assert(!std::is_constructible<out::result<NotCopyMoveConstructible>, NotCopyMoveConstructible &&>::value, "result<NotCopyMoveConstructible> is constructible from NotCopyMoveConstructible&&!");
+
+  // Immovable items should fall back to copy
+  static_assert(!std::is_move_constructible<NotMoveConstructible>::value, "NotMoveConstructible is move constructible!");
+  static_assert(std::is_move_constructible<out::result<NotMoveConstructible>>::value, "result<NotMoveConstructible> is not move constructible!");
+  static_assert(std::is_constructible<out::result<NotMoveConstructible>, const NotMoveConstructible &>::value, "result<NotMoveConstructible> is not constructible from NotMoveConstructible&&!");
+
+  // Uncopyable items should never move (this was the bug report)
+  static_assert(!std::is_copy_constructible<out::result<NotCopyConstructible>>::value, "result<NotCopyConstructible> is copy constructible!");
+  static_assert(!std::is_constructible<out::result<NotCopyConstructible>, const NotCopyConstructible &>::value, "result<NotCopyConstructible> is constructible from const NotCopyConstructible&!");
+
+  BOOST_CHECK(true);
+}
diff --git a/src/boost/libs/outcome/test/tests/issue0182.cpp b/src/boost/libs/outcome/test/tests/issue0182.cpp
new file mode 100644
index 00000000..c59bbf47
--- /dev/null
+++ b/src/boost/libs/outcome/test/tests/issue0182.cpp
@@ -0,0 +1,42 @@
+/* Unit testing for outcomes
+(C) 2013-2019 Niall Douglas <http://www.nedproductions.biz/> (1 commit)
+
+
+Boost Software License - Version 1.0 - August 17th, 2003
+
+Permission is hereby granted, free of charge, to any person or organization
+obtaining a copy of the software and accompanying documentation covered by
+this license (the "Software") to use, reproduce, display, distribute,
+execute, and transmit the Software, and to prepare derivative works of the
+Software, and to permit third-parties to whom the Software is furnished to
+do so, all subject to the following:
+
+The copyright notices in the Software and this entire statement, including
+the above license grant, this restriction and the following disclaimer,
+must be included in all copies of the Software, in whole or in part, and
+all derivative works of the Software, unless such copies or derivative
+works are solely in the form of machine-executable object code generated by
+a source language processor.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
+SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
+FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
+*/
+
+#include <boost/outcome/outcome.hpp>
+#include <boost/test/unit_test.hpp>
+#include <boost/test/unit_test_monitor.hpp>
+
+BOOST_OUTCOME_AUTO_TEST_CASE(issues_0189_test, "result<void, int>.value() compiles without tripping fail_to_compile_observers")
+{
+  namespace outcome = BOOST_OUTCOME_V2_NAMESPACE;
+  static_assert(!outcome::trait::is_error_code_available<int>::value, "int is clearly not a source for make_error_code()");
+  static_assert(!outcome::trait::is_exception_ptr_available<int>::value, "int is clearly not a source for make_exception_ptr()");
+  //outcome::result<void, int> r(5);
+  //r.value();
+  BOOST_CHECK(true);
+}
diff --git a/src/boost/libs/outcome/test/tests/issue0203.cpp b/src/boost/libs/outcome/test/tests/issue0203.cpp
new file mode 100644
index 00000000..df5a619d
--- /dev/null
+++ b/src/boost/libs/outcome/test/tests/issue0203.cpp
@@ -0,0 +1,103 @@
+/* Unit testing for outcomes
+(C) 2013-2019 Niall Douglas <http://www.nedproductions.biz/> (1 commit)
+
+
+Boost Software License - Version 1.0 - August 17th, 2003
+
+Permission is hereby granted, free of charge, to any person or organization
+obtaining a copy of the software and accompanying documentation covered by
+this license (the "Software") to use, reproduce, display, distribute,
+execute, and transmit the Software, and to prepare derivative works of the
+Software, and to permit third-parties to whom the Software is furnished to
+do so, all subject to the following:
+
+The copyright notices in the Software and this entire statement, including
+the above license grant, this restriction and the following disclaimer,
+must be included in all copies of the Software, in whole or in part, and
+all derivative works of the Software, unless such copies or derivative
+works are solely in the form of machine-executable object code generated by
+a source language processor.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
+SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
+FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
+*/
+
+#include <boost/outcome/std_result.hpp>
+#include <boost/outcome/try.hpp>
+#include <boost/test/unit_test.hpp>
+#include <boost/test/unit_test_monitor.hpp>
+
+namespace outcome = BOOST_OUTCOME_V2_NAMESPACE;
+
+enum class error
+{
+  test,
+  abcde
+};
+
+class error_category_impl : public std::error_category
+{
+public:
+  const char *name() const noexcept override { return "test"; }
+
+  std::string message(int code) const noexcept override
+  {
+    switch(static_cast<error>(code))
+    {
+    case error::test:
+      return "test";
+    case error::abcde:
+      return "abcde";
+    }
+    return "unknown";
+  }
+};
+const std::error_category &error_category() noexcept
+{
+  static error_category_impl instance;
+  return instance;
+}
+
+boost::system::error_code make_error_code(error error) noexcept
+{
+  return {static_cast<int>(error), error_category()};
+}
+
+namespace std
+{
+  template <> struct is_error_code_enum<error> : true_type
+  {
+  };
+}  // namespace std
+
+template <typename T> using enum_result = outcome::basic_result<T, error, outcome::policy::default_policy<T, error, void>>;
+
+enum_result<int> test()
+{
+  return 5;
+}
+
+outcome::std_result<int> abc()
+{
+  static_assert(std::is_error_code_enum<error>::value, "custom enum is not marked convertible to error code");
+  static_assert(std::is_constructible<boost::system::error_code, error>::value, "error code is not explicitly constructible from custom enum");
+  static_assert(std::is_convertible<error, boost::system::error_code>::value, "error code is not implicitly constructible from custom enum");
+  boost::system::error_code ec = error::test;  // custom enum is definitely convertible to error code
+  BOOST_OUTCOME_TRY(test());               // hence this should compile, as implicit conversions work here
+  (void) ec;
+
+  // But explicit conversions are required between dissimilar basic_result, implicit conversions are disabled
+  static_assert(std::is_constructible<outcome::std_result<int>, enum_result<int>>::value, "basic_result with error code is not explicitly constructible from basic_result with custom enum");
+  static_assert(!std::is_convertible<enum_result<int>, outcome::std_result<int>>::value, "basic_result with error code is implicitly constructible from basic_result with custom enum");
+  return 5;
+}
+
+BOOST_OUTCOME_AUTO_TEST_CASE(issues_0203_test, "enum convertible to error code works as designed")
+{
+  BOOST_CHECK(abc().value() == 5);
+}
diff --git a/src/boost/libs/outcome/test/tests/issue0210.cpp b/src/boost/libs/outcome/test/tests/issue0210.cpp
new file mode 100644
index 00000000..0f7d75e2
--- /dev/null
+++ b/src/boost/libs/outcome/test/tests/issue0210.cpp
@@ -0,0 +1,78 @@
+/* Unit testing for outcomes
+(C) 2013-2019 Niall Douglas <http://www.nedproductions.biz/> (1 commit)
+
+
+Boost Software License - Version 1.0 - August 17th, 2003
+
+Permission is hereby granted, free of charge, to any person or organization
+obtaining a copy of the software and accompanying documentation covered by
+this license (the "Software") to use, reproduce, display, distribute,
+execute, and transmit the Software, and to prepare derivative works of the
+Software, and to permit third-parties to whom the Software is furnished to
+do so, all subject to the following:
+
+The copyright notices in the Software and this entire statement, including
+the above license grant, this restriction and the following disclaimer,
+must be included in all copies of the Software, in whole or in part, and
+all derivative works of the Software, unless such copies or derivative
+works are solely in the form of machine-executable object code generated by
+a source language processor.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
+SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
+FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
+*/
+
+#include <boost/outcome/outcome.hpp>
+#include <boost/outcome/try.hpp>
+#include <boost/test/unit_test.hpp>
+#include <boost/test/unit_test_monitor.hpp>
+
+namespace issues210
+{
+  namespace outcome = BOOST_OUTCOME_V2_NAMESPACE;
+
+  struct error
+  {
+    boost::system::error_code code;
+  };
+
+  // say that my custom error code type is error code compatible
+  inline boost::system::error_code make_error_code(error error) noexcept { return error.code; }
+
+  template <typename T> using custom_result = outcome::basic_result<T, error, outcome::policy::default_policy<T, error, void>>;
+
+  // source of custom result type with error code compatible error type
+  inline custom_result<int> funcA(int x) { return x; }
+
+  // Is the custom result type explicitly constructible to an ordinary result type?
+  inline outcome::result<int> funcB(int x) { return outcome::result<int>(funcA(x)); }
+
+  // Does the custom result type TRY-convert to an ordinary result type?
+  inline outcome::result<int> func1(int x)
+  {
+    BOOST_OUTCOME_TRY(y, funcA(x));
+    return funcB(y);
+  }
+
+  // Is the custom result type explicitly constructible to an ordinary outcome type?
+  inline outcome::outcome<int> funcC(int x) { return outcome::outcome<int>(funcA(x)); }
+
+  // Does the custom result type TRY-convert to an ordinary outcome type?
+  inline outcome::outcome<int> func2(int x)
+  {
+    BOOST_OUTCOME_TRY(y, funcA(x));
+    return funcC(y);
+  }
+}  // namespace issues210
+
+
+BOOST_OUTCOME_AUTO_TEST_CASE(issues_0210_test, "result<int, E> with error code compatible custom E does not TRY into a result<int, boost::system::error_code> function")
+{
+  BOOST_CHECK(issues210::func1(5).value() == 5);
+  BOOST_CHECK(issues210::func2(5).value() == 5);
+}
diff --git a/src/boost/libs/outcome/test/tests/noexcept-propagation.cpp b/src/boost/libs/outcome/test/tests/noexcept-propagation.cpp
new file mode 100644
index 00000000..8a7a934b
--- /dev/null
+++ b/src/boost/libs/outcome/test/tests/noexcept-propagation.cpp
@@ -0,0 +1,84 @@
+/* Unit testing for outcomes
+(C) 2013-2019 Niall Douglas <http://www.nedproductions.biz/> (6 commits)
+
+
+Boost Software License - Version 1.0 - August 17th, 2003
+
+Permission is hereby granted, free of charge, to any person or organization
+obtaining a copy of the software and accompanying documentation covered by
+this license (the "Software") to use, reproduce, display, distribute,
+execute, and transmit the Software, and to prepare derivative works of the
+Software, and to permit third-parties to whom the Software is furnished to
+do so, all subject to the following:
+
+The copyright notices in the Software and this entire statement, including
+the above license grant, this restriction and the following disclaimer,
+must be included in all copies of the Software, in whole or in part, and
+all derivative works of the Software, unless such copies or derivative
+works are solely in the form of machine-executable object code generated by
+a source language processor.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
+SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
+FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
+*/
+
+#include <boost/outcome/outcome.hpp>
+#include <boost/test/unit_test.hpp>
+#include <boost/test/unit_test_monitor.hpp>
+
+#ifdef _MSC_VER
+#pragma warning(disable : 4127)  // conditional expression is constant
+#endif
+
+#ifndef BOOST_NO_EXCEPTIONS
+// std nothrow traits seem to return random values if exceptions are disabled on MSVC
+BOOST_OUTCOME_AUTO_TEST_CASE(works_outcome_noexcept, "Tests that the outcome correctly inherits noexcept from its type R")
+{
+  using namespace BOOST_OUTCOME_V2_NAMESPACE;
+  {
+    using type = outcome<int>;
+    BOOST_CHECK(std::is_nothrow_copy_constructible<type>::value);
+    BOOST_CHECK(std::is_nothrow_move_constructible<type>::value);
+    BOOST_CHECK(std::is_nothrow_copy_assignable<type>::value);
+    BOOST_CHECK(std::is_nothrow_move_assignable<type>::value);
+    BOOST_CHECK(std::is_nothrow_destructible<type>::value);
+  }
+  {
+    using type = outcome<std::string>;
+    BOOST_CHECK(std::is_nothrow_copy_constructible<type>::value == std::is_nothrow_copy_constructible<std::string>::value);
+    BOOST_CHECK(std::is_nothrow_move_constructible<type>::value == std::is_nothrow_move_constructible<std::string>::value);
+    BOOST_CHECK(std::is_nothrow_copy_assignable<type>::value == std::is_nothrow_copy_assignable<std::string>::value);
+    BOOST_CHECK(std::is_nothrow_move_assignable<type>::value == std::is_nothrow_move_assignable<std::string>::value);
+    BOOST_CHECK(std::is_nothrow_destructible<type>::value == std::is_nothrow_destructible<std::string>::value);
+  }
+  {
+    struct Except
+    {
+      int n;
+      Except() = delete;
+      Except(const Except & /*unused*/) noexcept(false)
+          : n(0)
+      {
+      }
+      Except(Except && /*unused*/) noexcept(false)
+          : n(0)
+      {
+      }
+      Except &operator=(const Except & /*unused*/) noexcept(false) { return *this; }
+      Except &operator=(Except && /*unused*/) noexcept(false) { return *this; }
+      ~Except() noexcept(false) { n = 0; }
+    };
+    using type = outcome<Except>;
+    BOOST_CHECK(!std::is_nothrow_copy_constructible<type>::value);
+    BOOST_CHECK(!std::is_nothrow_move_constructible<type>::value);
+    BOOST_CHECK(!std::is_nothrow_copy_assignable<type>::value);
+    BOOST_CHECK(!std::is_nothrow_move_assignable<type>::value);
+    BOOST_CHECK(!std::is_nothrow_destructible<type>::value);
+  }
+}
+#endif
diff --git a/src/boost/libs/outcome/test/tests/propagate.cpp b/src/boost/libs/outcome/test/tests/propagate.cpp
new file mode 100644
index 00000000..36b2869c
--- /dev/null
+++ b/src/boost/libs/outcome/test/tests/propagate.cpp
@@ -0,0 +1,90 @@
+/* Unit testing for outcomes
+(C) 2013-2019 Niall Douglas <http://www.nedproductions.biz/> (7 commits)
+
+
+Boost Software License - Version 1.0 - August 17th, 2003
+
+Permission is hereby granted, free of charge, to any person or organization
+obtaining a copy of the software and accompanying documentation covered by
+this license (the "Software") to use, reproduce, display, distribute,
+execute, and transmit the Software, and to prepare derivative works of the
+Software, and to permit third-parties to whom the Software is furnished to
+do so, all subject to the following:
+
+The copyright notices in the Software and this entire statement, including
+the above license grant, this restriction and the following disclaimer,
+must be included in all copies of the Software, in whole or in part, and
+all derivative works of the Software, unless such copies or derivative
+works are solely in the form of machine-executable object code generated by
+a source language processor.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
+SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
+FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
+*/
+
+#include <boost/outcome/outcome.hpp>
+#include <boost/outcome/try.hpp>
+#include <boost/test/unit_test.hpp>
+#include <boost/test/unit_test_monitor.hpp>
+
+BOOST_OUTCOME_AUTO_TEST_CASE(works_outcome_propagate, "Tests that the outcome propagates errors between different editions of itself")
+{
+  using namespace BOOST_OUTCOME_V2_NAMESPACE;
+  {
+    auto t0 = [&](int a) { return result<long>(boost::system::error_code(a, boost::system::generic_category())); };
+    auto t1 = [&](int a) {
+      result<double> f(t0(a));  // double is constructible from long
+      BOOST_CHECK(!f.has_value());
+      BOOST_CHECK(f.has_error());
+      return f;
+    };
+    auto t2 = [&](int a) {
+      result<void> f(t1(a).error());
+      BOOST_CHECK(!f.has_value());
+      BOOST_CHECK(f.has_error());
+      return f;
+    };
+    auto t3 = [&](int a) {
+      outcome<std::string> f(t2(a));
+      BOOST_CHECK(!f.has_value());
+      BOOST_CHECK(f.has_error());
+      return f;
+    };
+    BOOST_CHECK(t3(5).error().value() == 5);
+    result<int> a2{result<void>(in_place_type<void>)};
+    result<int> a3{result<void>(boost::system::error_code(5, boost::system::generic_category()))};
+    BOOST_CHECK(a2.has_value());
+    BOOST_CHECK(!a2.has_error());
+    BOOST_CHECK(!a3.has_value());
+    BOOST_CHECK(a3.has_error());
+  }
+  {
+    auto t0 = [&](int a) { return result<long>(a); };
+    auto t1 = [&](int a) -> result<std::string> {
+      BOOST_OUTCOME_TRY(f, (t0(a)));
+      return std::to_string(f);
+    };
+    BOOST_CHECK(t1(5).value() == "5");
+  }
+  {
+    auto t0 = [&](int a) { return result<long>(a); };
+    auto t1 = [&](int a) -> outcome<std::string> {
+      BOOST_OUTCOME_TRY(f, (t0(a)));
+      return std::to_string(f);
+    };
+    BOOST_CHECK(t1(5).value() == "5");
+  }
+  {
+    auto t0 = [&](int a) -> result<long> { return result<long>(a); };
+    auto t1 = [&](int a) -> outcome<void> {
+      BOOST_OUTCOME_TRY((t0(a)));
+      return outcome<void>(in_place_type<void>);
+    };
+    (void) t1(5);
+  }
+}
diff --git a/src/boost/libs/outcome/test/tests/serialisation.cpp b/src/boost/libs/outcome/test/tests/serialisation.cpp
new file mode 100644
index 00000000..949a0543
--- /dev/null
+++ b/src/boost/libs/outcome/test/tests/serialisation.cpp
@@ -0,0 +1,49 @@
+/* Unit testing for outcomes
+(C) 2013-2019 Niall Douglas <http://www.nedproductions.biz/> (7 commits)
+
+
+Boost Software License - Version 1.0 - August 17th, 2003
+
+Permission is hereby granted, free of charge, to any person or organization
+obtaining a copy of the software and accompanying documentation covered by
+this license (the "Software") to use, reproduce, display, distribute,
+execute, and transmit the Software, and to prepare derivative works of the
+Software, and to permit third-parties to whom the Software is furnished to
+do so, all subject to the following:
+
+The copyright notices in the Software and this entire statement, including
+the above license grant, this restriction and the following disclaimer,
+must be included in all copies of the Software, in whole or in part, and
+all derivative works of the Software, unless such copies or derivative
+works are solely in the form of machine-executable object code generated by
+a source language processor.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
+SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
+FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
+*/
+
+#include <boost/outcome/iostream_support.hpp>
+#include <boost/test/unit_test.hpp>
+#include <boost/test/unit_test_monitor.hpp>
+
+BOOST_OUTCOME_AUTO_TEST_CASE(works_outcome_serialisation, "Tests that the outcome serialises and deserialises as intended")
+{
+#if !defined(__APPLE__) || defined(__cpp_exceptions)
+  using namespace BOOST_OUTCOME_V2_NAMESPACE;
+  outcome<std::string> a("niall"), b(boost::system::error_code(5, boost::system::generic_category())), c(boost::copy_exception(std::ios_base::failure("A test failure message")));
+  std::cout << "a contains " << print(a) << " and b contains " << print(b) << " and c contains " << print(c) << std::endl;
+
+  std::stringstream ss;
+  outcome<int, std::string, long> d(success(5));
+  ss << d;
+  ss.seekg(0);
+  outcome<int, std::string, long> e(failure(""));
+  ss >> e;
+  BOOST_CHECK(d == e);
+#endif
+}
diff --git a/src/boost/libs/outcome/test/tests/success-failure.cpp b/src/boost/libs/outcome/test/tests/success-failure.cpp
new file mode 100644
index 00000000..4c4ece3d
--- /dev/null
+++ b/src/boost/libs/outcome/test/tests/success-failure.cpp
@@ -0,0 +1,69 @@
+/* Unit testing for outcomes
+(C) 2017-2019 Niall Douglas <http://www.nedproductions.biz/> (10 commits)
+
+
+Boost Software License - Version 1.0 - August 17th, 2003
+
+Permission is hereby granted, free of charge, to any person or organization
+obtaining a copy of the software and accompanying documentation covered by
+this license (the "Software") to use, reproduce, display, distribute,
+execute, and transmit the Software, and to prepare derivative works of the
+Software, and to permit third-parties to whom the Software is furnished to
+do so, all subject to the following:
+
+The copyright notices in the Software and this entire statement, including
+the above license grant, this restriction and the following disclaimer,
+must be included in all copies of the Software, in whole or in part, and
+all derivative works of the Software, unless such copies or derivative
+works are solely in the form of machine-executable object code generated by
+a source language processor.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
+SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
+FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
+*/
+
+#include <boost/outcome/result.hpp>
+#include <boost/test/unit_test.hpp>
+#include <boost/test/unit_test_monitor.hpp>
+
+#include <iostream>
+
+BOOST_OUTCOME_AUTO_TEST_CASE(works_success_failure, "Tests that the success and failure type sugars work as intended")
+{
+  using namespace BOOST_OUTCOME_V2_NAMESPACE;
+#ifdef __cpp_deduction_guides
+  std::cout << "__cpp_deduction_guides = 1" << std::endl;
+#endif
+  {
+    auto a = success(5);
+    auto b = success();
+    auto c = success("hello");
+    static_assert(std::is_same<decltype(a), success_type<int>>::value, "");
+    static_assert(std::is_same<decltype(b), success_type<void>>::value, "");
+    static_assert(std::is_same<decltype(c), success_type<const char *>>::value, "");
+    static_assert(std::is_same<decltype(a)::value_type, int>::value, "");
+    // static_assert(std::is_same<decltype(b.value), int>::value, "");
+    static_assert(std::is_same<decltype(c)::value_type, const char *>::value, "");
+  }
+#if !defined(__APPLE__) || defined(__cpp_exceptions)
+  {
+    auto e = boost::copy_exception(std::exception());
+    auto a = failure(5);
+    auto b = failure(5, e);
+    auto c = failure(5, 5);
+    static_assert(std::is_same<decltype(a), failure_type<int, void>>::value, "");
+    static_assert(std::is_same<decltype(b), failure_type<int, boost::exception_ptr>>::value, "");
+    static_assert(std::is_same<decltype(c), failure_type<int, int>>::value, "");
+    static_assert(std::is_same<decltype(a)::error_type, int>::value, "");
+    static_assert(std::is_same<decltype(b)::error_type, int>::value, "");
+    static_assert(std::is_same<decltype(b)::exception_type, boost::exception_ptr>::value, "");
+    static_assert(std::is_same<decltype(c)::error_type, int>::value, "");
+    static_assert(std::is_same<decltype(c)::exception_type, int>::value, "");
+  }
+#endif
+}
diff --git a/src/boost/libs/outcome/test/tests/swap.cpp b/src/boost/libs/outcome/test/tests/swap.cpp
new file mode 100644
index 00000000..cd62d348
--- /dev/null
+++ b/src/boost/libs/outcome/test/tests/swap.cpp
@@ -0,0 +1,374 @@
+/* Unit testing for outcomes
+(C) 2013-2019 Niall Douglas <http://www.nedproductions.biz/> (5 commits)
+
+
+Boost Software License - Version 1.0 - August 17th, 2003
+
+Permission is hereby granted, free of charge, to any person or organization
+obtaining a copy of the software and accompanying documentation covered by
+this license (the "Software") to use, reproduce, display, distribute,
+execute, and transmit the Software, and to prepare derivative works of the
+Software, and to permit third-parties to whom the Software is furnished to
+do so, all subject to the following:
+
+The copyright notices in the Software and this entire statement, including
+the above license grant, this restriction and the following disclaimer,
+must be included in all copies of the Software, in whole or in part, and
+all derivative works of the Software, unless such copies or derivative
+works are solely in the form of machine-executable object code generated by
+a source language processor.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
+SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
+FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
+*/
+
+#include <boost/outcome/outcome.hpp>
+#include <boost/test/unit_test.hpp>
+#include <boost/test/unit_test_monitor.hpp>
+
+#ifndef BOOST_NO_EXCEPTIONS
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable: 4297)  // function assumed not to throw an exception but does
+#endif
+#if defined(__GNUC__) && !defined(__clang__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wterminate"
+#endif
+template <bool mc, bool ma> struct Throwy
+{
+  int count{0}, inc{0}, id{0};
+  Throwy() = default;
+  Throwy(int c, int d, int i = 1) noexcept
+      : count(c)
+      , inc(i)
+      , id(d)
+  {
+  }
+  Throwy(const Throwy &) = delete;
+  Throwy &operator=(const Throwy &) = delete;
+  Throwy(Throwy &&o) noexcept(!mc)
+      : count(o.count - o.inc)
+      , inc(o.inc)
+      , id(o.id)  // NOLINT
+  {
+    if(mc)
+    {
+      std::cout << id << " move constructor count = " << count << std::endl;
+      if(!count)
+      {
+        throw std::bad_alloc();
+      }
+    }
+    o.count = 0;
+    o.inc = 0;
+    o.id = 0;
+  }
+  Throwy &operator=(Throwy &&o) noexcept(!ma)
+  {
+    count = o.count - o.inc;
+    if(ma)
+    {
+      std::cout << o.id << " move assignment count = " << count << std::endl;
+      if(!count)
+      {
+        throw std::bad_alloc();
+      }
+    }
+    inc = o.inc;
+    id = o.id;
+    o.count = 0;
+    o.inc = 0;
+    o.id = 0;
+    return *this;
+  }
+  ~Throwy() = default;
+};
+#if defined(__GNUC__) && !defined(__clang__)
+#pragma GCC diagnostic pop
+#endif
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+enum class ErrorCode
+{
+  dummy
+};
+enum class ErrorCode2
+{
+  dummy
+};
+template <bool mc, bool ma> using resulty1 = BOOST_OUTCOME_V2_NAMESPACE::result<Throwy<mc, ma>, ErrorCode, BOOST_OUTCOME_V2_NAMESPACE::policy::all_narrow>;
+template <bool mc, bool ma> using resulty2 = BOOST_OUTCOME_V2_NAMESPACE::result<ErrorCode, Throwy<mc, ma>, BOOST_OUTCOME_V2_NAMESPACE::policy::all_narrow>;
+template <bool mc, bool ma> using outcomey1 = BOOST_OUTCOME_V2_NAMESPACE::outcome<ErrorCode, Throwy<mc, ma>, ErrorCode2, BOOST_OUTCOME_V2_NAMESPACE::policy::all_narrow>;
+template <bool mc, bool ma> using outcomey2 = BOOST_OUTCOME_V2_NAMESPACE::outcome<ErrorCode, ErrorCode2, Throwy<mc, ma>, BOOST_OUTCOME_V2_NAMESPACE::policy::all_narrow>;
+#endif
+
+BOOST_OUTCOME_AUTO_TEST_CASE(works_outcome_swap, "Tests that the outcome swaps as intended")
+{
+  using namespace BOOST_OUTCOME_V2_NAMESPACE;
+  {  // Does swap actually swap?
+    outcome<std::string> a("niall"), b("douglas");
+    BOOST_CHECK(a.value() == "niall");
+    BOOST_CHECK(b.value() == "douglas");
+    swap(a, b);
+    BOOST_CHECK(a.value() == "douglas");
+    BOOST_CHECK(b.value() == "niall");
+    a = boost::system::errc::not_enough_memory;
+    swap(a, b);
+    BOOST_CHECK(a.value() == "niall");
+    BOOST_CHECK(b.error() == boost::system::errc::not_enough_memory);
+    BOOST_CHECK(!a.has_lost_consistency());
+    BOOST_CHECK(!b.has_lost_consistency());
+  }
+#ifndef BOOST_NO_EXCEPTIONS
+  {  // Is noexcept propagated?
+    using nothrow_t = Throwy<false, false>;
+    using nothrow = resulty1<false, false>;
+    static_assert(std::is_nothrow_move_constructible<nothrow_t>::value, "throwy not correct!");
+    static_assert(std::is_nothrow_move_assignable<nothrow_t>::value, "throwy not correct!");
+    static_assert(std::is_nothrow_move_constructible<nothrow>::value, "type not correct!");
+    static_assert(std::is_nothrow_move_assignable<nothrow>::value, "type not correct!");
+
+    static_assert(detail::is_nothrow_swappable<nothrow_t>::value, "is_nothrow_swappable is not correct!");
+
+    static_assert(noexcept(nothrow(0, 0)), "type has a throwing value constructor!");
+    nothrow a(1, 78), b(1, 65);
+    a.swap(b);
+    static_assert(noexcept(a.swap(b)), "type has a throwing swap!");
+  }
+  {  // Is noexcept propagated?
+    using nothrow_t = Throwy<false, false>;
+    using nothrow = resulty2<false, false>;
+    static_assert(std::is_nothrow_move_constructible<nothrow_t>::value, "throwy not correct!");
+    static_assert(std::is_nothrow_move_assignable<nothrow_t>::value, "throwy not correct!");
+    static_assert(std::is_nothrow_move_constructible<nothrow>::value, "type not correct!");
+    static_assert(std::is_nothrow_move_assignable<nothrow>::value, "type not correct!");
+
+    static_assert(detail::is_nothrow_swappable<nothrow_t>::value, "is_nothrow_swappable is not correct!");
+
+    static_assert(noexcept(nothrow(0, 0)), "type has a throwing value constructor!");
+    nothrow a(1, 78), b(1, 65);
+    a.swap(b);
+    static_assert(noexcept(a.swap(b)), "type has a throwing swap!");
+  }
+
+  {  // Does swap implement the strong guarantee?
+    using throwy_t = Throwy<true, true>;
+    using throwy = resulty1<true, true>;
+    static_assert(!std::is_nothrow_move_constructible<throwy_t>::value, "throwy not correct!");
+    static_assert(!std::is_nothrow_move_assignable<throwy_t>::value, "throwy not correct!");
+    static_assert(!std::is_nothrow_move_constructible<throwy>::value, "type not correct!");
+    static_assert(!std::is_nothrow_move_assignable<throwy>::value, "type not correct!");
+
+    static_assert(!detail::is_nothrow_swappable<throwy_t>::value, "is_nothrow_swappable is not correct!");
+
+    {
+      throwy a(3, 78), b(4, 65);
+      a.swap(b);
+      static_assert(!noexcept(a.swap(b)), "type has a non-throwing swap!");
+      BOOST_CHECK(a.value().id == 65);
+      BOOST_CHECK(b.value().id == 78);
+      try
+      {
+        a.swap(b);  // fails on first assignment
+        BOOST_REQUIRE(false);
+      }
+      catch(const std::bad_alloc & /*unused*/)
+      {
+        BOOST_CHECK(a.value().id == 65);  // ensure it is perfectly restored
+        BOOST_CHECK(b.value().id == 78);
+      }
+      BOOST_CHECK(!a.has_lost_consistency());
+      BOOST_CHECK(!b.has_lost_consistency());
+    }
+    std::cout << std::endl;
+    {
+      throwy a(2, 78), b(3, 65);  // fails on second assignment, cannot restore
+      try
+      {
+        a.swap(b);
+        BOOST_REQUIRE(false);
+      }
+      catch(const std::bad_alloc & /*unused*/)
+      {
+        BOOST_CHECK(a.has_lost_consistency());  // both must be marked tainted
+        BOOST_CHECK(b.has_lost_consistency());
+      }
+    }
+    std::cout << std::endl;
+  }
+  {  // Does swap implement the strong guarantee?
+    using throwy_t = Throwy<true, true>;
+    using throwy = resulty2<true, true>;
+    static_assert(!std::is_nothrow_move_constructible<throwy_t>::value, "throwy not correct!");
+    static_assert(!std::is_nothrow_move_assignable<throwy_t>::value, "throwy not correct!");
+    static_assert(!std::is_nothrow_move_constructible<throwy>::value, "type not correct!");
+    static_assert(!std::is_nothrow_move_assignable<throwy>::value, "type not correct!");
+
+    static_assert(!detail::is_nothrow_swappable<throwy_t>::value, "is_nothrow_swappable is not correct!");
+
+    {
+      throwy a(3, 78), b(4, 65);
+      a.swap(b);
+      static_assert(!noexcept(a.swap(b)), "type has a non-throwing swap!");
+      BOOST_CHECK(a.error().id == 65);
+      BOOST_CHECK(b.error().id == 78);
+      try
+      {
+        a.swap(b);  // fails on first assignment
+        BOOST_REQUIRE(false);
+      }
+      catch(const std::bad_alloc & /*unused*/)
+      {
+        BOOST_CHECK(a.error().id == 65);  // ensure it is perfectly restored
+        BOOST_CHECK(b.error().id == 78);
+      }
+      BOOST_CHECK(!a.has_lost_consistency());
+      BOOST_CHECK(!b.has_lost_consistency());
+    }
+    std::cout << std::endl;
+    {
+      throwy a(2, 78), b(3, 65);  // fails on second assignment, cannot restore
+      try
+      {
+        a.swap(b);
+        BOOST_REQUIRE(false);
+      }
+      catch(const std::bad_alloc & /*unused*/)
+      {
+        BOOST_CHECK(a.has_lost_consistency());  // both must be marked tainted
+        BOOST_CHECK(b.has_lost_consistency());
+      }
+    }
+    std::cout << std::endl;
+  }
+
+  {  // Is noexcept propagated?
+    using nothrow_t = Throwy<false, false>;
+    using nothrow = outcomey1<false, false>;
+    static_assert(std::is_nothrow_move_constructible<nothrow_t>::value, "throwy not correct!");
+    static_assert(std::is_nothrow_move_assignable<nothrow_t>::value, "throwy not correct!");
+    static_assert(std::is_nothrow_move_constructible<nothrow>::value, "type not correct!");
+    static_assert(std::is_nothrow_move_assignable<nothrow>::value, "type not correct!");
+
+    static_assert(detail::is_nothrow_swappable<nothrow_t>::value, "is_nothrow_swappable is not correct!");
+
+    static_assert(noexcept(nothrow(0, 0)), "type has a throwing value constructor!");
+    nothrow a(1, 78), b(1, 65);
+    a.swap(b);
+    static_assert(noexcept(a.swap(b)), "type has a throwing swap!");
+  }
+  {  // Is noexcept propagated?
+    using nothrow_t = Throwy<false, false>;
+    using nothrow = outcomey1<false, false>;
+    static_assert(std::is_nothrow_move_constructible<nothrow_t>::value, "throwy not correct!");
+    static_assert(std::is_nothrow_move_assignable<nothrow_t>::value, "throwy not correct!");
+    static_assert(std::is_nothrow_move_constructible<nothrow>::value, "type not correct!");
+    static_assert(std::is_nothrow_move_assignable<nothrow>::value, "type not correct!");
+
+    static_assert(detail::is_nothrow_swappable<nothrow_t>::value, "is_nothrow_swappable is not correct!");
+
+    static_assert(noexcept(nothrow(0, 0)), "type has a throwing value constructor!");
+    nothrow a(1, 78), b(1, 65);
+    a.swap(b);
+    static_assert(noexcept(a.swap(b)), "type has a throwing swap!");
+  }
+
+  {  // Does swap implement the strong guarantee?
+    using throwy_t = Throwy<true, true>;
+    using throwy = outcomey1<true, true>;
+    static_assert(!std::is_nothrow_move_constructible<throwy_t>::value, "throwy not correct!");
+    static_assert(!std::is_nothrow_move_assignable<throwy_t>::value, "throwy not correct!");
+    static_assert(!std::is_nothrow_move_constructible<throwy>::value, "type not correct!");
+    static_assert(!std::is_nothrow_move_assignable<throwy>::value, "type not correct!");
+
+    static_assert(!detail::is_nothrow_swappable<throwy_t>::value, "is_nothrow_swappable is not correct!");
+
+    {
+      throwy a(3, 78), b(4, 65);
+      a.swap(b);
+      static_assert(!noexcept(a.swap(b)), "type has a non-throwing swap!");
+      BOOST_CHECK(a.error().id == 65);
+      BOOST_CHECK(b.error().id == 78);
+      try
+      {
+        a.swap(b);  // fails on first assignment
+        BOOST_REQUIRE(false);
+      }
+      catch(const std::bad_alloc & /*unused*/)
+      {
+        BOOST_CHECK(a.error().id == 65);  // ensure it is perfectly restored
+        BOOST_CHECK(b.error().id == 78);
+      }
+      BOOST_CHECK(!a.has_lost_consistency());
+      BOOST_CHECK(!b.has_lost_consistency());
+    }
+    std::cout << std::endl;
+    {
+      throwy a(2, 78), b(3, 65);  // fails on second assignment, cannot restore
+      try
+      {
+        a.swap(b);
+        BOOST_REQUIRE(false);
+      }
+      catch(const std::bad_alloc & /*unused*/)
+      {
+        BOOST_CHECK(a.has_lost_consistency());  // both must be marked tainted
+        BOOST_CHECK(b.has_lost_consistency());
+      }
+    }
+    std::cout << std::endl;
+  }
+  {  // Does swap implement the strong guarantee?
+    using throwy_t = Throwy<true, true>;
+    using throwy = outcomey2<true, true>;
+    static_assert(!std::is_nothrow_move_constructible<throwy_t>::value, "throwy not correct!");
+    static_assert(!std::is_nothrow_move_assignable<throwy_t>::value, "throwy not correct!");
+    static_assert(!std::is_nothrow_move_constructible<throwy>::value, "type not correct!");
+    static_assert(!std::is_nothrow_move_assignable<throwy>::value, "type not correct!");
+
+    static_assert(!detail::is_nothrow_swappable<throwy_t>::value, "is_nothrow_swappable is not correct!");
+
+    {
+      throwy a(3, 78), b(4, 65);
+      a.swap(b);
+      static_assert(!noexcept(a.swap(b)), "type has a non-throwing swap!");
+      BOOST_CHECK(a.exception().id == 65);
+      BOOST_CHECK(b.exception().id == 78);
+      try
+      {
+        a.swap(b);  // fails on first assignment
+        BOOST_REQUIRE(false);
+      }
+      catch(const std::bad_alloc & /*unused*/)
+      {
+        BOOST_CHECK(a.exception().id == 65);  // ensure it is perfectly restored
+        BOOST_CHECK(b.exception().id == 78);
+      }
+      BOOST_CHECK(!a.has_lost_consistency());
+      BOOST_CHECK(!b.has_lost_consistency());
+    }
+    std::cout << std::endl;
+    {
+      throwy a(2, 78), b(3, 65);  // fails on second assignment, cannot restore
+      try
+      {
+        a.swap(b);
+        BOOST_REQUIRE(false);
+      }
+      catch(const std::bad_alloc & /*unused*/)
+      {
+        BOOST_CHECK(a.has_lost_consistency());  // both must be marked tainted
+        BOOST_CHECK(b.has_lost_consistency());
+      }
+    }
+    std::cout << std::endl;
+  }
+#endif
+}
diff --git a/src/boost/libs/outcome/test/tests/udts.cpp b/src/boost/libs/outcome/test/tests/udts.cpp
new file mode 100644
index 00000000..de87120c
--- /dev/null
+++ b/src/boost/libs/outcome/test/tests/udts.cpp
@@ -0,0 +1,154 @@
+/* Unit testing for outcomes
+(C) 2013-2019 Niall Douglas <http://www.nedproductions.biz/> (7 commits)
+
+
+Boost Software License - Version 1.0 - August 17th, 2003
+
+Permission is hereby granted, free of charge, to any person or organization
+obtaining a copy of the software and accompanying documentation covered by
+this license (the "Software") to use, reproduce, display, distribute,
+execute, and transmit the Software, and to prepare derivative works of the
+Software, and to permit third-parties to whom the Software is furnished to
+do so, all subject to the following:
+
+The copyright notices in the Software and this entire statement, including
+the above license grant, this restriction and the following disclaimer,
+must be included in all copies of the Software, in whole or in part, and
+all derivative works of the Software, unless such copies or derivative
+works are solely in the form of machine-executable object code generated by
+a source language processor.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
+SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
+FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
+*/
+
+#ifdef _MSC_VER
+#pragma warning(disable : 4702)  // unreachable code
+#endif
+
+#include <boost/outcome/outcome.hpp>
+#include <boost/test/unit_test.hpp>
+#include <boost/test/unit_test_monitor.hpp>
+
+BOOST_OUTCOME_AUTO_TEST_CASE(works_outcome_udts, "Tests that the outcome works as intended with user-defined types")
+{
+  using namespace BOOST_OUTCOME_V2_NAMESPACE;
+  // No default constructor, no copy/move, no assignment
+  {
+    struct udt
+    {
+      int a;
+      explicit udt(int _a)
+          : a(_a)
+      {
+      }
+      udt() = delete;
+      udt(const udt &) = delete;
+      udt(udt &&) = delete;
+      udt &operator=(const udt &) = delete;
+      udt &operator=(udt &&) = delete;
+      ~udt() = default;
+    };
+    outcome<udt> foo(in_place_type<udt>, 5);
+    BOOST_CHECK(5 == foo.value().a);
+  }
+#ifndef BOOST_NO_EXCEPTIONS
+  // Emplace construct, throws during move and copy
+  {
+    struct udt
+    {
+      std::string a;
+      explicit udt(std::string _a)
+          : a(std::move(_a))
+      {
+      }
+      udt() = delete;
+      udt(const udt & /*unused*/) { throw std::logic_error("copy"); }
+      udt(udt && /*unused*/) noexcept(false) { throw std::logic_error("move"); }  // NOLINT
+      udt &operator=(const udt & /*unused*/) { throw std::logic_error("copy"); }
+      udt &operator=(udt && /*unused*/) noexcept(false) { throw std::logic_error("move"); }  // NOLINT
+      ~udt() { a.clear(); }
+    };
+    static_assert(!std::is_default_constructible<udt>::value, "udt is default constructible");
+    static_assert(std::is_copy_constructible<udt>::value, "udt is not copy constructible");
+    static_assert(std::is_move_constructible<udt>::value, "udt is not move constructible");
+    static_assert(!std::is_default_constructible<outcome<udt>>::value, "outcome<udt> is default constructible");
+    static_assert(std::is_copy_constructible<outcome<udt>>::value, "outcome<udt> is not copy constructible");
+    static_assert(std::is_move_constructible<outcome<udt>>::value, "outcome<udt> is not move constructible");
+    // Emplace constructs
+    outcome<udt> foo(in_place_type<udt>, "niall");
+    BOOST_CHECK("niall" == foo.value().a);
+    try
+    {
+      auto foo2(foo);  // NOLINT
+      BOOST_CHECK(false);
+    }
+    catch(const std::logic_error &e)
+    {
+      BOOST_CHECK(!strcmp(e.what(), "copy"));
+    }
+    catch(...)
+    {
+      BOOST_CHECK(false);
+    }
+    BOOST_CHECK("niall" == foo.value().a);
+    try
+    {
+      auto foo2(std::move(foo));
+      BOOST_CHECK(false);
+    }
+    catch(const std::logic_error &e)
+    {
+      BOOST_CHECK(!strcmp(e.what(), "move"));
+    }
+    catch(...)
+    {
+      BOOST_CHECK(false);
+    }
+    BOOST_CHECK("niall" == foo.value().a);  // NOLINT
+    // Does throwing during copy assignment work?
+    {
+      outcome<udt> foo2(in_place_type<udt>, "douglas");
+      try
+      {
+        foo2 = foo;
+        BOOST_CHECK(false);
+      }
+      catch(const std::logic_error &e)
+      {
+        BOOST_CHECK(!strcmp(e.what(), "copy"));
+        BOOST_CHECK(foo2.value().a == "douglas");
+      }
+      catch(...)
+      {
+        BOOST_CHECK(false);
+      }
+      BOOST_CHECK("niall" == foo.value().a);
+    }
+    // Does throwing during move assignment work?
+    {
+      outcome<udt> foo2(in_place_type<udt>, "douglas");
+      try
+      {
+        foo2 = std::move(foo);
+        BOOST_CHECK(false);
+      }
+      catch(const std::logic_error &e)
+      {
+        BOOST_CHECK(!strcmp(e.what(), "move"));
+        BOOST_CHECK(foo2.value().a == "douglas");
+      }
+      catch(...)
+      {
+        BOOST_CHECK(false);
+      }
+      BOOST_CHECK("niall" == foo.value().a);  // NOLINT
+    }
+  }
+#endif
+}
diff --git a/src/boost/libs/outcome/test/tests/value-or-error.cpp b/src/boost/libs/outcome/test/tests/value-or-error.cpp
new file mode 100644
index 00000000..ecd611db
--- /dev/null
+++ b/src/boost/libs/outcome/test/tests/value-or-error.cpp
@@ -0,0 +1,54 @@
+/* Unit testing for outcomes
+(C) 2013-2019 Niall Douglas <http://www.nedproductions.biz/> (3 commits)
+
+
+Boost Software License - Version 1.0 - August 17th, 2003
+
+Permission is hereby granted, free of charge, to any person or organization
+obtaining a copy of the software and accompanying documentation covered by
+this license (the "Software") to use, reproduce, display, distribute,
+execute, and transmit the Software, and to prepare derivative works of the
+Software, and to permit third-parties to whom the Software is furnished to
+do so, all subject to the following:
+
+The copyright notices in the Software and this entire statement, including
+the above license grant, this restriction and the following disclaimer,
+must be included in all copies of the Software, in whole or in part, and
+all derivative works of the Software, unless such copies or derivative
+works are solely in the form of machine-executable object code generated by
+a source language processor.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
+SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
+FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
+*/
+
+#include <boost/outcome/outcome.hpp>
+#include <boost/test/unit_test.hpp>
+#include <boost/test/unit_test_monitor.hpp>
+
+BOOST_OUTCOME_AUTO_TEST_CASE(works_outcome_valueorerror, "Tests that outcome constructs from ValueOrError and ValueOrNone concept inputs")
+{
+  using namespace BOOST_OUTCOME_V2_NAMESPACE;
+  {
+    struct value_or_error
+    {
+      using value_type = int;
+      using error_type = void;
+      bool has_value() const { return true; }
+      int value() const { return 78; }
+      void error() const {}
+    } a;
+    static_assert(convert::ValueOrNone<value_or_error>, "");
+    static_assert(convert::ValueOrError<value_or_error>, "");
+    BOOST_CHECK((convert::value_or_error<result<long>, value_or_error>{}(a).value() == 78));
+
+    result<long> b(a);
+    BOOST_CHECK(b.has_value());
+    BOOST_CHECK(b.value() == 78);
+  }
+}
author	Daniel Baumann <daniel.baumann@progress-linux.org>	2024-04-27 18:24:20 +0000
committer	Daniel Baumann <daniel.baumann@progress-linux.org>	2024-04-27 18:24:20 +0000
commit	483eb2f56657e8e7f419ab1a4fab8dce9ade8609 (patch)
tree	e5d88d25d870d5dedacb6bbdbe2a966086a0a5cf /src/boost/libs/outcome
parent	Initial commit. (diff)
download	ceph-483eb2f56657e8e7f419ab1a4fab8dce9ade8609.tar.xz ceph-483eb2f56657e8e7f419ab1a4fab8dce9ade8609.zip