Protect std::experimental::optional tests under libcpp-no-exceptions

[rogfer01]

Summary

In these tests there are some paths that explicitly throw, so use
the TEST_THROW macro that was proposed for this and then skip the tests
that may enter the throwing path.

[EricWF]

LGTM after addressing inline comments.

Thanks again!

test/std/experimental/optional/optional.object/optional.object.ctor/copy.pass.cpp

30

#ifdef TEST_HAS_NO_EXCEPTIONS
  if (is_going_to_throw) return;
#else
  try
#endif

41

also add `assert(is_going_to_throw);`

test/std/experimental/optional/optional.object/optional.object.ctor/move.pass.cpp

30

Some comments as above.

[rogfer01]

Updated with changes suggested by @EricWF

test/std/experimental/optional/optional.object/optional.object.assign/copy.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++98, c++03, c++11
-// XFAIL: libcpp-no-exceptions
 // <optional>
 
 // optional<T>& operator=(const optional<T>& rhs);
 
 #include <experimental/optional>
 #include <type_traits>
 #include <cassert>
 
+#include "test_macros.h"
+
 using std::experimental::optional;
 
 struct AllowConstAssign {
   AllowConstAssign(AllowConstAssign const&) {}
   AllowConstAssign const& operator=(AllowConstAssign const&) const {
       return *this;
   }
 };
 
 struct X
 {
     static bool throw_now;
 
     X() = default;
     X(const X&)
     {
         if (throw_now)
-            throw 6;
+            TEST_THROW(6);
     }
 };
 
 bool X::throw_now = false;
 
 int main()
 {
     {
int main()
         optional<int> opt(3);
         constexpr optional<int> opt2(2);
         opt = opt2;
         static_assert(static_cast<bool>(opt2) == true, "");
         static_assert(*opt2 == 2, "");
         assert(static_cast<bool>(opt) == static_cast<bool>(opt2));
         assert(*opt == *opt2);
     }
+#ifndef TEST_HAS_NO_EXCEPTIONS
     {
         optional<X> opt;
         optional<X> opt2(X{});
         assert(static_cast<bool>(opt2) == true);
         try
         {
             X::throw_now = true;
             opt = opt2;
             assert(false);
         }
         catch (int i)
         {
             assert(i == 6);
             assert(static_cast<bool>(opt) == false);
         }
     }
+#endif
 }

test/std/experimental/optional/optional.object/optional.object.assign/emplace.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++98, c++03, c++11
-// XFAIL: libcpp-no-exceptions
 // <optional>
 
 // template <class... Args> void optional<T>::emplace(Args&&... args);
 
 #include <experimental/optional>
 #include <type_traits>
 #include <cassert>
 #include <memory>
 
+#include "test_macros.h"
+
 using std::experimental::optional;
 
 class X
 {
     int i_;
     int j_ = 0;
 public:
     X() : i_(0) {}

 
 bool Y::dtor_called = false;
 
 class Z
 {
 public:
     static bool dtor_called;
     Z() = default;
-    Z(int) {throw 6;}
+    Z(int) {TEST_THROW(6);}
     ~Z() {dtor_called = true;}
 };
 
 bool Z::dtor_called = false;
 
 int main()
 {
     {
int main()
         Y y;
         {
             optional<Y> opt(y);
             assert(Y::dtor_called == false);
             opt.emplace();
             assert(Y::dtor_called == true);
         }
     }
+#ifndef TEST_HAS_NO_EXCEPTIONS
     {
         Z z;
         optional<Z> opt(z);
         try
         {
             assert(static_cast<bool>(opt) == true);
             assert(Z::dtor_called == false);
             opt.emplace(1);
         }
         catch (int i)
         {
             assert(i == 6);
             assert(static_cast<bool>(opt) == false);
             assert(Z::dtor_called == true);
         }
     }
+#endif
 }

test/std/experimental/optional/optional.object/optional.object.assign/emplace_initializer_list.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++98, c++03, c++11
-// XFAIL: libcpp-no-exceptions
 // <optional>
 
 // template <class U, class... Args>
 //   void optional<T>::emplace(initializer_list<U> il, Args&&... args);
 
 #include <experimental/optional>
 #include <type_traits>
 #include <cassert>
 #include <vector>
 
+#include "test_macros.h"
+
 using std::experimental::optional;
 
 class X
 {
     int i_;
     int j_ = 0;
 public:
     static bool dtor_called;

 {
     int i_;
     int j_ = 0;
 public:
     static bool dtor_called;
     constexpr Z() : i_(0) {}
     constexpr Z(int i) : i_(i) {}
     Z(std::initializer_list<int> il) : i_(il.begin()[0]), j_(il.begin()[1])
-        {throw 6;}
+        {TEST_THROW(6);}
     ~Z() {dtor_called = true;}
 
     friend constexpr bool operator==(const Z& x, const Z& y)
         {return x.i_ == y.i_ && x.j_ == y.j_;}
 };
 
 bool Z::dtor_called = false;
 
X::dtor_called = false;
         assert(*opt == std::vector<int>({1, 2, 3}));
     }
     {
         optional<Y> opt;
         opt.emplace({1, 2});
         assert(static_cast<bool>(opt) == true);
         assert(*opt == Y({1, 2}));
     }
+#ifndef TEST_HAS_NO_EXCEPTIONS
     {
         Z z;
         optional<Z> opt(z);
         try
         {
             assert(static_cast<bool>(opt) == true);
             assert(Z::dtor_called == false);
             opt.emplace({1, 2});
         }
         catch (int i)
         {
             assert(i == 6);
             assert(static_cast<bool>(opt) == false);
             assert(Z::dtor_called == true);
         }
     }
+#endif
 }

