int tc_libcxx_containers_vector_capacity_resize_size_value(void) { { std::vector<int> v(100); v.resize(50, 1); TC_ASSERT_EXPR(v.size() == 50); TC_ASSERT_EXPR(v.capacity() == 100); TC_ASSERT_EXPR(v == std::vector<int>(50)); v.resize(200, 1); TC_ASSERT_EXPR(v.size() == 200); TC_ASSERT_EXPR(v.capacity() >= 200); TC_ASSERT_EXPR(is_contiguous_container_asan_correct(v)); for (unsigned i = 0; i < 50; ++i) TC_ASSERT_EXPR(v[i] == 0); for (unsigned i = 50; i < 200; ++i) TC_ASSERT_EXPR(v[i] == 1); } { // Add 1 for implementations that dynamically allocate a container proxy. std::vector<int, limited_allocator<int, 300 + 1> > v(100); v.resize(50, 1); TC_ASSERT_EXPR(v.size() == 50); TC_ASSERT_EXPR(v.capacity() == 100); v.resize(200, 1); TC_ASSERT_EXPR(v.size() == 200); TC_ASSERT_EXPR(v.capacity() >= 200); TC_ASSERT_EXPR(is_contiguous_container_asan_correct(v)); } TC_SUCCESS_RESULT(); return 0; }
int main(int, char**) { { std::vector<int> d; d = {3, 4, 5, 6}; assert(d.size() == 4); assert(is_contiguous_container_asan_correct(d)); assert(d[0] == 3); assert(d[1] == 4); assert(d[2] == 5); assert(d[3] == 6); } { std::vector<int, min_allocator<int>> d; d = {3, 4, 5, 6}; assert(d.size() == 4); assert(is_contiguous_container_asan_correct(d)); assert(d[0] == 3); assert(d[1] == 4); assert(d[2] == 5); assert(d[3] == 6); } return 0; }
int main() { #ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS { std::vector<int> d = {3, 4, 5, 6}; assert(d.size() == 4); assert(is_contiguous_container_asan_correct(d)); assert(d[0] == 3); assert(d[1] == 4); assert(d[2] == 5); assert(d[3] == 6); } #if TEST_STD_VER >= 11 { std::vector<int, min_allocator<int>> d = {3, 4, 5, 6}; assert(d.size() == 4); assert(is_contiguous_container_asan_correct(d)); assert(d[0] == 3); assert(d[1] == 4); assert(d[2] == 5); assert(d[3] == 6); } #endif #endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS }
int main() { #ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS { std::vector<int, test_allocator<int>> d({3, 4, 5, 6}, test_allocator<int>(3)); assert(d.get_allocator() == test_allocator<int>(3)); assert(d.size() == 4); assert(is_contiguous_container_asan_correct(d)); assert(d[0] == 3); assert(d[1] == 4); assert(d[2] == 5); assert(d[3] == 6); } #if __cplusplus >= 201103L { std::vector<int, min_allocator<int>> d({3, 4, 5, 6}, min_allocator<int>()); assert(d.get_allocator() == min_allocator<int>()); assert(d.size() == 4); assert(is_contiguous_container_asan_correct(d)); assert(d[0] == 3); assert(d[1] == 4); assert(d[2] == 5); assert(d[3] == 6); } #endif #endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS }
int main() { #ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS { std::vector<int> d(10, 1); std::vector<int>::iterator i = d.insert(d.cbegin() + 2, {3, 4, 5, 6}); assert(d.size() == 14); assert(is_contiguous_container_asan_correct(d)); assert(i == d.begin() + 2); assert(d[0] == 1); assert(d[1] == 1); assert(d[2] == 3); assert(d[3] == 4); assert(d[4] == 5); assert(d[5] == 6); assert(d[6] == 1); assert(d[7] == 1); assert(d[8] == 1); assert(d[9] == 1); assert(d[10] == 1); assert(d[11] == 1); assert(d[12] == 1); assert(d[13] == 1); } #if __cplusplus >= 201103L { std::vector<int, min_allocator<int>> d(10, 1); std::vector<int, min_allocator<int>>::iterator i = d.insert(d.cbegin() + 2, {3, 4, 5, 6}); assert(d.size() == 14); assert(is_contiguous_container_asan_correct(d)); assert(i == d.begin() + 2); assert(d[0] == 1); assert(d[1] == 1); assert(d[2] == 3); assert(d[3] == 4); assert(d[4] == 5); assert(d[5] == 6); assert(d[6] == 1); assert(d[7] == 1); assert(d[8] == 1); assert(d[9] == 1); assert(d[10] == 1); assert(d[11] == 1); assert(d[12] == 1); assert(d[13] == 1); } #endif #endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS }
int main() { #if __cplusplus >= 201103L { typedef int T; typedef std::vector<T, min_allocator<T>> C; const T t[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}; C c(std::begin(t), std::end(t)); c.reserve(2*c.size()); T foo = c[c.size()]; // bad, but not caught by ASAN } #endif __asan_set_error_exit_code(0); { typedef int T; typedef std::vector<T> C; const T t[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}; C c(std::begin(t), std::end(t)); c.reserve(2*c.size()); assert(is_contiguous_container_asan_correct(c)); assert(!__sanitizer_verify_contiguous_container ( c.data(), c.data() + 1, c.data() + c.capacity())); T foo = c[c.size()]; // should trigger ASAN assert(false); // if we got here, ASAN didn't trigger } }
int main() { CMyClass instance(42); std::vector<CMyClass> vec; vec.push_back(instance); std::vector<CMyClass> vec2(vec); assert(is_contiguous_container_asan_correct(vec)); assert(is_contiguous_container_asan_correct(vec2)); gCopyConstructorShouldThow = true; try { vec.push_back(instance); } catch (...) { assert(vec==vec2); assert(is_contiguous_container_asan_correct(vec)); } }
void test(const C& x) { typename C::size_type s = x.size(); C c(x); LIBCPP_ASSERT(c.__invariants()); assert(c.size() == s); assert(c == x); LIBCPP_ASSERT(is_contiguous_container_asan_correct(c)); }
void test ( Vec &v ) { v.assign({3, 4, 5, 6}); assert(v.size() == 4); assert(is_contiguous_container_asan_correct(v)); assert(v[0] == 3); assert(v[1] == 4); assert(v[2] == 5); assert(v[3] == 6); }
void test(Iterator first, Iterator last, const A& a) { C c(first, last, a); LIBCPP_ASSERT(c.__invariants()); assert(c.size() == std::distance(first, last)); LIBCPP_ASSERT(is_contiguous_container_asan_correct(c)); for (typename C::const_iterator i = c.cbegin(), e = c.cend(); i != e; ++i, ++first) assert(*i == *first); }
void test(const C& x, const typename C::allocator_type& a) { unsigned s = x.size(); C c(x, a); assert(c.__invariants()); assert(c.size() == s); assert(c == x); assert(is_contiguous_container_asan_correct(c)); }
void test(typename C::size_type n, const typename C::value_type& x) { C c(n, x); assert(c.__invariants()); assert(c.size() == n); assert(is_contiguous_container_asan_correct(c)); for (typename C::const_iterator i = c.cbegin(), e = c.cend(); i != e; ++i) assert(*i == x); }
static int test(typename C::size_type n, const typename C::value_type& x) { C c(n, x); LIBCPP_ASSERT(c.__invariants()); TC_ASSERT_EXPR(c.size() == n); LIBCPP_ASSERT(is_contiguous_container_asan_correct(c)); for (typename C::const_iterator i = c.cbegin(), e = c.cend(); i != e; ++i) TC_ASSERT_EXPR(*i == x); return 0; }
void test0() { #if TEST_STD_VER > 14 static_assert((noexcept(C{})), "" ); #elif TEST_STD_VER >= 11 static_assert((noexcept(C()) == noexcept(typename C::allocator_type())), "" ); #endif C c; LIBCPP_ASSERT(c.__invariants()); assert(c.empty()); assert(c.get_allocator() == typename C::allocator_type()); LIBCPP_ASSERT(is_contiguous_container_asan_correct(c)); #if TEST_STD_VER >= 11 C c1 = {}; LIBCPP_ASSERT(c1.__invariants()); assert(c1.empty()); assert(c1.get_allocator() == typename C::allocator_type()); LIBCPP_ASSERT(is_contiguous_container_asan_correct(c1)); #endif }
int main() { { std::vector<int> v; assert(v.data() == 0); assert(is_contiguous_container_asan_correct(v)); } { std::vector<int> v(100); assert(v.data() == std::addressof(v.front())); assert(is_contiguous_container_asan_correct(v)); } { std::vector<Nasty> v(100); assert(v.data() == std::addressof(v.front())); assert(is_contiguous_container_asan_correct(v)); } #if TEST_STD_VER >= 11 { std::vector<int, min_allocator<int>> v; assert(v.data() == 0); assert(is_contiguous_container_asan_correct(v)); } { std::vector<int, min_allocator<int>> v(100); assert(v.data() == std::addressof(v.front())); assert(is_contiguous_container_asan_correct(v)); } { std::vector<Nasty, min_allocator<Nasty>> v(100); assert(v.data() == std::addressof(v.front())); assert(is_contiguous_container_asan_correct(v)); } #endif }
void test_resize_param() { std::vector<X> v; v.reserve(3); v.push_back(X(0)); try { v.resize(3, X(66)); assert(0); } catch (int e) { assert(v.size() == 1); } assert(v.size() == 1); assert(is_contiguous_container_asan_correct(v)); }
void test1(const typename C::allocator_type& a) { #if TEST_STD_VER > 14 static_assert((noexcept(C{typename C::allocator_type{}})), "" ); #elif TEST_STD_VER >= 11 static_assert((noexcept(C(typename C::allocator_type())) == std::is_nothrow_copy_constructible<typename C::allocator_type>::value), "" ); #endif C c(a); LIBCPP_ASSERT(c.__invariants()); assert(c.empty()); assert(c.get_allocator() == a); LIBCPP_ASSERT(is_contiguous_container_asan_correct(c)); }
int main() { #if TEST_STD_VER >= 11 { typedef int T; typedef std::vector<T, min_allocator<T>> C; const T t[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}; C c(std::begin(t), std::end(t)); c.reserve(2*c.size()); T foo = c[c.size()]; // bad, but not caught by ASAN } #endif { typedef input_iterator<int*> MyInputIter; // Sould not trigger ASan. std::vector<int> v; v.reserve(1); int i[] = {42}; v.insert(v.begin(), MyInputIter(i), MyInputIter(i + 1)); assert(v[0] == 42); assert(is_contiguous_container_asan_correct(v)); } __asan_set_error_exit_code(0); { typedef int T; typedef std::vector<T> C; const T t[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}; C c(std::begin(t), std::end(t)); c.reserve(2*c.size()); assert(is_contiguous_container_asan_correct(c)); assert(!__sanitizer_verify_contiguous_container ( c.data(), c.data() + 1, c.data() + c.capacity())); T foo = c[c.size()]; // should trigger ASAN assert(false); // if we got here, ASAN didn't trigger } }
void test_insert() { std::vector<X> v; v.reserve(3); v.insert(v.end(), X(1)); v.insert(v.begin(), X(2)); assert(v.size() == 2); try { v.insert(v.end(), X(66)); assert(0); } catch (int e) { assert(v.size() == 2); } assert(v.size() == 2); assert(is_contiguous_container_asan_correct(v)); }
void test_insert_n2() { std::vector<ThrowOnCopy> v(10); v.reserve(100); assert(v.size() == 10); v[6].should_throw = true; try { v.insert(v.cbegin(), 5, ThrowOnCopy()); assert(0); } catch (int e) { assert(v.size() == 11); assert(is_contiguous_container_asan_correct(v)); return; } assert(0); }
int tc_libcxx_containers_vector_cons_initializer_list_alloc(void) { { std::vector<int, test_allocator<int>> d({3, 4, 5, 6}, test_allocator<int>(3)); TC_ASSERT_EXPR(d.get_allocator() == test_allocator<int>(3)); TC_ASSERT_EXPR(d.size() == 4); TC_ASSERT_EXPR(is_contiguous_container_asan_correct(d)); TC_ASSERT_EXPR(d[0] == 3); TC_ASSERT_EXPR(d[1] == 4); TC_ASSERT_EXPR(d[2] == 5); TC_ASSERT_EXPR(d[3] == 6); } TC_SUCCESS_RESULT(); return 0; }
void test_emplace_back() { #ifndef _LIBCPP_HAS_NO_VARIADICS std::vector<X> v; v.reserve(2); v.push_back(X(2)); assert(v.size() == 1); try { v.emplace_back(42); assert(0); } catch (int e) { assert(v.size() == 1); } assert(v.size() == 1); assert(is_contiguous_container_asan_correct(v)); #endif // _LIBCPP_HAS_NO_VARIADICS }
void test_emplace() { #ifndef _LIBCPP_HAS_NO_VARIADICS std::vector<X> v; v.reserve(3); v.insert(v.end(), X(1)); v.insert(v.begin(), X(2)); assert(v.size() == 2); try { v.emplace(v.end(), 42); assert(0); } catch (int e) { assert(v.size() == 2); } assert(v.size() == 2); assert(is_contiguous_container_asan_correct(v)); #endif // _LIBCPP_HAS_NO_VARIADICS }
void test_insert_range() { std::vector<X> v; v.reserve(4); v.push_back(X(1)); v.push_back(X(2)); assert(v.size() == 2); assert(v.capacity() >= 4); try { char a[2] = {21, 42}; v.insert(v.end(), a, a + 2); assert(0); } catch (int e) { assert(v.size() == 3); } assert(v.size() == 3); assert(is_contiguous_container_asan_correct(v)); }
int main() { { std::vector<int> v(100); v.push_back(1); assert(is_contiguous_container_asan_correct(v)); v.shrink_to_fit(); assert(v.capacity() == 101); assert(v.size() == 101); assert(is_contiguous_container_asan_correct(v)); } { std::vector<int, limited_allocator<int, 401> > v(100); v.push_back(1); assert(is_contiguous_container_asan_correct(v)); v.shrink_to_fit(); assert(v.capacity() == 101); assert(v.size() == 101); assert(is_contiguous_container_asan_correct(v)); } #ifndef _LIBCPP_NO_EXCEPTIONS { std::vector<int, limited_allocator<int, 400> > v(100); v.push_back(1); assert(is_contiguous_container_asan_correct(v)); v.shrink_to_fit(); LIBCPP_ASSERT(v.capacity() == 200); // assumes libc++'s 2x growth factor assert(v.size() == 101); assert(is_contiguous_container_asan_correct(v)); } #endif #if TEST_STD_VER >= 11 { std::vector<int, min_allocator<int>> v(100); v.push_back(1); assert(is_contiguous_container_asan_correct(v)); v.shrink_to_fit(); assert(v.capacity() == 101); assert(v.size() == 101); assert(is_contiguous_container_asan_correct(v)); } #endif }
void test_insert_range2() { std::vector<X> v; v.reserve(4); v.insert(v.end(), X(1)); v.insert(v.begin(), X(2)); assert(v.size() == 2); assert(v.capacity() >= 4); try { char a[2] = {10, 42}; v.insert(v.begin(), a, a + 2); assert(0); } catch (int e) { assert(v.size() <= 4); assert(is_contiguous_container_asan_correct(v)); return; } assert(0); }
int main() { { std::vector<A> c; std::vector<A>::iterator i = c.emplace(c.cbegin(), 2, 3.5); assert(i == c.begin()); assert(c.size() == 1); assert(c.front().geti() == 2); assert(c.front().getd() == 3.5); assert(is_contiguous_container_asan_correct(c)); i = c.emplace(c.cend(), 3, 4.5); assert(i == c.end()-1); assert(c.size() == 2); assert(c.front().geti() == 2); assert(c.front().getd() == 3.5); assert(c.back().geti() == 3); assert(c.back().getd() == 4.5); assert(is_contiguous_container_asan_correct(c)); i = c.emplace(c.cbegin()+1, 4, 6.5); assert(i == c.begin()+1); assert(c.size() == 3); assert(c.front().geti() == 2); assert(c.front().getd() == 3.5); assert(c[1].geti() == 4); assert(c[1].getd() == 6.5); assert(c.back().geti() == 3); assert(c.back().getd() == 4.5); assert(is_contiguous_container_asan_correct(c)); } { std::vector<A, limited_allocator<A, 7> > c; std::vector<A, limited_allocator<A, 7> >::iterator i = c.emplace(c.cbegin(), 2, 3.5); assert(i == c.begin()); assert(c.size() == 1); assert(c.front().geti() == 2); assert(c.front().getd() == 3.5); assert(is_contiguous_container_asan_correct(c)); i = c.emplace(c.cend(), 3, 4.5); assert(i == c.end()-1); assert(c.size() == 2); assert(c.front().geti() == 2); assert(c.front().getd() == 3.5); assert(c.back().geti() == 3); assert(c.back().getd() == 4.5); assert(is_contiguous_container_asan_correct(c)); i = c.emplace(c.cbegin()+1, 4, 6.5); assert(i == c.begin()+1); assert(c.size() == 3); assert(c.front().geti() == 2); assert(c.front().getd() == 3.5); assert(c[1].geti() == 4); assert(c[1].getd() == 6.5); assert(c.back().geti() == 3); assert(c.back().getd() == 4.5); assert(is_contiguous_container_asan_correct(c)); } { std::vector<A, min_allocator<A>> c; std::vector<A, min_allocator<A>>::iterator i = c.emplace(c.cbegin(), 2, 3.5); assert(i == c.begin()); assert(c.size() == 1); assert(c.front().geti() == 2); assert(c.front().getd() == 3.5); i = c.emplace(c.cend(), 3, 4.5); assert(i == c.end()-1); assert(c.size() == 2); assert(c.front().geti() == 2); assert(c.front().getd() == 3.5); assert(c.back().geti() == 3); assert(c.back().getd() == 4.5); i = c.emplace(c.cbegin()+1, 4, 6.5); assert(i == c.begin()+1); assert(c.size() == 3); assert(c.front().geti() == 2); assert(c.front().getd() == 3.5); assert(c[1].geti() == 4); assert(c[1].getd() == 6.5); assert(c.back().geti() == 3); assert(c.back().getd() == 4.5); } }
int main() { int a1[] = {1, 2, 3}; { std::vector<int> l1(a1, a1+3); assert(is_contiguous_container_asan_correct(l1)); std::vector<int>::iterator i = l1.erase(l1.cbegin(), l1.cbegin()); assert(l1.size() == 3); assert(distance(l1.cbegin(), l1.cend()) == 3); assert(i == l1.begin()); assert(is_contiguous_container_asan_correct(l1)); } { std::vector<int> l1(a1, a1+3); assert(is_contiguous_container_asan_correct(l1)); std::vector<int>::iterator i = l1.erase(l1.cbegin(), next(l1.cbegin())); assert(l1.size() == 2); assert(distance(l1.cbegin(), l1.cend()) == 2); assert(i == l1.begin()); assert(l1 == std::vector<int>(a1+1, a1+3)); assert(is_contiguous_container_asan_correct(l1)); } { std::vector<int> l1(a1, a1+3); assert(is_contiguous_container_asan_correct(l1)); std::vector<int>::iterator i = l1.erase(l1.cbegin(), next(l1.cbegin(), 2)); assert(l1.size() == 1); assert(distance(l1.cbegin(), l1.cend()) == 1); assert(i == l1.begin()); assert(l1 == std::vector<int>(a1+2, a1+3)); assert(is_contiguous_container_asan_correct(l1)); } { std::vector<int> l1(a1, a1+3); assert(is_contiguous_container_asan_correct(l1)); std::vector<int>::iterator i = l1.erase(l1.cbegin(), next(l1.cbegin(), 3)); assert(l1.size() == 0); assert(distance(l1.cbegin(), l1.cend()) == 0); assert(i == l1.begin()); assert(is_contiguous_container_asan_correct(l1)); } { std::vector<std::vector<int> > outer(2, std::vector<int>(1)); assert(is_contiguous_container_asan_correct(outer)); assert(is_contiguous_container_asan_correct(outer[0])); assert(is_contiguous_container_asan_correct(outer[1])); outer.erase(outer.begin(), outer.begin()); assert(outer.size() == 2); assert(outer[0].size() == 1); assert(outer[1].size() == 1); assert(is_contiguous_container_asan_correct(outer)); assert(is_contiguous_container_asan_correct(outer[0])); assert(is_contiguous_container_asan_correct(outer[1])); } #if TEST_STD_VER >= 11 { std::vector<int, min_allocator<int>> l1(a1, a1+3); assert(is_contiguous_container_asan_correct(l1)); std::vector<int, min_allocator<int>>::iterator i = l1.erase(l1.cbegin(), l1.cbegin()); assert(l1.size() == 3); assert(distance(l1.cbegin(), l1.cend()) == 3); assert(i == l1.begin()); assert(is_contiguous_container_asan_correct(l1)); } { std::vector<int, min_allocator<int>> l1(a1, a1+3); assert(is_contiguous_container_asan_correct(l1)); std::vector<int, min_allocator<int>>::iterator i = l1.erase(l1.cbegin(), next(l1.cbegin())); assert(l1.size() == 2); assert(distance(l1.cbegin(), l1.cend()) == 2); assert(i == l1.begin()); assert((l1 == std::vector<int, min_allocator<int>>(a1+1, a1+3))); assert(is_contiguous_container_asan_correct(l1)); } { std::vector<int, min_allocator<int>> l1(a1, a1+3); assert(is_contiguous_container_asan_correct(l1)); std::vector<int, min_allocator<int>>::iterator i = l1.erase(l1.cbegin(), next(l1.cbegin(), 2)); assert(l1.size() == 1); assert(distance(l1.cbegin(), l1.cend()) == 1); assert(i == l1.begin()); assert((l1 == std::vector<int, min_allocator<int>>(a1+2, a1+3))); assert(is_contiguous_container_asan_correct(l1)); } { std::vector<int, min_allocator<int>> l1(a1, a1+3); assert(is_contiguous_container_asan_correct(l1)); std::vector<int, min_allocator<int>>::iterator i = l1.erase(l1.cbegin(), next(l1.cbegin(), 3)); assert(l1.size() == 0); assert(distance(l1.cbegin(), l1.cend()) == 0); assert(i == l1.begin()); assert(is_contiguous_container_asan_correct(l1)); } { std::vector<std::vector<int, min_allocator<int>>, min_allocator<std::vector<int, min_allocator<int>>>> outer(2, std::vector<int, min_allocator<int>>(1)); assert(is_contiguous_container_asan_correct(outer)); assert(is_contiguous_container_asan_correct(outer[0])); assert(is_contiguous_container_asan_correct(outer[1])); outer.erase(outer.begin(), outer.begin()); assert(outer.size() == 2); assert(outer[0].size() == 1); assert(outer[1].size() == 1); assert(is_contiguous_container_asan_correct(outer)); assert(is_contiguous_container_asan_correct(outer[0])); assert(is_contiguous_container_asan_correct(outer[1])); } #endif #ifndef TEST_HAS_NO_EXCEPTIONS // Test for LWG2853: // Throws: Nothing unless an exception is thrown by the assignment operator or move assignment operator of T. { Throws arr[] = {1, 2, 3}; std::vector<Throws> v(arr, arr+3); Throws::sThrows = true; v.erase(v.begin(), --v.end()); assert(v.size() == 1); v.erase(v.begin(), v.end()); assert(v.size() == 0); } #endif }
int main() { { std::vector<MoveOnly, test_allocator<MoveOnly> > l(test_allocator<MoveOnly>(5)); std::vector<MoveOnly, test_allocator<MoveOnly> > lo(test_allocator<MoveOnly>(5)); assert(is_contiguous_container_asan_correct(l)); assert(is_contiguous_container_asan_correct(lo)); for (int i = 1; i <= 3; ++i) { l.push_back(i); lo.push_back(i); } assert(is_contiguous_container_asan_correct(l)); assert(is_contiguous_container_asan_correct(lo)); std::vector<MoveOnly, test_allocator<MoveOnly> > l2(std::move(l), test_allocator<MoveOnly>(6)); assert(l2 == lo); assert(!l.empty()); assert(l2.get_allocator() == test_allocator<MoveOnly>(6)); assert(is_contiguous_container_asan_correct(l2)); } { std::vector<MoveOnly, test_allocator<MoveOnly> > l(test_allocator<MoveOnly>(5)); std::vector<MoveOnly, test_allocator<MoveOnly> > lo(test_allocator<MoveOnly>(5)); assert(is_contiguous_container_asan_correct(l)); assert(is_contiguous_container_asan_correct(lo)); for (int i = 1; i <= 3; ++i) { l.push_back(i); lo.push_back(i); } assert(is_contiguous_container_asan_correct(l)); assert(is_contiguous_container_asan_correct(lo)); std::vector<MoveOnly, test_allocator<MoveOnly> > l2(std::move(l), test_allocator<MoveOnly>(5)); assert(l2 == lo); assert(l.empty()); assert(l2.get_allocator() == test_allocator<MoveOnly>(5)); assert(is_contiguous_container_asan_correct(l2)); } { std::vector<MoveOnly, other_allocator<MoveOnly> > l(other_allocator<MoveOnly>(5)); std::vector<MoveOnly, other_allocator<MoveOnly> > lo(other_allocator<MoveOnly>(5)); assert(is_contiguous_container_asan_correct(l)); assert(is_contiguous_container_asan_correct(lo)); for (int i = 1; i <= 3; ++i) { l.push_back(i); lo.push_back(i); } assert(is_contiguous_container_asan_correct(l)); assert(is_contiguous_container_asan_correct(lo)); std::vector<MoveOnly, other_allocator<MoveOnly> > l2(std::move(l), other_allocator<MoveOnly>(4)); assert(l2 == lo); assert(!l.empty()); assert(l2.get_allocator() == other_allocator<MoveOnly>(4)); assert(is_contiguous_container_asan_correct(l2)); } { std::vector<MoveOnly, min_allocator<MoveOnly> > l(min_allocator<MoveOnly>{}); std::vector<MoveOnly, min_allocator<MoveOnly> > lo(min_allocator<MoveOnly>{}); assert(is_contiguous_container_asan_correct(l)); assert(is_contiguous_container_asan_correct(lo)); for (int i = 1; i <= 3; ++i) { l.push_back(i); lo.push_back(i); } assert(is_contiguous_container_asan_correct(l)); assert(is_contiguous_container_asan_correct(lo)); std::vector<MoveOnly, min_allocator<MoveOnly> > l2(std::move(l), min_allocator<MoveOnly>()); assert(l2 == lo); assert(l.empty()); assert(l2.get_allocator() == min_allocator<MoveOnly>()); assert(is_contiguous_container_asan_correct(l2)); } }
int main() { { std::vector<int> v(100); std::vector<int>::iterator i = v.insert(v.cbegin() + 10, 1); assert(v.size() == 101); assert(is_contiguous_container_asan_correct(v)); assert(i == v.begin() + 10); int j; for (j = 0; j < 10; ++j) assert(v[j] == 0); assert(v[j] == 1); for (++j; j < 101; ++j) assert(v[j] == 0); } { std::vector<int, stack_allocator<int, 300> > v(100); std::vector<int, stack_allocator<int, 300> >::iterator i = v.insert(v.cbegin() + 10, 1); assert(v.size() == 101); assert(is_contiguous_container_asan_correct(v)); assert(i == v.begin() + 10); int j; for (j = 0; j < 10; ++j) assert(v[j] == 0); assert(v[j] == 1); for (++j; j < 101; ++j) assert(v[j] == 0); } #if _LIBCPP_DEBUG >= 1 { std::vector<int> v1(3); std::vector<int> v2(3); int i = 4; v1.insert(v2.begin(), i); assert(false); } #endif #if __cplusplus >= 201103L || defined(_LIBCPP_MSVC) { std::vector<int, min_allocator<int>> v(100); std::vector<int, min_allocator<int>>::iterator i = v.insert(v.cbegin() + 10, 1); assert(v.size() == 101); assert(is_contiguous_container_asan_correct(v)); assert(i == v.begin() + 10); int j; for (j = 0; j < 10; ++j) assert(v[j] == 0); assert(v[j] == 1); for (++j; j < 101; ++j) assert(v[j] == 0); } #if _LIBCPP_DEBUG >= 1 { std::vector<int, min_allocator<int>> v1(3); std::vector<int, min_allocator<int>> v2(3); int i = 4; v1.insert(v2.begin(), i); assert(false); } #endif #endif }