[libcxx][test][NFC] Various tests for std::vector

[kboyarinov]

Summary

Add missing tests for std::vector funcionality to improve code coverage:

• Access tests were rewritten to test modification of the container using the reference returned by the non-const overload
• Added tests for reverse iterators: rbegin, rend, etc.
• Added exception test for vector::reserve
• Extended test cases for vector copy assignment
• Fixed insert_iter_value.pass.cpp to use insert overload with const value_type& (not with value_type&& which is tested in iter_rvalue.pass.cpp test)

[kboyarinov]

Fix C++03

[• Quuxplusone]

libcxx/test/std/containers/sequences/vector/access.pass.cpp

32

Here again, I think the default argument is never used (and if it is, please change the caller).

59

The default argument is never used. (Or if it is and I missed it, please just change that caller to pass , 0 explicitly.)
https://quuxplusone.github.io/blog/2020/04/18/default-function-arguments-are-the-devil/

96–97

Ah, here's the caller that should change to test_get<Vector>(0);.
But also, can you explain why you are testing with both 0 and 36? What would you expect to "go wrong" with the 0 case — why not just test with 36 alone? (And then you wouldn't even need to pass N at all; it could be a constant.)

libcxx/test/std/containers/sequences/vector/reverse_iterators.pass.cpp

29–33

The body of std::distance(i, j) is just going to return j - i; so I think you should just check that expression directly. Or, don't even bother, because the reverse_iterator tests should (I hope) be dealing with that operator.
If you omit it, then these 13 lines can become 3, which is great:

Vector vec;
assert(vec.rbegin() == vec.rend());
assert(vec.crbegin() == vec.crend());

Do we have any existing test for ASSERT_SAME_TYPE(typename Vector::reverse_iterator, std::reverse_iterator<typename Vector::iterator>)? If not, I'd add that here.

libcxx/test/std/containers/sequences/vector/vector.capacity/reserve.pass.cpp

59

Nit throughout: Catch by const reference.

libcxx/test/std/containers/sequences/vector/vector.modifiers/emplace_extra.pass.cpp

61–72

Having variables with the same name as methods is confusing (and verbose). I think this can just be

std::vector<int> v;
v.reserve(8);
size_t oldCapacity = v.capacity();
assert(oldCapacity >= 8);
v.resize(4);  // keep the existing capacity
assert(v.capacity() == oldCapacity);
v.emplace(v.cend(), 42);
assert(v.size() == 5);
assert(v.capacity() == oldCapacity);

Also notice that simplifying the code found a bug: after v.reserve(8) it is not necessarily true that v.capacity() == 8. The capacity might be greater than 8.

libcxx/test/std/containers/sequences/vector/vector.modifiers/insert_iter_lvalue.pass.cpp

54

Same comment here: at least rename size to n.

59–61

This seems gratuitous... Ah, you're aiming for something subtle with value categories: trying to ensure that the thing being inserted is an lvalue. If I've guessed correctly, then please s/value/lvalue/g and also rename this test to insert_iter_lvalue.pass.cpp.

[kboyarinov]

Fix comments from differential review

[kboyarinov]

libcxx/test/std/containers/sequences/vector/access.pass.cpp

96–97

I have double-checked and it seems like testing with 0 is not necessary. Thanks for catching this!

libcxx/test/std/containers/sequences/vector/reverse_iterators.pass.cpp

29–33

Removed std::distance for empty vector test-case.

Do we have any existing test for ASSERT_SAME_TYPE(typename Vector::reverse_iterator, std::reverse_iterator<typename Vector::iterator>)? If not, I'd add that here.

We have such a test in types.pass.cpp for vector.

libcxx/test/std/containers/sequences/vector/vector.modifiers/emplace_extra.pass.cpp

61–72

Applied. Thank you for catching an issue with capacity!

libcxx/test/std/containers/sequences/vector/vector.modifiers/insert_iter_lvalue.pass.cpp

59–61

You are correct, currently we have 2 overloads for std::vector::insert: one takes an argument as const value_type&, an other - as value_type&&. This test is intended to test the first one, but actually tests the second. We have the test insert_iter_rvalue.pass.cpp for the second overload.

If I've guessed correctly, then please s/value/lvalue/g and also rename this test to insert_iter_lvalue.pass.cpp.

I have renamed this test to insert_iter_lvalue.pass.cpp. Could you please clarify what you mean with s/value/lvalue/g?

[• Quuxplusone]

libcxx/test/std/containers/sequences/vector/vector.modifiers/insert_iter_lvalue.pass.cpp

59–61

s/value/lvalue/g — "replace value with lvalue, not stopping at the first occurrence."
Renaming int value to int lvalue will help the reader understand that the value category is important here.

[kboyarinov]

Renaming value to lvalue for insert_iter_lvalue.pass.cpp

[kboyarinov]

libcxx/test/std/containers/sequences/vector/vector.modifiers/insert_iter_lvalue.pass.cpp

59–61

Thank you for the clarification! I have renamed the variable across the file.

[ldionne]

Deferring approval to Arthur who seem to have taken a deep look. Thanks for improving the tests!

[• Quuxplusone]

I still have a few more nits.

libcxx/test/std/containers/sequences/vector/access.pass.cpp

116–117

Today I wonder, what do you expect to be the salient difference between int and EqComparable?
If you'd used MoveOnly instead of EqComparable, I would have said "okay, I guess that makes sense to test," but EqComparable... it's still copyable, it's still trivial... basically the only difference is that it doesn't support operator< (which has nothing to do with this test). I don't see why we need it.

libcxx/test/std/containers/sequences/vector/reverse_iterators.pass.cpp

47–55

Instead of this loop, I believe you can just do

assert(cvec.rbegin() == vec.crbegin());
assert(cvec.rend() == vec.crend());

70

Might as well assert(std::distance(cvec.crbegin(), cvec.crend()) == 10); to complete the foursome.

libcxx/test/std/containers/sequences/vector/vector.capacity/reserve.pass.cpp

77

I suggest s/0/42/ here and line 65, just to make sure that the vector didn't magically get filled with zeros specifically.
Alternatively, assuming .data() is C++03, just do

int *previous_data = v.data();
size_t previous_capacity = v.capacity();
[...]
assert(v.size() == 10);
assert(v.capacity() == previous_capacity);
assert(v.data() == previous_data);

(and actually I'd say old_ rather than previous_, for brevity)

libcxx/test/std/containers/sequences/vector/vector.cons/assign_copy.pass.cpp

37

In this case, do we expect other_allocator::operator= to be called, or not?
If we don't verify our expectation, then I think this new test is useless — it's equivalent to either lines 22-26 or lines 29-33, but we don't know which.
How can we verify that the behavior is as we expect?
(Do we have a test allocator type where "identity" is distinguishable from "equality"? I seem to recall we do, but I haven't looked.)

[kboyarinov]

Fix comments from the last revision of the review

[kboyarinov]

libcxx/test/std/containers/sequences/vector/vector.capacity/reserve.pass.cpp

77

I have changed 0 value to 42 and also added an assertion with v.data().
I did not removed the loop that checks values inside of the vector to ensure not only that reserve did not modified the memory (v.data()) but also did not changed the actual values inside of that memory.

libcxx/test/std/containers/sequences/vector/vector.cons/assign_copy.pass.cpp

37

We expect allocator::operator= to be called only if allocator_traits<allocator>::propagate_on_container_copy_assignment::value is true.

I have replaced this test-case with the following three:

• POCCA false (Allocator is A1 from allocators.h)
• POCCA true and the allocators compares equal (Allocator is A3)
• POCCA true and the allocators compares unequal (Allocator is A3)

This change also required A1 and A3 to provide allocate and deallocate that provides real memory. Absence of these method seemed really strange for me.

[kboyarinov]

A1 and A3 class templates from allocator.h cannot be used to test propagate_on_container_copy_assignment option during the vector::operator=(const vector&).
I have tried to change allocate and deallocate methods in these allocators to use new-delete to provide the real memory, but tests for std::scoped_allocator_adaptor has failed.
I have introduced the new class POCCAAllocator<T, bool> to test the behavior of vector on copy assignment.
Tests for other containers can also be rewritten to use the new allocator class.

[• Quuxplusone]

LGTM % comments... tempted to mark this "accepted," but let's go around one more time. ;)

libcxx/test/std/containers/sequences/vector/vector.cons/assign_copy.pass.cpp

47

With my suggestion below, this becomes

using Alloc = NonPOCCAAllocator<int>;
bool copy_assigned_into = false;
std::vector<int, Alloc> l(3, 2, Alloc(5, &copy_assigned_into));
std::vector<int, Alloc> l2(l, Alloc(3, nullptr));
l2 = l;
assert(!copy_assigned_into);
assert(l2 == l);
assert(l2.get_allocator() == Alloc(3, nullptr));

For the cases below where we expect assert(copy_assigned_into), it might be a good idea to assert(!copy_assigned_into) on the line immediately before the assignment, just to be safe; but I'm not married to that idea.

libcxx/test/support/allocators.h

188

Please remove the default argument. Besides that unused defaults are just typo-bug-magnets, even if you were using this default, it would be the wrong default — surely a POCCAAllocator<int> should be POCCA!
I also notice that you felt the need to /*comment=*/ on each use of this class, which indicates there's room for improvement. Since this is C++11-only, how about creating two alias templates

template<class T>
using POCCAAllocator = MaybePOCCAAllocator<T, true>;
template<class T>
using NonPOCCAAllocator = MaybePOCCAAllocator<T, false>;

and using them consistently throughout?
Finally, static bool copy_assign_called; is a libcxx/test/ antipattern, because it's not constexpr-friendly. Could we easily make that a non-static bool *copy_assigned_into_ and set it up in the constructor like we set up id_, to point to a stack variable controlled by the caller? I'll give an example usage above.

197

Default function arguments being the devil, please spend 2 lines on this. :)

explicit POCCAAllocator() = default;
explicit POCCAAllocator(int id, bool *p) : id_(id), copy_assigned_into_(p) {}
~~~
int id_ = 0;
bool *copy_assigned_into_ = nullptr;

[kboyarinov]

Removed static bool variable, renamed POCCAAllocator, added aliases

[kboyarinov]

libcxx/test/std/containers/sequences/vector/vector.cons/assign_copy.pass.cpp

47

Applied, thank you for the great suggestion!

libcxx/test/support/allocators.h

197

I have splitted the constructor into default, the constructor that accepts id only and the constructor with id and bool*.

[• Quuxplusone]

libcxx/test/std/containers/sequences/vector/vector.cons/assign_copy.pass.cpp

47

I notice you added a third constructor Alloc(int) so that you could write Alloc(3) instead of Alloc(3, nullptr). I don't think this buys you enough (in terms of characters saved) to offset its cost (in terms of risk-of-typo-bug-where-you-omit-the-parameter-accidentally). So I'd prefer to eliminate that ctor and pass nullptr explicitly in these ~6 places.

libcxx/test/support/allocators.h

206

After this line, arguably you should do copy_assigned_into_ = a.copy_assigned_into_... but I guess I can see it either way, and the existing tests don't care at all, so I'm happy to leave it like this. Just bringing it up for the record. No action required.

[kboyarinov]

Removed the constructor of MaybePOCCAAllocator from int argument

[rarutyun]

Overall, looks good to me, but I believe some small improvements could be done.

libcxx/test/std/containers/sequences/vector/access.pass.cpp

42

Here we rely that the size of vector is 10. But it goes from outer context. IMO, it's error prone and not very convenient for further maintenance. I would suggest to either pass the size from outer context or just read it from Vector object depending on what's more appropriate for the test purpose.

72

Here is the similar situation. Even if we have 10 in the same context refactoring of this code in not as good as might be. I would suggest to either create a variable for the size (as you do in one of the other tests) or call c.size()

[kboyarinov]

Fix comments by @rarutyun

[rarutyun]

libcxx/test/std/containers/sequences/vector/reverse_iterators.pass.cpp

62

Here the comment with easier refactoring is not addressed yet.

[kboyarinov]

Changed reverse_iterators.pass.cpp to use int n = 10 instead of n in all places

[rarutyun]

LGTM, waiting for CI to complete

libcxx/test/std/containers/sequences/vector/access.pass.cpp

 #include <vector>
 #include <cassert>
 
 #include "min_allocator.h"
 #include "test_macros.h"
 
 template <class C>
 C
-make(int size, int start = 0)
+make(int size, int start)
 {
     C c;
     for (int i = 0; i < size; ++i)
         c.push_back(start + i);
     return c;
 }
 
-int main(int, char**)
-{
-    {
-        typedef std::vector<int> C;
-        C c = make<C>(10);
-        LIBCPP_ASSERT_NOEXCEPT(c[0]);
-        LIBCPP_ASSERT_NOEXCEPT(c.front());
-        LIBCPP_ASSERT_NOEXCEPT(c.back());
-        // at() is NOT noexcept
-        ASSERT_SAME_TYPE(C::reference, decltype(c[0]));
-        ASSERT_SAME_TYPE(C::reference, decltype(c.at(0)));
-        ASSERT_SAME_TYPE(C::reference, decltype(c.front()));
-        ASSERT_SAME_TYPE(C::reference, decltype(c.back()));
-        for (int i = 0; i < 10; ++i)
-            assert(c[i] == i);
-        for (int i = 0; i < 10; ++i)
-            assert(c.at(i) == i);
-        assert(c.front() == 0);
-        assert(c.back() == 9);
-    }
-    {
-        typedef std::vector<int> C;
-        const int N = 5;
-        const C c = make<C>(10, N);
-        LIBCPP_ASSERT_NOEXCEPT(c[0]);
-        LIBCPP_ASSERT_NOEXCEPT(c.front());
-        LIBCPP_ASSERT_NOEXCEPT(c.back());
-        // at() is NOT noexcept
-        ASSERT_SAME_TYPE(C::const_reference, decltype(c[0]));
-        ASSERT_SAME_TYPE(C::const_reference, decltype(c.at(0)));
-        ASSERT_SAME_TYPE(C::const_reference, decltype(c.front()));
-        ASSERT_SAME_TYPE(C::const_reference, decltype(c.back()));
-        for (int i = 0; i < 10; ++i)
-            assert(c[i] == N + i);
-        for (int i = 0; i < 10; ++i)
-            assert(c.at(i) == N + i);
-        assert(c.front() == N);
-        assert(c.back() == N + 9);
-    }
-#if TEST_STD_VER >= 11
-    {
-        typedef std::vector<int, min_allocator<int>> C;
-        const int N = 34;
-        C c = make<C>(10, N);
-        LIBCPP_ASSERT_NOEXCEPT(c[0]);
-        LIBCPP_ASSERT_NOEXCEPT(c.front());
-        LIBCPP_ASSERT_NOEXCEPT(c.back());
-        // at() is NOT noexcept
-        ASSERT_SAME_TYPE(C::reference, decltype(c[0]));
-        ASSERT_SAME_TYPE(C::reference, decltype(c.at(0)));
-        ASSERT_SAME_TYPE(C::reference, decltype(c.front()));
-        ASSERT_SAME_TYPE(C::reference, decltype(c.back()));
-        for (int i = 0; i < 10; ++i)
-            assert(c[i] == N + i);
-        for (int i = 0; i < 10; ++i)
-            assert(c.at(i) == N + i);
-        assert(c.front() == N);
-        assert(c.back() == N + 9);
+template <class Vector>
+void test_get_basic(Vector& c, int start_value) {
+    const int n = c.size();
+    for (int i = 0; i < n; ++i)
+        assert(c[i] == start_value + i);
+    for (int i = 0; i < n; ++i)
+        assert(c.at(i) == start_value + i);
+
+#ifndef TEST_HAS_NO_EXCEPTIONS
+    try {
+        c.at(n);
+        assert(false);
+    } catch (const std::out_of_range&) {}
+#endif
+
+    assert(c.front() == start_value);
+    assert(c.back() == start_value + n - 1);
+
+template <class Vector>
+void test_get() {
+    int start_value = 35;
+    Vector c = make<Vector>(10, start_value);
+    const Vector& cc = c;
+    test_get_basic(c, start_value);
+    test_get_basic(cc, start_value);
+
+template <class Vector>
+void test_set() {
+    int start_value = 35;
+    const int n = 10;
+    Vector c = make<Vector>(n, start_value);
+
+    for (int i = 0; i < n; ++i) {
+        assert(c[i] == start_value + i);
+        c[i] = start_value + i + 1;
+        assert(c[i] == start_value + i + 1);
     }
-    {
-        typedef std::vector<int, min_allocator<int>> C;
-        const int N = 23;
-        const C c = make<C>(10, N);
-        LIBCPP_ASSERT_NOEXCEPT(c[0]);
-        LIBCPP_ASSERT_NOEXCEPT(c.front());
-        LIBCPP_ASSERT_NOEXCEPT(c.back());
-        // at() is NOT noexcept
-        ASSERT_SAME_TYPE(C::const_reference, decltype(c[0]));
-        ASSERT_SAME_TYPE(C::const_reference, decltype(c.at(0)));
-        ASSERT_SAME_TYPE(C::const_reference, decltype(c.front()));
-        ASSERT_SAME_TYPE(C::const_reference, decltype(c.back()));
-        for (int i = 0; i < 10; ++i)
-            assert(c[i] == N + i);
-        for (int i = 0; i < 10; ++i)
-            assert(c.at(i) == N + i);
-        assert(c.front() == N);
-        assert(c.back() == N + 9);
+    for (int i = 0; i < n; ++i) {
+        assert(c.at(i) == start_value + i + 1);
+        c.at(i) = start_value + i + 2;
+        assert(c.at(i) == start_value + i + 2);
     }
+
+    assert(c.front() == start_value + 2);
+    c.front() = start_value + 3;
+    assert(c.front() == start_value + 3);
+
+    assert(c.back() == start_value + n + 1);
+    c.back() = start_value + n + 2;
+    assert(c.back() == start_value + n + 2);
+}
+
+template <class Vector>
+void test() {
+    test_get<Vector>();
+    test_set<Vector>();
+
+    Vector c;
+    const Vector& cc = c;
+    ASSERT_SAME_TYPE(typename Vector::reference, decltype(c[0]));
+    ASSERT_SAME_TYPE(typename Vector::const_reference, decltype(cc[0]));
+
+    ASSERT_SAME_TYPE(typename Vector::reference, decltype(c.at(0)));
+    ASSERT_SAME_TYPE(typename Vector::const_reference, decltype(cc.at(0)));
+
+    ASSERT_SAME_TYPE(typename Vector::reference, decltype(c.front()));
+    ASSERT_SAME_TYPE(typename Vector::const_reference, decltype(cc.front()));
+
+    ASSERT_SAME_TYPE(typename Vector::reference, decltype(c.back()));
+    ASSERT_SAME_TYPE(typename Vector::const_reference, decltype(cc.back()));
+}
+
+int main(int, char**)
+{
+    test<std::vector<int> >();
+#if TEST_STD_VER >= 11
+    test<std::vector<int, min_allocator<int> > >();
 #endif
 
   return 0;
 }

libcxx/test/std/containers/sequences/vector/reverse_iterators.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// <vector>
+
+// reverse_iterator       rbegin();
+// reverse_iterator       rend();
+// const_reverse_iterator rbegin()  const;
+// const_reverse_iterator rend()    const;
+// const_reverse_iterator crbegin() const;
+// const_reverse_iterator crend()   const;
+
+#include <vector>
+#include <cassert>
+#include <iterator>
+
+#include "min_allocator.h"
+
+template <class Vector>
+void check_vector_reverse_iterators() {
+    {
+        Vector vec;
+        assert(vec.rbegin() == vec.rend());
+        assert(vec.crbegin() == vec.crend());
+    }
+    {
+        Vector vec;
+        const Vector& cvec = vec;
+        vec.reserve(10);
+        for (int i = 0; i < 10; ++i)
+            vec.push_back(i);
+        {
+            int iterations = 0;
+
+            for (typename Vector::const_reverse_iterator it = vec.crbegin(); it != vec.crend(); ++it) {
+                assert(*it == (10 - iterations - 1));
+                ++iterations;
+            }
+            assert(iterations == 10);
+        }
+        {
+            assert(cvec.rbegin() == vec.crbegin());
+            assert(cvec.rend() == vec.crend());
+        }
+        {
+            int iterations = 0;
+
+            for (typename Vector::reverse_iterator it = vec.rbegin(); it != vec.rend(); ++it) {
+                assert(*it == (10 - iterations - 1));
+                *it = 40;
+                assert(*it == 40);
+                ++iterations;
+            }
+            assert(iterations == 10);
+        }
+
+        assert(std::distance(vec.rbegin(), vec.rend()) == 10);
+        assert(std::distance(cvec.rbegin(), cvec.rend()) == 10);
+        assert(std::distance(vec.crbegin(), vec.crend()) == 10);
+        assert(std::distance(cvec.crbegin(), cvec.crend()) == 10);
+    }
+}
+
+int main(int, char**) {
+    check_vector_reverse_iterators<std::vector<int> >();
+#if TEST_STD_VER >= 11
+    check_vector_reverse_iterators<std::vector<int, min_allocator<int> > >();
+#endif
+
+    return 0;
+}

libcxx/test/std/containers/sequences/vector/vector.capacity/reserve.pass.cpp

int main(int, char**)
         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
+    {
+        std::vector<int> v;
+        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);
+        }
+    }
+    {
+        std::vector<int> v(10, 42);
+        int* previous_data = v.data();
+        size_t previous_capacity = v.capacity();
+        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
 #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));
     }
     {

libcxx/test/std/containers/sequences/vector/vector.cons/assign_copy.pass.cpp

 
 // vector& operator=(const vector& c);
 
 #include <vector>
 #include <cassert>
 #include "test_macros.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
+#include "allocators.h"
 
 int main(int, char**)
 {
     {
         std::vector<int, test_allocator<int> > l(3, 2, test_allocator<int>(5));
         std::vector<int, test_allocator<int> > l2(l, test_allocator<int>(3));
         l2 = l;
         assert(l2 == l);
         assert(l2.get_allocator() == test_allocator<int>(3));
     }
     {
         std::vector<int, other_allocator<int> > l(3, 2, other_allocator<int>(5));
         std::vector<int, other_allocator<int> > l2(l, other_allocator<int>(3));
         l2 = l;
         assert(l2 == l);
         assert(l2.get_allocator() == other_allocator<int>(5));
     }
 #if TEST_STD_VER >= 11
     {
+        // Test with Allocator::propagate_on_container_copy_assignment == false_type
+        using Alloc = NonPOCCAAllocator<int>;
+        bool copy_assigned_into = false;
+        std::vector<int, Alloc> l(3, 2, Alloc(5, nullptr));
+        std::vector<int, Alloc> l2(l, Alloc(3, &copy_assigned_into));
+        assert(!copy_assigned_into);
+        l2 = l;
+        assert(!copy_assigned_into);
+        assert(l2 == l);
+        assert(l2.get_allocator() == Alloc(3, nullptr));
+    }
+    {
+        // Test with Allocator::propagate_on_container_copy_assignment == true_type
+        // and equal allocators
+        using Alloc = POCCAAllocator<int>;
+        bool copy_assigned_into = false;
+        std::vector<int, Alloc> l(3, 2, Alloc(5, nullptr));
+        std::vector<int, Alloc> l2(l, Alloc(5, &copy_assigned_into));
+        assert(!copy_assigned_into);
+        l2 = l;
+        assert(copy_assigned_into);
+        assert(l2 == l);
+        assert(l2.get_allocator() == Alloc(5, nullptr));
+    }
+    {
+        // Test with Allocator::propagate_on_container_copy_assignment == true_type
+        // and unequal allocators
+        using Alloc = POCCAAllocator<int>;
+        bool copy_assigned_into = false;
+        std::vector<int, Alloc> l(3, 2, Alloc(5, nullptr));
+        std::vector<int, Alloc> l2(l, Alloc(3, &copy_assigned_into));
+        assert(!copy_assigned_into);
+        l2 = l;
+        assert(copy_assigned_into);
+        assert(l2 == l);
+        assert(l2.get_allocator() == Alloc(5, nullptr));
+    }
+    {
         std::vector<int, min_allocator<int> > l(3, 2, min_allocator<int>());
         std::vector<int, min_allocator<int> > l2(l, min_allocator<int>());
         l2 = l;
         assert(l2 == l);
         assert(l2.get_allocator() == min_allocator<int>());
     }
 #endif
 
   return 0;
 }

libcxx/test/std/containers/sequences/vector/vector.modifiers/emplace_extra.pass.cpp

int main(int, char**)
         std::vector<int, min_allocator<int>> v;
         v.reserve(4);
         assert(is_contiguous_container_asan_correct(v));
         v = { 1, 2, 3 };
         v.emplace(v.begin(), v.back());
         assert(v[0] == 3);
         assert(is_contiguous_container_asan_correct(v));
     }
-
+    {
+        std::vector<int> v;
+        v.reserve(8);
+        size_t old_capacity = v.capacity();
+        assert(old_capacity >= 8);
+
+        v.resize(4); // keep the existing capacity
+        assert(v.capacity() == old_capacity);
+
+        v.emplace(v.cend(), 42);
+        assert(v.size() == 5);
+        assert(v.capacity() == old_capacity);
+        assert(v[4] == 42);
+    }
   return 0;
 }

libcxx/test/std/containers/sequences/vector/vector.modifiers/insert_iter_lvalue.pass.cpp

 #include "test_allocator.h"
 #include "min_allocator.h"
 #include "asan_testing.h"
 
 int main(int, char**)
 {
     {
         std::vector<int> v(100);
-        std::vector<int>::iterator i = v.insert(v.cbegin() + 10, 1);
+        const int lvalue = 1;
+        std::vector<int>::iterator i = v.insert(v.cbegin() + 10, lvalue);
         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);
     }
     {
+        const size_t n = 100;
+        std::vector<int> v(n);
+        v.reserve(n + 1);
+        const int lvalue = 1;
+
+        // no reallocation expected
+        std::vector<int>::iterator it = v.insert(v.cbegin() + n, lvalue);
+
+        assert(v.size() == n + 1);
+        assert(is_contiguous_container_asan_correct(v));
+        assert(it == v.begin() + n);
+        for (size_t i = 0; i < n; ++i) {
+            assert(v[i] == 0);
+        }
+        assert(v[n] == lvalue);
+    }
+    {
         std::vector<int> v(100);
         while(v.size() < v.capacity()) v.push_back(0); // force reallocation
         size_t sz = v.size();
-        std::vector<int>::iterator i = v.insert(v.cbegin() + 10, 1);
+        const int lvalue = 1;
+        std::vector<int>::iterator i = v.insert(v.cbegin() + 10, lvalue);
         assert(v.size() == sz + 1);
         assert(is_contiguous_container_asan_correct(v));
         assert(i == v.begin() + 10);
         std::size_t j;
         for (j = 0; j < 10; ++j)
             assert(v[j] == 0);
         assert(v[j] == 1);
         for (++j; j < v.size(); ++j)
             assert(v[j] == 0);
     }
     {
         std::vector<int> v(100);
         while(v.size() < v.capacity()) v.push_back(0);
         v.pop_back(); v.pop_back(); // force no reallocation
         size_t sz = v.size();
-        std::vector<int>::iterator i = v.insert(v.cbegin() + 10, 1);
+        const int lvalue = 1;
+        std::vector<int>::iterator i = v.insert(v.cbegin() + 10, lvalue);
         assert(v.size() == sz + 1);
         assert(is_contiguous_container_asan_correct(v));
         assert(i == v.begin() + 10);
         std::size_t j;
         for (j = 0; j < 10; ++j)
             assert(v[j] == 0);
         assert(v[j] == 1);
         for (++j; j < v.size(); ++j)
             assert(v[j] == 0);
     }
     {
         std::vector<int, limited_allocator<int, 300> > v(100);
-        std::vector<int, limited_allocator<int, 300> >::iterator i = v.insert(v.cbegin() + 10, 1);
+        const int lvalue = 1;
+        std::vector<int, limited_allocator<int, 300> >::iterator i = v.insert(v.cbegin() + 10, lvalue);
         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 TEST_STD_VER >= 11
     {
         std::vector<int, min_allocator<int>> v(100);
-        std::vector<int, min_allocator<int>>::iterator i = v.insert(v.cbegin() + 10, 1);
+        const int lvalue = 1;
+        std::vector<int, min_allocator<int>>::iterator i = v.insert(v.cbegin() + 10, lvalue);
         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);
     }
 #endif
 
   return 0;
 }

libcxx/test/support/allocators.h

 
 template <class T, class U>
 inline
 bool operator!=(const A3<T>& x, const A3<U>& y)
 {
     return !(x == y);
 }
 
+template <class T, bool POCCAValue>
+class MaybePOCCAAllocator {
+    int id_ = 0;
+    bool* copy_assigned_into_ = nullptr;
+public:
+    typedef std::integral_constant<bool, POCCAValue> propagate_on_container_copy_assignment;
+    typedef T value_type;
+
+    MaybePOCCAAllocator() = default;
+    MaybePOCCAAllocator(int id, bool* copy_assigned_into)
+        : id_(id), copy_assigned_into_(copy_assigned_into) {}
+
+    MaybePOCCAAllocator(const MaybePOCCAAllocator&) = default;
+    MaybePOCCAAllocator& operator=(const MaybePOCCAAllocator& a)
+    {
+        id_ = a.id();
+        if (copy_assigned_into_)
+            *copy_assigned_into_ = true;
+        return *this;
+    }
+
+    T* allocate(std::size_t n)
+    {
+        return static_cast<T*>(::operator new(n * sizeof(T)));
+    }
+
+    void deallocate(T* ptr, std::size_t)
+    {
+        ::operator delete(ptr);
+    }
+
+    int id() const { return id_; }
+
+    friend bool operator==(const MaybePOCCAAllocator& lhs, const MaybePOCCAAllocator& rhs)
+    {
+        return lhs.id() == rhs.id();
+    }
+
+    friend bool operator!=(const MaybePOCCAAllocator& lhs, const MaybePOCCAAllocator& rhs)
+    {
+        return !(lhs == rhs);
+    }
+};
+
+template <class T>
+using POCCAAllocator = MaybePOCCAAllocator<T, /*POCCAValue = */true>;
+template <class T>
+using NonPOCCAAllocator = MaybePOCCAAllocator<T, /*POCCAValue = */false>;
+
 #endif // TEST_STD_VER >= 11
 
 #endif // ALLOCATORS_H