[libcxx-commits] [libcxx] [libc++][test] Add exception tests for vector capacity operations (PR #118141)
Peng Liu via libcxx-commits
libcxx-commits at lists.llvm.org
Mon Dec 2 22:24:37 PST 2024
https://github.com/winner245 updated https://github.com/llvm/llvm-project/pull/118141
>From a58e4e4f97d868a8d7487ba2eba20cd936d6140a Mon Sep 17 00:00:00 2001
From: Peng Liu <winner245 at hotmail.com>
Date: Fri, 29 Nov 2024 17:38:31 -0500
Subject: [PATCH] Add exception tests for vector capacity operations
---
.../std/containers/sequences/vector/common.h | 89 +++++
.../vector/vector.capacity/reserve.pass.cpp | 180 ++++------
.../reserve_exceptions.pass.cpp | 338 ++++++++++++++++++
.../resize_exceptions.pass.cpp | 336 +++++++++++++++++
.../shrink_to_fit_exceptions.pass.cpp | 294 +++++++++++++++
libcxx/test/support/increasing_allocator.h | 61 ++++
libcxx/test/support/test_allocator.h | 3 +
7 files changed, 1186 insertions(+), 115 deletions(-)
create mode 100644 libcxx/test/std/containers/sequences/vector/vector.capacity/reserve_exceptions.pass.cpp
create mode 100644 libcxx/test/std/containers/sequences/vector/vector.capacity/resize_exceptions.pass.cpp
create mode 100644 libcxx/test/std/containers/sequences/vector/vector.capacity/shrink_to_fit_exceptions.pass.cpp
create mode 100644 libcxx/test/support/increasing_allocator.h
diff --git a/libcxx/test/std/containers/sequences/vector/common.h b/libcxx/test/std/containers/sequences/vector/common.h
index e793ab2a21c1d0..417ac493d13c90 100644
--- a/libcxx/test/std/containers/sequences/vector/common.h
+++ b/libcxx/test/std/containers/sequences/vector/common.h
@@ -13,8 +13,97 @@
#include <cstddef>
#include <memory>
#include <type_traits>
+#include <utility>
#include "count_new.h"
+#include "test_macros.h"
+
+#if TEST_STD_VER >= 11
+
+template <typename T>
+struct move_only_throwing_t {
+ T data_;
+ int* throw_after_n_ = nullptr;
+ bool moved_from_ = false;
+
+ move_only_throwing_t(const T& data, int& throw_after_n) : data_(data), throw_after_n_(&throw_after_n) {
+ if (throw_after_n == 0)
+ throw 0;
+ --throw_after_n;
+ }
+
+ move_only_throwing_t(T&& data, int& throw_after_n) : data_(std::move(data)), throw_after_n_(&throw_after_n) {
+ if (throw_after_n == 0)
+ throw 0;
+ --throw_after_n;
+ }
+
+ move_only_throwing_t(const move_only_throwing_t&) = delete;
+ move_only_throwing_t& operator=(const move_only_throwing_t&) = delete;
+
+ move_only_throwing_t(move_only_throwing_t&& rhs) : data_(std::move(rhs.data_)), throw_after_n_(rhs.throw_after_n_) {
+ rhs.throw_after_n_ = nullptr;
+ rhs.moved_from_ = true;
+ if (throw_after_n_ == nullptr || *throw_after_n_ == 0)
+ throw 1;
+ --*throw_after_n_;
+ }
+
+ move_only_throwing_t& operator=(move_only_throwing_t&& rhs) {
+ if (this == &rhs)
+ return *this;
+ data_ = std::move(rhs.data_);
+ throw_after_n_ = rhs.throw_after_n_;
+ rhs.moved_from_ = true;
+ rhs.throw_after_n_ = nullptr;
+ if (throw_after_n_ == nullptr || *throw_after_n_ == 0)
+ throw 1;
+ --*throw_after_n_;
+ return *this;
+ }
+
+ friend bool operator==(const move_only_throwing_t& lhs, const move_only_throwing_t& rhs) {
+ return lhs.data_ == rhs.data_;
+ }
+ friend bool operator!=(const move_only_throwing_t& lhs, const move_only_throwing_t& rhs) {
+ return lhs.data_ != rhs.data_;
+ }
+};
+
+#endif
+
+template <typename T>
+struct throwing_data {
+ T data_;
+ int* throw_after_n_ = nullptr;
+ throwing_data() { throw 0; }
+
+ throwing_data(const T& data, int& throw_after_n) : data_(data), throw_after_n_(&throw_after_n) {
+ if (throw_after_n == 0)
+ throw 0;
+ --throw_after_n;
+ }
+
+ throwing_data(const throwing_data& rhs) : data_(rhs.data_), throw_after_n_(rhs.throw_after_n_) {
+ if (throw_after_n_ == nullptr || *throw_after_n_ == 0)
+ throw 1;
+ --*throw_after_n_;
+ }
+
+ throwing_data& operator=(const throwing_data& rhs) {
+ data_ = rhs.data_;
+ throw_after_n_ = rhs.throw_after_n_;
+ if (throw_after_n_ == nullptr || *throw_after_n_ == 0)
+ throw 1;
+ --*throw_after_n_;
+ return *this;
+ }
+
+ friend bool operator==(const throwing_data& lhs, const throwing_data& rhs) {
+ return lhs.data_ == rhs.data_ && lhs.throw_after_n_ == rhs.throw_after_n_;
+ }
+ friend bool operator!=(const throwing_data& lhs, const throwing_data& rhs) { return !(lhs == rhs); }
+};
template <class T>
struct throwing_allocator {
diff --git a/libcxx/test/std/containers/sequences/vector/vector.capacity/reserve.pass.cpp b/libcxx/test/std/containers/sequences/vector/vector.capacity/reserve.pass.cpp
index b8548ad72d4376..38e969335e0adb 100644
--- a/libcxx/test/std/containers/sequences/vector/vector.capacity/reserve.pass.cpp
+++ b/libcxx/test/std/containers/sequences/vector/vector.capacity/reserve.pass.cpp
@@ -19,126 +19,76 @@
#include "asan_testing.h"
TEST_CONSTEXPR_CXX20 bool tests() {
- {
- std::vector<int> v;
- v.reserve(10);
- assert(v.capacity() >= 10);
- assert(is_contiguous_container_asan_correct(v));
- }
- {
- std::vector<int> v(100);
- assert(v.capacity() == 100);
- v.reserve(50);
- assert(v.size() == 100);
- assert(v.capacity() == 100);
- v.reserve(150);
- assert(v.size() == 100);
- assert(v.capacity() == 150);
- assert(is_contiguous_container_asan_correct(v));
- }
- {
- // Add 1 for implementations that dynamically allocate a container proxy.
- std::vector<int, limited_allocator<int, 250 + 1> > v(100);
- assert(v.capacity() == 100);
- v.reserve(50);
- assert(v.size() == 100);
- assert(v.capacity() == 100);
- v.reserve(150);
- assert(v.size() == 100);
- assert(v.capacity() == 150);
- assert(is_contiguous_container_asan_correct(v));
- }
-#ifndef TEST_HAS_NO_EXCEPTIONS
- if (!TEST_IS_CONSTANT_EVALUATED) {
- std::vector<int> v;
- std::size_t sz = v.max_size() + 1;
-
- try {
- v.reserve(sz);
- assert(false);
- } catch (const std::length_error&) {
- assert(v.size() == 0);
- assert(v.capacity() == 0);
- }
- }
- if (!TEST_IS_CONSTANT_EVALUATED) {
- std::vector<int> v(10, 42);
- int* previous_data = v.data();
- std::size_t previous_capacity = v.capacity();
- std::size_t sz = v.max_size() + 1;
-
- try {
- v.reserve(sz);
- assert(false);
- } catch (std::length_error&) {
- assert(v.size() == 10);
- assert(v.capacity() == previous_capacity);
- assert(v.data() == previous_data);
-
- for (int i = 0; i < 10; ++i) {
- assert(v[i] == 42);
- }
- }
- }
-#endif
+ {
+ std::vector<int> v;
+ v.reserve(10);
+ assert(v.capacity() >= 10);
+ assert(is_contiguous_container_asan_correct(v));
+ }
+ {
+ std::vector<int> v(100);
+ assert(v.capacity() == 100);
+ v.reserve(50);
+ assert(v.size() == 100);
+ assert(v.capacity() == 100);
+ v.reserve(150);
+ assert(v.size() == 100);
+ assert(v.capacity() == 150);
+ assert(is_contiguous_container_asan_correct(v));
+ }
+ {
+ // Add 1 for implementations that dynamically allocate a container proxy.
+ std::vector<int, limited_allocator<int, 250 + 1> > v(100);
+ assert(v.capacity() == 100);
+ v.reserve(50);
+ assert(v.size() == 100);
+ assert(v.capacity() == 100);
+ v.reserve(150);
+ assert(v.size() == 100);
+ assert(v.capacity() == 150);
+ assert(is_contiguous_container_asan_correct(v));
+ }
#if TEST_STD_VER >= 11
- {
- std::vector<int, min_allocator<int>> v;
- v.reserve(10);
- assert(v.capacity() >= 10);
- assert(is_contiguous_container_asan_correct(v));
- }
- {
- std::vector<int, min_allocator<int>> v(100);
- assert(v.capacity() == 100);
- v.reserve(50);
- assert(v.size() == 100);
- assert(v.capacity() == 100);
- v.reserve(150);
- assert(v.size() == 100);
- assert(v.capacity() == 150);
- assert(is_contiguous_container_asan_correct(v));
- }
- {
- std::vector<int, safe_allocator<int>> v;
- v.reserve(10);
- assert(v.capacity() >= 10);
- assert(is_contiguous_container_asan_correct(v));
- }
- {
- std::vector<int, safe_allocator<int>> v(100);
- assert(v.capacity() == 100);
- v.reserve(50);
- assert(v.size() == 100);
- assert(v.capacity() == 100);
- v.reserve(150);
- assert(v.size() == 100);
- assert(v.capacity() == 150);
- assert(is_contiguous_container_asan_correct(v));
- }
-#endif
-#ifndef TEST_HAS_NO_EXCEPTIONS
- if (!TEST_IS_CONSTANT_EVALUATED) {
- std::vector<int, limited_allocator<int, 100> > v;
- v.reserve(50);
- assert(v.capacity() == 50);
- assert(is_contiguous_container_asan_correct(v));
- try {
- v.reserve(101);
- assert(false);
- } catch (const std::length_error&) {
- // no-op
- }
- assert(v.capacity() == 50);
- assert(is_contiguous_container_asan_correct(v));
- }
+ {
+ std::vector<int, min_allocator<int>> v;
+ v.reserve(10);
+ assert(v.capacity() >= 10);
+ assert(is_contiguous_container_asan_correct(v));
+ }
+ {
+ std::vector<int, min_allocator<int>> v(100);
+ assert(v.capacity() == 100);
+ v.reserve(50);
+ assert(v.size() == 100);
+ assert(v.capacity() == 100);
+ v.reserve(150);
+ assert(v.size() == 100);
+ assert(v.capacity() == 150);
+ assert(is_contiguous_container_asan_correct(v));
+ }
+ {
+ std::vector<int, safe_allocator<int>> v;
+ v.reserve(10);
+ assert(v.capacity() >= 10);
+ assert(is_contiguous_container_asan_correct(v));
+ }
+ {
+ std::vector<int, safe_allocator<int>> v(100);
+ assert(v.capacity() == 100);
+ v.reserve(50);
+ assert(v.size() == 100);
+ assert(v.capacity() == 100);
+ v.reserve(150);
+ assert(v.size() == 100);
+ assert(v.capacity() == 150);
+ assert(is_contiguous_container_asan_correct(v));
+ }
#endif
- return true;
+ return true;
}
-int main(int, char**)
-{
+int main(int, char**) {
tests();
#if TEST_STD_VER > 17
diff --git a/libcxx/test/std/containers/sequences/vector/vector.capacity/reserve_exceptions.pass.cpp b/libcxx/test/std/containers/sequences/vector/vector.capacity/reserve_exceptions.pass.cpp
new file mode 100644
index 00000000000000..f9349c565957c0
--- /dev/null
+++ b/libcxx/test/std/containers/sequences/vector/vector.capacity/reserve_exceptions.pass.cpp
@@ -0,0 +1,338 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: no-exceptions
+
+// This test file checks that std::vector<T>::reserve provides a strong exception guarantee if T is Cpp17CopyInsertible.
+// It also checks that if T is Cpp17MoveInsertible && !Cpp17CopyInsertible, and T's move constructor is not noexcept,
+// std::vector<T>::reserve provides a basic exception guarantee.
+
+#include <cstddef>
+#include <memory>
+#include <stdexcept>
+#include <type_traits>
+#include <vector>
+
+#include "../common.h"
+#include "MoveOnly.h"
+#include "count_new.h"
+#include "increasing_allocator.h"
+#include "min_allocator.h"
+#include "test_allocator.h"
+#include "test_iterators.h"
+#include "test_macros.h"
+#if TEST_STD_VER >= 11
+# include "../../../../../benchmarks/GenerateInput.h"
+#endif
+
+template <typename T, typename Alloc>
+void test_allocation_exception_for_strong_guarantee(
+ std::vector<T, Alloc>& v, const std::vector<T>& values, std::size_t new_cap) {
+ T* old_data = v.data();
+ std::size_t old_size = v.size();
+ std::size_t old_cap = v.capacity();
+
+ try {
+ v.reserve(new_cap);
+ } catch (std::exception&) {
+ std::printf("allocation exception!\n");
+ assert(v.data() == old_data);
+ assert(v.size() == old_size);
+ assert(v.capacity() == old_cap);
+ for (std::size_t i = 0; i < v.size(); ++i)
+ assert(v[i] == values[i]);
+ }
+}
+
+template <typename T, typename Alloc>
+void test_copy_ctor_exception_for_strong_guarantee(std::vector<throwing_data<T>, Alloc>& v,
+ const std::vector<T>& values) {
+ assert(v.empty() && !values.empty());
+ int throw_after = values.size() + values.size() / 2; // Throw in the middle of reallocation
+ v.reserve(values.size());
+ for (std::size_t i = 0; i < values.size(); ++i)
+ v.emplace_back(values[i], throw_after);
+
+ throwing_data<T>* old_data = v.data();
+ std::size_t old_size = v.size();
+ std::size_t old_cap = v.capacity();
+ std::size_t new_cap = 2 * old_cap;
+
+ std::printf("throw_after = %2d, ", throw_after);
+
+ try {
+ v.reserve(new_cap);
+ } catch (...) {
+ std::printf("copy-ctor exception\n");
+ assert(v.data() == old_data);
+ assert(v.size() == old_size);
+ assert(v.capacity() == old_cap);
+ for (std::size_t i = 0; i < v.size(); ++i)
+ assert(v[i].data_ == values[i]);
+ }
+}
+
+#if TEST_STD_VER >= 11
+
+template <typename T, typename Alloc>
+void test_move_ctor_exception_for_basic_guarantee(std::vector<move_only_throwing_t<T>, Alloc>& v,
+ const std::vector<T>& values) {
+ assert(v.empty() && !values.empty());
+ int throw_after = values.size() + values.size() / 2; // Throw in the middle of reallocation
+ v.reserve(values.size());
+ for (std::size_t i = 0; i < values.size(); ++i)
+ v.emplace_back(values[i], throw_after);
+
+ move_only_throwing_t<T>* old_data = v.data();
+ std::size_t old_size = v.size();
+ std::size_t old_cap = v.capacity();
+ std::size_t new_cap = 2 * old_cap;
+
+ try {
+ v.reserve(new_cap);
+ } catch (...) {
+ std::printf("move-ctor exception\n");
+ assert(v.data() == old_data);
+ assert(v.size() == old_size);
+ assert(v.capacity() == old_cap);
+
+ // After a failure during element-wise move, the vector elements are left in a valid but unspecified state.
+ for (std::size_t i = 0; i < v.size(); ++i) {
+ assert(((void)v[i],
+ (void)v[i].data_,
+ (void)v[i].throw_after_n_,
+ (void)(v[i] == v[i]),
+ v[i].moved_from_ || v[i].data_ == values[i]));
+ }
+ }
+}
+
+#endif
+
+// Check the strong exception guarantee during reallocation failures
+void test_allocation_exceptions() {
+ //
+ // Tests for std::length_error during reallocation failures
+ //
+ {
+ std::vector<int> v;
+ test_allocation_exception_for_strong_guarantee(v, std::vector<int>(), v.max_size() + 1);
+ }
+ check_new_delete_called();
+
+ {
+ int a[] = {1, 2, 3, 4, 5};
+ std::vector<int> in(a, a + sizeof(a) / sizeof(a[0]));
+ std::vector<int> v(in.begin(), in.end());
+ test_allocation_exception_for_strong_guarantee(v, in, v.max_size() + 1);
+ }
+ check_new_delete_called();
+
+ {
+ int a[] = {1, 2, 3, 4, 5};
+ std::vector<int> in(a, a + sizeof(a) / sizeof(a[0]));
+ std::vector<int, min_allocator<int> > v(in.begin(), in.end());
+ test_allocation_exception_for_strong_guarantee(v, in, v.max_size() + 1);
+ }
+ check_new_delete_called();
+
+ {
+ int a[] = {1, 2, 3, 4, 5};
+ std::vector<int> in(a, a + sizeof(a) / sizeof(a[0]));
+ std::vector<int, safe_allocator<int> > v(in.begin(), in.end());
+ test_allocation_exception_for_strong_guarantee(v, in, v.max_size() + 1);
+ }
+ check_new_delete_called();
+
+ {
+ int a[] = {1, 2, 3, 4, 5};
+ std::vector<int> in(a, a + sizeof(a) / sizeof(a[0]));
+ std::vector<int, test_allocator<int> > v(in.begin(), in.end());
+ test_allocation_exception_for_strong_guarantee(v, in, v.max_size() + 1);
+ }
+ check_new_delete_called();
+
+ {
+ std::vector<int> in(10, 42);
+ std::vector<int, limited_allocator<int, 100> > v(in.begin(), in.end());
+ std::printf("Alloc remaining = %zu, ", v.get_allocator().max_alloc_remaining());
+ test_allocation_exception_for_strong_guarantee(v, in, v.max_size() + 1);
+ }
+ check_new_delete_called();
+
+#if TEST_STD_VER >= 23
+ {
+ std::vector<int> in{0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
+ std::vector<int, increasing_allocator<int>> v(in.begin(), in.end());
+ test_allocation_exception_for_strong_guarantee(v, in, v.max_size() + 1);
+ }
+ check_new_delete_called();
+#endif
+
+ //
+ // Tests for std::bad_alloc during reallocation failures
+ //
+ {
+ std::vector<int> in(10, 42);
+ std::vector<int, limited_allocator<int, 100> > v(in.begin(), in.end());
+ std::printf("Alloc remaining = %zu, ", v.get_allocator().max_alloc_remaining());
+ test_allocation_exception_for_strong_guarantee(v, in, 91);
+ }
+ check_new_delete_called();
+
+ {
+ std::vector<int> in(10, 42);
+ std::vector<int, limited_allocator<int, 100> > v(in.begin(), in.end());
+ v.reserve(30);
+ std::printf("Alloc remaining = %zu, ", v.get_allocator().max_alloc_remaining());
+ test_allocation_exception_for_strong_guarantee(v, in, 61);
+ }
+ check_new_delete_called();
+
+#if TEST_STD_VER >= 11
+ {
+ std::vector<MoveOnly> in(10);
+ std::vector<MoveOnly, limited_allocator<MoveOnly, 100> > v(10);
+ std::printf("Alloc remaining = %zu, ", v.get_allocator().max_alloc_remaining());
+ test_allocation_exception_for_strong_guarantee(v, in, 91);
+ }
+ check_new_delete_called();
+
+ {
+ std::vector<MoveOnly> in(10);
+ in.insert(in.cbegin() + 5, MoveOnly(42));
+ std::vector<MoveOnly, limited_allocator<MoveOnly, 100> > v(10);
+ v.reserve(30);
+ v.insert(v.cbegin() + 5, MoveOnly(42));
+ std::printf("Alloc remaining = %zu, ", v.get_allocator().max_alloc_remaining());
+ test_allocation_exception_for_strong_guarantee(v, in, 61);
+ }
+ check_new_delete_called();
+
+ { // Practical example: Testing with 100 randomly generated integers.
+ auto in = getRandomIntegerInputs<int>(100);
+ std::vector<int, limited_allocator<int, 299>> v(in.begin(), in.end());
+ std::printf("Alloc remaining = %zu, ", v.get_allocator().max_alloc_remaining());
+ test_allocation_exception_for_strong_guarantee(v, in, 200);
+ }
+ check_new_delete_called();
+
+ { // Practical example: Testing with 100 randomly generated strings, each 256 characters long.
+ std::vector<std::string> in = getRandomStringInputsWithLength(100, 256);
+ std::vector<std::string, limited_allocator<std::string, 299>> v(in.begin(), in.end());
+ std::printf("Alloc remaining = %zu, ", v.get_allocator().max_alloc_remaining());
+ test_allocation_exception_for_strong_guarantee(v, in, 200);
+ }
+ check_new_delete_called();
+#endif
+}
+
+// Check the strong exception guarantee during copy-constructor failures
+void test_copy_ctor_exceptions() {
+ {
+ int a[] = {1, 2, 3, 4, 5};
+ std::vector<int> in(a, a + sizeof(a) / sizeof(a[0]));
+ std::vector<throwing_data<int> > v;
+ test_copy_ctor_exception_for_strong_guarantee(v, in);
+ }
+ check_new_delete_called();
+
+ {
+ int a[] = {1, 2, 3, 4, 5};
+ std::vector<int> in(a, a + sizeof(a) / sizeof(a[0]));
+ std::vector<throwing_data<int>, min_allocator<throwing_data<int> > > v;
+ test_copy_ctor_exception_for_strong_guarantee(v, in);
+ }
+ check_new_delete_called();
+
+ {
+ std::vector<int> in(10, 42);
+ std::vector<throwing_data<int>, safe_allocator<throwing_data<int> > > v;
+ test_copy_ctor_exception_for_strong_guarantee(v, in);
+ }
+ check_new_delete_called();
+
+ {
+ std::vector<int> in(10, 42);
+ std::vector<throwing_data<int>, test_allocator<throwing_data<int> > > v;
+ test_copy_ctor_exception_for_strong_guarantee(v, in);
+ }
+ check_new_delete_called();
+
+ {
+ std::vector<int> in(10, 42);
+ std::vector<throwing_data<int>, limited_allocator<throwing_data<int>, 100> > v;
+ test_copy_ctor_exception_for_strong_guarantee(v, in);
+ }
+ check_new_delete_called();
+
+#if TEST_STD_VER >= 23
+ {
+ std::vector<int> in{0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
+ std::vector<throwing_data<int>, increasing_allocator<throwing_data<int>>> v;
+ test_copy_ctor_exception_for_strong_guarantee(v, in);
+ }
+ check_new_delete_called();
+#endif
+
+#if TEST_STD_VER >= 11
+ { // Practical example: Testing with 100 randomly generated integers.
+ auto in = getRandomIntegerInputs<int>(100);
+ std::vector<throwing_data<int>> v;
+ test_copy_ctor_exception_for_strong_guarantee(v, in);
+ }
+ check_new_delete_called();
+
+ { // Practical example: Testing with 100 randomly generated strings, each 256 characters long.
+ std::vector<std::string> in = getRandomStringInputsWithLength(100, 256);
+ std::vector<throwing_data<std::string>> v;
+ test_copy_ctor_exception_for_strong_guarantee(v, in);
+ }
+ check_new_delete_called();
+#endif
+}
+
+#if TEST_STD_VER >= 11
+
+// Check that if T is Cpp17MoveInsertible && !Cpp17CopyInsertible, and T's move-ctor is not noexcept, then
+// std::vector::reserve only provides basic guarantee.
+void test_move_ctor_exceptions() {
+ {
+ std::vector<int> in{0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
+ std::vector<move_only_throwing_t<int>> v;
+ test_move_ctor_exception_for_basic_guarantee(v, in);
+ }
+ check_new_delete_called();
+
+# if TEST_STD_VER >= 23
+ {
+ std::vector<int> in{0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
+ std::vector<move_only_throwing_t<int>, increasing_allocator<move_only_throwing_t<int>>> v;
+ test_move_ctor_exception_for_basic_guarantee(v, in);
+ }
+ check_new_delete_called();
+# endif
+
+ {
+ // Practical example: Testing with 100 randomly generated strings, each 256 characters long.
+ std::vector<std::string> in = getRandomStringInputsWithLength(100, 256);
+ std::vector<move_only_throwing_t<std::string> > v;
+ test_move_ctor_exception_for_basic_guarantee(v, in);
+ }
+ check_new_delete_called();
+}
+
+#endif
+
+int main(int, char**) {
+ test_allocation_exceptions();
+ test_copy_ctor_exceptions();
+#if TEST_STD_VER >= 11
+ test_move_ctor_exceptions();
+#endif
+}
diff --git a/libcxx/test/std/containers/sequences/vector/vector.capacity/resize_exceptions.pass.cpp b/libcxx/test/std/containers/sequences/vector/vector.capacity/resize_exceptions.pass.cpp
new file mode 100644
index 00000000000000..57dfef2ccf1b9f
--- /dev/null
+++ b/libcxx/test/std/containers/sequences/vector/vector.capacity/resize_exceptions.pass.cpp
@@ -0,0 +1,336 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: no-exceptions
+
+// Check that std::vector<T>::resize provides a strong exception guarantee
+
+#include <cstddef>
+#include <memory>
+#include <stdexcept>
+#include <type_traits>
+#include <vector>
+
+#include "../common.h"
+#include "MoveOnly.h"
+#include "count_new.h"
+#include "increasing_allocator.h"
+#include "min_allocator.h"
+#include "test_allocator.h"
+#include "test_iterators.h"
+#include "test_macros.h"
+#if TEST_STD_VER >= 11
+# include "../../../../../benchmarks/GenerateInput.h"
+#endif
+
+template <typename T, typename Alloc>
+void test_allocation_exception_for_strong_guarantee(
+ std::vector<T, Alloc>& v, const std::vector<T>& values, std::size_t new_size) {
+ T* old_data = v.data();
+ std::size_t old_size = v.size();
+ std::size_t old_cap = v.capacity();
+
+ try {
+ v.resize(new_size);
+ } catch (std::exception&) {
+ std::printf("allocation exception!\n");
+ assert(v.data() == old_data);
+ assert(v.size() == old_size);
+ assert(v.capacity() == old_cap);
+ for (std::size_t i = 0; i < v.size(); ++i)
+ assert(v[i] == values[i]);
+ }
+}
+
+template <typename T, typename Alloc>
+void test_copy_ctor_exception_for_strong_guarantee(std::vector<throwing_data<T>, Alloc>& v,
+ const std::vector<T>& values) {
+ assert(v.empty() && !values.empty());
+ int throw_after = values.size() + values.size() / 2; // Throw in the middle of reallocation
+ v.reserve(values.size());
+ for (std::size_t i = 0; i < values.size(); ++i)
+ v.emplace_back(values[i], throw_after);
+
+ throwing_data<T>* old_data = v.data();
+ std::size_t old_size = v.size();
+ std::size_t old_cap = v.capacity();
+ std::size_t new_size = 2 * old_size;
+
+ std::printf("throw_after = %2d, ", throw_after);
+
+ try {
+ v.resize(new_size);
+ } catch (...) {
+ std::printf("copy-ctor exception\n");
+ assert(v.data() == old_data);
+ assert(v.size() == old_size);
+ assert(v.capacity() == old_cap);
+ for (std::size_t i = 0; i < v.size(); ++i)
+ assert(v[i].data_ == values[i]);
+ }
+}
+
+#if TEST_STD_VER >= 11
+
+template <typename T, typename Alloc>
+void test_move_ctor_exception_for_basic_guarantee(std::vector<move_only_throwing_t<T>, Alloc>& v,
+ const std::vector<T>& values) {
+ assert(v.empty() && !values.empty());
+ int throw_after = values.size() + values.size() / 2; // Throw in the middle of reallocation
+ v.reserve(values.size());
+ for (std::size_t i = 0; i < values.size(); ++i)
+ v.emplace_back(values[i], throw_after);
+
+ move_only_throwing_t<T>* old_data = v.data();
+ std::size_t old_size = v.size();
+ std::size_t old_cap = v.capacity();
+ std::size_t new_size = 2 * old_size;
+
+ try {
+ v.resize(new_size);
+ } catch (...) {
+ std::printf("move-ctor exception\n");
+ assert(v.data() == old_data);
+ assert(v.size() == old_size);
+ assert(v.capacity() == old_cap);
+
+ // After a failure during element-wise move, the vector elements are left in a valid but unspecified state.
+ for (std::size_t i = 0; i < v.size(); ++i) {
+ assert(((void)v[i],
+ (void)v[i].data_,
+ (void)v[i].throw_after_n_,
+ (void)(v[i] == v[i]),
+ v[i].moved_from_ || v[i].data_ == values[i]));
+ }
+ }
+}
+
+#endif
+
+// Check the strong exception guarantee during reallocation failures
+void test_allocation_exceptions() {
+ //
+ // Tests for std::length_error during reallocation failures
+ //
+ {
+ std::vector<int> v;
+ test_allocation_exception_for_strong_guarantee(v, std::vector<int>(), v.max_size() + 1);
+ }
+ check_new_delete_called();
+
+ {
+ int a[] = {1, 2, 3, 4, 5};
+ std::vector<int> in(a, a + sizeof(a) / sizeof(a[0]));
+ std::vector<int> v(in.begin(), in.end());
+ test_allocation_exception_for_strong_guarantee(v, in, v.max_size() + 1);
+ }
+ check_new_delete_called();
+
+ {
+ int a[] = {1, 2, 3, 4, 5};
+ std::vector<int> in(a, a + sizeof(a) / sizeof(a[0]));
+ std::vector<int, min_allocator<int> > v(in.begin(), in.end());
+ test_allocation_exception_for_strong_guarantee(v, in, v.max_size() + 1);
+ }
+ check_new_delete_called();
+
+ {
+ int a[] = {1, 2, 3, 4, 5};
+ std::vector<int> in(a, a + sizeof(a) / sizeof(a[0]));
+ std::vector<int, safe_allocator<int> > v(in.begin(), in.end());
+ test_allocation_exception_for_strong_guarantee(v, in, v.max_size() + 1);
+ }
+ check_new_delete_called();
+
+ {
+ int a[] = {1, 2, 3, 4, 5};
+ std::vector<int> in(a, a + sizeof(a) / sizeof(a[0]));
+ std::vector<int, test_allocator<int> > v(in.begin(), in.end());
+ test_allocation_exception_for_strong_guarantee(v, in, v.max_size() + 1);
+ }
+ check_new_delete_called();
+
+ {
+ std::vector<int> in(10, 42);
+ std::vector<int, limited_allocator<int, 100> > v(in.begin(), in.end());
+ std::printf("Alloc remaining = %zu, ", v.get_allocator().max_alloc_remaining());
+ test_allocation_exception_for_strong_guarantee(v, in, v.max_size() + 1);
+ }
+ check_new_delete_called();
+
+#if TEST_STD_VER >= 23
+ {
+ std::vector<int> in{0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
+ std::vector<int, increasing_allocator<int>> v(in.begin(), in.end());
+ test_allocation_exception_for_strong_guarantee(v, in, v.max_size() + 1);
+ }
+ check_new_delete_called();
+#endif
+
+ //
+ // Tests for std::bad_alloc during reallocation failures
+ //
+ {
+ std::vector<int> in(10, 42);
+ std::vector<int, limited_allocator<int, 100> > v(in.begin(), in.end());
+ std::printf("Alloc remaining = %zu, ", v.get_allocator().max_alloc_remaining());
+ test_allocation_exception_for_strong_guarantee(v, in, 91);
+ }
+ check_new_delete_called();
+
+ {
+ std::vector<int> in(10, 42);
+ std::vector<int, limited_allocator<int, 100> > v(in.begin(), in.end());
+ v.reserve(30);
+ std::printf("Alloc remaining = %zu, ", v.get_allocator().max_alloc_remaining());
+ test_allocation_exception_for_strong_guarantee(v, in, 61);
+ }
+ check_new_delete_called();
+
+#if TEST_STD_VER >= 11
+ {
+ std::vector<MoveOnly> in(10);
+ std::vector<MoveOnly, limited_allocator<MoveOnly, 100> > v(10);
+ std::printf("Alloc remaining = %zu, ", v.get_allocator().max_alloc_remaining());
+ test_allocation_exception_for_strong_guarantee(v, in, 91);
+ }
+ check_new_delete_called();
+
+ {
+ std::vector<MoveOnly> in(10);
+ in.insert(in.cbegin() + 5, MoveOnly(42));
+ std::vector<MoveOnly, limited_allocator<MoveOnly, 100> > v(10);
+ v.reserve(30);
+ v.insert(v.cbegin() + 5, MoveOnly(42));
+ std::printf("Alloc remaining = %zu, ", v.get_allocator().max_alloc_remaining());
+ test_allocation_exception_for_strong_guarantee(v, in, 61);
+ }
+ check_new_delete_called();
+
+ { // Practical example: Testing with 100 randomly generated integers.
+ auto in = getRandomIntegerInputs<int>(100);
+ std::vector<int, limited_allocator<int, 299>> v(in.begin(), in.end());
+ std::printf("Alloc remaining = %zu, ", v.get_allocator().max_alloc_remaining());
+ test_allocation_exception_for_strong_guarantee(v, in, 200);
+ }
+ check_new_delete_called();
+
+ { // Practical example: Testing with 100 randomly generated strings, each 256 characters long.
+ std::vector<std::string> in = getRandomStringInputsWithLength(100, 256);
+ std::vector<std::string, limited_allocator<std::string, 299>> v(in.begin(), in.end());
+ std::printf("Alloc remaining = %zu, ", v.get_allocator().max_alloc_remaining());
+ test_allocation_exception_for_strong_guarantee(v, in, 200);
+ }
+ check_new_delete_called();
+#endif
+}
+
+// Check the strong exception guarantee during copy-constructor failures
+void test_copy_ctor_exceptions() {
+ {
+ int a[] = {1, 2, 3, 4, 5};
+ std::vector<int> in(a, a + sizeof(a) / sizeof(a[0]));
+ std::vector<throwing_data<int> > v;
+ test_copy_ctor_exception_for_strong_guarantee(v, in);
+ }
+ check_new_delete_called();
+
+ {
+ int a[] = {1, 2, 3, 4, 5};
+ std::vector<int> in(a, a + sizeof(a) / sizeof(a[0]));
+ std::vector<throwing_data<int>, min_allocator<throwing_data<int> > > v;
+ test_copy_ctor_exception_for_strong_guarantee(v, in);
+ }
+ check_new_delete_called();
+
+ {
+ std::vector<int> in(10, 42);
+ std::vector<throwing_data<int>, safe_allocator<throwing_data<int> > > v;
+ test_copy_ctor_exception_for_strong_guarantee(v, in);
+ }
+ check_new_delete_called();
+
+ {
+ std::vector<int> in(10, 42);
+ std::vector<throwing_data<int>, test_allocator<throwing_data<int> > > v;
+ test_copy_ctor_exception_for_strong_guarantee(v, in);
+ }
+ check_new_delete_called();
+
+ {
+ std::vector<int> in(10, 42);
+ std::vector<throwing_data<int>, limited_allocator<throwing_data<int>, 100> > v;
+ test_copy_ctor_exception_for_strong_guarantee(v, in);
+ }
+ check_new_delete_called();
+
+#if TEST_STD_VER >= 23
+ {
+ std::vector<int> in{0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
+ std::vector<throwing_data<int>, increasing_allocator<throwing_data<int>>> v;
+ test_copy_ctor_exception_for_strong_guarantee(v, in);
+ }
+ check_new_delete_called();
+#endif
+
+#if TEST_STD_VER >= 11
+ { // Practical example: Testing with 100 randomly generated integers.
+ auto in = getRandomIntegerInputs<int>(100);
+ std::vector<throwing_data<int>> v;
+ test_copy_ctor_exception_for_strong_guarantee(v, in);
+ }
+ check_new_delete_called();
+
+ { // Practical example: Testing with 100 randomly generated strings, each 256 characters long.
+ std::vector<std::string> in = getRandomStringInputsWithLength(100, 256);
+ std::vector<throwing_data<std::string>> v;
+ test_copy_ctor_exception_for_strong_guarantee(v, in);
+ }
+ check_new_delete_called();
+#endif
+}
+
+#if TEST_STD_VER >= 11
+
+// Check that if T is Cpp17MoveInsertible && !Cpp17CopyInsertible, and T's move-ctor is not noexcept, then
+// std::vector::reserve only provides basic guarantee.
+void test_move_ctor_exceptions() {
+ {
+ std::vector<int> in{0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
+ std::vector<move_only_throwing_t<int>> v;
+ test_move_ctor_exception_for_basic_guarantee(v, in);
+ }
+ check_new_delete_called();
+
+# if TEST_STD_VER >= 23
+ {
+ std::vector<int> in{0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
+ std::vector<move_only_throwing_t<int>, increasing_allocator<move_only_throwing_t<int>>> v;
+ test_move_ctor_exception_for_basic_guarantee(v, in);
+ }
+ check_new_delete_called();
+# endif
+
+ {
+ // Practical example: Testing with 100 randomly generated strings, each 256 characters long.
+ std::vector<std::string> in = getRandomStringInputsWithLength(100, 256);
+ std::vector<move_only_throwing_t<std::string> > v;
+ test_move_ctor_exception_for_basic_guarantee(v, in);
+ }
+ check_new_delete_called();
+}
+
+#endif
+
+int main(int, char**) {
+ test_allocation_exceptions();
+ test_copy_ctor_exceptions();
+#if TEST_STD_VER >= 11
+ test_move_ctor_exceptions();
+#endif
+}
diff --git a/libcxx/test/std/containers/sequences/vector/vector.capacity/shrink_to_fit_exceptions.pass.cpp b/libcxx/test/std/containers/sequences/vector/vector.capacity/shrink_to_fit_exceptions.pass.cpp
new file mode 100644
index 00000000000000..7526cbbcbdde77
--- /dev/null
+++ b/libcxx/test/std/containers/sequences/vector/vector.capacity/shrink_to_fit_exceptions.pass.cpp
@@ -0,0 +1,294 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: no-exceptions
+
+// Check that std::vector<T>::shrink_to_fit provides a strong exception guarantee
+// when T is Cpp17MoveInsertible and its move constructor does not throw exceptions
+// during the shrink_to_fit call. Additionally, it checks that for move-only types
+// where T's move constructor is not noexcept, the strong exception guarantee is
+// waived, and only the basic exception guarantee is ensured.
+
+#include <cstddef>
+#include <memory>
+#include <stdexcept>
+#include <type_traits>
+#include <vector>
+
+#include "../common.h"
+#include "MoveOnly.h"
+#include "count_new.h"
+#include "increasing_allocator.h"
+#include "min_allocator.h"
+#include "test_allocator.h"
+#include "test_iterators.h"
+#include "test_macros.h"
+#if TEST_STD_VER >= 11
+# include "../../../../../benchmarks/GenerateInput.h"
+#endif
+
+template <typename T, typename Alloc>
+void test_allocation_exception_for_strong_guarantee(std::vector<T, Alloc>& v, const std::vector<T>& values) {
+ T* old_data = v.data();
+ std::size_t old_size = v.size();
+ std::size_t old_cap = v.capacity();
+
+ std::printf("Alloc remaining: %zu, ", v.get_allocator().max_alloc_remaining());
+
+ try {
+ v.shrink_to_fit();
+ } catch (std::exception&) {
+ }
+
+ // As shrink_to_fit may swallow any exceptions, we place the checks outisde the catch block.
+ std::printf("allocation exception!\n");
+ assert(v.data() == old_data);
+ assert(v.size() == old_size);
+ assert(v.capacity() == old_cap);
+ for (std::size_t i = 0; i < v.size(); ++i)
+ assert(v[i] == values[i]);
+}
+
+template <typename T, typename Alloc>
+void test_copy_ctor_exception_for_strong_guarantee(std::vector<throwing_data<T>, Alloc>& v,
+ const std::vector<T>& values) {
+ assert(v.empty() && !values.empty());
+ v.reserve(values.size() * 2);
+ int throw_after = values.size() + values.size() / 2; // Ensure to throw in the middle of reallocation
+ for (std::size_t i = 0; i < values.size(); ++i)
+ v.emplace_back(values[i], throw_after);
+
+ throwing_data<T>* old_data = v.data();
+ std::size_t old_size = v.size();
+ std::size_t old_cap = v.capacity();
+
+ std::printf("throw_after = %2d, ", throw_after);
+
+ try {
+ v.shrink_to_fit();
+ } catch (...) {
+ }
+
+ std::printf("copy-ctor exception\n");
+ assert(v.data() == old_data);
+ assert(v.size() == old_size);
+ assert(v.capacity() == old_cap);
+ for (std::size_t i = 0; i < v.size(); ++i)
+ assert(v[i].data_ == values[i]);
+}
+
+#if TEST_STD_VER >= 11
+
+template <typename T, typename Alloc>
+void test_move_ctor_exception_for_basic_guarantee(std::vector<move_only_throwing_t<T>, Alloc>& v,
+ const std::vector<T>& values) {
+ assert(v.empty() && !values.empty());
+ v.reserve(values.size() * 2);
+ int throw_after = values.size() + values.size() / 2; // Ensure to throw in the middle of reallocation
+ for (std::size_t i = 0; i < values.size(); ++i)
+ v.emplace_back(values[i], throw_after);
+
+ // move_only_throwing_t<T>* old_data = v.data();
+ // std::size_t old_size = v.size();
+ // std::size_t old_cap = v.capacity();
+
+ try {
+ v.shrink_to_fit();
+ } catch (int) {
+ }
+
+ std::printf("move-ctor exception\n");
+ // assert(v.data() == old_data); // assertion failed on macos!!!
+ // assert(v.size() == old_size);
+ // assert(v.capacity() == old_cap);
+
+ // After a failure during element-wise move, the vector elements are left in a valid but unspecified state.
+ for (std::size_t i = 0; i < v.size(); ++i) {
+ assert(((void)v[i],
+ (void)v[i].data_,
+ (void)v[i].throw_after_n_,
+ (void)(v[i] == v[i]),
+ v[i].moved_from_ || v[i].data_ == values[i]));
+ }
+}
+
+#endif
+
+// Check the strong exception guarantee during reallocation failures
+void test_allocation_exceptions() {
+ {
+ int a[] = {1, 2, 3, 4, 5};
+ std::vector<int> in(a, a + sizeof(a) / sizeof(a[0]));
+ std::vector<int, limited_allocator<int, 100> > v;
+ v.reserve(100);
+ for (std::size_t i = 0; i < in.size(); ++i)
+ v.push_back(in[i]);
+ test_allocation_exception_for_strong_guarantee(v, in);
+ }
+ check_new_delete_called();
+
+ {
+ std::vector<int> in(50, 42);
+ std::vector<int, limited_allocator<int, 100> > v;
+ v.reserve(100);
+ for (std::size_t i = 0; i < in.size(); ++i)
+ v.push_back(in[i]);
+ test_allocation_exception_for_strong_guarantee(v, in);
+ }
+ check_new_delete_called();
+
+ {
+ std::vector<int> in(10, 42);
+ std::vector<int, limited_allocator<int, 100> > v(in.begin(), in.end());
+ v.reserve(90);
+ test_allocation_exception_for_strong_guarantee(v, in);
+ }
+ check_new_delete_called();
+
+#if TEST_STD_VER >= 11
+ {
+ std::vector<MoveOnly> in(10);
+ std::vector<MoveOnly, limited_allocator<MoveOnly, 100> > v(10);
+ v.reserve(90);
+ test_allocation_exception_for_strong_guarantee(v, in);
+ }
+ check_new_delete_called();
+
+ {
+ std::vector<MoveOnly> in(10);
+ std::vector<MoveOnly, limited_allocator<MoveOnly, 100> > v(10);
+ v.reserve(90);
+ in.insert(in.cbegin() + 5, MoveOnly(42));
+ v.insert(v.cbegin() + 5, MoveOnly(42));
+ test_allocation_exception_for_strong_guarantee(v, in);
+ }
+ check_new_delete_called();
+
+ { // Practical example: Testing with 100 randomly generated integers.
+ auto in = getRandomIntegerInputs<int>(100);
+ std::vector<int, limited_allocator<int, 100>> v(in.begin(), in.end());
+ in.erase(in.end() - 10, in.end());
+ v.erase(v.end() - 10, v.end());
+ test_allocation_exception_for_strong_guarantee(v, in);
+ }
+ check_new_delete_called();
+
+ { // Practical example: Testing with 100 randomly generated strings, each 256 characters long.
+ std::vector<std::string> in = getRandomStringInputsWithLength(100, 256);
+ std::vector<std::string, limited_allocator<std::string, 300>> v(in.begin(), in.end());
+ v.reserve(200);
+ test_allocation_exception_for_strong_guarantee(v, in);
+ }
+ check_new_delete_called();
+#endif
+}
+
+// Check the strong exception guarantee during copy-constructor failures
+void test_copy_ctor_exceptions() {
+ {
+ int a[] = {1, 2, 3, 4, 5};
+ std::vector<int> in(a, a + sizeof(a) / sizeof(a[0]));
+ std::vector<throwing_data<int> > v;
+ test_copy_ctor_exception_for_strong_guarantee(v, in);
+ }
+ check_new_delete_called();
+
+ {
+ int a[] = {1, 2, 3, 4, 5};
+ std::vector<int> in(a, a + sizeof(a) / sizeof(a[0]));
+ std::vector<throwing_data<int>, min_allocator<throwing_data<int> > > v;
+ test_copy_ctor_exception_for_strong_guarantee(v, in);
+ }
+ check_new_delete_called();
+
+ {
+ std::vector<int> in(10, 42);
+ std::vector<throwing_data<int>, safe_allocator<throwing_data<int> > > v;
+ test_copy_ctor_exception_for_strong_guarantee(v, in);
+ }
+ check_new_delete_called();
+
+ {
+ std::vector<int> in(10, 42);
+ std::vector<throwing_data<int>, test_allocator<throwing_data<int> > > v;
+ test_copy_ctor_exception_for_strong_guarantee(v, in);
+ }
+ check_new_delete_called();
+
+ {
+ std::vector<int> in(10, 42);
+ std::vector<throwing_data<int>, limited_allocator<throwing_data<int>, 100> > v;
+ test_copy_ctor_exception_for_strong_guarantee(v, in);
+ }
+ check_new_delete_called();
+
+#if TEST_STD_VER >= 23
+ {
+ std::vector<int> in{0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
+ std::vector<throwing_data<int>, increasing_allocator<throwing_data<int>>> v;
+ test_copy_ctor_exception_for_strong_guarantee(v, in);
+ }
+ check_new_delete_called();
+#endif
+
+#if TEST_STD_VER >= 11
+ { // Practical example: Testing with 100 randomly generated integers.
+ auto in = getRandomIntegerInputs<int>(100);
+ std::vector<throwing_data<int>> v;
+ test_copy_ctor_exception_for_strong_guarantee(v, in);
+ }
+ check_new_delete_called();
+
+ { // Practical example: Testing with 100 randomly generated strings, each 256 characters long.
+ std::vector<std::string> in = getRandomStringInputsWithLength(100, 256);
+ std::vector<throwing_data<std::string>> v;
+ test_copy_ctor_exception_for_strong_guarantee(v, in);
+ }
+ check_new_delete_called();
+#endif
+}
+
+#if TEST_STD_VER >= 11
+
+// Check that if T is Cpp17MoveInsertible && !Cpp17CopyInsertible, and T's move-ctor is not noexcept, then
+// std::vector::shrink_to_fit only provides basic guarantee.
+void test_move_ctor_exceptions() {
+ {
+ std::vector<int> in{0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
+ std::vector<move_only_throwing_t<int>> v;
+ test_move_ctor_exception_for_basic_guarantee(v, in);
+ }
+ check_new_delete_called();
+
+# if TEST_STD_VER >= 23
+ {
+ std::vector<int> in{0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
+ std::vector<move_only_throwing_t<int>, increasing_allocator<move_only_throwing_t<int>>> v;
+ test_move_ctor_exception_for_basic_guarantee(v, in);
+ }
+ check_new_delete_called();
+# endif
+
+ {
+ // Practical example: Testing with 100 randomly generated strings, each 256 characters long.
+ std::vector<std::string> in = getRandomStringInputsWithLength(100, 256);
+ std::vector<move_only_throwing_t<std::string> > v;
+ test_move_ctor_exception_for_basic_guarantee(v, in);
+ }
+ check_new_delete_called();
+}
+
+#endif
+
+int main(int, char**) {
+ test_allocation_exceptions();
+ test_copy_ctor_exceptions();
+#if TEST_STD_VER >= 11
+ test_move_ctor_exceptions();
+#endif
+}
diff --git a/libcxx/test/support/increasing_allocator.h b/libcxx/test/support/increasing_allocator.h
new file mode 100644
index 00000000000000..2536e50db61782
--- /dev/null
+++ b/libcxx/test/support/increasing_allocator.h
@@ -0,0 +1,61 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef TEST_SUPPORT_INCREASING_ALLOCATOR_H
+#define TEST_SUPPORT_INCREASING_ALLOCATOR_H
+
+#include <cstddef>
+#include <memory>
+
+#include "test_macros.h"
+
+// The increasing_allocator is a custom allocator that enforces an increasing minimum allocation size,
+// ensuring that it allocates an increasing amount of memory, possibly exceeding the requested amount.
+// This unique behavior is particularly useful for testing the shrink_to_fit functionality in std::vector,
+// vector<bool>, and std::basic_string, ensuring that shrink_to_fit does not increase the capacity of
+// the allocated memory.
+
+template <typename T>
+struct increasing_allocator {
+ using value_type = T;
+ std::size_t min_elements = 1000;
+ increasing_allocator() = default;
+
+ template <typename U>
+ TEST_CONSTEXPR_CXX20 increasing_allocator(const increasing_allocator<U>& other) TEST_NOEXCEPT
+ : min_elements(other.min_elements) {}
+
+#if TEST_STD_VER >= 23
+ TEST_CONSTEXPR_CXX23 std::allocation_result<T*> allocate_at_least(std::size_t n) {
+ if (n < min_elements)
+ n = min_elements;
+ min_elements += 1000;
+ return std::allocator<T>{}.allocate_at_least(n);
+ }
+#endif // TEST_STD_VER >= 23
+
+ TEST_CONSTEXPR_CXX20 T* allocate(std::size_t n) {
+#if TEST_STD_VER >= 23
+ return allocate_at_least(n).ptr;
+#else
+ if (n < min_elements)
+ n = min_elements;
+ min_elements += 1000;
+ return std::allocator<T>().allocate(n);
+#endif
+ }
+
+ TEST_CONSTEXPR_CXX20 void deallocate(T* p, std::size_t n) TEST_NOEXCEPT { std::allocator<T>().deallocate(p, n); }
+};
+
+template <typename T, typename U>
+TEST_CONSTEXPR_CXX20 bool operator==(increasing_allocator<T>, increasing_allocator<U>) TEST_NOEXCEPT {
+ return true;
+}
+
+#endif // TEST_SUPPORT_INCREASING_ALLOCATOR_H
diff --git a/libcxx/test/support/test_allocator.h b/libcxx/test/support/test_allocator.h
index dcd15332ca304f..1cc005c12876ac 100644
--- a/libcxx/test/support/test_allocator.h
+++ b/libcxx/test/support/test_allocator.h
@@ -468,6 +468,9 @@ class limited_allocator {
TEST_CONSTEXPR_CXX20 void deallocate(pointer p, size_type n) { handle_->template deallocate<T>(p, n); }
TEST_CONSTEXPR size_type max_size() const { return N; }
TEST_CONSTEXPR BuffT* getHandle() const { return handle_.get(); }
+
+ // For testing purpose
+ TEST_CONSTEXPR std::size_t max_alloc_remaining() const { return N - handle_->outstanding_; }
};
template <class T, class U, std::size_t N>
More information about the libcxx-commits
mailing list