[libc++][NFC] Reformat test

I didn't notice in the review that clang-format made a poor job at
formatting the test so I went back and did it manually.

1 files changed, 142 insertions, 134 deletions

diff --git a/libcxx/test/std/algorithms/alg.nonmodifying/alg.starts_with/ranges.starts_with.pass.cpp b/libcxx/test/std/algorithms/alg.nonmodifying/alg.starts_with/ranges.starts_with.pass.cpp
index 3a9c1aeeaf87..78565b354c04 100644
--- a/libcxx/test/std/algorithms/alg.nonmodifying/alg.starts_with/ranges.starts_with.pass.cpp
+++ b/libcxx/test/std/algorithms/alg.nonmodifying/alg.starts_with/ranges.starts_with.pass.cpp
@@ -29,7 +29,7 @@
 #include "test_iterators.h"
 
 template <class Iter1, class Sent1 = Iter1, class Iter2 = int*, class Sent2 = Iter2>
-concept HasStartsWithIt = requires (Iter1 first1, Sent1 last1, Iter2 first2, Sent2 last2) {
+concept HasStartsWithIt = requires(Iter1 first1, Sent1 last1, Iter2 first2, Sent2 last2) {
   std::ranges::starts_with(first1, last1, first2, last2);
 };
 
@@ -45,9 +45,7 @@ static_assert(!HasStartsWithIt<int*, int*, int*, SentinelForNotSemiregular>);
 static_assert(!HasStartsWithIt<int*, int*, int*, SentinelForNotWeaklyEqualityComparableWith>);
 
 template <class Range1, class Range2 = UncheckedRange<int*>>
-concept HasStartsWithR = requires (Range1 range1, Range2 range2) {
-  std::ranges::starts_with(range1, range2);
-};
+concept HasStartsWithR = requires(Range1 range1, Range2 range2) { std::ranges::starts_with(range1, range2); };
 
 static_assert(HasStartsWithR<UncheckedRange<int*>>);
 static_assert(HasStartsWithR<ForwardRangeNotDerivedFrom>);
@@ -62,155 +60,164 @@ static_assert(!HasStartsWithR<UncheckedRange<int*>, ForwardRangeNotSentinelEqual
 
 template <class Iter1, class Sent1 = Iter1, class Iter2, class Sent2 = Iter2>
 constexpr void test_iterators() {
-  {// simply tests
-   {int a[] = {1, 2, 3, 4, 5, 6};
-    int p[] = {1, 2};
-    std::same_as<bool> decltype(auto) ret =
+  // simple tests
+  {
+    {
+      int a[] = {1, 2, 3, 4, 5, 6};
+      int p[] = {1, 2};
+      std::same_as<bool> decltype(auto) ret =
         std::ranges::starts_with(Iter1(a), Sent1(Iter1(a + 6)), Iter2(p), Sent2(Iter2(p + 2)));
-    assert(ret);
-   }
-   {
-    int a[]                               = {1, 2, 3, 4, 5, 6};
-    int p[]                               = {1, 2};
-    auto whole                            = std::ranges::subrange(Iter1(a), Sent1(Iter1(a + 6)));
-    auto prefix                           = std::ranges::subrange(Iter2(p), Sent2(Iter2(p + 2)));
-    std::same_as<bool> decltype(auto) ret = std::ranges::starts_with(whole, prefix);
-    assert(ret);
-   }
-  }
-
-  {// prefix doesn't match
-   {
-    int a[] = {1, 2, 3, 4, 5, 6};
-    int p[] = {4, 5, 6};
-    std::same_as<bool> decltype(auto) ret =
-    std::ranges::starts_with(Iter1(a), Sent1(Iter1(a + 6)), Iter2(p), Sent2(Iter2(p + 3)));
-    assert(!ret);
-   }
-   {
-    int a[]                               = {1, 2, 3, 4, 5, 6};
-    int p[]                               = {4, 5, 6};
-    auto whole                            = std::ranges::subrange(Iter1(a), Sent1(Iter1(a + 6)));
-    auto prefix                           = std::ranges::subrange(Iter2(p), Sent2(Iter2(p + 3)));
-    std::same_as<bool> decltype(auto) ret = std::ranges::starts_with(whole, prefix);
-    assert(!ret);
-   }
-  }
-
-  {// range and prefix are identical
-   {
-    int a[] = {1, 2, 3, 4, 5, 6};
-    int p[] = {1, 2, 3, 4, 5, 6};
-    std::same_as<bool> decltype(auto) ret =
-    std::ranges::starts_with(Iter1(a), Sent1(Iter1(a + 6)), Iter2(p), Sent2(Iter2(p + 6)));
-    assert(ret);
-   }
-   {
-    int a[]                               = {1, 2, 3, 4, 5, 6};
-    int p[]                               = {1, 2, 3, 4, 5, 6};
-    auto whole                            = std::ranges::subrange(Iter1(a), Sent1(Iter1(a + 6)));
-    auto prefix                           = std::ranges::subrange(Iter2(p), Sent2(Iter2(p + 6)));
-    std::same_as<bool> decltype(auto) ret = std::ranges::starts_with(whole, prefix);
-    assert(ret);
-   }
+      assert(ret);
+    }
+    {
+      int a[]                               = {1, 2, 3, 4, 5, 6};
+      int p[]                               = {1, 2};
+      auto whole                            = std::ranges::subrange(Iter1(a), Sent1(Iter1(a + 6)));
+      auto prefix                           = std::ranges::subrange(Iter2(p), Sent2(Iter2(p + 2)));
+      std::same_as<bool> decltype(auto) ret = std::ranges::starts_with(whole, prefix);
+      assert(ret);
+    }
   }
 
- {// prefix is longer than range
-  {
-   int a[] = {1, 2, 3, 4, 5, 6};
-   int p[] = {1, 2, 3, 4, 5, 6, 7, 8};
-   std::same_as<bool> decltype(auto) ret =
-   std::ranges::starts_with(Iter1(a), Sent1(Iter1(a + 6)), Iter2(p), Sent2(Iter2(p + 8)));
-   assert(!ret);
-  }
+  // prefix doesn't match
   {
-   int a[]                               = {1, 2, 3, 4, 5, 6};
-   int p[]                               = {1, 2, 3, 4, 5, 6, 7, 8};
-   auto whole                            = std::ranges::subrange(Iter1(a), Sent1(Iter1(a + 6)));
-   auto prefix                           = std::ranges::subrange(Iter2(p), Sent2(Iter2(p + 8)));
-   std::same_as<bool> decltype(auto) ret = std::ranges::starts_with(whole, prefix);
-   assert(!ret);
+    {
+      int a[] = {1, 2, 3, 4, 5, 6};
+      int p[] = {4, 5, 6};
+      std::same_as<bool> decltype(auto) ret =
+          std::ranges::starts_with(Iter1(a), Sent1(Iter1(a + 6)), Iter2(p), Sent2(Iter2(p + 3)));
+      assert(!ret);
+    }
+    {
+      int a[]                               = {1, 2, 3, 4, 5, 6};
+      int p[]                               = {4, 5, 6};
+      auto whole                            = std::ranges::subrange(Iter1(a), Sent1(Iter1(a + 6)));
+      auto prefix                           = std::ranges::subrange(Iter2(p), Sent2(Iter2(p + 3)));
+      std::same_as<bool> decltype(auto) ret = std::ranges::starts_with(whole, prefix);
+      assert(!ret);
+    }
   }
- }
 
- {// prefix has zero length
+  // range and prefix are identical
   {
-   int a[] = {1, 2, 3, 4, 5, 6};
-   int p[] = {};
-   std::same_as<bool> decltype(auto) ret =
-   std::ranges::starts_with(Iter1(a), Sent1(Iter1(a + 6)), Iter2(p), Sent2(Iter2(p)));
-   assert(ret);
-  }
-  {
-   int a[]                               = {1, 2, 3, 4, 5, 6};
-   int p[]                               = {};
-   auto whole                            = std::ranges::subrange(Iter1(a), Sent1(Iter1(a + 6)));
-   auto prefix                           = std::ranges::subrange(Iter2(p), Sent2(Iter2(p)));
-   std::same_as<bool> decltype(auto) ret = std::ranges::starts_with(whole, prefix);
-   assert(ret);
+    {
+      int a[] = {1, 2, 3, 4, 5, 6};
+      int p[] = {1, 2, 3, 4, 5, 6};
+      std::same_as<bool> decltype(auto) ret =
+          std::ranges::starts_with(Iter1(a), Sent1(Iter1(a + 6)), Iter2(p), Sent2(Iter2(p + 6)));
+      assert(ret);
+    }
+    {
+      int a[]                               = {1, 2, 3, 4, 5, 6};
+      int p[]                               = {1, 2, 3, 4, 5, 6};
+      auto whole                            = std::ranges::subrange(Iter1(a), Sent1(Iter1(a + 6)));
+      auto prefix                           = std::ranges::subrange(Iter2(p), Sent2(Iter2(p + 6)));
+      std::same_as<bool> decltype(auto) ret = std::ranges::starts_with(whole, prefix);
+      assert(ret);
+    }
   }
- }
 
- {// range has zero length
-  {
-   int a[] = {};
-   int p[] = {1, 2, 3, 4, 5, 6, 7, 8};
-   std::same_as<bool> decltype(auto) ret =
-   std::ranges::starts_with(Iter1(a), Sent1(Iter1(a)), Iter2(p), Sent2(Iter2(p + 8)));
-   assert(!ret);
-  }
+  // prefix is longer than range
   {
-   int a[]                               = {};
-   int p[]                               = {1, 2, 3, 4, 5, 6, 7, 8};
-   auto whole                            = std::ranges::subrange(Iter1(a), Sent1(Iter1(a)));
-   auto prefix                           = std::ranges::subrange(Iter2(p), Sent2(Iter2(p + 8)));
-   std::same_as<bool> decltype(auto) ret = std::ranges::starts_with(whole, prefix);
-   assert(!ret);
+    {
+      int a[] = {1, 2, 3, 4, 5, 6};
+      int p[] = {1, 2, 3, 4, 5, 6, 7, 8};
+      std::same_as<bool> decltype(auto) ret =
+          std::ranges::starts_with(Iter1(a), Sent1(Iter1(a + 6)), Iter2(p), Sent2(Iter2(p + 8)));
+      assert(!ret);
+    }
+    {
+      int a[]                               = {1, 2, 3, 4, 5, 6};
+      int p[]                               = {1, 2, 3, 4, 5, 6, 7, 8};
+      auto whole                            = std::ranges::subrange(Iter1(a), Sent1(Iter1(a + 6)));
+      auto prefix                           = std::ranges::subrange(Iter2(p), Sent2(Iter2(p + 8)));
+      std::same_as<bool> decltype(auto) ret = std::ranges::starts_with(whole, prefix);
+      assert(!ret);
+    }
   }
- }
 
- {// check that the predicate is used
+  // prefix has zero length
   {
-   int a[] = {11, 8, 3, 4, 0, 6};
-   int p[] = {1, 12};
-   std::same_as<bool> decltype(auto) ret = std::ranges::starts_with(
-   Iter1(a), Sent1(Iter1(a + 6)), Iter2(p), Sent2(Iter2(p + 2)), [](int l, int r) { return l > r; });
-   assert(!ret);
+    {
+      int a[] = {1, 2, 3, 4, 5, 6};
+      int p[] = {};
+      std::same_as<bool> decltype(auto) ret =
+          std::ranges::starts_with(Iter1(a), Sent1(Iter1(a + 6)), Iter2(p), Sent2(Iter2(p)));
+      assert(ret);
+    }
+    {
+      int a[]                               = {1, 2, 3, 4, 5, 6};
+      int p[]                               = {};
+      auto whole                            = std::ranges::subrange(Iter1(a), Sent1(Iter1(a + 6)));
+      auto prefix                           = std::ranges::subrange(Iter2(p), Sent2(Iter2(p)));
+      std::same_as<bool> decltype(auto) ret = std::ranges::starts_with(whole, prefix);
+      assert(ret);
+    }
   }
+
+  // range has zero length
   {
-   int a[]                               = {11, 8, 3, 4, 0, 6};
-   int p[]                               = {1, 12};
-   auto whole                            = std::ranges::subrange(Iter1(a), Sent1(Iter1(a + 6)));
-   auto prefix                           = std::ranges::subrange(Iter2(p), Sent2(Iter2(p + 2)));
-   std::same_as<bool> decltype(auto) ret = std::ranges::starts_with(whole, prefix, [](int l, int r) { return l > r; });
-   assert(!ret);
+    {
+      int a[] = {};
+      int p[] = {1, 2, 3, 4, 5, 6, 7, 8};
+      std::same_as<bool> decltype(auto) ret =
+          std::ranges::starts_with(Iter1(a), Sent1(Iter1(a)), Iter2(p), Sent2(Iter2(p + 8)));
+      assert(!ret);
+    }
+    {
+      int a[]                               = {};
+      int p[]                               = {1, 2, 3, 4, 5, 6, 7, 8};
+      auto whole                            = std::ranges::subrange(Iter1(a), Sent1(Iter1(a)));
+      auto prefix                           = std::ranges::subrange(Iter2(p), Sent2(Iter2(p + 8)));
+      std::same_as<bool> decltype(auto) ret = std::ranges::starts_with(whole, prefix);
+      assert(!ret);
+    }
   }
- }
 
- {// check that the projections are used
+  // check that the predicate is used
   {
-    int a[]                               = {1, 3, 5, 1, 5, 6};
-    int p[]                               = {2, 3, 4};
-    std::same_as<bool> decltype(auto) ret = std::ranges::starts_with(
-        Iter1(a),
-        Sent1(Iter1(a + 6)),
-        Iter2(p),
-        Sent2(Iter2(p + 3)),
-        {},
-        [](int i) { return i + 3; },
-        [](int i) { return i * 2; });
-    assert(ret);
+    {
+      int a[] = {11, 8, 3, 4, 0, 6};
+      int p[]                               = {1, 12};
+      std::same_as<bool> decltype(auto) ret = std::ranges::starts_with(
+          Iter1(a), Sent1(Iter1(a + 6)), Iter2(p), Sent2(Iter2(p + 2)), [](int l, int r) { return l > r; });
+      assert(!ret);
+    }
+    {
+      int a[]                               = {11, 8, 3, 4, 0, 6};
+      int p[]                               = {1, 12};
+      auto whole                            = std::ranges::subrange(Iter1(a), Sent1(Iter1(a + 6)));
+      auto prefix                           = std::ranges::subrange(Iter2(p), Sent2(Iter2(p + 2)));
+      std::same_as<bool> decltype(auto) ret = std::ranges::starts_with(whole, prefix, [](int l, int r) { return l > r; });
+      assert(!ret);
+    }
   }
+
+  // check that the projections are used
   {
-    int a[]                               = {1, 3, 5, 1, 5, 6};
-    int p[]                               = {2, 3, 4};
-    auto whole                            = std::ranges::subrange(Iter1(a), Sent1(Iter1(a + 6)));
-    auto prefix                           = std::ranges::subrange(Iter2(p), Sent2(Iter2(p + 3)));
-    std::same_as<bool> decltype(auto) ret = std::ranges::starts_with(
-        whole, prefix, {}, [](int i) { return i + 3; }, [](int i) { return i * 2; });
-    assert(ret);
+    {
+      int a[]                               = {1, 3, 5, 1, 5, 6};
+      int p[]                               = {2, 3, 4};
+      std::same_as<bool> decltype(auto) ret = std::ranges::starts_with(
+          Iter1(a),
+          Sent1(Iter1(a + 6)),
+          Iter2(p),
+          Sent2(Iter2(p + 3)),
+          {},
+          [](int i) { return i + 3; },
+          [](int i) { return i * 2; });
+      assert(ret);
+    }
+    {
+      int a[]                               = {1, 3, 5, 1, 5, 6};
+      int p[]                               = {2, 3, 4};
+      auto whole                            = std::ranges::subrange(Iter1(a), Sent1(Iter1(a + 6)));
+      auto prefix                           = std::ranges::subrange(Iter2(p), Sent2(Iter2(p + 3)));
+      std::same_as<bool> decltype(auto) ret = std::ranges::starts_with(
+          whole, prefix, {}, [](int i) { return i + 3; }, [](int i) { return i * 2; });
+      assert(ret);
+    }
   }
- }
 }
 
 constexpr bool test() {
@@ -221,9 +228,10 @@ constexpr bool test() {
       test_iterators<I1, I1, I2, sized_sentinel<I2>>();
       test_iterators<I1, sized_sentinel<I1>, I2, sized_sentinel<I2>>();
     });
-});
+  });
 
-  { // check that std::invoke is used
+  // check that std::invoke is used
+  {
     struct S {
       int i;