test/std/experimental/optional/optional.object/optional.object.assign/move.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++98, c++03, c++11
-// XFAIL: libcpp-no-exceptions
 // <optional>
 
 // optional<T>& operator=(optional<T>&& rhs)
 //     noexcept(is_nothrow_move_assignable<T>::value &&
 //              is_nothrow_move_constructible<T>::value);
 
 #include <experimental/optional>
 #include <type_traits>
 #include <cassert>
 
+#include "test_macros.h"
+
 using std::experimental::optional;
 
 struct AllowConstAssign {
   AllowConstAssign(AllowConstAssign const&) {}
   AllowConstAssign const& operator=(AllowConstAssign const&) const {
       return *this;
   }
 };
 
 struct X
 {
     static bool throw_now;
 
     X() = default;
     X(X&&)
     {
         if (throw_now)
-            throw 6;
+            TEST_THROW(6);
     }
     X& operator=(X&&) noexcept
     {
         return *this;
     }
 };
 
-struct Y {};
-
 bool X::throw_now = false;
 
+struct Y {};
+
 int main()
 {
     {
         static_assert(std::is_nothrow_move_assignable<optional<int>>::value, "");
         optional<int> opt;
         constexpr optional<int> opt2;
         opt = std::move(opt2);
         static_assert(static_cast<bool>(opt2) == false, "");
int main()
         assert(static_cast<bool>(opt) == static_cast<bool>(opt2));
         assert(*opt == *opt2);
     }
     {
         optional<const AllowConstAssign> opt;
         optional<const AllowConstAssign> opt2;
         opt = std::move(opt2);
     }
+#ifndef TEST_HAS_NO_EXCEPTIONS
     {
         static_assert(!std::is_nothrow_move_assignable<optional<X>>::value, "");
         optional<X> opt;
         optional<X> opt2(X{});
         assert(static_cast<bool>(opt2) == true);
         try
         {
             X::throw_now = true;
             opt = std::move(opt2);
             assert(false);
         }
         catch (int i)
         {
             assert(i == 6);
             assert(static_cast<bool>(opt) == false);
         }
     }
+#endif
     {
         static_assert(std::is_nothrow_move_assignable<optional<Y>>::value, "");
     }
 }

test/std/experimental/optional/optional.object/optional.object.ctor/const_T.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // UNSUPPORTED: c++98, c++03, c++11
-// XFAIL: libcpp-no-exceptions
 
 // <optional>
 
 // constexpr optional(const T& v);
 
 #include <experimental/optional>
 #include <type_traits>
 #include <cassert>
 
+#include "test_macros.h"
+
 using std::experimental::optional;
 
 class X
 {
     int i_;
 public:
     X(int i) : i_(i) {}
 
     friend bool operator==(const X& x, const X& y) {return x.i_ == y.i_;}
 };
 
 class Y
 {
     int i_;
 public:
     constexpr Y(int i) : i_(i) {}
 
     friend constexpr bool operator==(const Y& x, const Y& y) {return x.i_ == y.i_;}
 };
 
 class Z
 {
 public:
     Z(int)  {}
-    Z(const Z&) {throw 6;}
+    Z(const Z&) {TEST_THROW(6);}
 };
 
 
 int main()
 {
     {
         typedef int T;
         constexpr T t(5);
int main()
 
         struct test_constexpr_ctor
             : public optional<T>
         {
             constexpr test_constexpr_ctor(const T&) {}
         };
 
     }
+#ifndef TEST_HAS_NO_EXCEPTIONS
     {
         typedef Z T;
         try
         {
             const T t(3);
             optional<T> opt(t);
             assert(false);
         }
         catch (int i)
         {
             assert(i == 6);
         }
     }
+#endif
 }

