Adding upstream version 16.2.11+ds.upstream/16.2.11+dsupstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 2015 insertions, 0 deletions

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 000000000..5c63b9118
--- /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