[libcxx-commits] [libcxx] 5b28e4d - [libc++][NFC] Reformat test
Louis Dionne via libcxx-commits
libcxx-commits at lists.llvm.org
Mon May 15 11:35:38 PDT 2023
Author: Louis Dionne
Date: 2023-05-15T11:35:30-07:00
New Revision: 5b28e4d79175ae74dbd5043b494c21a87966fe81
URL: https://github.com/llvm/llvm-project/commit/5b28e4d79175ae74dbd5043b494c21a87966fe81
DIFF: https://github.com/llvm/llvm-project/commit/5b28e4d79175ae74dbd5043b494c21a87966fe81.diff
LOG: [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.
Added:
Modified:
libcxx/test/std/algorithms/alg.nonmodifying/alg.starts_with/ranges.starts_with.pass.cpp
Removed:
################################################################################
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;
More information about the libcxx-commits
mailing list