Add a optional<T&> copy and move test

Author: smallp-o-p

libcxx/test/std/utilities/optional/optional.object/optional.object.ctor/const_optional_U.pass.cpp

@@ -87,6 +87,7 @@ constexpr bool test_all() {
 }
 
 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>();
@@ -126,6 +127,5 @@ int main(int, char**) {
     test_throwing();
   }
 
-  static_assert(!(std::is_constructible<optional<X>, const optional<Y>&>::value));
   return 0;
 }

libcxx/test/std/utilities/optional/optional.object/optional.object.ctor/copy.pass.cpp

@@ -65,9 +65,26 @@ void test_ref(InitArgs&&... args) {
     assert(&(*lhs) == &(*rhs));
 }
 
-// TODO: Add constexpr tests
-void test_reference_extension() {
 #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() {
   using T = TestTypes::TestType;
   T::reset();
   {
@@ -103,13 +120,15 @@ void test_reference_extension() {
     static_assert(!std::is_copy_constructible<std::optional<T const&&>>::value);
   }
 #  endif
-#endif
 }
+#endif
 
 constexpr bool test() {
   test<int>();
   test<int>(3);
   test<const int>(42);
+  test<TrivialTestTypes::TestType>();
+  test<TrivialTestTypes::TestType>(42);
 
   // FIXME: Why is this in ctor copy.pass.cpp?
   {
@@ -129,34 +148,19 @@ constexpr bool test() {
     }
   }
 
-  {
-    using T = TrivialTestTypes::TestType;
-    test<T>();
-    test<T>(42);
-  }
+#if TEST_STD_VER >= 26
+  test_ref();
 
   // TODO: Enable once P3068R6 is implemented
-#if TEST_STD_VER >= 26 && 0
+#  if 0
   test_throwing_ctor();
+#  endif
 #endif
 
   return true;
 }
 
-int main(int, char**) {
-  test();
-  static_assert(test());
-
-  {
-    test_throwing_ctor();
-  }
-
-#if TEST_STD_VER >= 26
-  {
-    test_reference_extension();
-  }
-#endif
-
+void test_rt() {
   { // FIXME: Shouldn't this be able to pass in a constexpr context since C++17?
     using T = ConstexprTestTypes::TestType;
     test<T>();
@@ -189,6 +193,25 @@ int main(int, char**) {
   }
 
   TestTypes::TestType::reset();
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  {
+    test_rt();
+  }
+
+  {
+    test_throwing_ctor();
+  }
+
+#if TEST_STD_VER >= 26
+  {
+    test_reference_extension();
+  }
+#endif
 
   return 0;
 }

libcxx/test/std/utilities/optional/optional.object/optional.object.ctor/move.pass.cpp

@@ -59,16 +59,33 @@ TEST_CONSTEXPR_CXX26 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);
 }
 
-// TODO: Add constexpr tests
-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();
   {
@@ -129,8 +146,8 @@ void test_reference_extension() {
     static_assert(!std::is_copy_constructible_v<std::optional<T const&&>>);
   }
 #  endif
-#endif
 }
+#endif
 
 constexpr bool test() {
   test<int>();
@@ -143,6 +160,10 @@ constexpr bool test() {
     test<T>(42);
   }
 
+#if TEST_STD_VER >= 26
+  test_ref();
+#endif
+
 #if TEST_STD_VER >= 26 && 0
   {
     test_throwing_ctor();
@@ -152,7 +173,7 @@ constexpr bool test() {
   return true;
 }
 
-bool rt_test() {
+bool test_rt() {
   {
     using T = TestTypes::TestType;
     T::reset();
@@ -213,7 +234,7 @@ int main(int, char**) {
   static_assert(test());
 
   {
-    rt_test();
+    test_rt();
   }
 
   {