U.pass

Author: smallp-o-p

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

@@ -44,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();
@@ -136,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;
@@ -148,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;
 }