test/std/experimental/optional/optional.object/optional.object.ctor/copy.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++98, c++03, c++11
-// XFAIL: libcpp-no-exceptions
 // <optional>
 
 // optional(const optional<T>& rhs);
 
 #include <experimental/optional>
 #include <type_traits>
 #include <cassert>
 
+#include "test_macros.h"
+
 using std::experimental::optional;
 
 template <class T>
 void
 test(const optional<T>& rhs, bool is_going_to_throw = false)
 {
     bool rhs_engaged = static_cast<bool>(rhs);
+#ifndef TEST_HAS_NO_EXCEPTIONS
     try
+#endif
     {
         optional<T> lhs = rhs;
         assert(is_going_to_throw == false);
         assert(static_cast<bool>(lhs) == rhs_engaged);
         if (rhs_engaged)
             assert(*lhs == *rhs);
     }
+#ifndef TEST_HAS_NO_EXCEPTIONS
     catch (int i)
     {
         assert(i == 6);
     }
+#endif
 }
 
 class X
 {
     int i_;
 public:
     X(int i) : i_(i) {}
     X(const X& x) : i_(x.i_) {}

 class Z
 {
     int i_;
 public:
     Z(int i) : i_(i) {}
     Z(const Z&)
     {
         if (++count == 2)
-            throw 6;
+            TEST_THROW(6);
     }
 
     friend constexpr bool operator==(const Z& x, const Z& y) {return x.i_ == y.i_;}
 };
 
 
 int main()
 {
int main()
         optional<T> rhs;
         test(rhs);
     }
     {
         typedef Y T;
         optional<T> rhs(Y(3));
         test(rhs);
     }
+#ifndef TEST_HAS_NO_EXCEPTIONS
     {
         typedef Z T;
         optional<T> rhs;
         test(rhs);
     }
     {
         typedef Z T;
         optional<T> rhs(Z(3));
         test(rhs, true);
     }
+#endif
 }

test/std/experimental/optional/optional.object/optional.object.ctor/in_place_t.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // UNSUPPORTED: c++98, c++03, c++11
-// XFAIL: libcpp-no-exceptions
 
 // <optional>
 
 // template <class... Args>
 //   constexpr explicit optional(in_place_t, Args&&... args);
 
 #include <experimental/optional>
 #include <type_traits>
 #include <cassert>
 
+#include "test_macros.h"
 
 using std::experimental::optional;
 using std::experimental::in_place_t;
 using std::experimental::in_place;
 
 class X
 {
     int i_;
public:
 
     friend constexpr bool operator==(const Y& x, const Y& y)
         {return x.i_ == y.i_ && x.j_ == y.j_;}
 };
 
 class Z
 {
 public:
-    Z(int i) {throw 6;}
+    Z(int i) {TEST_THROW(6);}
 };
 
 
 int main()
 {
     {
         constexpr optional<int> opt(in_place, 5);
         static_assert(static_cast<bool>(opt) == true, "");
int main()
         struct test_constexpr_ctor
             : public optional<Y>
         {
             constexpr test_constexpr_ctor(in_place_t, int i, int j)
                 : optional<Y>(in_place, i, j) {}
         };
 
     }
+#ifndef TEST_HAS_NO_EXCEPTIONS
     {
         try
         {
             const optional<Z> opt(in_place, 1);
             assert(false);
         }
         catch (int i)
         {
             assert(i == 6);
         }
     }
+#endif
 }

test/std/experimental/optional/optional.object/optional.object.ctor/initializer_list.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++98, c++03, c++11
-// XFAIL: libcpp-no-exceptions
 // <optional>
 
 // template <class U, class... Args>
 //     constexpr
 //     explicit optional(in_place_t, initializer_list<U> il, Args&&... args);
 
 #include <experimental/optional>
 #include <type_traits>
 #include <vector>
 #include <cassert>
 
