[libcxx] Fix incorrect iterator type in vector container test.

[amakc11]

Summary

The iterator types for different specializations of containers with the same element type but different allocators are not required to be convertible. This patch makes the test to take the iterator type from the same container specialization as the created container.

[ldionne]

test/std/containers/sequences/vector/vector.modifiers/insert_iter_iter_iter.pass.cpp

102–103

Please introduce a typedef to avoid repeating std::vector<int, limited_allocator<int, 308> >.

[amakc11]

My intention was to be consistent with the #if TEST_STD_VER >= 11 segment of the test, which does not introduce any typedef in the similar context. Should I change both?

[ldionne]

In D54806#1305547, @amakc11 wrote:

My intention was to be consistent with the #if TEST_STD_VER >= 11 segment of the test, which does not introduce any typedef in the similar context. Should I change both?

Ah, I missed that. Please make the change throughout. Otherwise, one can wonder whether these tests are meant to check for SCARY iterators, which they aren't.

[amakc11]

typedef added throughout the test to avoid confusion whether the implemented test actions are meant to check for SCARY iterators.

[amakc11]

BTW, which tests in the test suite are meant to check for SCARY iterators?

[ldionne]

In D54806#1305594, @amakc11 wrote:

BTW, which tests in the test suite are meant to check for SCARY iterators?

The only ones I could find with a quick grep are:

libcxx/test/std/containers/unord/unord.multimap/scary.pass.cpp
libcxx/test/std/containers/unord/unord.multiset/scary.pass.cpp
libcxx/test/std/containers/associative/multimap/scary.pass.cpp
libcxx/test/std/containers/associative/multiset/scary.pass.cpp

There doesn't seem to be such tests for all containers. However, I don't this SCARY iterators are actually required by the standard (am I wrong?).

[ldionne]

test/std/containers/sequences/vector/vector.modifiers/insert_iter_iter_iter.pass.cpp

102

You need spaces between consecutive >>'s, otherwise the test won't pass in C++03 mode.

[ldionne]

test/std/containers/sequences/vector/vector.modifiers/insert_iter_iter_iter.pass.cpp

102

Also, we usually use names like V instead of test_vector_type, but it doesn't really matter. Just FYI.

[amakc11]

In D54806#1305601, @ldionne wrote:

However, I don't this SCARY iterators are actually required by the standard (am I wrong?).

You are right: SCARY iterators are permitted but not required by the standard. Thanks for the tests list.

[amakc11]

Missing space restored. Type name changed according to the coding standard (sorry, I prefer readable identifiers by default).

[ldionne]

LGTM. Committed as r347423. Thanks for the patch!

