Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

[libc++][test] Augment ranges::{fill, fill_n, find} with missing tests #121209

Merged
merged 3 commits into from
Feb 26, 2025
Merged

[libc++][test] Augment ranges::{fill, fill_n, find} with missing tests #121209

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
3 commits
Select commit Hold shift + click to select a range
241835d
Augment ranges::{fill, fill_n, find} with missing tests
winner245 Dec 27, 2024
df759c7
Add test cases for odd-sized vector<bool>
winner245 Jan 30, 2025
34bbd48
Fix test coverage and inline tests for vector<bool>
winner245 Feb 20, 2025
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
137 changes: 72 additions & 65 deletions libcxx/test/std/algorithms/alg.modifying.operations/alg.fill/fill.pass.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -48,89 +48,96 @@ struct Test {
}
};

// Make sure std::fill behaves properly with std::vector<bool> iterators with custom size types.
// See https://github.com/llvm/llvm-project/pull/122410.
TEST_CONSTEXPR_CXX20 void test_bititer_with_custom_sized_types() {
{
using Alloc = sized_allocator<bool, std::uint8_t, std::int8_t>;
std::vector<bool, Alloc> in(100, false, Alloc(1));
std::vector<bool, Alloc> expected(100, true, Alloc(1));
std::fill(in.begin(), in.end(), true);
assert(in == expected);
}
{
using Alloc = sized_allocator<bool, std::uint16_t, std::int16_t>;
std::vector<bool, Alloc> in(200, false, Alloc(1));
std::vector<bool, Alloc> expected(200, true, Alloc(1));
std::fill(in.begin(), in.end(), true);
assert(in == expected);
}
{
using Alloc = sized_allocator<bool, std::uint32_t, std::int32_t>;
std::vector<bool, Alloc> in(200, false, Alloc(1));
std::vector<bool, Alloc> expected(200, true, Alloc(1));
std::fill(in.begin(), in.end(), true);
assert(in == expected);
TEST_CONSTEXPR_CXX20 bool test_vector_bool(std::size_t N) {
{ // Test cases validating leading/trailing bits unfilled remain unchanged
{ // Leading bits are not filled
std::vector<bool> in(N, false);
std::vector<bool> expected(N, true);
expected[0] = expected[1] = false;
std::fill(in.begin() + 2, in.end(), true);
assert(in == expected);
}
{ // Trailing bits are not filled
std::vector<bool> in(N, false);
std::vector<bool> expected(N, true);
expected[N - 1] = expected[N - 2] = false;
std::fill(in.begin(), in.end() - 2, true);
assert(in == expected);
}
{ // Leading and trailing bits are not filled
std::vector<bool> in(N, false);
std::vector<bool> expected(N, true);
expected[0] = expected[1] = expected[N - 1] = expected[N - 2] = false;
std::fill(in.begin() + 2, in.end() - 2, true);
assert(in == expected);
}
}
{
using Alloc = sized_allocator<bool, std::uint64_t, std::int64_t>;
std::vector<bool, Alloc> in(200, false, Alloc(1));
std::vector<bool, Alloc> expected(200, true, Alloc(1));
std::fill(in.begin(), in.end(), true);
assert(in == expected);

{ // Test cases with full or partial bytes filled
{ // Full bytes filled
std::vector<bool> in(N, false);
std::vector<bool> expected(N, true);
std::fill(in.begin(), in.end(), true);
assert(in == expected);
}
{ // Partial bytes with offset filled
std::vector<bool> in(N, false);
std::vector<bool> expected(N, true);
std::fill(in.begin() + 4, in.end() - 4, true);
std::fill(expected.begin(), expected.begin() + 4, false);
std::fill(expected.end() - 4, expected.end(), false);
assert(in == expected);
}
}

return true;
}

TEST_CONSTEXPR_CXX20 bool test() {
types::for_each(types::forward_iterator_list<char*>(), Test<char>());
types::for_each(types::forward_iterator_list<int*>(), Test<int>());
{ // test vector<bool>::iterator optimization
{ // simple case
std::vector<bool> in(4, false);
std::vector<bool> expected(4, true);

{ // Test vector<bool>::iterator optimization
assert(test_vector_bool(8));
assert(test_vector_bool(19));
assert(test_vector_bool(32));
assert(test_vector_bool(49));
assert(test_vector_bool(64));
assert(test_vector_bool(199));
assert(test_vector_bool(256));

// Make sure std::fill behaves properly with std::vector<bool> iterators with custom size types.
// See https://github.com/llvm/llvm-project/pull/122410.
{
using Alloc = sized_allocator<bool, std::uint8_t, std::int8_t>;
std::vector<bool, Alloc> in(100, false, Alloc(1));
std::vector<bool, Alloc> expected(100, true, Alloc(1));
std::fill(in.begin(), in.end(), true);
assert(in == expected);
}
{ // partial byte in the front is not filled
std::vector<bool> in(8, false);
std::vector<bool> expected(8, true);
expected[0] = false;
expected[1] = false;
std::fill(in.begin() + 2, in.end(), true);
assert(in == expected);
}
{ // partial byte in the back is not filled
std::vector<bool> in(8, false);
std::vector<bool> expected(8, true);
expected[6] = false;
expected[7] = false;
std::fill(in.begin(), in.end() - 2, true);
{
using Alloc = sized_allocator<bool, std::uint16_t, std::int16_t>;
std::vector<bool, Alloc> in(200, false, Alloc(1));
std::vector<bool, Alloc> expected(200, true, Alloc(1));
std::fill(in.begin(), in.end(), true);
assert(in == expected);
}
{ // partial byte in the front and back is not filled
std::vector<bool> in(16, false);
std::vector<bool> expected(16, true);
expected[0] = false;
expected[1] = false;
expected[14] = false;
expected[15] = false;
std::fill(in.begin() + 2, in.end() - 2, true);
{
using Alloc = sized_allocator<bool, std::uint32_t, std::int32_t>;
std::vector<bool, Alloc> in(200, false, Alloc(1));
std::vector<bool, Alloc> expected(200, true, Alloc(1));
std::fill(in.begin(), in.end(), true);
assert(in == expected);
}
{ // only a few bits of a byte are set
std::vector<bool> in(8, false);
std::vector<bool> expected(8, true);
expected[0] = false;
expected[1] = false;
expected[6] = false;
expected[7] = false;
std::fill(in.begin() + 2, in.end() - 2, true);
{
using Alloc = sized_allocator<bool, std::uint64_t, std::int64_t>;
std::vector<bool, Alloc> in(200, false, Alloc(1));
std::vector<bool, Alloc> expected(200, true, Alloc(1));
std::fill(in.begin(), in.end(), true);
assert(in == expected);
}
}

test_bititer_with_custom_sized_types();

return true;
}

Expand Down
112 changes: 82 additions & 30 deletions libcxx/test/std/algorithms/alg.modifying.operations/alg.fill/fill_n.pass.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -109,37 +109,49 @@ struct Storage {
};
};

// Make sure std::fill_n behaves properly with std::vector<bool> iterators with custom size types.
// See https://github.com/llvm/llvm-project/pull/122410.
TEST_CONSTEXPR_CXX20 void test_bititer_with_custom_sized_types() {
{
using Alloc = sized_allocator<bool, std::uint8_t, std::int8_t>;
std::vector<bool, Alloc> in(100, false, Alloc(1));
std::vector<bool, Alloc> expected(100, true, Alloc(1));
std::fill_n(in.begin(), in.size(), true);
assert(in == expected);
}
{
using Alloc = sized_allocator<bool, std::uint16_t, std::int16_t>;
std::vector<bool, Alloc> in(200, false, Alloc(1));
std::vector<bool, Alloc> expected(200, true, Alloc(1));
std::fill_n(in.begin(), in.size(), true);
assert(in == expected);
}
{
using Alloc = sized_allocator<bool, std::uint32_t, std::int32_t>;
std::vector<bool, Alloc> in(200, false, Alloc(1));
std::vector<bool, Alloc> expected(200, true, Alloc(1));
std::fill_n(in.begin(), in.size(), true);
assert(in == expected);
TEST_CONSTEXPR_CXX20 bool test_vector_bool(std::size_t N) {
{ // Test cases validating leading/trailing bits unfilled remain unchanged
{ // Leading bits are not filled
std::vector<bool> in(N, false);
std::vector<bool> expected(N, true);
expected[0] = expected[1] = false;
std::fill_n(in.begin() + 2, N - 2, true);
assert(in == expected);
}
{ // Trailing bits are not filled
std::vector<bool> in(N, false);
std::vector<bool> expected(N, true);
expected[N - 1] = expected[N - 2] = false;
std::fill_n(in.begin(), N - 2, true);
assert(in == expected);
}
{ // Leading and trailing bits are not filled
std::vector<bool> in(N, false);
std::vector<bool> expected(N, true);
expected[0] = expected[1] = expected[N - 1] = expected[N - 2] = false;
std::fill_n(in.begin() + 2, N - 4, true);
assert(in == expected);
}
}
{
using Alloc = sized_allocator<bool, std::uint64_t, std::int64_t>;
std::vector<bool, Alloc> in(200, false, Alloc(1));
std::vector<bool, Alloc> expected(200, true, Alloc(1));
std::fill_n(in.begin(), in.size(), true);
assert(in == expected);

{ // Test cases with full or partial bytes filled
{ // Full bytes filled
std::vector<bool> in(N, false);
std::vector<bool> expected(N, true);
std::fill_n(in.begin(), N, true);
assert(in == expected);
}
{ // Partial bytes with offset filled
std::vector<bool> in(N, false);
std::vector<bool> expected(N, true);
std::fill_n(in.begin() + 4, N - 8, true);
std::fill_n(expected.begin(), 4, false);
std::fill_n(expected.end() - 4, 4, false);
assert(in == expected);
}
}

return true;
}

TEST_CONSTEXPR_CXX20 void test_struct_array() {
Expand Down Expand Up @@ -171,7 +183,47 @@ TEST_CONSTEXPR_CXX20 bool test() {
test_int_array();
test_struct_array();
test_int_array_struct_source();
test_bititer_with_custom_sized_types();

{ // Test vector<bool>::iterator optimization
assert(test_vector_bool(8));
assert(test_vector_bool(19));
assert(test_vector_bool(32));
assert(test_vector_bool(49));
assert(test_vector_bool(64));
assert(test_vector_bool(199));
assert(test_vector_bool(256));

// Make sure std::fill_n behaves properly with std::vector<bool> iterators with custom size types.
// See https://github.com/llvm/llvm-project/pull/122410.
{
using Alloc = sized_allocator<bool, std::uint8_t, std::int8_t>;
std::vector<bool, Alloc> in(100, false, Alloc(1));
std::vector<bool, Alloc> expected(100, true, Alloc(1));
std::fill_n(in.begin(), in.size(), true);
assert(in == expected);
}
{
using Alloc = sized_allocator<bool, std::uint16_t, std::int16_t>;
std::vector<bool, Alloc> in(200, false, Alloc(1));
std::vector<bool, Alloc> expected(200, true, Alloc(1));
std::fill_n(in.begin(), in.size(), true);
assert(in == expected);
}
{
using Alloc = sized_allocator<bool, std::uint32_t, std::int32_t>;
std::vector<bool, Alloc> in(200, false, Alloc(1));
std::vector<bool, Alloc> expected(200, true, Alloc(1));
std::fill_n(in.begin(), in.size(), true);
assert(in == expected);
}
{
using Alloc = sized_allocator<bool, std::uint64_t, std::int64_t>;
std::vector<bool, Alloc> in(200, false, Alloc(1));
std::vector<bool, Alloc> expected(200, true, Alloc(1));
std::fill_n(in.begin(), in.size(), true);
assert(in == expected);
}
}

return true;
}
Expand Down
Loading
Loading