141 changes: 141 additions & 0 deletions libcxx/test/std/containers/sequences/vector.bool/ctor_exceptions.pass.cpp
View file
Original file line number Diff line number Diff line change
@@ -0,0 +1,141 @@
//===----------------------------------------------------------------------===//
//
// 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

// (bug report: https://llvm.org/PR58392)
// Check that vector<bool> constructors don't leak memory when an operation inside the constructor throws an exception

#include <type_traits>
#include <vector>

#include "count_new.h"
#include "test_iterators.h"

template <class T>
struct Allocator {
using value_type = T;
using is_always_equal = std::false_type;

template <class U>
Allocator(const Allocator<U>&) {}

Allocator(bool should_throw = true) {
if (should_throw)
throw 0;
}

T* allocate(int n) { return std::allocator<T>().allocate(n); }
void deallocate(T* ptr, int n) { std::allocator<T>().deallocate(ptr, n); }

friend bool operator==(const Allocator&, const Allocator&) { return false; }
};

template <class IterCat>
struct Iterator {
using iterator_category = IterCat;
using difference_type = std::ptrdiff_t;
using value_type = bool;
using reference = bool&;
using pointer = bool*;

int i_;
bool b_ = true;
Iterator(int i = 0) : i_(i) {}
bool& operator*() {
if (i_ == 1)
throw 1;
return b_;
}

friend bool operator==(const Iterator& lhs, const Iterator& rhs) { return lhs.i_ == rhs.i_; }

friend bool operator!=(const Iterator& lhs, const Iterator& rhs) { return lhs.i_ != rhs.i_; }

Iterator& operator++() {
++i_;
return *this;
}

Iterator operator++(int) {
auto tmp = *this;
++i_;
return tmp;
}
};

void check_new_delete_called() {
assert(globalMemCounter.new_called == globalMemCounter.delete_called);
assert(globalMemCounter.new_array_called == globalMemCounter.delete_array_called);
assert(globalMemCounter.aligned_new_called == globalMemCounter.aligned_delete_called);
assert(globalMemCounter.aligned_new_array_called == globalMemCounter.aligned_delete_array_called);
}

int main(int, char**) {
using AllocVec = std::vector<bool, Allocator<bool> >;

#if TEST_STD_VER >= 14
try { // Throw in vector(size_type, const allocator_type&) from allocator
Allocator<bool> alloc(false);
AllocVec get_alloc(0, alloc);
} catch (int) {
}
check_new_delete_called();
#endif // TEST_STD_VER >= 14

try { // Throw in vector(InputIterator, InputIterator) from input iterator
std::vector<bool> vec((Iterator<std::input_iterator_tag>()), Iterator<std::input_iterator_tag>(2));
} catch (int) {
}
check_new_delete_called();

try { // Throw in vector(InputIterator, InputIterator) from forward iterator
std::vector<bool> vec((Iterator<std::forward_iterator_tag>()), Iterator<std::forward_iterator_tag>(2));
} catch (int) {
}
check_new_delete_called();

try { // Throw in vector(InputIterator, InputIterator) from allocator
int a[] = {1, 2};
AllocVec vec(cpp17_input_iterator<int*>(a), cpp17_input_iterator<int*>(a + 2));
} catch (int) {
}
check_new_delete_called();

try { // Throw in vector(InputIterator, InputIterator, const allocator_type&) from input iterator
std::allocator<bool> alloc;
std::vector<bool> vec(Iterator<std::input_iterator_tag>(), Iterator<std::input_iterator_tag>(2), alloc);
} catch (int) {
}
check_new_delete_called();

try { // Throw in vector(InputIterator, InputIterator, const allocator_type&) from forward iterator
std::allocator<bool> alloc;
std::vector<bool> vec(Iterator<std::forward_iterator_tag>(), Iterator<std::forward_iterator_tag>(2), alloc);
} catch (int) {
}
check_new_delete_called();

try { // Throw in vector(InputIterator, InputIterator, const allocator_type&) from allocator
bool a[] = {true, false};
Allocator<bool> alloc(false);
AllocVec vec(cpp17_input_iterator<bool*>(a), cpp17_input_iterator<bool*>(a + 2), alloc);
} catch (int) {
}
check_new_delete_called();

try { // Throw in vector(InputIterator, InputIterator, const allocator_type&) from allocator
bool a[] = {true, false};
Allocator<bool> alloc(false);
AllocVec vec(forward_iterator<bool*>(a), forward_iterator<bool*>(a + 2), alloc);
} catch (int) {
}
check_new_delete_called();

return 0;
}
229 changes: 229 additions & 0 deletions libcxx/test/std/containers/sequences/vector/vector.cons/exceptions.pass.cpp
View file
Original file line number Diff line number Diff line change
@@ -0,0 +1,229 @@
//===----------------------------------------------------------------------===//
//
// 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