test/std/containers/sequences/vector/vector.modifiers/insert_iter_iter_iter.pass.cpp

 #include "test_allocator.h"
 #include "test_iterators.h"
 #include "min_allocator.h"
 #include "asan_testing.h"
 
 int main()
 {
     {
-        std::vector<int> v(100);
+        typedef std::vector<int> test_vector_type;
+        test_vector_type v(100);
         int a[] = {1, 2, 3, 4, 5};
         const int N = sizeof(a)/sizeof(a[0]);
-        std::vector<int>::iterator i = v.insert(v.cbegin() + 10, input_iterator<const int*>(a),
+        test_vector_type::iterator i = v.insert(v.cbegin() + 10, input_iterator<const int*>(a),
                                         input_iterator<const int*>(a+N));
         assert(v.size() == 100 + N);
         assert(is_contiguous_container_asan_correct(v));
         assert(i == v.begin() + 10);
         int j;
         for (j = 0; j < 10; ++j)
             assert(v[j] == 0);
         for (std::size_t k = 0; k < N; ++j, ++k)
             assert(v[j] == a[k]);
         for (; j < 105; ++j)
             assert(v[j] == 0);
     }
     {
-        std::vector<int> v(100);
+        typedef std::vector<int> test_vector_type;
+        test_vector_type v(100);
         int a[] = {1, 2, 3, 4, 5};
         const int N = sizeof(a)/sizeof(a[0]);
-        std::vector<int>::iterator i = v.insert(v.cbegin() + 10, forward_iterator<const int*>(a),
+        test_vector_type::iterator i = v.insert(v.cbegin() + 10, forward_iterator<const int*>(a),
                                         forward_iterator<const int*>(a+N));
         assert(v.size() == 100 + N);
         assert(is_contiguous_container_asan_correct(v));
         assert(i == v.begin() + 10);
         int j;
         for (j = 0; j < 10; ++j)
             assert(v[j] == 0);
         for (std::size_t k = 0; k < N; ++j, ++k)
             assert(v[j] == a[k]);
         for (; j < 105; ++j)
             assert(v[j] == 0);
     }
     {
-        std::vector<int> v(100);
+        typedef std::vector<int> test_vector_type;
+        test_vector_type v(100);
         while(v.size() < v.capacity()) v.push_back(0); // force reallocation
         size_t sz = v.size();
         int a[] = {1, 2, 3, 4, 5};
         const unsigned N = sizeof(a)/sizeof(a[0]);
-        std::vector<int>::iterator i = v.insert(v.cbegin() + 10, forward_iterator<const int*>(a),
+        test_vector_type::iterator i = v.insert(v.cbegin() + 10, forward_iterator<const int*>(a),
                                         forward_iterator<const int*>(a+N));
         assert(v.size() == sz + N);
         assert(i == v.begin() + 10);
         std::size_t j;
         for (j = 0; j < 10; ++j)
             assert(v[j] == 0);
         for (std::size_t k = 0; k < N; ++j, ++k)
             assert(v[j] == a[k]);
         for (; j < v.size(); ++j)
             assert(v[j] == 0);
     }
     {
-        std::vector<int> v(100);
+        typedef std::vector<int> test_vector_type;
+        test_vector_type v(100);
         v.reserve(128); // force no reallocation
         size_t sz = v.size();
         int a[] = {1, 2, 3, 4, 5};
         const unsigned N = sizeof(a)/sizeof(a[0]);
-        std::vector<int>::iterator i = v.insert(v.cbegin() + 10, forward_iterator<const int*>(a),
+        test_vector_type::iterator i = v.insert(v.cbegin() + 10, forward_iterator<const int*>(a),
                                         forward_iterator<const int*>(a+N));
         assert(v.size() == sz + N);
         assert(i == v.begin() + 10);
         std::size_t j;
         for (j = 0; j < 10; ++j)
             assert(v[j] == 0);
         for (std::size_t k = 0; k < N; ++j, ++k)
             assert(v[j] == a[k]);
         for (; j < v.size(); ++j)
             assert(v[j] == 0);
     }
     {
-        std::vector<int, limited_allocator<int, 308> > v(100);
+        typedef std::vector<int, limited_allocator<int, 308>> test_vector_type;
+        test_vector_type v(100);
         int a[] = {1, 2, 3, 4, 5};
         const int N = sizeof(a)/sizeof(a[0]);
-        std::vector<int>::iterator i = v.insert(v.cbegin() + 10, input_iterator<const int*>(a),
+        test_vector_type::iterator i = v.insert(v.cbegin() + 10, input_iterator<const int*>(a),
                                         input_iterator<const int*>(a+N));
         assert(v.size() == 100 + N);
         assert(is_contiguous_container_asan_correct(v));
         assert(i == v.begin() + 10);
         int j;
         for (j = 0; j < 10; ++j)
             assert(v[j] == 0);
         for (std::size_t k = 0; k < N; ++j, ++k)
             assert(v[j] == a[k]);
         for (; j < 105; ++j)
             assert(v[j] == 0);
     }
     {
-        std::vector<int, limited_allocator<int, 300> > v(100);
+        typedef std::vector<int, limited_allocator<int, 300>> test_vector_type;
+        test_vector_type v(100);
         int a[] = {1, 2, 3, 4, 5};
         const int N = sizeof(a)/sizeof(a[0]);
-        std::vector<int>::iterator i = v.insert(v.cbegin() + 10, forward_iterator<const int*>(a),
+        test_vector_type::iterator i = v.insert(v.cbegin() + 10, forward_iterator<const int*>(a),
                                         forward_iterator<const int*>(a+N));
         assert(v.size() == 100 + N);
         assert(is_contiguous_container_asan_correct(v));
         assert(i == v.begin() + 10);
         int j;
         for (j = 0; j < 10; ++j)
             assert(v[j] == 0);
         for (std::size_t k = 0; k < N; ++j, ++k)
             assert(v[j] == a[k]);
         for (; j < 105; ++j)
             assert(v[j] == 0);
     }
 #if TEST_STD_VER >= 11
     {
-        std::vector<int, min_allocator<int>> v(100);
+        typedef std::vector<int, min_allocator<int>> test_vector_type;
+        test_vector_type v(100);
         int a[] = {1, 2, 3, 4, 5};
         const int N = sizeof(a)/sizeof(a[0]);
-        std::vector<int, min_allocator<int>>::iterator i = v.insert(v.cbegin() + 10, input_iterator<const int*>(a),
+        test_vector_type::iterator i = v.insert(v.cbegin() + 10, input_iterator<const int*>(a),
                                         input_iterator<const int*>(a+N));
         assert(v.size() == 100 + N);
         assert(is_contiguous_container_asan_correct(v));
         assert(i == v.begin() + 10);
         int j;
         for (j = 0; j < 10; ++j)
             assert(v[j] == 0);
         for (std::size_t k = 0; k < N; ++j, ++k)
             assert(v[j] == a[k]);
         for (; j < 105; ++j)
             assert(v[j] == 0);
     }
     {
-        std::vector<int, min_allocator<int>> v(100);
+        typedef std::vector<int, min_allocator<int>> test_vector_type;
+        test_vector_type v(100);
         int a[] = {1, 2, 3, 4, 5};
         const int N = sizeof(a)/sizeof(a[0]);
-        std::vector<int, min_allocator<int>>::iterator i = v.insert(v.cbegin() + 10, forward_iterator<const int*>(a),
+        test_vector_type::iterator i = v.insert(v.cbegin() + 10, forward_iterator<const int*>(a),
                                         forward_iterator<const int*>(a+N));
         assert(v.size() == 100 + N);
         assert(is_contiguous_container_asan_correct(v));
         assert(i == v.begin() + 10);
         int j;
         for (j = 0; j < 10; ++j)
             assert(v[j] == 0);
         for (std::size_t k = 0; k < N; ++j, ++k)
             assert(v[j] == a[k]);
         for (; j < 105; ++j)
             assert(v[j] == 0);
     }
 #endif
 }