+#include "test_macros.h"
+
 using std::experimental::optional;
 using std::experimental::in_place_t;
 using std::experimental::in_place;
 
 class X
 {
     int i_;
     int j_ = 0;

 class Z
 {
     int i_;
     int j_ = 0;
 public:
     constexpr Z() : i_(0) {}
     constexpr Z(int i) : i_(i) {}
     Z(std::initializer_list<int> il) : i_(il.begin()[0]), j_(il.begin()[1])
-        {throw 6;}
+        {TEST_THROW(6);}
 
     friend constexpr bool operator==(const Z& x, const Z& y)
         {return x.i_ == y.i_ && x.j_ == y.j_;}
 };
 
 int main()
 {
     {
int main()
         {
             constexpr test_constexpr_ctor(in_place_t, std::initializer_list<int> i)
                 : optional<Y>(in_place, i) {}
         };
 
         constexpr test_constexpr_ctor dopt(in_place, {42, 101, -1});
         static_assert(*dopt == Y{42, 101, -1}, "");
     }
+#ifndef TEST_HAS_NO_EXCEPTIONS
     {
         static_assert(std::is_constructible<optional<Z>, std::initializer_list<int>&>::value, "");
         try
         {
             optional<Z> opt(in_place, {3, 1});
             assert(false);
         }
         catch (int i)
         {
             assert(i == 6);
         }
     }
+#endif
 }

test/std/experimental/optional/optional.object/optional.object.ctor/move.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++98, c++03, c++11
-// XFAIL: libcpp-no-exceptions
 // <optional>
 
 // optional(optional<T>&& rhs) noexcept(is_nothrow_move_constructible<T>::value);
 
 #include <experimental/optional>
 #include <type_traits>
 #include <cassert>
 
+#include "test_macros.h"
+
 using std::experimental::optional;
 
 template <class T>
 void
 test(optional<T>& rhs, bool is_going_to_throw = false)
 {
     static_assert(std::is_nothrow_move_constructible<optional<T>>::value ==
                   std::is_nothrow_move_constructible<T>::value, "");
     bool rhs_engaged = static_cast<bool>(rhs);
+#ifndef TEST_HAS_NO_EXCEPTIONS
     try
+#endif
     {
         optional<T> lhs = std::move(rhs);
         assert(is_going_to_throw == false);
         assert(static_cast<bool>(lhs) == rhs_engaged);
     }
+#ifndef TEST_HAS_NO_EXCEPTIONS
     catch (int i)
     {
         assert(i == 6);
     }
+#endif
 }
 
 class X
 {
     int i_;
 public:
     X(int i) : i_(i) {}
     X(X&& x) : i_(x.i_) {x.i_ = 0;}

 class Z
 {
     int i_;
 public:
     Z(int i) : i_(i) {}
     Z(Z&&)
     {
         if (++count == 2)
-            throw 6;
+            TEST_THROW(6);
     }
 
     friend constexpr bool operator==(const Z& x, const Z& y) {return x.i_ == y.i_;}
 };
 
 
 class ConstMovable
 {
int main()
         optional<T> rhs;
         test(rhs);
     }
     {
         typedef Y T;
         optional<T> rhs(Y(3));
         test(rhs);
     }
+#ifndef TEST_HAS_NO_EXCEPTIONS
     {
         typedef Z T;
         optional<T> rhs;
         test(rhs);
     }
     {
         typedef Z T;
         optional<T> rhs(Z(3));
         test(rhs, true);
     }
+#endif
 }

test/std/experimental/optional/optional.object/optional.object.ctor/rvalue_T.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // UNSUPPORTED: c++98, c++03, c++11
-// XFAIL: libcpp-no-exceptions
 
 // <optional>
 
 // constexpr optional(T&& v);
 
 #include <experimental/optional>
 #include <type_traits>
 #include <cassert>
 
+#include "test_macros.h"
+
 using std::experimental::optional;
 
 class X
 {
     int i_;
 public:
     X(int i) : i_(i) {}
     X(X&& x) : i_(x.i_) {}
public:
 
     friend constexpr bool operator==(const Y& x, const Y& y) {return x.i_ == y.i_;}
 };
 
 class Z
 {
 public:
     Z(int) {}
-    Z(Z&&) {throw 6;}
+    Z(Z&&) {TEST_THROW(6);}
 };
 
 
 int main()
 {
     {
         typedef int T;
         constexpr optional<T> opt(T(5));
int main()
         static_assert(*opt == 3, "");
 
         struct test_constexpr_ctor
             : public optional<T>
         {
             constexpr test_constexpr_ctor(T&&) {}
         };
     }
+#ifndef TEST_HAS_NO_EXCEPTIONS
     {
         typedef Z T;
         try
         {
             optional<T> opt(T(3));
             assert(false);
         }
         catch (int i)
         {
             assert(i == 6);
         }
     }
+#endif
 }

test/std/experimental/optional/optional.object/optional.object.observe/value.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++98, c++03, c++11
-// XFAIL: libcpp-no-exceptions
 // <optional>
 
 // T& optional<T>::value();
 
 #include <experimental/optional>
 #include <type_traits>
 #include <cassert>
 
+#include "test_macros.h"
+
 using std::experimental::optional;
 using std::experimental::bad_optional_access;
 
 struct X
 {
     X() = default;
     X(const X&) = delete;
     constexpr int test() const {return 3;}
     int test() {return 4;}
 };
 
 int main()
 {
     {
         optional<X> opt;
         opt.emplace();
         assert(opt.value().test() == 4);
     }
+#ifndef TEST_HAS_NO_EXCEPTIONS
     {
         optional<X> opt;
         try
         {
             opt.value();
             assert(false);
         }
         catch (const bad_optional_access&)
         {
         }
     }
+#endif
 }

test/std/experimental/optional/optional.object/optional.object.observe/value_const.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++98, c++03, c++11
-// XFAIL: libcpp-no-exceptions
 // <optional>
 
 // constexpr const T& optional<T>::value() const;
 
 #include <experimental/optional>
 #include <type_traits>
 #include <cassert>
 
+#include "test_macros.h"
+
 using std::experimental::optional;
 using std::experimental::in_place_t;
 using std::experimental::in_place;
 using std::experimental::bad_optional_access;
 
 struct X
 {
     X() = default;
     X(const X&) = delete;
    constexpr int test() const {return 3;}
     int test() {return 4;}
 };
 
 int main()
 {
     {
         constexpr optional<X> opt(in_place);
         static_assert(opt.value().test() == 3, "");
     }
     {
         const optional<X> opt(in_place);
         assert(opt.value().test() == 3);
     }
+#ifndef TEST_HAS_NO_EXCEPTIONS
     {
         const optional<X> opt;
         try
         {
             opt.value();
             assert(false);
         }
         catch (const bad_optional_access&)
         {
         }
     }
+#endif
 }

test/std/experimental/optional/optional.object/optional.object.swap/swap.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++98, c++03, c++11
-// XFAIL: libcpp-no-exceptions
 // <optional>
 
 // void swap(optional&)
 //     noexcept(is_nothrow_move_constructible<T>::value &&
 //              noexcept(swap(declval<T&>(), declval<T&>())));
 
 #include <experimental/optional>
 #include <type_traits>
 #include <cassert>
 
+#include "test_macros.h"
+
 using std::experimental::optional;
 
 class X
 {
     int i_;
 public:
     static unsigned dtor_called;
     X(int i) : i_(i) {}

 
 unsigned Y::dtor_called = 0;
 
 class Z
 {
     int i_;
 public:
     Z(int i) : i_(i) {}
-    Z(Z&&) {throw 7;}
+    Z(Z&&) {TEST_THROW(7);}
 
     friend constexpr bool operator==(const Z& x, const Z& y) {return x.i_ == y.i_;}
-    friend void swap(Z& x, Z& y) {throw 6;}
+    friend void swap(Z& x, Z& y) {TEST_THROW(6);}
 };
 
 struct ConstSwappable {
 };
 void swap(ConstSwappable const&, ConstSwappable const&) {}
 
 int main()
 {
int main()
         Y::dtor_called = 0;
         opt1.swap(opt2);
         assert(Y::dtor_called == 0);
         assert(static_cast<bool>(opt1) == true);
         assert(*opt1 == 2);
         assert(static_cast<bool>(opt2) == true);
         assert(*opt2 == 1);
     }
+#ifndef TEST_HAS_NO_EXCEPTIONS
     {
         optional<Z> opt1;
         optional<Z> opt2;
         static_assert(noexcept(opt1.swap(opt2)) == false, "");
         assert(static_cast<bool>(opt1) == false);
         assert(static_cast<bool>(opt2) == false);
         opt1.swap(opt2);
         assert(static_cast<bool>(opt1) == false);
#ifndef TEST_HAS_NO_EXCEPTIONS
         {
             assert(i == 6);
         }
         assert(static_cast<bool>(opt1) == true);
         assert(*opt1 == 1);
         assert(static_cast<bool>(opt2) == true);
         assert(*opt2 == 2);
     }
+#endif
 }