Skip to content

Commit 83ae1ac

Browse files
winner245winner245
committed
Augment ranges::{fill, fill_n, find} with missing tests
1 parent 70906f0 commit 83ae1ac

File tree

7 files changed

+148
-94
lines changed

7 files changed

+148
-94
lines changed

‎libcxx/test/std/algorithms/alg.modifying.operations/alg.fill/fill.pass.cpp‎

Lines changed: 10 additions & 42 deletions
Original file line numberDiff line numberDiff line change
@@ -83,48 +83,16 @@ TEST_CONSTEXPR_CXX20 void test_bititer_with_custom_sized_types() {
8383
TEST_CONSTEXPR_CXX20 bool test() {
8484
types::for_each(types::forward_iterator_list<char*>(), Test<char>());
8585
types::for_each(types::forward_iterator_list<int*>(), Test<int>());
86-
{ // test vector<bool>::iterator optimization
87-
{ // simple case
88-
std::vector<bool> in(4, false);
89-
std::vector<bool> expected(4, true);
90-
std::fill(in.begin(), in.end(), true);
91-
assert(in == expected);
92-
}
93-
{ // partial byte in the front is not filled
94-
std::vector<bool> in(8, false);
95-
std::vector<bool> expected(8, true);
96-
expected[0] = false;
97-
expected[1] = false;
98-
std::fill(in.begin() + 2, in.end(), true);
99-
assert(in == expected);
100-
}
101-
{ // partial byte in the back is not filled
102-
std::vector<bool> in(8, false);
103-
std::vector<bool> expected(8, true);
104-
expected[6] = false;
105-
expected[7] = false;
106-
std::fill(in.begin(), in.end() - 2, true);
107-
assert(in == expected);
108-
}
109-
{ // partial byte in the front and back is not filled
110-
std::vector<bool> in(16, false);
111-
std::vector<bool> expected(16, true);
112-
expected[0] = false;
113-
expected[1] = false;
114-
expected[14] = false;
115-
expected[15] = false;
116-
std::fill(in.begin() + 2, in.end() - 2, true);
117-
assert(in == expected);
118-
}
119-
{ // only a few bits of a byte are set
120-
std::vector<bool> in(8, false);
121-
std::vector<bool> expected(8, true);
122-
expected[0] = false;
123-
expected[1] = false;
124-
expected[6] = false;
125-
expected[7] = false;
126-
std::fill(in.begin() + 2, in.end() - 2, true);
127-
assert(in == expected);
86+
87+
{ // Test vector<bool>::iterator optimization
88+
for (std::size_t N = 8; N <= 256; N *= 2) {
89+
// Test with both full and partial bytes
90+
for (std::size_t offset = 0; offset <= 4; offset += 4) {
91+
std::vector<bool> in(N + 2 * offset);
92+
std::vector<bool> expected(N, true);
93+
std::fill(in.begin() + offset, in.end() - offset, true);
94+
assert(std::equal(in.begin() + offset, in.end() - offset, expected.begin()));
95+
}
12896
}
12997
}
13098

‎libcxx/test/std/algorithms/alg.modifying.operations/alg.fill/fill_n.pass.cpp‎

Lines changed: 12 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -182,6 +182,18 @@ int main(int, char**) {
182182
test5();
183183
test6();
184184

185+
{ // Test vector<bool>::iterator optimization
186+
for (std::size_t N = 8; N <= 256; N *= 2) {
187+
// Test with both full and partial bytes
188+
for (std::size_t offset = 0; offset <= 4; offset += 4) {
189+
std::vector<bool> in(N + 2 * offset);
190+
std::vector<bool> expected(N, true);
191+
std::fill_n(in.begin() + offset, N + offset, true);
192+
assert(std::equal(in.begin() + offset, in.end() - offset, expected.begin()));
193+
}
194+
}
195+
}
196+
185197
test_bititer_with_custom_sized_types();
186198

187199
#if TEST_STD_VER > 17

‎libcxx/test/std/algorithms/alg.modifying.operations/alg.fill/ranges.fill.pass.cpp‎

Lines changed: 13 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -173,7 +173,19 @@ constexpr bool test() {
173173
}
174174
}
175175

176-
#if TEST_STD_VER >= 23
176+
#if TEST_STD_VER >= 23
177+
{ // Test vector<bool>::iterator optimization
178+
for (std::size_t N = 8; N <= 256; N *= 2) {
179+
// Test with both full and partial bytes
180+
for (std::size_t offset : {0, 4}) {
181+
std::vector<bool> in(N + 2 * offset);
182+
std::vector<bool> expected(N, true);
183+
std::ranges::fill(std::ranges::begin(in) + offset, std::ranges::end(in) - offset, true);
184+
assert(std::equal(in.begin() + offset, in.end() - offset, expected.begin()));
185+
}
186+
}
187+
}
188+
177189
test_bititer_with_custom_sized_types();
178190
#endif
179191

‎libcxx/test/std/algorithms/alg.modifying.operations/alg.fill/ranges.fill_n.pass.cpp‎

Lines changed: 12 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -122,6 +122,18 @@ constexpr bool test() {
122122
}
123123

124124
#if TEST_STD_VER >= 23
125+
{ // Test vector<bool>::iterator optimization
126+
for (std::size_t N = 8; N <= 256; N *= 2) {
127+
// Test with both full and partial bytes
128+
for (std::size_t offset : {0, 4}) {
129+
std::vector<bool> in(N + 2 * offset);
130+
std::vector<bool> expected(N, true);
131+
std::ranges::fill_n(std::ranges::begin(in) + offset, N, true);
132+
assert(std::equal(in.begin() + offset, in.end() - offset, expected.begin()));
133+
}
134+
}
135+
}
136+
125137
test_bititer_with_custom_sized_types();
126138
#endif
127139

‎libcxx/test/std/algorithms/alg.nonmodifying/alg.count/ranges.count.pass.cpp‎

Lines changed: 46 additions & 33 deletions
Original file line numberDiff line numberDiff line change
@@ -67,13 +67,13 @@ constexpr void test_iterators() {
6767
{
6868
// simple test
6969
{
70-
int a[] = {1, 2, 3, 4};
70+
int a[] = {1, 2, 3, 4};
7171
std::same_as<std::ptrdiff_t> auto ret = std::ranges::count(It(a), Sent(It(a + 4)), 3);
7272
assert(ret == 1);
7373
}
7474
{
75-
int a[] = {1, 2, 3, 4};
76-
auto range = std::ranges::subrange(It(a), Sent(It(a + 4)));
75+
int a[] = {1, 2, 3, 4};
76+
auto range = std::ranges::subrange(It(a), Sent(It(a + 4)));
7777
std::same_as<std::ptrdiff_t> auto ret = std::ranges::count(range, 3);
7878
assert(ret == 1);
7979
}
@@ -83,13 +83,13 @@ constexpr void test_iterators() {
8383
// check that an empty range works
8484
{
8585
std::array<int, 0> a = {};
86-
auto ret = std::ranges::count(It(a.data()), Sent(It(a.data() + a.size())), 1);
86+
auto ret = std::ranges::count(It(a.data()), Sent(It(a.data() + a.size())), 1);
8787
assert(ret == 0);
8888
}
8989
{
9090
std::array<int, 0> a = {};
91-
auto range = std::ranges::subrange(It(a.data()), Sent(It(a.data() + a.size())));
92-
auto ret = std::ranges::count(range, 1);
91+
auto range = std::ranges::subrange(It(a.data()), Sent(It(a.data() + a.size())));
92+
auto ret = std::ranges::count(range, 1);
9393
assert(ret == 0);
9494
}
9595
}
@@ -98,13 +98,13 @@ constexpr void test_iterators() {
9898
// check that a range with a single element works
9999
{
100100
std::array a = {2};
101-
auto ret = std::ranges::count(It(a.data()), Sent(It(a.data() + a.size())), 2);
101+
auto ret = std::ranges::count(It(a.data()), Sent(It(a.data() + a.size())), 2);
102102
assert(ret == 1);
103103
}
104104
{
105105
std::array a = {2};
106-
auto range = std::ranges::subrange(It(a.data()), Sent(It(a.data() + a.size())));
107-
auto ret = std::ranges::count(range, 2);
106+
auto range = std::ranges::subrange(It(a.data()), Sent(It(a.data() + a.size())));
107+
auto ret = std::ranges::count(range, 2);
108108
assert(ret == 1);
109109
}
110110
}
@@ -113,13 +113,13 @@ constexpr void test_iterators() {
113113
// check that 0 is returned with no match
114114
{
115115
std::array a = {1, 1, 1};
116-
auto ret = std::ranges::count(It(a.data()), Sent(It(a.data() + a.size())), 0);
116+
auto ret = std::ranges::count(It(a.data()), Sent(It(a.data() + a.size())), 0);
117117
assert(ret == 0);
118118
}
119119
{
120120
std::array a = {1, 1, 1};
121-
auto range = std::ranges::subrange(It(a.data()), Sent(It(a.data() + a.size())));
122-
auto ret = std::ranges::count(range, 0);
121+
auto range = std::ranges::subrange(It(a.data()), Sent(It(a.data() + a.size())));
122+
auto ret = std::ranges::count(range, 0);
123123
assert(ret == 0);
124124
}
125125
}
@@ -128,13 +128,13 @@ constexpr void test_iterators() {
128128
// check that more than one element is counted
129129
{
130130
std::array a = {3, 3, 4, 3, 3};
131-
auto ret = std::ranges::count(It(a.data()), Sent(It(a.data() + a.size())), 3);
131+
auto ret = std::ranges::count(It(a.data()), Sent(It(a.data() + a.size())), 3);
132132
assert(ret == 4);
133133
}
134134
{
135135
std::array a = {3, 3, 4, 3, 3};
136-
auto range = std::ranges::subrange(It(a.data()), Sent(It(a.data() + a.size())));
137-
auto ret = std::ranges::count(range, 3);
136+
auto range = std::ranges::subrange(It(a.data()), Sent(It(a.data() + a.size())));
137+
auto ret = std::ranges::count(range, 3);
138138
assert(ret == 4);
139139
}
140140
}
@@ -143,13 +143,13 @@ constexpr void test_iterators() {
143143
// check that all elements are counted
144144
{
145145
std::array a = {5, 5, 5, 5};
146-
auto ret = std::ranges::count(It(a.data()), Sent(It(a.data() + a.size())), 5);
146+
auto ret = std::ranges::count(It(a.data()), Sent(It(a.data() + a.size())), 5);
147147
assert(ret == 4);
148148
}
149149
{
150150
std::array a = {5, 5, 5, 5};
151-
auto range = std::ranges::subrange(It(a.data()), Sent(It(a.data() + a.size())));
152-
auto ret = std::ranges::count(range, 5);
151+
auto range = std::ranges::subrange(It(a.data()), Sent(It(a.data() + a.size())));
152+
auto ret = std::ranges::count(range, 5);
153153
assert(ret == 4);
154154
}
155155
}
@@ -167,38 +167,46 @@ constexpr bool test() {
167167
{
168168
// check that projections are used properly and that they are called with the iterator directly
169169
{
170-
int a[] = {1, 2, 3, 4};
170+
int a[] = {1, 2, 3, 4};
171171
auto ret = std::ranges::count(a, a + 4, a + 3, [](int& i) { return &i; });
172172
assert(ret == 1);
173173
}
174174
{
175-
int a[] = {1, 2, 3, 4};
175+
int a[] = {1, 2, 3, 4};
176176
auto ret = std::ranges::count(a, a + 3, [](int& i) { return &i; });
177177
assert(ret == 1);
178178
}
179179
}
180180

181181
{
182182
// check that std::invoke is used
183-
struct S { int i; };
184-
S a[] = { S{1}, S{3}, S{2} };
183+
struct S {
184+
int i;
185+
};
186+
S a[] = {S{1}, S{3}, S{2}};
185187
std::same_as<std::ptrdiff_t> auto ret = std::ranges::count(a, 4, &S::i);
186188
assert(ret == 0);
187189
}
188190

189191
{
190192
// count invocations of the projection
191193
{
192-
int a[] = {1, 2, 3, 4};
194+
int a[] = {1, 2, 3, 4};
193195
int projection_count = 0;
194-
auto ret = std::ranges::count(a, a + 4, 2, [&](int i) { ++projection_count; return i; });
196+
auto ret = std::ranges::count(a, a + 4, 2, [&](int i) {
197+
++projection_count;
198+
return i;
199+
});
195200
assert(ret == 1);
196201
assert(projection_count == 4);
197202
}
198203
{
199-
int a[] = {1, 2, 3, 4};
204+
int a[] = {1, 2, 3, 4};
200205
int projection_count = 0;
201-
auto ret = std::ranges::count(a, 2, [&](int i) { ++projection_count; return i; });
206+
auto ret = std::ranges::count(a, 2, [&](int i) {
207+
++projection_count;
208+
return i;
209+
});
202210
assert(ret == 1);
203211
assert(projection_count == 4);
204212
}
@@ -208,20 +216,20 @@ constexpr bool test() {
208216
// check that an immobile type works
209217
struct NonMovable {
210218
NonMovable(const NonMovable&) = delete;
211-
NonMovable(NonMovable&&) = delete;
219+
NonMovable(NonMovable&&) = delete;
212220
constexpr NonMovable(int i_) : i(i_) {}
213221
int i;
214222

215223
bool operator==(const NonMovable&) const = default;
216224
};
217225
{
218226
NonMovable a[] = {9, 8, 4, 3};
219-
auto ret = std::ranges::count(a, a + 4, NonMovable(8));
227+
auto ret = std::ranges::count(a, a + 4, NonMovable(8));
220228
assert(ret == 1);
221229
}
222230
{
223231
NonMovable a[] = {9, 8, 4, 3};
224-
auto ret = std::ranges::count(a, NonMovable(8));
232+
auto ret = std::ranges::count(a, NonMovable(8));
225233
assert(ret == 1);
226234
}
227235
}
@@ -230,15 +238,18 @@ constexpr bool test() {
230238
// check that difference_type is used
231239
struct DiffTypeIterator {
232240
using difference_type = signed char;
233-
using value_type = int;
241+
using value_type = int;
234242

235243
int* it = nullptr;
236244

237245
constexpr DiffTypeIterator() = default;
238246
constexpr DiffTypeIterator(int* i) : it(i) {}
239247

240248
constexpr int& operator*() const { return *it; }
241-
constexpr DiffTypeIterator& operator++() { ++it; return *this; }
249+
constexpr DiffTypeIterator& operator++() {
250+
++it;
251+
return *this;
252+
}
242253
constexpr void operator++(int) { ++it; }
243254

244255
bool operator==(const DiffTypeIterator&) const = default;
@@ -251,7 +262,7 @@ constexpr bool test() {
251262
assert(ret == 1);
252263
}
253264
{
254-
int a[] = {5, 5, 4, 3, 2, 1};
265+
int a[] = {5, 5, 4, 3, 2, 1};
255266
auto range = std::ranges::subrange(DiffTypeIterator(a), DiffTypeIterator(a + 6));
256267
std::same_as<signed char> decltype(auto) ret = std::ranges::count(range, 4);
257268
assert(ret == 1);
@@ -264,7 +275,9 @@ constexpr bool test() {
264275
for (size_t offset = 0; offset != 64; ++offset) {
265276
std::fill(vec.begin(), vec.end(), false);
266277
std::fill(vec.begin() + offset, vec.begin() + i + offset, true);
267-
assert(std::ranges::count(vec.begin() + offset, vec.begin() + offset + 256, true) == i);
278+
279+
// check both (range) and (iterator, sentinel) overloads
280+
assert(std::ranges::count(vec, true) == i);
268281
assert(std::ranges::count(vec.begin() + offset, vec.begin() + offset + 256, false) == 256 - i);
269282
}
270283
}

‎libcxx/test/std/algorithms/alg.nonmodifying/alg.find/find.pass.cpp‎

Lines changed: 15 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -14,6 +14,8 @@
1414
// MSVC warning C4389: '==': signed/unsigned mismatch
1515
// MSVC warning C4805: '==': unsafe mix of type 'char' and type 'bool' in operation
1616
// ADDITIONAL_COMPILE_FLAGS(cl-style-warnings): /wd4245 /wd4305 /wd4310 /wd4389 /wd4805
17+
// ADDITIONAL_COMPILE_FLAGS(has-fconstexpr-steps): -fconstexpr-steps=20000000
18+
// ADDITIONAL_COMPILE_FLAGS(has-fconstexpr-ops-limit): -fconstexpr-ops-limit=80000000
1719

1820
// <algorithm>
1921

@@ -24,6 +26,7 @@
2426

2527
#include <algorithm>
2628
#include <cassert>
29+
#include <cstddef>
2730
#include <deque>
2831
#include <vector>
2932
#include <type_traits>
@@ -227,6 +230,18 @@ TEST_CONSTEXPR_CXX20 bool test() {
227230

228231
types::for_each(types::integral_types(), TestIntegerPromotions());
229232

233+
{ // Test vector<bool>::iterator optimization
234+
std::vector<bool> vec(256 + 8);
235+
for (ptrdiff_t i = 8; i <= 256; i *= 2) {
236+
for (size_t offset = 0; offset < 8; offset += 2) {
237+
std::fill(vec.begin(), vec.end(), false);
238+
std::fill(vec.begin() + offset, vec.begin() + i + offset, true);
239+
assert(std::find(vec.begin(), vec.begin() + i + offset, true) == vec.begin() + offset);
240+
assert(std::find(vec.begin() + offset, vec.end(), false) == vec.begin() + offset + i);
241+
}
242+
}
243+
}
244+
230245
return true;
231246
}
232247

0 commit comments

Comments
 (0)