// (bug report: https://llvm.org/PR58392)
// Check that vector constructors don't leak memory when an operation inside the constructor throws an exception

#include <type_traits>
#include <vector>

#include "count_new.h"
#include "test_iterators.h"

template <class T>
struct Allocator {
using value_type = T;
using is_always_equal = std::false_type;

Allocator(bool should_throw = true) {
if (should_throw)
throw 0;
}

T* allocate(int n) { return std::allocator<T>().allocate(n); }
void deallocate(T* ptr, int n) { std::allocator<T>().deallocate(ptr, n); }

friend bool operator==(const Allocator&, const Allocator&) { return false; }
};

struct ThrowingT {
int* throw_after_n_ = nullptr;
ThrowingT() { throw 0; }

ThrowingT(int& throw_after_n) : throw_after_n_(&throw_after_n) {
if (throw_after_n == 0)
throw 0;
--throw_after_n;
}

ThrowingT(const ThrowingT&) {
if (throw_after_n_ == nullptr || *throw_after_n_ == 0)
throw 1;
--*throw_after_n_;
}

ThrowingT& operator=(const ThrowingT&) {
if (throw_after_n_ == nullptr || *throw_after_n_ == 0)
throw 1;
--*throw_after_n_;
return *this;
}
};

template <class IterCat>
struct Iterator {
using iterator_category = IterCat;
using difference_type = std::ptrdiff_t;
using value_type = int;
using reference = int&;
using pointer = int*;

int i_;
Iterator(int i = 0) : i_(i) {}
int& operator*() {
if (i_ == 1)
throw 1;
return i_;
}

friend bool operator==(const Iterator& lhs, const Iterator& rhs) { return lhs.i_ == rhs.i_; }

friend bool operator!=(const Iterator& lhs, const Iterator& rhs) { return lhs.i_ != rhs.i_; }

Iterator& operator++() {
++i_;
return *this;
}

Iterator operator++(int) {
auto tmp = *this;
++i_;
return tmp;
}
};

void check_new_delete_called() {
assert(globalMemCounter.new_called == globalMemCounter.delete_called);
assert(globalMemCounter.new_array_called == globalMemCounter.delete_array_called);
assert(globalMemCounter.aligned_new_called == globalMemCounter.aligned_delete_called);
assert(globalMemCounter.aligned_new_array_called == globalMemCounter.aligned_delete_array_called);
}

