[libc++][NFC] Run two tests I'm about to modify a bunch under clang-format

Author: ldionne

libcxx/test/std/utilities/memory/specialized.algorithms/specialized.construct/construct_at.pass.cpp

@@ -21,88 +21,83 @@
 #include "test_iterators.h"
 
 struct Foo {
-    constexpr Foo() { }
-    constexpr Foo(int a, char b, double c) : a_(a), b_(b), c_(c) { }
-    constexpr Foo(int a, char b, double c, int* count) : Foo(a, b, c) { *count += 1; }
-    constexpr bool operator==(Foo const& other) const {
-        return a_ == other.a_ && b_ == other.b_ && c_ == other.c_;
-    }
+  constexpr Foo() {}
+  constexpr Foo(int a, char b, double c) : a_(a), b_(b), c_(c) {}
+  constexpr Foo(int a, char b, double c, int* count) : Foo(a, b, c) { *count += 1; }
+  constexpr bool operator==(Foo const& other) const { return a_ == other.a_ && b_ == other.b_ && c_ == other.c_; }
 
 private:
-    int a_;
-    char b_;
-    double c_;
+  int a_;
+  char b_;
+  double c_;
 };
 
 struct Counted {
-    int& count_;
-    constexpr Counted(int& count) : count_(count) { ++count; }
-    constexpr Counted(Counted const& that) : count_(that.count_) { ++count_; }
-    constexpr ~Counted() { --count_; }
+  int& count_;
+  constexpr Counted(int& count) : count_(count) { ++count; }
+  constexpr Counted(Counted const& that) : count_(that.count_) { ++count_; }
+  constexpr ~Counted() { --count_; }
 };
 
-constexpr bool test()
-{
-    {
-        int i = 99;
-        int* res = std::construct_at(&i);
-        assert(res == &i);
-        assert(*res == 0);
-    }
-
-    {
-        int i = 0;
-        int* res = std::construct_at(&i, 42);
-        assert(res == &i);
-        assert(*res == 42);
-    }
-
-    {
-        Foo foo = {};
-        int count = 0;
-        Foo* res = std::construct_at(&foo, 42, 'x', 123.89, &count);
-        assert(res == &foo);
-        assert(*res == Foo(42, 'x', 123.89));
-        assert(count == 1);
-    }
-
-    {
-        std::allocator<Counted> a;
-        Counted* p = a.allocate(2);
-        int count = 0;
-        std::construct_at(p, count);
-        assert(count == 1);
-        std::construct_at(p+1, count);
-        assert(count == 2);
-        (p+1)->~Counted();
-        assert(count == 1);
-        p->~Counted();
-        assert(count == 0);
-        a.deallocate(p, 2);
-    }
-
-    return true;
+constexpr bool test() {
+  {
+    int i    = 99;
+    int* res = std::construct_at(&i);
+    assert(res == &i);
+    assert(*res == 0);
+  }
+
+  {
+    int i    = 0;
+    int* res = std::construct_at(&i, 42);
+    assert(res == &i);
+    assert(*res == 42);
+  }
+
+  {
+    Foo foo   = {};
+    int count = 0;
+    Foo* res  = std::construct_at(&foo, 42, 'x', 123.89, &count);
+    assert(res == &foo);
+    assert(*res == Foo(42, 'x', 123.89));
+    assert(count == 1);
+  }
+
+  {
+    std::allocator<Counted> a;
+    Counted* p = a.allocate(2);
+    int count  = 0;
+    std::construct_at(p, count);
+    assert(count == 1);
+    std::construct_at(p + 1, count);
+    assert(count == 2);
+    (p + 1)->~Counted();
+    assert(count == 1);
+    p->~Counted();
+    assert(count == 0);
+    a.deallocate(p, 2);
+  }
+
+  return true;
 }
 
-template <class ...Args>
-constexpr bool can_construct_at = requires {
-    std::construct_at(std::declval<Args>()...);
-};
+template <class... Args>
+constexpr bool can_construct_at = requires { std::construct_at(std::declval<Args>()...); };
 
 // Check that SFINAE works.
-static_assert( can_construct_at<int*, int>);
-static_assert( can_construct_at<Foo*, int, char, double>);
+static_assert(can_construct_at<int*, int>);
+static_assert(can_construct_at<Foo*, int, char, double>);
 static_assert(!can_construct_at<Foo*, int, char>);
 static_assert(!can_construct_at<Foo*, int, char, double, int>);
 static_assert(!can_construct_at<std::nullptr_t, int, char, double>);
 static_assert(!can_construct_at<int*, int, char, double>);
 static_assert(!can_construct_at<contiguous_iterator<Foo*>, int, char, double>);
 // Can't construct function pointers.
-static_assert(!can_construct_at<int(*)()>);
-static_assert(!can_construct_at<int(*)(), std::nullptr_t>);
+static_assert(!can_construct_at<int (*)()>);
+static_assert(!can_construct_at<int (*)(), std::nullptr_t>);
 
 int main(int, char**) {
-    test();
-    static_assert(test());
-    return 0;
+  test();
+  static_assert(test());
+  return 0;
 }

libcxx/test/std/utilities/memory/specialized.algorithms/specialized.construct/ranges_construct_at.pass.cpp

@@ -85,7 +85,7 @@ constexpr bool test() {
   {
     std::allocator<Counted> alloc;
     Counted* out = alloc.allocate(2);
-    int count = 0;
+    int count    = 0;
 
     Counted* result = std::ranges::construct_at(out, count);
     assert(result == out);
@@ -104,20 +104,22 @@ constexpr bool test() {
 
 constexpr bool can_construct_at(auto&&... args)
   requires requires { std::ranges::construct_at(decltype(args)(args)...); }
-  { return true; }
+{
+  return true;
+}
 
 constexpr bool can_construct_at(auto&&...) { return false; }
 
 // Check that SFINAE works.
-static_assert( can_construct_at((Foo*)nullptr, 1, 2));
+static_assert(can_construct_at((Foo*)nullptr, 1, 2));
 static_assert(!can_construct_at((Foo*)nullptr, 1));
 static_assert(!can_construct_at((Foo*)nullptr, 1, 2, 3));
 static_assert(!can_construct_at(nullptr, 1, 2));
 static_assert(!can_construct_at((int*)nullptr, 1, 2));
 static_assert(!can_construct_at(contiguous_iterator<Foo*>(), 1, 2));
 // Can't construct function pointers.
-static_assert(!can_construct_at((int(*)())nullptr));
-static_assert(!can_construct_at((int(*)())nullptr, nullptr));
+static_assert(!can_construct_at((int (*)()) nullptr));
+static_assert(!can_construct_at((int (*)()) nullptr, nullptr));
 // TODO(varconst): check that array types work once D114649 implementing LWG3639 lands.
 
 int main(int, char**) {