diff --git a/libcxx/test/std/utilities/optional/optional.object/optional.object.ctor/U.pass.cpp b/libcxx/test/std/utilities/optional/optional.object/optional.object.ctor/U.pass.cpp
index 1e951ebdf1d74..61dfe1166a980 100644
--- a/libcxx/test/std/utilities/optional/optional.object/optional.object.ctor/U.pass.cpp
+++ b/libcxx/test/std/utilities/optional/optional.object/optional.object.ctor/U.pass.cpp
@@ -5,19 +5,18 @@
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
-//
+
 // UNSUPPORTED: c++03, c++11, c++14
 
 // <optional>
 
 // template <class U>
-//   constexpr EXPLICIT optional(U&& u);
+//   constexpr explicit optional(U&& u);
 
 #include <cassert>
 #include <optional>
 #include <type_traits>
 
-#include "test_macros.h"
 #include "archetypes.h"
 #include "test_convertible.h"
 
@@ -45,80 +44,47 @@ struct ImplicitAny {
 template <class To, class From>
 constexpr bool implicit_conversion(optional<To>&& opt, const From& v) {
   using O = optional<To>;
-  static_assert(test_convertible<O, From>(), "");
-  static_assert(!test_convertible<O, void*>(), "");
-  static_assert(!test_convertible<O, From, int>(), "");
-  return opt && *opt == static_cast<To>(v);
+  assert((test_convertible<O, From>()));
+  assert(!(test_convertible<O, void*>()));
+  assert(!(test_convertible<O, From, int>()));
+  assert(opt);
+  assert(*opt == static_cast<To>(v));
+
+  return true;
 }
 
 template <class To, class Input, class Expect>
 constexpr bool explicit_conversion(Input&& in, const Expect& v) {
   using O = optional<To>;
-  static_assert(std::is_constructible<O, Input>::value, "");
-  static_assert(!std::is_convertible<Input, O>::value, "");
-  static_assert(!std::is_constructible<O, void*>::value, "");
-  static_assert(!std::is_constructible<O, Input, int>::value, "");
+  assert((std::is_constructible<O, Input>::value));
+  assert(!(std::is_convertible<Input, O>::value));
+  assert(!(std::is_constructible<O, void*>::value));
+  assert(!(std::is_constructible<O, Input, int>::value));
+
   optional<To> opt(std::forward<Input>(in));
   optional<To> opt2{std::forward<Input>(in)};
-  return opt && *opt == static_cast<To>(v) && (opt2 && *opt2 == static_cast<To>(v));
+  assert(opt);
+  assert(opt2);
+  assert(*opt == static_cast<To>(v));
+  assert(*opt2 == static_cast<To>(v));
+
+  return true;
 }
 
 void test_implicit() {
-  {
-    static_assert(implicit_conversion<long long>(42, 42), "");
-  }
-  {
-    static_assert(implicit_conversion<long double>(3.14, 3.14), "");
-  }
-  {
-    int x = 42;
-    optional<void* const> o(&x);
-    assert(*o == &x);
-  }
-  {
-    using T = TrivialTestTypes::TestType;
-    static_assert(implicit_conversion<T>(42, 42), "");
-  }
-  {
-    using T = TestTypes::TestType;
-    assert(implicit_conversion<T>(3, T(3)));
-  }
   {
     using T = TestTypes::TestType;
     optional<T> opt({3});
     assert(opt && *opt == static_cast<T>(3));
   }
+
   {
-    using O = optional<ImplicitAny>;
-    static_assert(!test_convertible<O, std::in_place_t>(), "");
-    static_assert(!test_convertible<O, std::in_place_t&>(), "");
-    static_assert(!test_convertible<O, const std::in_place_t&>(), "");
-    static_assert(!test_convertible<O, std::in_place_t&&>(), "");
-    static_assert(!test_convertible<O, const std::in_place_t&&>(), "");
-  }
-#ifndef TEST_HAS_NO_EXCEPTIONS
-  {
-    try {
-      using T       = ImplicitThrow;
-      optional<T> t = 42;
-      assert(false);
-      ((void)t);
-    } catch (int) {
-    }
+    using T = TestTypes::TestType;
+    assert((implicit_conversion<T>(3, T(3))));
   }
-#endif
 }
 
 void test_explicit() {
-  {
-    using T = ExplicitTrivialTestTypes::TestType;
-    static_assert(explicit_conversion<T>(42, 42), "");
-  }
-  {
-    using T = ExplicitConstexprTestTypes::TestType;
-    static_assert(explicit_conversion<T>(42, 42), "");
-    static_assert(!std::is_convertible<int, T>::value, "");
-  }
   {
     using T = ExplicitTestTypes::TestType;
     T::reset();
@@ -137,7 +103,20 @@ void test_explicit() {
     }
     assert(T::alive == 0);
   }
+}
+
+TEST_CONSTEXPR_CXX26 void test_throwing() {
 #ifndef TEST_HAS_NO_EXCEPTIONS
+  {
+    try {
+      using T       = ImplicitThrow;
+      optional<T> t = 42;
+      assert(false);
+      ((void)t);
+    } catch (int) {
+    }
+  }
+
   {
     try {
       using T = ExplicitThrow;
@@ -149,9 +128,68 @@ void test_explicit() {
 #endif
 }
 
+constexpr bool test() {
+  {
+    assert((implicit_conversion<long long>(42, 42)));
+  }
+
+  {
+    assert((implicit_conversion<long double>(3.14, 3.14)));
+  }
+
+  {
+    int x = 42;
+    optional<void* const> o(&x);
+    assert(*o == &x);
+  }
+
+  {
+    using T = TrivialTestTypes::TestType;
+    assert((implicit_conversion<T>(42, 42)));
+  }
+
+  {
+    using O = optional<ImplicitAny>;
+    assert(!(test_convertible<O, std::in_place_t>()));
+    assert(!(test_convertible<O, std::in_place_t&>()));
+    assert(!(test_convertible<O, const std::in_place_t&>()));
+    assert(!(test_convertible<O, std::in_place_t&&>()));
+    assert(!(test_convertible<O, const std::in_place_t&&>()));
+  }
+
+  {
+    using T = ExplicitTrivialTestTypes::TestType;
+    assert((explicit_conversion<T>(42, 42)));
+  }
+
+  {
+    using T = ExplicitConstexprTestTypes::TestType;
+    assert(explicit_conversion<T>(42, 42));
+    assert(!(std::is_convertible<int, T>::value));
+  }
+
+#if TEST_STD_VER >= 26 && 0
+  test_throwing();
+#endif
+
+  return true;
+}
+
 int main(int, char**) {
-  test_implicit();
-  test_explicit();
+  test();
+  static_assert(test());
+
+  {
+    test_implicit();
+  }
+
+  {
+    test_explicit();
+  }
+
+  {
+    test_throwing();
+  }
 
   return 0;
 }
diff --git a/libcxx/test/std/utilities/optional/optional.object/optional.object.ctor/const_T.pass.cpp b/libcxx/test/std/utilities/optional/optional.object/optional.object.ctor/const_T.pass.cpp
index 67d0fcfc18b86..2f045bd19be77 100644
--- a/libcxx/test/std/utilities/optional/optional.object/optional.object.ctor/const_T.pass.cpp
+++ b/libcxx/test/std/utilities/optional/optional.object/optional.object.ctor/const_T.pass.cpp
@@ -5,7 +5,7 @@
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
-//
+
 // UNSUPPORTED: c++03, c++11, c++14
 
 // <optional>
@@ -20,35 +20,38 @@
 #include "archetypes.h"
 
 using std::optional;
+template <typename T, typename... Args>
+constexpr void test_ctor(Args... args) {
+  const T t(args...);
+  const std::optional<T> opt(t);
+
+  assert(static_cast<bool>(opt));
+  assert(*opt == t);
+
+  struct test_constexpr_ctor : public optional<T> {
+    constexpr test_constexpr_ctor(const T&) {}
+  };
+}
+
+constexpr bool test() {
+  test_ctor<int>(5);
+  test_ctor<double>(3.0);
+  test_ctor<const int>(42);
+  test_ctor<ConstexprTestTypes::TestType>(3);
 
-int main(int, char**) {
-  {
-    typedef int T;
-    constexpr T t(5);
-    constexpr optional<T> opt(t);
-    static_assert(static_cast<bool>(opt) == true, "");
-    static_assert(*opt == 5, "");
-
-    struct test_constexpr_ctor : public optional<T> {
-      constexpr test_constexpr_ctor(const T&) {}
-    };
-  }
-  {
-    typedef double T;
-    constexpr T t(3);
-    constexpr optional<T> opt(t);
-    static_assert(static_cast<bool>(opt) == true, "");
-    static_assert(*opt == 3, "");
-
-    struct test_constexpr_ctor : public optional<T> {
-      constexpr test_constexpr_ctor(const T&) {}
-    };
-  }
   {
-    const int x = 42;
-    optional<const int> o(x);
-    assert(*o == x);
+    using T = ExplicitConstexprTestTypes::TestType;
+    static_assert(!std::is_convertible_v<const T&, optional<T>>);
+    test_ctor<T>(3);
   }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
   {
     typedef TestTypes::TestType T;
     T::reset();
@@ -59,6 +62,7 @@ int main(int, char**) {
     assert(static_cast<bool>(opt) == true);
     assert(opt.value().value == 3);
   }
+
   {
     typedef ExplicitTestTypes::TestType T;
     static_assert(!std::is_convertible<T const&, optional<T>>::value, "");
@@ -70,29 +74,7 @@ int main(int, char**) {
     assert(static_cast<bool>(opt) == true);
     assert(opt.value().value == 3);
   }
-  {
-    typedef ConstexprTestTypes::TestType T;
-    constexpr T t(3);
-    constexpr optional<T> opt = {t};
-    static_assert(static_cast<bool>(opt) == true, "");
-    static_assert(opt.value().value == 3, "");
-
-    struct test_constexpr_ctor : public optional<T> {
-      constexpr test_constexpr_ctor(const T&) {}
-    };
-  }
-  {
-    typedef ExplicitConstexprTestTypes::TestType T;
-    static_assert(!std::is_convertible<const T&, optional<T>>::value, "");
-    constexpr T t(3);
-    constexpr optional<T> opt(t);
-    static_assert(static_cast<bool>(opt) == true, "");
-    static_assert(opt.value().value == 3, "");
-
-    struct test_constexpr_ctor : public optional<T> {
-      constexpr test_constexpr_ctor(const T&) {}
-    };
-  }
+
 #ifndef TEST_HAS_NO_EXCEPTIONS
   {
     struct Z {
diff --git a/libcxx/test/std/utilities/optional/optional.object/optional.object.ctor/const_optional_U.pass.cpp b/libcxx/test/std/utilities/optional/optional.object/optional.object.ctor/const_optional_U.pass.cpp
index 70fd76ec6ed0b..8f2105e409a8f 100644
--- a/libcxx/test/std/utilities/optional/optional.object/optional.object.ctor/const_optional_U.pass.cpp
+++ b/libcxx/test/std/utilities/optional/optional.object/optional.object.ctor/const_optional_U.pass.cpp
@@ -7,6 +7,7 @@
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14
+
 // <optional>
 
 // template <class U>
@@ -68,7 +69,7 @@ class Z {
   int i_;
 
 public:
-  Z(int i) : i_(i) { TEST_THROW(6); }
+  constexpr Z(int i) : i_(i) { TEST_THROW(6); }
 
   friend bool operator==(const Z& x, const Z& y) { return x.i_ == y.i_; }
 };
@@ -86,15 +87,21 @@ constexpr bool test_all() {
   return true;
 }
 
-int main(int, char**) {
+constexpr bool test() {
+  static_assert(!(std::is_constructible<optional<X>, const optional<Y>&>::value));
   test_all<int, short>();
   test_all<X, int>();
   test_all<Y, int>();
-#if TEST_STD_VER > 17
-  static_assert(test_all<int, short>());
-  static_assert(test_all<X, int>());
-  static_assert(test_all<Y, int>());
+
+// TODO: Enable once P3068R6 is implemented
+#if TEST_STD_VER >= 26 && 0
+  test_throwing();
 #endif
+
+  return true;
+}
+
+TEST_CONSTEXPR_CXX26 bool test_throwing() {
   {
     typedef Z T;
     typedef int U;
@@ -108,7 +115,18 @@ int main(int, char**) {
     test<T>(rhs, true);
   }
 
-  static_assert(!(std::is_constructible<optional<X>, const optional<Y>&>::value), "");
+  return true;
+}
+
+int main(int, char**) {
+  test();
+#if TEST_STD_VER >= 20
+  static_assert(test());
+#endif
+
+  {
+    test_throwing();
+  }
 
   return 0;
 }
diff --git a/libcxx/test/std/utilities/optional/optional.object/optional.object.ctor/copy.pass.cpp b/libcxx/test/std/utilities/optional/optional.object/optional.object.ctor/copy.pass.cpp
index f61a22c23a04d..0237cfd1ca596 100644
--- a/libcxx/test/std/utilities/optional/optional.object/optional.object.ctor/copy.pass.cpp
+++ b/libcxx/test/std/utilities/optional/optional.object/optional.object.ctor/copy.pass.cpp
@@ -7,6 +7,7 @@
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14
+
 // <optional>
 
 // constexpr optional(const optional<T>& rhs);
@@ -21,24 +22,18 @@
 using std::optional;
 
 template <class T, class... InitArgs>
-void test(InitArgs&&... args) {
-  const optional<T> rhs(std::forward<InitArgs>(args)...);
-  bool rhs_engaged = static_cast<bool>(rhs);
-  optional<T> lhs  = rhs;
-  assert(static_cast<bool>(lhs) == rhs_engaged);
-  if (rhs_engaged)
-    assert(*lhs == *rhs);
-}
+constexpr bool test(InitArgs&&... args) {
+  static_assert(std::is_trivially_copy_constructible_v<T> ==
+                std::is_trivially_copy_constructible_v<std::optional<T>>); // requirement
+  const optional<T> lhs(std::forward<InitArgs>(args)...);
+  optional<T> rhs(lhs);
+  assert(lhs.has_value() == rhs.has_value());
+  assert(lhs.has_value() ? *lhs == *rhs : true);
 
-template <class T, class... InitArgs>
-constexpr bool constexpr_test(InitArgs&&... args) {
-  static_assert(std::is_trivially_copy_constructible_v<T>, ""); // requirement
-  const optional<T> rhs(std::forward<InitArgs>(args)...);
-  optional<T> lhs = rhs;
-  return (lhs.has_value() == rhs.has_value()) && (lhs.has_value() ? *lhs == *rhs : true);
+  return true;
 }
 
-void test_throwing_ctor() {
+TEST_CONSTEXPR_CXX26 bool test_throwing_ctor() {
 #ifndef TEST_HAS_NO_EXCEPTIONS
   struct Z {
     Z() : count(0) {}
@@ -57,6 +52,8 @@ void test_throwing_ctor() {
     assert(i == 6);
   }
 #endif
+
+  return true;
 }
 
 template <class T, class... InitArgs>
@@ -69,8 +66,26 @@ void test_ref(InitArgs&&... args) {
     assert(&(*lhs) == &(*rhs));
 }
 
+#if TEST_STD_VER >= 26
+struct X {
+  int copy_count = 0;
+
+  constexpr X() {}
+  constexpr X(const X&) { copy_count++; }
+};
+
+constexpr void test_ref() {
+  {
+    X x{};
+    std::optional<X&> o1(x);
+    std::optional<X&> o2(o1);
+    assert(o1.has_value() && o2.has_value());
+    assert(x.copy_count == 0);
+    assert(&*o1 == &*o2);
+  }
+}
+
 void test_reference_extension() {
-#if defined(_LIBCPP_VERSION) && 0 // FIXME these extensions are currently disabled.
   using T = TestTypes::TestType;
   T::reset();
   {
@@ -99,24 +114,60 @@ void test_reference_extension() {
   }
   assert(T::alive == 0);
   assert(T::destroyed == 1);
+
+#  if 0 // FIXME: optional<T&&> is not allowed.
   {
-    static_assert(!std::is_copy_constructible<std::optional<T&&>>::value, "");
-    static_assert(!std::is_copy_constructible<std::optional<T const&&>>::value, "");
+    static_assert(!std::is_copy_constructible<std::optional<T&&>>::value);
+    static_assert(!std::is_copy_constructible<std::optional<T const&&>>::value);
   }
-#endif
+#  endif
 }
+#endif
 
-int main(int, char**) {
+constexpr bool test() {
   test<int>();
   test<int>(3);
-  static_assert(constexpr_test<int>(), "");
-  static_assert(constexpr_test<int>(3), "");
+  test<const int>(42);
+  test<TrivialTestTypes::TestType>();
+  test<TrivialTestTypes::TestType>(42);
 
+  // FIXME: Why is this in ctor copy.pass.cpp?
   {
-    const optional<const int> o(42);
-    optional<const int> o2(o);
-    assert(*o2 == 42);
+    constexpr std::optional<int> o1{4};
+    constexpr std::optional<int> o2 = o1;
+    static_assert(*o2 == 4, "");
   }
+
+  {
+    // LWG3836 https://wg21.link/LWG3836
+    // std::optional<bool> conversion constructor optional(const optional<U>&)
+    // should take precedence over optional(U&&) with operator bool
+    {
+      std::optional<bool> o1(false);
+      std::optional<bool> o2(o1);
+      assert(!o2.value());
+    }
+  }
+
+#if TEST_STD_VER >= 26
+  test_ref();
+
+  // TODO: Enable once P3068R6 is implemented
+#  if 0
+  test_throwing_ctor();
+#  endif
+#endif
+
+  return true;
+}
+
+void test_rt() {
+  { // FIXME: Shouldn't this be able to pass in a constexpr context since C++17?
+    using T = ConstexprTestTypes::TestType;
+    test<T>();
+    test<T>(42);
+  }
+
   {
     using T = TestTypes::TestType;
     T::reset();
@@ -126,7 +177,9 @@ int main(int, char**) {
     assert(lhs.has_value() == false);
     assert(T::alive == 0);
   }
+
   TestTypes::TestType::reset();
+
   {
     using T = TestTypes::TestType;
     T::reset();
@@ -139,36 +192,26 @@ int main(int, char**) {
     assert(T::copy_constructed == 1);
     assert(T::alive == 2);
   }
+
   TestTypes::TestType::reset();
-  {
-    using namespace ConstexprTestTypes;
-    test<TestType>();
-    test<TestType>(42);
-  }
-  {
-    using namespace TrivialTestTypes;
-    test<TestType>();
-    test<TestType>(42);
-  }
+
   {
     test_throwing_ctor();
   }
+
+#if TEST_STD_VER >= 26
   {
     test_reference_extension();
   }
-  {
-    constexpr std::optional<int> o1{4};
-    constexpr std::optional<int> o2 = o1;
-    static_assert(*o2 == 4, "");
-  }
+#endif
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
 
-  // LWG3836 https://wg21.link/LWG3836
-  // std::optional<bool> conversion constructor optional(const optional<U>&)
-  // should take precedence over optional(U&&) with operator bool
   {
-    std::optional<bool> o1(false);
-    std::optional<bool> o2(o1);
-    assert(!o2.value());
+    test_rt();
   }
 
   return 0;
diff --git a/libcxx/test/std/utilities/optional/optional.object/optional.object.ctor/ctor.verify.cpp b/libcxx/test/std/utilities/optional/optional.object/optional.object.ctor/ctor.verify.cpp
index 00ca941668eb2..10f3defbd6f44 100644
--- a/libcxx/test/std/utilities/optional/optional.object/optional.object.ctor/ctor.verify.cpp
+++ b/libcxx/test/std/utilities/optional/optional.object/optional.object.ctor/ctor.verify.cpp
@@ -7,6 +7,7 @@
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14
+
 // <optional>
 
 // T shall be an object type other than cv in_place_t or cv nullopt_t
@@ -23,30 +24,40 @@ struct NonDestructible {
 };
 
 int main(int, char**) {
-  // clang-format off
   {
 #if TEST_STD_VER >= 26
-    std::optional<int&&> opt2; // expected-error-re@optional:* {{static assertion failed{{.*}}instantiation of optional with an rvalue reference type is ill-formed}}
+    std::optional<int&&> opt2;
+    // expected-error-re@optional:* {{static assertion failed{{.*}}instantiation of optional with an rvalue reference type is ill-formed}}
 #else
-    std::optional<char&> o1; // expected-error-re@optional:* {{static assertion failed{{.*}}instantiation of optional with a reference type is ill-formed}}
+    std::optional<char&> o1;
+    // expected-error-re@optional:* {{static assertion failed{{.*}}instantiation of optional with a reference type is ill-formed}}
 #endif
-    std::optional<NonDestructible> o2; // expected-error-re@optional:* {{static assertion failed{{.*}}instantiation of optional with a non-destructible type is ill-formed}}
-    std::optional<char[20]> o3; // expected-error-re@optional:* {{static assertion failed{{.*}}instantiation of optional with an array type is ill-formed}}
+    std::optional<NonDestructible> o2;
+    // expected-error-re@optional:* {{static assertion failed{{.*}}instantiation of optional with a non-destructible type is ill-formed}}
+    std::optional<char[20]> o3;
+    // expected-error-re@optional:* {{static assertion failed{{.*}}instantiation of optional with an array type is ill-formed}}
   }
 
   {
-    std::optional<               std::in_place_t> o1; // expected-error-re@optional:* {{static assertion failed{{.*}}instantiation of optional with in_place_t is ill-formed}}
-    std::optional<const          std::in_place_t> o2; // expected-error-re@optional:* {{static assertion failed{{.*}}instantiation of optional with in_place_t is ill-formed}}
-    std::optional<      volatile std::in_place_t> o3; // expected-error-re@optional:* {{static assertion failed{{.*}}instantiation of optional with in_place_t is ill-formed}}
-    std::optional<const volatile std::in_place_t> o4; // expected-error-re@optional:* {{static assertion failed{{.*}}instantiation of optional with in_place_t is ill-formed}}
+    std::optional< std::in_place_t> o1;
+    // expected-error-re@optional:* {{static assertion failed{{.*}}instantiation of optional with in_place_t is ill-formed}}
+    std::optional<const std::in_place_t> o2;
+    // expected-error-re@optional:* {{static assertion failed{{.*}}instantiation of optional with in_place_t is ill-formed}}
+    std::optional< volatile std::in_place_t> o3;
+    // expected-error-re@optional:* {{static assertion failed{{.*}}instantiation of optional with in_place_t is ill-formed}}
+    std::optional<const volatile std::in_place_t> o4;
+    // expected-error-re@optional:* {{static assertion failed{{.*}}instantiation of optional with in_place_t is ill-formed}}
   }
 
   {
-    std::optional<               std::nullopt_t> o1; // expected-error-re@optional:* {{static assertion failed{{.*}}instantiation of optional with nullopt_t is ill-formed}}
-    std::optional<const          std::nullopt_t> o2; // expected-error-re@optional:* {{static assertion failed{{.*}}instantiation of optional with nullopt_t is ill-formed}}
-    std::optional<      volatile std::nullopt_t> o3; // expected-error-re@optional:* {{static assertion failed{{.*}}instantiation of optional with nullopt_t is ill-formed}}
-    std::optional<const volatile std::nullopt_t> o4; // expected-error-re@optional:* {{static assertion failed{{.*}}instantiation of optional with nullopt_t is ill-formed}}
+    std::optional< std::nullopt_t> o1;
+    // expected-error-re@optional:* {{static assertion failed{{.*}}instantiation of optional with nullopt_t is ill-formed}}
+    std::optional<const std::nullopt_t> o2;
+    // expected-error-re@optional:* {{static assertion failed{{.*}}instantiation of optional with nullopt_t is ill-formed}}
+    std::optional< volatile std::nullopt_t> o3;
+    // expected-error-re@optional:* {{static assertion failed{{.*}}instantiation of optional with nullopt_t is ill-formed}}
+    std::optional<const volatile std::nullopt_t> o4;
+    // expected-error-re@optional:* {{static assertion failed{{.*}}instantiation of optional with nullopt_t is ill-formed}}
   }
-  // clang-format on
   return 0;
 }
diff --git a/libcxx/test/std/utilities/optional/optional.object/optional.object.ctor/deduct.pass.cpp b/libcxx/test/std/utilities/optional/optional.object/optional.object.ctor/deduct.pass.cpp
index bc1d26aa8bd18..1d7707a6d3f05 100644
--- a/libcxx/test/std/utilities/optional/optional.object/optional.object.ctor/deduct.pass.cpp
+++ b/libcxx/test/std/utilities/optional/optional.object/optional.object.ctor/deduct.pass.cpp
@@ -6,8 +6,9 @@
 //
 //===----------------------------------------------------------------------===//
 
+// REQUIRES: std-at-least-c++17
+
 // <optional>
-// UNSUPPORTED: c++03, c++11, c++14
 
 // template<class T>
 //   optional(T) -> optional<T>;
@@ -17,47 +18,41 @@
 
 #include "test_macros.h"
 
-struct A {};
+struct A {
+  friend constexpr bool operator==(const A&, const A&) { return true; }
+};
 
-int main(int, char**) {
-  //  Test the explicit deduction guides
-  {
-    //  optional(T)
-    std::optional opt(5);
-    ASSERT_SAME_TYPE(decltype(opt), std::optional<int>);
-    assert(static_cast<bool>(opt));
-    assert(*opt == 5);
-  }
+template <typename T>
+constexpr void test_deduct(T arg) {
+  std::optional opt(arg);
 
-  {
-    //  optional(T)
-    std::optional opt(A{});
-    ASSERT_SAME_TYPE(decltype(opt), std::optional<A>);
-    assert(static_cast<bool>(opt));
-  }
+  ASSERT_SAME_TYPE(decltype(opt), std::optional<T>);
+  assert(static_cast<bool>(opt));
+  assert(*opt == arg);
+}
+
+constexpr bool test() {
+  //  optional(T)
+  test_deduct<int>(5);
+  test_deduct<A>(A{});
 
   {
     //  optional(const T&);
     const int& source = 5;
-    std::optional opt(source);
-    ASSERT_SAME_TYPE(decltype(opt), std::optional<int>);
-    assert(static_cast<bool>(opt));
-    assert(*opt == 5);
+    test_deduct<int>(source);
   }
 
   {
     //  optional(T*);
     const int* source = nullptr;
-    std::optional opt(source);
-    ASSERT_SAME_TYPE(decltype(opt), std::optional<const int*>);
-    assert(static_cast<bool>(opt));
-    assert(*opt == nullptr);
+    test_deduct<const int*>(source);
   }
 
   {
     //  optional(T[]);
     int source[] = {1, 2, 3};
     std::optional opt(source);
+
     ASSERT_SAME_TYPE(decltype(opt), std::optional<int*>);
     assert(static_cast<bool>(opt));
     assert((*opt)[0] == 1);
@@ -68,10 +63,18 @@ int main(int, char**) {
     //  optional(optional);
     std::optional<char> source('A');
     std::optional opt(source);
+
     ASSERT_SAME_TYPE(decltype(opt), std::optional<char>);
     assert(static_cast<bool>(opt) == static_cast<bool>(source));
     assert(*opt == *source);
   }
 
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
   return 0;
 }
diff --git a/libcxx/test/std/utilities/optional/optional.object/optional.object.ctor/deduct.verify.cpp b/libcxx/test/std/utilities/optional/optional.object/optional.object.ctor/deduct.verify.cpp
index 7ab842bf68c51..5616b2e0676e3 100644
--- a/libcxx/test/std/utilities/optional/optional.object/optional.object.ctor/deduct.verify.cpp
+++ b/libcxx/test/std/utilities/optional/optional.object/optional.object.ctor/deduct.verify.cpp
@@ -19,10 +19,6 @@
 struct A {};
 
 int main(int, char**) {
-  //  Test the explicit deduction guides
-
-  //  Test the implicit deduction guides
-
   // clang-format off
   {
     //  optional()
diff --git a/libcxx/test/std/utilities/optional/optional.object/optional.object.ctor/default.pass.cpp b/libcxx/test/std/utilities/optional/optional.object/optional.object.ctor/default.pass.cpp
index 71d4d052da3b7..6fdf8d8898e38 100644
--- a/libcxx/test/std/utilities/optional/optional.object/optional.object.ctor/default.pass.cpp
+++ b/libcxx/test/std/utilities/optional/optional.object/optional.object.ctor/default.pass.cpp
@@ -7,6 +7,7 @@
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14
+
 // <optional>
 
 // constexpr optional() noexcept;
@@ -18,56 +19,64 @@
 #include "test_macros.h"
 #include "archetypes.h"
 
-using std::optional;
-
-template <class Opt>
-void test_constexpr() {
-  static_assert(std::is_nothrow_default_constructible<Opt>::value, "");
-  static_assert(std::is_trivially_destructible<Opt>::value, "");
-  static_assert(std::is_trivially_destructible<typename Opt::value_type>::value, "");
-
-  constexpr Opt opt;
-  static_assert(static_cast<bool>(opt) == false, "");
+template <class T>
+constexpr void test() {
+  static_assert(std::is_nothrow_default_constructible_v<std::optional<T>>);
+  static_assert(std::is_trivially_destructible_v<T> == std::is_trivially_destructible_v<std::optional<T>>);
 
-  struct test_constexpr_ctor : public Opt {
-    constexpr test_constexpr_ctor() {}
-  };
-}
+  if constexpr (!std::is_lvalue_reference_v<T>) {
+    static_assert(
+        std::is_trivially_destructible_v<T> == std::is_trivially_destructible_v<typename std::optional<T>::value_type>);
+  }
 
-template <class Opt>
-void test() {
-  static_assert(std::is_nothrow_default_constructible<Opt>::value, "");
-  static_assert(!std::is_trivially_destructible<Opt>::value, "");
-  static_assert(!std::is_trivially_destructible<typename Opt::value_type>::value, "");
   {
-    Opt opt;
+    std::optional<T> opt;
     assert(static_cast<bool>(opt) == false);
   }
   {
-    const Opt opt;
+    const std::optional<T> opt;
     assert(static_cast<bool>(opt) == false);
   }
 
-  struct test_constexpr_ctor : public Opt {
+  struct test_constexpr_ctor : public std::optional<T> {
     constexpr test_constexpr_ctor() {}
   };
 }
 
-int main(int, char**) {
-  test_constexpr<optional<int>>();
-  test_constexpr<optional<int*>>();
-  test_constexpr<optional<ImplicitTypes::NoCtors>>();
-  test_constexpr<optional<NonTrivialTypes::NoCtors>>();
-  test_constexpr<optional<NonConstexprTypes::NoCtors>>();
-  test<optional<NonLiteralTypes::NoCtors>>();
-  // EXTENSIONS
-#if defined(_LIBCPP_VERSION) && 0 // FIXME these extensions are currently disabled.
-  test_constexpr<optional<int&>>();
-  test_constexpr<optional<const int&>>();
-  test_constexpr<optional<int&>>();
-  test_constexpr<optional<NonLiteralTypes::NoCtors&>>();
-  test_constexpr<optional<NonLiteralTypes::NoCtors&&>>();
+TEST_CONSTEXPR_CXX23 void non_literal_test() {
+  test<NonLiteralTypes::NoCtors>();
+  test<NonLiteralTypes::NoCtors>();
+}
+
+constexpr bool test() {
+  test<int>();
+  test<int*>();
+  test<ImplicitTypes::NoCtors>();
+  test<NonTrivialTypes::NoCtors>();
+  test<NonConstexprTypes::NoCtors>();
+#if TEST_STD_VER >= 23
+  non_literal_test();
+#endif
+#if TEST_STD_VER >= 26
+  test<int&>();
+  test<const int&>();
+  test<int&>();
+  test<NonLiteralTypes::NoCtors&>();
+// TODO: optional<T&&> is not allowed.
+#  if 0
+  test<NonLiteralTypes::NoCtors&&>();
+#  endif
 #endif
 
+  return true;
+}
+
+int main(int, char**) {
+  assert(test());
+  static_assert(test());
+
+  {
+    non_literal_test();
+  }
   return 0;
 }
diff --git a/libcxx/test/std/utilities/optional/optional.object/optional.object.ctor/empty_in_place_t_does_not_clobber.pass.cpp b/libcxx/test/std/utilities/optional/optional.object/optional.object.ctor/empty_in_place_t_does_not_clobber.pass.cpp
index f19174841813c..c624911cb8c25 100644
--- a/libcxx/test/std/utilities/optional/optional.object/optional.object.ctor/empty_in_place_t_does_not_clobber.pass.cpp
+++ b/libcxx/test/std/utilities/optional/optional.object/optional.object.ctor/empty_in_place_t_does_not_clobber.pass.cpp
@@ -7,6 +7,7 @@
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14
+
 // <optional>
 
 // constexpr optional(in_place_t);
diff --git a/libcxx/test/std/utilities/optional/optional.object/optional.object.ctor/explicit_const_optional_U.pass.cpp b/libcxx/test/std/utilities/optional/optional.object/optional.object.ctor/explicit_const_optional_U.pass.cpp
index 1b9882fb25633..3f8bfb3a60e5e 100644
--- a/libcxx/test/std/utilities/optional/optional.object/optional.object.ctor/explicit_const_optional_U.pass.cpp
+++ b/libcxx/test/std/utilities/optional/optional.object/optional.object.ctor/explicit_const_optional_U.pass.cpp
@@ -7,6 +7,7 @@
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14
+
 // <optional>
 
 // template <class U>
@@ -22,7 +23,7 @@ using std::optional;
 
 template <class T, class U>
 TEST_CONSTEXPR_CXX20 void test(const optional<U>& rhs, bool is_going_to_throw = false) {
-  static_assert(!(std::is_convertible<const optional<U>&, optional<T>>::value), "");
+  static_assert(!(std::is_convertible<const optional<U>&, optional<T>>::value));
   bool rhs_engaged = static_cast<bool>(rhs);
 #ifndef TEST_HAS_NO_EXCEPTIONS
   try {
@@ -69,9 +70,9 @@ class Z {
   int i_;
 
 public:
-  explicit Z(int i) : i_(i) { TEST_THROW(6); }
+  constexpr explicit Z(int i) : i_(i) { TEST_THROW(6); }
 
-  friend bool operator==(const Z& x, const Z& y) { return x.i_ == y.i_; }
+  friend constexpr bool operator==(const Z& x, const Z& y) { return x.i_ == y.i_; }
 };
 
 template <class T, class U>
@@ -87,13 +88,7 @@ constexpr bool test_all() {
   return true;
 }
 
-int main(int, char**) {
-  test_all<X, int>();
-  test_all<Y, int>();
-#if TEST_STD_VER > 17
-  static_assert(test_all<X, int>());
-  static_assert(test_all<Y, int>());
-#endif
+TEST_CONSTEXPR_CXX26 bool test_throwing() {
   {
     typedef Z T;
     typedef int U;
@@ -107,5 +102,28 @@ int main(int, char**) {
     test<T>(rhs, true);
   }
 
+  return true;
+}
+
+TEST_CONSTEXPR_CXX20 bool test() {
+  test_all<X, int>();
+  test_all<Y, int>();
+
+// TODO: Enable once P3068R6 is implemented
+#if TEST_STD_VER >= 26 && 0
+  test_throwing();
+#endif
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+#if TEST_STD_VER >= 20
+  static_assert(test());
+#endif
+  {
+    test_throwing();
+  }
   return 0;
 }
diff --git a/libcxx/test/std/utilities/optional/optional.object/optional.object.ctor/explicit_optional_U.pass.cpp b/libcxx/test/std/utilities/optional/optional.object/optional.object.ctor/explicit_optional_U.pass.cpp
index bddbd4ba93d5a..07e36a54872c4 100644
--- a/libcxx/test/std/utilities/optional/optional.object/optional.object.ctor/explicit_optional_U.pass.cpp
+++ b/libcxx/test/std/utilities/optional/optional.object/optional.object.ctor/explicit_optional_U.pass.cpp
@@ -7,6 +7,7 @@
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14
+
 // <optional>
 
 // template <class U>
@@ -22,7 +23,7 @@ using std::optional;
 
 template <class T, class U>
 TEST_CONSTEXPR_CXX20 void test(optional<U>&& rhs, bool is_going_to_throw = false) {
-  static_assert(!(std::is_convertible<optional<U>&&, optional<T>>::value), "");
+  static_assert(!(std::is_convertible<optional<U>&&, optional<T>>::value));
   bool rhs_engaged = static_cast<bool>(rhs);
 #ifndef TEST_HAS_NO_EXCEPTIONS
   try {
@@ -57,6 +58,19 @@ class Z {
   explicit Z(int) { TEST_THROW(6); }
 };
 
+TEST_CONSTEXPR_CXX26 bool test_throwing() {
+  {
+    optional<int> rhs;
+    test<Z>(std::move(rhs));
+  }
+  {
+    optional<int> rhs(3);
+    test<Z>(std::move(rhs), true);
+  }
+
+  return true;
+}
+
 TEST_CONSTEXPR_CXX20 bool test() {
   {
     optional<int> rhs;
@@ -67,21 +81,23 @@ TEST_CONSTEXPR_CXX20 bool test() {
     test<X>(std::move(rhs));
   }
 
+  {
+// TODO: Enable once P3068R6 is implemented
+#if TEST_STD_VER >= 26 && 0
+    test_throwing();
+#endif
+  }
+
   return true;
 }
 
 int main(int, char**) {
-#if TEST_STD_VER > 17
+  test();
+#if TEST_STD_VER >= 20
   static_assert(test());
 #endif
-  test();
   {
-    optional<int> rhs;
-    test<Z>(std::move(rhs));
-  }
-  {
-    optional<int> rhs(3);
-    test<Z>(std::move(rhs), true);
+    test_throwing();
   }
 
   return 0;
diff --git a/libcxx/test/std/utilities/optional/optional.object/optional.object.ctor/in_place_t.pass.cpp b/libcxx/test/std/utilities/optional/optional.object/optional.object.ctor/in_place_t.pass.cpp
index 902754418fbde..2b78968ae521c 100644
--- a/libcxx/test/std/utilities/optional/optional.object/optional.object.ctor/in_place_t.pass.cpp
+++ b/libcxx/test/std/utilities/optional/optional.object/optional.object.ctor/in_place_t.pass.cpp
@@ -5,7 +5,7 @@
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
-//
+
 // UNSUPPORTED: c++03, c++11, c++14
 
 // <optional>
@@ -16,6 +16,7 @@
 #include <cassert>
 #include <optional>
 #include <type_traits>
+#include <utility>
 
 #include "test_macros.h"
 
@@ -28,25 +29,13 @@ class X {
   int j_ = 0;
 
 public:
-  X() : i_(0) {}
-  X(int i) : i_(i) {}
-  X(int i, int j) : i_(i), j_(j) {}
-
-  ~X() {}
-
-  friend bool operator==(const X& x, const X& y) { return x.i_ == y.i_ && x.j_ == y.j_; }
-};
+  constexpr X() : i_(0) {}
+  constexpr X(int i) : i_(i) {}
+  constexpr X(int i, int j) : i_(i), j_(j) {}
 
-class Y {
-  int i_;
-  int j_ = 0;
+  ~X() = default;
 
-public:
-  constexpr Y() : i_(0) {}
-  constexpr Y(int i) : i_(i) {}
-  constexpr Y(int i, int j) : i_(i), j_(j) {}
-
-  friend constexpr bool operator==(const Y& x, const Y& y) { return x.i_ == y.i_ && x.j_ == y.j_; }
+  friend constexpr bool operator==(const X& x, const X& y) { return x.i_ == y.i_ && x.j_ == y.j_; }
 };
 
 class Z {
@@ -54,62 +43,18 @@ class Z {
   Z(int) { TEST_THROW(6); }
 };
 
-int main(int, char**) {
-  {
-    constexpr optional<int> opt(in_place, 5);
-    static_assert(static_cast<bool>(opt) == true, "");
-    static_assert(*opt == 5, "");
+template <typename T, typename... Args>
+constexpr void test_inplace(Args... args) {
+  optional<T> opt(in_place, args...);
+  assert(bool(opt));
+  assert(*opt == T(args...));
 
-    struct test_constexpr_ctor : public optional<int> {
-      constexpr test_constexpr_ctor(in_place_t, int i) : optional<int>(in_place, i) {}
-    };
-  }
-  {
-    optional<const int> opt(in_place, 5);
-    assert(*opt == 5);
-  }
-  {
-    const optional<X> opt(in_place);
-    assert(static_cast<bool>(opt) == true);
-    assert(*opt == X());
-  }
-  {
-    const optional<X> opt(in_place, 5);
-    assert(static_cast<bool>(opt) == true);
-    assert(*opt == X(5));
-  }
-  {
-    const optional<X> opt(in_place, 5, 4);
-    assert(static_cast<bool>(opt) == true);
-    assert(*opt == X(5, 4));
-  }
-  {
-    constexpr optional<Y> opt(in_place);
-    static_assert(static_cast<bool>(opt) == true, "");
-    static_assert(*opt == Y(), "");
-
-    struct test_constexpr_ctor : public optional<Y> {
-      constexpr test_constexpr_ctor(in_place_t) : optional<Y>(in_place) {}
-    };
-  }
-  {
-    constexpr optional<Y> opt(in_place, 5);
-    static_assert(static_cast<bool>(opt) == true, "");
-    static_assert(*opt == Y(5), "");
-
-    struct test_constexpr_ctor : public optional<Y> {
-      constexpr test_constexpr_ctor(in_place_t, int i) : optional<Y>(in_place, i) {}
-    };
-  }
-  {
-    constexpr optional<Y> opt(in_place, 5, 4);
-    static_assert(static_cast<bool>(opt) == true, "");
-    static_assert(*opt == Y(5, 4), "");
+  struct test_constexpr_ctor : public optional<int> {
+    constexpr test_constexpr_ctor(in_place_t, int i) : optional<int>(in_place, i) {}
+  };
+}
 
-    struct test_constexpr_ctor : public optional<Y> {
-      constexpr test_constexpr_ctor(in_place_t, int i, int j) : optional<Y>(in_place, i, j) {}
-    };
-  }
+TEST_CONSTEXPR_CXX26 void test_throwing() {
 #ifndef TEST_HAS_NO_EXCEPTIONS
   {
     try {
@@ -120,6 +65,26 @@ int main(int, char**) {
     }
   }
 #endif
+}
+
+constexpr bool test() {
+  test_inplace<int>(5);
+  test_inplace<const int>(5);
+  test_inplace<X>();
+  test_inplace<X>(5);
+  test_inplace<X>(5, 4);
+#if TEST_STD_VER >= 26 && 0
+  test_throwing();
+#endif
+  return true;
+}
 
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  {
+    test_throwing();
+  }
   return 0;
 }
diff --git a/libcxx/test/std/utilities/optional/optional.object/optional.object.ctor/initializer_list.pass.cpp b/libcxx/test/std/utilities/optional/optional.object/optional.object.ctor/initializer_list.pass.cpp
index 1993476792878..be1edc8f6c190 100644
--- a/libcxx/test/std/utilities/optional/optional.object/optional.object.ctor/initializer_list.pass.cpp
+++ b/libcxx/test/std/utilities/optional/optional.object/optional.object.ctor/initializer_list.pass.cpp
@@ -7,6 +7,7 @@
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14
+
 // <optional>
 
 // template <class U, class... Args>
diff --git a/libcxx/test/std/utilities/optional/optional.object/optional.object.ctor/move.pass.cpp b/libcxx/test/std/utilities/optional/optional.object/optional.object.ctor/move.pass.cpp
index 583debcaac650..b4df9c4e43bbb 100644
--- a/libcxx/test/std/utilities/optional/optional.object/optional.object.ctor/move.pass.cpp
+++ b/libcxx/test/std/utilities/optional/optional.object/optional.object.ctor/move.pass.cpp
@@ -22,26 +22,20 @@
 using std::optional;
 
 template <class T, class... InitArgs>
-void test(InitArgs&&... args) {
+constexpr bool test(InitArgs&&... args) {
+  static_assert(std::is_trivially_move_constructible_v<T> == std::is_trivially_move_constructible_v<std::optional<T>>);
   const optional<T> orig(std::forward<InitArgs>(args)...);
-  optional<T> rhs(orig);
-  bool rhs_engaged = static_cast<bool>(rhs);
-  optional<T> lhs  = std::move(rhs);
-  assert(static_cast<bool>(lhs) == rhs_engaged);
-  if (rhs_engaged)
-    assert(*lhs == *orig);
-}
 
-template <class T, class... InitArgs>
-constexpr bool constexpr_test(InitArgs&&... args) {
-  static_assert(std::is_trivially_copy_constructible_v<T>, ""); // requirement
-  const optional<T> orig(std::forward<InitArgs>(args)...);
-  optional<T> rhs(orig);
-  optional<T> lhs = std::move(rhs);
-  return (lhs.has_value() == orig.has_value()) && (lhs.has_value() ? *lhs == *orig : true);
+  optional<T> lhs(orig);
+  optional<T> rhs(std::move(lhs));
+
+  assert(lhs.has_value() == rhs.has_value());
+  assert(lhs.has_value() ? *rhs == *orig : true);
+
+  return true;
 }
 
-void test_throwing_ctor() {
+TEST_CONSTEXPR_CXX26 void test_throwing_ctor() {
 #ifndef TEST_HAS_NO_EXCEPTIONS
   struct Z {
     Z() : count(0) {}
@@ -65,15 +59,33 @@ void test_throwing_ctor() {
 template <class T, class... InitArgs>
 void test_ref(InitArgs&&... args) {
   optional<T> rhs(std::forward<InitArgs>(args)...);
-  bool rhs_engaged = static_cast<bool>(rhs);
-  optional<T> lhs  = std::move(rhs);
-  assert(static_cast<bool>(lhs) == rhs_engaged);
-  if (rhs_engaged)
-    assert(&(*lhs) == &(*rhs));
+  optional<T> lhs(std::move(rhs));
+
+  assert(lhs.has_value() == rhs.has_value());
+  assert(rhs.has_value() ? &*lhs == &*rhs : true);
 }
 
-void test_reference_extension() {
+struct F {
+  int move_count = 0;
+
+  constexpr F() {}
+  constexpr F(F&&) { move_count++; }
+};
+
 #if TEST_STD_VER >= 26
+
+constexpr void test_ref() {
+  { // Test that moving from an optional<T&> doesn't also move the object it's referencing
+    F f{};
+    std::optional<F&> o1(f);
+    std::optional<F&> o2(std::move(o1));
+    assert(f.move_count == 0);
+    assert(o1.has_value() && o2.has_value());
+    assert(&*o1 == &*o2);
+  }
+}
+
+void test_reference_extension() {
   using T = TestTypes::TestType;
   T::reset();
   {
@@ -134,20 +146,34 @@ void test_reference_extension() {
     static_assert(!std::is_copy_constructible_v<std::optional<T const&&>>);
   }
 #  endif
-#endif
 }
+#endif
 
-int main(int, char**) {
+constexpr bool test() {
   test<int>();
   test<int>(3);
-  static_assert(constexpr_test<int>(), "");
-  static_assert(constexpr_test<int>(3), "");
+  test<const int>(42);
 
   {
-    optional<const int> o(42);
-    optional<const int> o2(std::move(o));
-    assert(*o2 == 42);
+    using T = TrivialTestTypes::TestType;
+    test<T>();
+    test<T>(42);
   }
+
+#if TEST_STD_VER >= 26
+  test_ref();
+#endif
+
+#if TEST_STD_VER >= 26 && 0
+  {
+    test_throwing_ctor();
+  }
+#endif
+
+  return true;
+}
+
+bool test_rt() {
   {
     using T = TestTypes::TestType;
     T::reset();
@@ -158,7 +184,9 @@ int main(int, char**) {
     assert(rhs.has_value() == false);
     assert(T::alive == 0);
   }
+
   TestTypes::TestType::reset();
+
   {
     using T = TestTypes::TestType;
     T::reset();
@@ -174,20 +202,15 @@ int main(int, char**) {
     assert(T::move_constructed == 1);
     assert(T::alive == 2);
   }
+
   TestTypes::TestType::reset();
-  {
+
+  { // TODO: Why doesn't this pass in a C++17 constexpr context?
     using namespace ConstexprTestTypes;
     test<TestType>();
     test<TestType>(42);
   }
-  {
-    using namespace TrivialTestTypes;
-    test<TestType>();
-    test<TestType>(42);
-  }
-  {
-    test_throwing_ctor();
-  }
+
   {
     struct ThrowsMove {
       ThrowsMove() noexcept(false) {}
@@ -202,13 +225,26 @@ int main(int, char**) {
     };
     static_assert(std::is_nothrow_move_constructible<optional<NoThrowMove>>::value, "");
   }
+
+  {
+    test_throwing_ctor();
+  }
+
+#if TEST_STD_VER >= 26
   {
     test_reference_extension();
   }
+#endif
+
+  return true;
+}
+
+int main(int, char**) {
+  assert(test());
+  static_assert(test());
+
   {
-    constexpr std::optional<int> o1{4};
-    constexpr std::optional<int> o2 = std::move(o1);
-    static_assert(*o2 == 4, "");
+    test_rt();
   }
 
   return 0;
diff --git a/libcxx/test/std/utilities/optional/optional.object/optional.object.ctor/nullopt_t.pass.cpp b/libcxx/test/std/utilities/optional/optional.object/optional.object.ctor/nullopt_t.pass.cpp
index c1bdd81e5ed47..60db025c3ffaa 100644
--- a/libcxx/test/std/utilities/optional/optional.object/optional.object.ctor/nullopt_t.pass.cpp
+++ b/libcxx/test/std/utilities/optional/optional.object/optional.object.ctor/nullopt_t.pass.cpp
@@ -7,6 +7,7 @@
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14
+
 // <optional>
 
 // constexpr optional(nullopt_t) noexcept;
@@ -19,49 +20,56 @@
 
 #include "test_macros.h"
 
-using std::nullopt;
-using std::nullopt_t;
-using std::optional;
-
-template <class Opt>
-void test_constexpr() {
-  static_assert(std::is_nothrow_constructible<Opt, nullopt_t&>::value, "");
-  static_assert(std::is_trivially_destructible<Opt>::value, "");
-  static_assert(std::is_trivially_destructible<typename Opt::value_type>::value, "");
+template <class T>
+constexpr void test() {
+  static_assert(std::is_nothrow_constructible_v<std::optional<T>, std::nullopt_t&>);
+  static_assert(std::is_trivially_destructible_v<T> == std::is_trivially_destructible_v<std::optional<T>>);
+  static_assert(
+      std::is_trivially_destructible_v<T> == std::is_trivially_destructible_v<typename std::optional<T>::value_type>);
 
-  constexpr Opt opt(nullopt);
-  static_assert(static_cast<bool>(opt) == false, "");
+  constexpr std::optional<T> opt(std::nullopt);
+  assert(!static_cast<bool>(opt));
 
-  struct test_constexpr_ctor : public Opt {
+  struct test_constexpr_ctor : public std::optional<T> {
     constexpr test_constexpr_ctor() {}
   };
 }
 
-template <class Opt>
-void test() {
-  static_assert(std::is_nothrow_constructible<Opt, nullopt_t&>::value, "");
-  static_assert(!std::is_trivially_destructible<Opt>::value, "");
-  static_assert(!std::is_trivially_destructible<typename Opt::value_type>::value, "");
-  {
-    Opt opt(nullopt);
-    assert(static_cast<bool>(opt) == false);
-  }
-  {
-    const Opt opt(nullopt);
-    assert(static_cast<bool>(opt) == false);
-  }
-  struct test_constexpr_ctor : public Opt {
-    constexpr test_constexpr_ctor() {}
-  };
+template <class T>
+TEST_CONSTEXPR_CXX23 void rt_test() {
+  static_assert(std::is_nothrow_constructible_v<std::optional<T>, std::nullopt_t&>);
+  static_assert(std::is_trivially_destructible_v<T> == std::is_trivially_destructible_v<std::optional<T>>);
+  static_assert(
+      std::is_trivially_destructible_v<T> == std::is_trivially_destructible_v<typename std::optional<T>::value_type>);
+
+  const std::optional<T> opt(std::nullopt);
+  assert(!static_cast<bool>(opt));
+}
+
+TEST_CONSTEXPR_CXX23 bool test_non_literal() {
+  rt_test<NonLiteralTypes::NoCtors>();
+  return true;
+}
+
+constexpr bool test() {
+  test<int>();
+  test<int*>();
+  test<ImplicitTypes::NoCtors>();
+  test<NonTrivialTypes::NoCtors>();
+  test<NonConstexprTypes::NoCtors>();
+#if TEST_STD_VER >= 23
+  test_non_literal();
+#endif
+  return true;
 }
 
 int main(int, char**) {
-  test_constexpr<optional<int>>();
-  test_constexpr<optional<int*>>();
-  test_constexpr<optional<ImplicitTypes::NoCtors>>();
-  test_constexpr<optional<NonTrivialTypes::NoCtors>>();
-  test_constexpr<optional<NonConstexprTypes::NoCtors>>();
-  test<optional<NonLiteralTypes::NoCtors>>();
+  assert(test());
+  static_assert(test());
+
+  {
+    test_non_literal();
+  }
 
   return 0;
 }
diff --git a/libcxx/test/std/utilities/optional/optional.object/optional.object.ctor/optional_U.pass.cpp b/libcxx/test/std/utilities/optional/optional.object/optional.object.ctor/optional_U.pass.cpp
index 709b106c800a6..f03ccaa0a0257 100644
--- a/libcxx/test/std/utilities/optional/optional.object/optional.object.ctor/optional_U.pass.cpp
+++ b/libcxx/test/std/utilities/optional/optional.object/optional.object.ctor/optional_U.pass.cpp
@@ -7,6 +7,7 @@
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14
+
 // <optional>
 
 // template <class U>
@@ -68,13 +69,7 @@ TEST_CONSTEXPR_CXX20 bool test_all() {
   return true;
 }
 
-int main(int, char**) {
-  test_all<short, int>();
-  test_all<int, X>();
-#if TEST_STD_VER > 17
-  static_assert(test_all<short, int>());
-  static_assert(test_all<int, X>());
-#endif
+TEST_CONSTEXPR_CXX26 void test_throw() {
   {
     optional<int> rhs;
     test<Z>(std::move(rhs));
@@ -85,6 +80,27 @@ int main(int, char**) {
   }
 
   static_assert(!(std::is_constructible<optional<X>, optional<Z>>::value), "");
+}
+
+TEST_CONSTEXPR_CXX20 bool test() {
+  test_all<short, int>();
+  test_all<int, X>();
+
+#if TEST_STD_VER >= 26 && 0
+  test_throw();
+#endif
+  return true;
+}
+
+int main(int, char**) {
+  test();
+#if TEST_STD_VER >= 20
+  static_assert(test());
+#endif
+
+  {
+    test_throw();
+  }
 
   return 0;
 }
diff --git a/libcxx/test/std/utilities/optional/optional.object/optional.object.ctor/rvalue_T.pass.cpp b/libcxx/test/std/utilities/optional/optional.object/optional.object.ctor/rvalue_T.pass.cpp
index e73eef4592256..e851cc82d60fb 100644
--- a/libcxx/test/std/utilities/optional/optional.object/optional.object.ctor/rvalue_T.pass.cpp
+++ b/libcxx/test/std/utilities/optional/optional.object/optional.object.ctor/rvalue_T.pass.cpp
@@ -5,7 +5,7 @@
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
-//
+
 // UNSUPPORTED: c++03, c++11, c++14
 
 // <optional>
@@ -27,32 +27,41 @@ class Z {
   Z(Z&&) { TEST_THROW(6); }
 };
 
-int main(int, char**) {
+template <typename T, typename U>
+constexpr void test_rvalueT(U arg) {
   {
-    typedef int T;
-    constexpr optional<T> opt(T(5));
-    static_assert(static_cast<bool>(opt) == true, "");
-    static_assert(*opt == 5, "");
-
-    struct test_constexpr_ctor : public optional<T> {
-      constexpr test_constexpr_ctor(T&&) {}
-    };
+    const optional<T> opt(arg);
+    assert(bool(opt));
+    assert(*opt == T(arg));
   }
+
   {
-    typedef double T;
-    constexpr optional<T> opt(T(3));
-    static_assert(static_cast<bool>(opt) == true, "");
-    static_assert(*opt == 3, "");
-
-    struct test_constexpr_ctor : public optional<T> {
-      constexpr test_constexpr_ctor(T&&) {}
-    };
+    T t(arg);
+    optional<T> opt(std::move(t));
+    assert(*opt == T(arg));
   }
+
+  struct test_constexpr_ctor : public optional<T> {
+    constexpr test_constexpr_ctor(T&&) {}
+    constexpr test_constexpr_ctor(const T&) {}
+  };
+}
+
+TEST_CONSTEXPR_CXX26 void test_throwing() {
+#ifndef TEST_HAS_NO_EXCEPTIONS
   {
-    const int x = 42;
-    optional<const int> o(std::move(x));
-    assert(*o == 42);
+    try {
+      Z z(3);
+      optional<Z> opt(std::move(z));
+      assert(false);
+    } catch (int i) {
+      assert(i == 6);
+    }
   }
+#endif
+}
+
+void test_rt() {
   {
     typedef TestTypes::TestType T;
     T::reset();
@@ -62,6 +71,7 @@ int main(int, char**) {
     assert(static_cast<bool>(opt) == true);
     assert(opt.value().value == 3);
   }
+
   {
     typedef ExplicitTestTypes::TestType T;
     static_assert(!std::is_convertible<T&&, optional<T>>::value, "");
@@ -72,6 +82,7 @@ int main(int, char**) {
     assert(static_cast<bool>(opt) == true);
     assert(opt.value().value == 3);
   }
+
   {
     typedef TestTypes::TestType T;
     T::reset();
@@ -83,48 +94,49 @@ int main(int, char**) {
     assert(static_cast<bool>(opt) == true);
     assert(opt.value().value == 3);
   }
+
   {
-    typedef ConstexprTestTypes::TestType T;
-    constexpr optional<T> opt = {T(3)};
-    static_assert(static_cast<bool>(opt) == true, "");
-    static_assert(opt.value().value == 3, "");
-
-    struct test_constexpr_ctor : public optional<T> {
-      constexpr test_constexpr_ctor(const T&) {}
-    };
+    test_throwing();
   }
+}
+
+constexpr bool test() {
+  test_rvalueT<int>(5);
+  test_rvalueT<double>(3.0);
+  test_rvalueT<const int>(42);
+
   {
-    typedef ConstexprTestTypes::TestType T;
-    constexpr optional<T> opt = {3};
-    static_assert(static_cast<bool>(opt) == true, "");
-    static_assert(opt.value().value == 3, "");
-
-    struct test_constexpr_ctor : public optional<T> {
-      constexpr test_constexpr_ctor(const T&) {}
-    };
+    using T = ConstexprTestTypes::TestType;
+    test_rvalueT<T>(T(3));
   }
+
   {
-    typedef ExplicitConstexprTestTypes::TestType T;
-    static_assert(!std::is_convertible<T&&, optional<T>>::value, "");
-    constexpr optional<T> opt(T{3});
-    static_assert(static_cast<bool>(opt) == true, "");
-    static_assert(opt.value().value == 3, "");
+    using T = ConstexprTestTypes::TestType;
+    test_rvalueT<T>(3);
+  }
 
-    struct test_constexpr_ctor : public optional<T> {
-      constexpr test_constexpr_ctor(T&&) {}
-    };
+  {
+    using T = ExplicitConstexprTestTypes::TestType;
+    static_assert(!std::is_convertible<T&&, optional<T>>::value);
+    test_rvalueT<T>(T(3));
   }
-#ifndef TEST_HAS_NO_EXCEPTIONS
+#if TEST_STD_VER >= 26 && 0
   {
-    try {
-      Z z(3);
-      optional<Z> opt(std::move(z));
-      assert(false);
-    } catch (int i) {
-      assert(i == 6);
-    }
+    test_throwing();
   }
+
 #endif
 
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  {
+    test_rt();
+  }
+
   return 0;
 }