Formatting

Author: smallp-o-p

libcxx/test/libcxx/utilities/optional/optional.iterator/iterator.compile.pass.cpp

@@ -25,5 +25,5 @@ static_assert(has_iterator_aliases<std::optional<int>>);
 static_assert(has_iterator_aliases<std::optional<const int>>);
 static_assert(has_iterator_aliases<std::optional<int&>>);
 static_assert(has_iterator_aliases<std::optional<const int&>>);
-static_assert(!has_iterator_aliases<std::optional<int(&)[1]>>);
-static_assert(!has_iterator_aliases<std::optional<int(&)()>>);
+static_assert(!has_iterator_aliases<std::optional<int (&)[1]>>);
+static_assert(!has_iterator_aliases<std::optional<int (&)()>>);

libcxx/test/libcxx/utilities/optional/optional.object/optional.object.observe/value_or.compile.pass.cpp

@@ -23,5 +23,5 @@ concept has_value_or = requires(Opt opt, T&& t) {
 static_assert(has_value_or<std::optional<int>, int>);
 static_assert(has_value_or<std::optional<int&>, int&>);
 static_assert(has_value_or<std::optional<const int&>, const int&>);
-static_assert(!has_value_or<std::optional<int(&)[1]>&&, int(&)[1]>);
-static_assert(!has_value_or<std::optional<int(&)()>&&, int(&)()>);
+static_assert(!has_value_or<std::optional<int (&)[1]>&&, int (&)[1]>);
+static_assert(!has_value_or<std::optional<int (&)()>&&, int (&)()>);

libcxx/test/std/utilities/optional/optional.monadic/and_then.pass.cpp

@@ -304,7 +304,6 @@ constexpr bool test_ref() {
       ASSERT_SAME_TYPE(decltype(i.and_then(l)), std::optional<int>);
     }
   }
-
   // Test && overload
   {
 

libcxx/test/std/utilities/optional/optional.monadic/transform.pass.cpp

@@ -238,7 +238,7 @@ constexpr bool test_ref() {
     }
   }
   // const& overload
-  { 
+  {
     // Without & qualifier on F's operator()
     {
       int i = 42;

libcxx/test/std/utilities/optional/optional.object/optional.object.assign/assign_value.pass.cpp

@@ -279,8 +279,7 @@ constexpr void test_with_ref() {
     assert(static_cast<bool>(opt) == false);
   }
 }
-#endif 
-
+#endif
 
 int main(int, char**)
 {

libcxx/test/std/utilities/optional/optional.object/optional.object.assign/emplace.pass.cpp

@@ -224,20 +224,20 @@ TEST_CONSTEXPR_CXX20 bool test_empty_emplace() {
 #if TEST_STD_VER >= 26
 template <class T, std::remove_reference_t<T> _Val>
 constexpr bool test_ref() {
-    using Opt = std::optional<T&>;
-    T t{_Val};
-    {
-        Opt opt;
-        auto & v = opt.emplace(t);
-        static_assert(std::is_same_v<T&, decltype(v)>, "");
-        assert(static_cast<bool>(opt) == true);
-        assert(*opt == t);
-        assert(&v == &*opt);
-        assert(&t == &*opt);
-    }
-    return true;
+  using Opt = std::optional<T&>;
+  T t{_Val};
+  {
+    Opt opt;
+    auto& v = opt.emplace(t);
+    static_assert(std::is_same_v<T&, decltype(v)>, "");
+    assert(static_cast<bool>(opt) == true);
+    assert(*opt == t);
+    assert(&v == &*opt);
+    assert(&t == &*opt);
+  }
+  return true;
 }
-#endif 
+#endif
 
 int main(int, char**)
 {
@@ -314,6 +314,6 @@ int main(int, char**)
     static_assert(test_ref<double, 15.0>());
     assert((test_ref<int, 1>()));
     assert((test_ref<double, 15.0>()));
-#endif 
-  return 0;
+#endif
+    return 0;
 }

libcxx/test/std/utilities/optional/optional.object/optional.object.ctor/ctor.verify.cpp

@@ -23,17 +23,21 @@ struct NonDestructible { ~NonDestructible() = delete; };
 
 int main(int, char**)
 {
-    {
+  {
 #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}}
-#else     
-    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<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}}
+#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<               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}}

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

@@ -25,8 +25,8 @@ constexpr bool test() {
     assert(&(*opt) == &item);
   }
   {
-    assert(*std::as_const(opt) == item);  
-    assert(&(*std::as_const(opt)) == &item);  
+    assert(*std::as_const(opt) == item);
+    assert(&(*std::as_const(opt)) == &item);
   }
 
   return true;

libcxx/test/std/utilities/optional/optional.object/optional.object.dtor/dtor.pass.cpp

@@ -66,10 +66,10 @@ int main(int, char**)
     }
 #if TEST_STD_VER >= 26
     {
-        typedef int& T;
-        static_assert(std::is_trivially_destructible<T>::value, "");
-        static_assert(std::is_trivially_destructible<optional<T>>::value, "");
+      typedef int& T;
+      static_assert(std::is_trivially_destructible<T>::value, "");
+      static_assert(std::is_trivially_destructible<optional<T>>::value, "");
     }
-#endif 
-  return 0;
+#endif
+    return 0;
 }

libcxx/test/std/utilities/optional/optional.object/optional.object.mod/reset.pass.cpp

@@ -78,7 +78,7 @@ int main(int, char**)
       assert(X::dtor_called == false);
       assert(static_cast<bool>(opt) == false);
     }
-#endif 
+#endif
 
-  return 0;
+    return 0;
 }