int main(int, char**) {
using AllocVec = std::vector<int, Allocator<int> >;
try { // vector()
AllocVec vec;
} catch (int) {
}
check_new_delete_called();

try { // Throw in vector(size_type) from type
std::vector<ThrowingT> get_alloc(1);
} catch (int) {
}
check_new_delete_called();

#if TEST_STD_VER >= 14
try { // Throw in vector(size_type, value_type) from type
int throw_after = 1;
ThrowingT v(throw_after);
std::vector<ThrowingT> get_alloc(1, v);
} catch (int) {
}
check_new_delete_called();

try { // Throw in vector(size_type, const allocator_type&) from allocator
Allocator<int> alloc(false);
AllocVec get_alloc(0, alloc);
} catch (int) {
}
check_new_delete_called();

try { // Throw in vector(size_type, const allocator_type&) from the type
std::vector<ThrowingT> vec(1, std::allocator<ThrowingT>());
} catch (int) {
}
check_new_delete_called();
#endif // TEST_STD_VER >= 14

try { // Throw in vector(InputIterator, InputIterator) from input iterator
std::vector<int> vec((Iterator<std::input_iterator_tag>()), Iterator<std::input_iterator_tag>(2));
} catch (int) {
}
check_new_delete_called();

try { // Throw in vector(InputIterator, InputIterator) from forward iterator
std::vector<int> vec((Iterator<std::forward_iterator_tag>()), Iterator<std::forward_iterator_tag>(2));
} catch (int) {
}
check_new_delete_called();

try { // Throw in vector(InputIterator, InputIterator) from allocator
int a[] = {1, 2};
AllocVec vec(cpp17_input_iterator<int*>(a), cpp17_input_iterator<int*>(a + 2));
} catch (int) {
}
check_new_delete_called();

try { // Throw in vector(InputIterator, InputIterator, const allocator_type&) from input iterator
std::allocator<int> alloc;
std::vector<int> vec(Iterator<std::input_iterator_tag>(), Iterator<std::input_iterator_tag>(2), alloc);
} catch (int) {
}
check_new_delete_called();

try { // Throw in vector(InputIterator, InputIterator, const allocator_type&) from forward iterator
std::allocator<int> alloc;
std::vector<int> vec(Iterator<std::forward_iterator_tag>(), Iterator<std::forward_iterator_tag>(2), alloc);
} catch (int) {
}
check_new_delete_called();

try { // Throw in vector(InputIterator, InputIterator, const allocator_type&) from allocator
int a[] = {1, 2};
Allocator<int> alloc(false);
AllocVec vec(cpp17_input_iterator<int*>(a), cpp17_input_iterator<int*>(a + 2), alloc);
} catch (int) {
}
check_new_delete_called();

try { // Throw in vector(InputIterator, InputIterator, const allocator_type&) from allocator
int a[] = {1, 2};
Allocator<int> alloc(false);
AllocVec vec(forward_iterator<int*>(a), forward_iterator<int*>(a + 2), alloc);
} catch (int) {
}
check_new_delete_called();

try { // Throw in vector(const vector&) from type
std::vector<ThrowingT> vec;
int throw_after = 0;
vec.emplace_back(throw_after);
auto vec2 = vec;
} catch (int) {
}
check_new_delete_called();

try { // Throw in vector(const vector&, const allocator_type&) from type
std::vector<ThrowingT> vec;
int throw_after = 1;
vec.emplace_back(throw_after);
std::vector<ThrowingT> vec2(vec, std::allocator<int>());
} catch (int) {
}
check_new_delete_called();

try { // Throw in vector(vector&&, const allocator_type&) from type
std::vector<ThrowingT, Allocator<ThrowingT> > vec(Allocator<ThrowingT>(false));
int throw_after = 1;
vec.emplace_back(throw_after);
std::vector<ThrowingT, Allocator<ThrowingT> > vec2(std::move(vec), Allocator<ThrowingT>(false));
} catch (int) {
}
check_new_delete_called();

#if TEST_STD_VER >= 11
try { // Throw in vector(initializer_list<value_type>) from type
int throw_after = 1;
std::vector<ThrowingT> vec({ThrowingT(throw_after)});
} catch (int) {
}
check_new_delete_called();

try { // Throw in vector(initializer_list<value_type>, const allocator_type&) constructor from type
int throw_after = 1;
std::vector<ThrowingT> vec({ThrowingT(throw_after)}, std::allocator<ThrowingT>());
} catch (int) {
}
check_new_delete_called();
#endif // TEST_STD_VER >= 11

return 0;
}