Skip to content

[libc++] Validate vector<bool> copy/move-assignment operators in realistic scenarios #119817

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

Merged
merged 1 commit into from
Mar 19, 2025
Merged

[libc++] Validate vector<bool> copy/move-assignment operators in realistic scenarios #119817

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
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
64 changes: 47 additions & 17 deletions libcxx/test/std/containers/sequences/vector.bool/assign_copy.pass.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -7,39 +7,69 @@
//===----------------------------------------------------------------------===//

// <vector>
// vector<bool>

// vector& operator=(const vector& c);

#include <vector>
#include <cassert>
#include "test_macros.h"
#include "test_allocator.h"
#include <vector>

#include "min_allocator.h"
#include "test_allocator.h"
#include "test_macros.h"

TEST_CONSTEXPR_CXX20 bool tests() {
{
std::vector<bool, test_allocator<bool> > l(3, true, test_allocator<bool>(5));
std::vector<bool, test_allocator<bool> > l2(l, test_allocator<bool>(3));
TEST_CONSTEXPR_CXX20 void test_copy_assignment(unsigned N) {
//
// Test with insufficient space where reallocation occurs during assignment
//
{ // POCCA = true_type, thus copy-assign the allocator
std::vector<bool, other_allocator<bool> > l(N, true, other_allocator<bool>(5));
std::vector<bool, other_allocator<bool> > l2(other_allocator<bool>(3));
l2 = l;
assert(l2 == l);
assert(l2.get_allocator() == test_allocator<bool>(3));
assert(l2.get_allocator() == other_allocator<bool>(5));
}
{
std::vector<bool, other_allocator<bool> > l(3, true, other_allocator<bool>(5));
std::vector<bool, other_allocator<bool> > l2(l, other_allocator<bool>(3));
{ // POCCA = false_type, thus allocator is unchanged
std::vector<bool, test_allocator<bool> > l(N + 64, true, test_allocator<bool>(5));
std::vector<bool, test_allocator<bool> > l2(10, false, test_allocator<bool>(3));
l2 = l;
assert(l2 == l);
assert(l2.get_allocator() == other_allocator<bool>(5));
assert(l2.get_allocator() == test_allocator<bool>(3));
}
#if TEST_STD_VER >= 11
{
std::vector<bool, min_allocator<bool> > l(3, true, min_allocator<bool>());
std::vector<bool, min_allocator<bool> > l2(l, min_allocator<bool>());
{ // Stateless allocator
std::vector<bool, min_allocator<bool> > l(N + 64, true, min_allocator<bool>());
std::vector<bool, min_allocator<bool> > l2(N / 2, false, min_allocator<bool>());
l2 = l;
assert(l2 == l);
assert(l2.get_allocator() == min_allocator<bool>());
}
#endif

//
// Test with sufficient size where no reallocation occurs during assignment
//
{ // POCCA = false_type, thus allocator is unchanged
std::vector<bool, test_allocator<bool> > l(N, true, test_allocator<bool>(5));
std::vector<bool, test_allocator<bool> > l2(N + 64, false, test_allocator<bool>(3));
l2 = l;
assert(l2 == l);
assert(l2.get_allocator() == test_allocator<bool>(3));
}
{ // POCCA = true_type, thus copy-assign the allocator
std::vector<bool, other_allocator<bool> > l(N, true, other_allocator<bool>(5));
std::vector<bool, other_allocator<bool> > l2(N * 2, false, other_allocator<bool>(3));
l2.reserve(5);
l2 = l;
assert(l2 == l);
assert(l2.get_allocator() == other_allocator<bool>(5));
}
}

TEST_CONSTEXPR_CXX20 bool tests() {
test_copy_assignment(3);
test_copy_assignment(18);
test_copy_assignment(33);
test_copy_assignment(65);
test_copy_assignment(299);

return true;
}
Expand Down
103 changes: 61 additions & 42 deletions libcxx/test/std/containers/sequences/vector.bool/assign_move.pass.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -9,68 +9,87 @@
// UNSUPPORTED: c++03

// <vector>
// vector<bool>

// vector& operator=(vector&& c);

#include <vector>
#include <cassert>
#include "test_macros.h"
#include "test_allocator.h"
#include <vector>

#include "min_allocator.h"
#include "test_allocator.h"
#include "test_macros.h"

TEST_CONSTEXPR_CXX20 bool tests() {
{
std::vector<bool, test_allocator<bool> > l(test_allocator<bool>(5));
std::vector<bool, test_allocator<bool> > lo(test_allocator<bool>(5));
for (int i = 1; i <= 3; ++i) {
l.push_back(i);
lo.push_back(i);
}
std::vector<bool, test_allocator<bool> > l2(test_allocator<bool>(5));
TEST_CONSTEXPR_CXX20 void test_move_assignment(unsigned N) {
//
// Testing for container move where either POCMA = true_type or the allocators compare equal
//
{ // Test with POCMA = true_type
std::vector<bool, other_allocator<bool> > l(N, true, other_allocator<bool>(5));
std::vector<bool, other_allocator<bool> > lo(N, true, other_allocator<bool>(5));
std::vector<bool, other_allocator<bool> > l2(N + 10, false, other_allocator<bool>(42));
l2 = std::move(l);
assert(l2 == lo);
LIBCPP_ASSERT(l.empty());
LIBCPP_ASSERT(l.empty()); // After move, source vector is in a vliad but unspecified state. libc++ leaves it empty.
assert(l2.get_allocator() == lo.get_allocator());
}
{
std::vector<bool, test_allocator<bool> > l(test_allocator<bool>(5));
std::vector<bool, test_allocator<bool> > lo(test_allocator<bool>(5));
for (int i = 1; i <= 3; ++i) {
l.push_back(i);
lo.push_back(i);
}
std::vector<bool, test_allocator<bool> > l2(test_allocator<bool>(6));
{ // Test with POCMA = false_type and allocators compare equal
std::vector<bool, test_allocator<bool> > l(N, true, test_allocator<bool>(5));
std::vector<bool, test_allocator<bool> > lo(N, true, test_allocator<bool>(5));
std::vector<bool, test_allocator<bool> > l2(N + 10, false, test_allocator<bool>(5));
l2 = std::move(l);
assert(l2 == lo);
assert(!l.empty());
assert(l2.get_allocator() == test_allocator<bool>(6));
LIBCPP_ASSERT(l.empty());
assert(l2.get_allocator() == lo.get_allocator());
}
{
std::vector<bool, other_allocator<bool> > l(other_allocator<bool>(5));
std::vector<bool, other_allocator<bool> > lo(other_allocator<bool>(5));
for (int i = 1; i <= 3; ++i) {
l.push_back(i);
lo.push_back(i);
}
std::vector<bool, other_allocator<bool> > l2(other_allocator<bool>(6));
{ // Test with POCMA = false_type and allocators compare equal
std::vector<bool, min_allocator<bool> > l(N, true, min_allocator<bool>{});
std::vector<bool, min_allocator<bool> > lo(N, true, min_allocator<bool>{});
std::vector<bool, min_allocator<bool> > l2(N + 10, false, min_allocator<bool>{});
l2 = std::move(l);
assert(l2 == lo);
assert(l.empty());
LIBCPP_ASSERT(l.empty());
assert(l2.get_allocator() == lo.get_allocator());
}
{
std::vector<bool, min_allocator<bool> > l(min_allocator<bool>{});
std::vector<bool, min_allocator<bool> > lo(min_allocator<bool>{});
for (int i = 1; i <= 3; ++i) {
l.push_back(i);
lo.push_back(i);
}
std::vector<bool, min_allocator<bool> > l2(min_allocator<bool>{});

//
// Testing for element-wise move where POCMA = false_type and allocators compare unequal
//
{ // Test with reallocation during the element-wise move due to empty destination vector.
std::vector<bool, test_allocator<bool> > l(N, true, test_allocator<bool>(5));
std::vector<bool, test_allocator<bool> > lo(N, true, test_allocator<bool>(5));
std::vector<bool, test_allocator<bool> > l2(test_allocator<bool>(42));
l2 = std::move(l);
assert(l2 == lo);
assert(l.empty());
assert(l2.get_allocator() == lo.get_allocator());
LIBCPP_ASSERT(!l.empty());
assert(l2.get_allocator() == test_allocator<bool>(42));
}
{ // Test with reallocation occurs during the element-wise move due to insufficient destination space.
std::vector<bool, test_allocator<bool> > l(N + 64, true, test_allocator<bool>(5));
std::vector<bool, test_allocator<bool> > lo(N + 64, true, test_allocator<bool>(5));
std::vector<bool, test_allocator<bool> > l2(10, false, test_allocator<bool>(42));
l2 = std::move(l);
assert(l2 == lo);
LIBCPP_ASSERT(!l.empty());
assert(l2.get_allocator() == test_allocator<bool>(42));
}
{ // Test without reallocation where source vector elements fit within destination size.
std::vector<bool, test_allocator<bool> > l(N, true, test_allocator<bool>(5));
std::vector<bool, test_allocator<bool> > lo(N, true, test_allocator<bool>(5));
std::vector<bool, test_allocator<bool> > l2(N * 2, false, test_allocator<bool>(42));
l2 = std::move(l);
assert(l2 == lo);
LIBCPP_ASSERT(!l.empty());
assert(l2.get_allocator() == test_allocator<bool>(42));
}
}

TEST_CONSTEXPR_CXX20 bool tests() {
test_move_assignment(3);
test_move_assignment(18);
test_move_assignment(33);
test_move_assignment(65);
test_move_assignment(299);

return true;
}
Expand Down
Loading