[libcxx][test][NFC] Extend testing for vector.cons

[kboyarinov]

Summary

Extending std::vector tests in vector.cons module:

• std::vector::assign when source range is bigger than destination capacity
• construction of empty vector using copy ctor, initializer_list ctor and others

[ldionne]

Generally LGTM with some suggestions. Ship it if CI passes and once suggestions have been applied! Thanks a lot for improving our test suite.

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

69

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

28–45

[kboyarinov]

Fix comments from @ldionne

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

using It = cpp17_input_iterator<int*>;
       assert(v[1].value == 101);
       assert(v[2].copied == 0);
       assert(v[2].value == 42);
     }
   }
 #endif
 }
 
+// Test with a number of elements in the source range
+// that is greater than capacity
+void test_assign_bigger() {
+  typedef forward_iterator<int*> It;
 
+  std::vector<int> dst(10);
+
+  size_t n = dst.capacity() * 2;
+  std::vector<int> src(n);
+
+  dst.assign(It(src.data()), It(src.data() + src.size()));
+  assert(dst == src);
+}
 
 int main(int, char**)
 {
     test_emplaceable_concept();
+    test_assign_bigger();
 
   return 0;
 }

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

int main(int, char**)
     {
     typedef std::vector<int> V;
     V d1;
     V d2;
     d2.reserve(10);  // no reallocation during assign.
     test(d1);
     test(d2);
     }
-
+    {
+    std::vector<int> vec;
+    vec.reserve(32);
+    vec.resize(16); // destruction during assign
+    test(vec);
+    }
 #if TEST_STD_VER >= 11
     {
     typedef std::vector<int, min_allocator<int>> V;
     V d1;
     V d2;
     d2.reserve(10);  // no reallocation during assign.
     test(d1);
     test(d2);
     }
 #endif
 
   return 0;
 }

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

 #include "min_allocator.h"
 #include "asan_testing.h"
 #if TEST_STD_VER >= 11
 #include "emplace_constructible.h"
 #include "container_test_types.h"
 #endif
 
 template <class C, class Iterator>
 void test(Iterator first, Iterator last) {
+  {
     C c(first, last);
     LIBCPP_ASSERT(c.__invariants());
     assert(c.size() == static_cast<std::size_t>(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);
   }
+  // Test with an empty range
+  {
+    C c(first, first);
+    LIBCPP_ASSERT(c.__invariants());
+    assert(c.empty());
+    LIBCPP_ASSERT(is_contiguous_container_asan_correct(c));
+  }
+}
 
 static void basic_test_cases() {
   int a[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 8, 7, 6, 5, 4, 3, 1, 0};
   int* an = a + sizeof(a) / sizeof(a[0]);
   test<std::vector<int> >(cpp17_input_iterator<const int*>(a),
                           cpp17_input_iterator<const int*>(an));
   test<std::vector<int> >(forward_iterator<const int*>(a),
                           forward_iterator<const int*>(an));

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

 test(typename C::size_type n)
 {
     test1<C> ( n );
     test2<C> ( n );
 }
 
 int main(int, char**)
 {
+    test<std::vector<int> >(0);
     test<std::vector<int> >(50);
+    test<std::vector<DefaultOnly> >(0);
     test<std::vector<DefaultOnly> >(500);
     assert(DefaultOnly::count == 0);
 #if TEST_STD_VER >= 11
+    test<std::vector<int, min_allocator<int>> >(0);
     test<std::vector<int, min_allocator<int>> >(50);
+    test<std::vector<DefaultOnly, min_allocator<DefaultOnly>> >(0);
     test<std::vector<DefaultOnly, min_allocator<DefaultOnly>> >(500);
+    test2<std::vector<DefaultOnly, test_allocator<DefaultOnly>> >( 0, test_allocator<DefaultOnly>(23));
     test2<std::vector<DefaultOnly, test_allocator<DefaultOnly>> >( 100, test_allocator<DefaultOnly>(23));
     assert(DefaultOnly::count == 0);
 #endif
 
   return 0;
 }

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

test(typename C::size_type n, const typename C::value_type& x)
     assert(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)
         assert(*i == x);
 }
 
 int main(int, char**)
 {
+    test<std::vector<int> >(0, 3);
     test<std::vector<int> >(50, 3);
     // Add 1 for implementations that dynamically allocate a container proxy.
+    test<std::vector<int, limited_allocator<int, 50 + 1> > >(0, 5);
+    test<std::vector<int, limited_allocator<int, 50 + 1> > >(50, 5);
     test<std::vector<int, limited_allocator<int, 50 + 1> > >(50, 5);
 #if TEST_STD_VER >= 11
+    test<std::vector<int, min_allocator<int>> >(0, 3);
     test<std::vector<int, min_allocator<int>> >(50, 3);
 #endif
 
   return 0;
 }

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

test(typename C::size_type n, const typename C::value_type& x,
     assert(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)
         assert(*i == x);
 }
 
 int main(int, char**)
 {
+    test<std::vector<int> >(0, 3, std::allocator<int>());
     test<std::vector<int> >(50, 3, std::allocator<int>());
 #if TEST_STD_VER >= 11
+    test<std::vector<int, min_allocator<int>> >(0, 3, min_allocator<int>());
     test<std::vector<int, min_allocator<int>> >(50, 3, min_allocator<int>());
 #endif
 
   return 0;
 }

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

int main(int, char**)
         std::vector<int, test_allocator<int> > v2 = v;
         assert(is_contiguous_container_asan_correct(v));
         assert(is_contiguous_container_asan_correct(v2));
         assert(v2 == v);
         assert(v2.get_allocator() == v.get_allocator());
         assert(is_contiguous_container_asan_correct(v));
         assert(is_contiguous_container_asan_correct(v2));
     }
+    {
+        // Test copy ctor with empty source
+        std::vector<int, test_allocator<int> > v(test_allocator<int>(5));
+        std::vector<int, test_allocator<int> > v2 = v;
+        assert(is_contiguous_container_asan_correct(v));
+        assert(is_contiguous_container_asan_correct(v2));
+        assert(v2 == v);
+        assert(v2.get_allocator() == v.get_allocator());
+        assert(is_contiguous_container_asan_correct(v));
+        assert(is_contiguous_container_asan_correct(v2));
+        assert(v2.empty());
+    }
 #if TEST_STD_VER >= 11
     {
         std::vector<int, other_allocator<int> > v(3, 2, other_allocator<int>(5));
         std::vector<int, other_allocator<int> > v2 = v;
         assert(is_contiguous_container_asan_correct(v));
         assert(is_contiguous_container_asan_correct(v2));
         assert(v2 == v);
         assert(v2.get_allocator() == other_allocator<int>(-2));

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

int main(int, char**)
         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));
         assert(l2 == l);
         assert(l2.get_allocator() == other_allocator<int>(3));
     }
+    {
+        // Test copy ctor with allocator and empty source
+        std::vector<int, other_allocator<int> > l(other_allocator<int>(5));
+        std::vector<int, other_allocator<int> > l2(l, other_allocator<int>(3));
+        assert(l2 == l);
+        assert(l2.get_allocator() == other_allocator<int>(3));
+        assert(l2.empty());
+    }
 #if TEST_STD_VER >= 11
     {
         int a[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 8, 7, 6, 5, 4, 3, 1, 0};
         int* an = a + sizeof(a)/sizeof(a[0]);
         test(std::vector<int, min_allocator<int>>(a, an), min_allocator<int>());
     }
     {
         std::vector<int, min_allocator<int> > l(3, 2, min_allocator<int>());
         std::vector<int, min_allocator<int> > l2(l, min_allocator<int>());
         assert(l2 == l);
         assert(l2.get_allocator() == min_allocator<int>());
     }
 #endif
 
   return 0;
 }

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

int main(int, char**)
     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);
     }
+    {
+    std::vector<int, min_allocator<int>> d({}, min_allocator<int>());
+    assert(d.size() == 0);
+    assert(d.empty());
+    assert(is_contiguous_container_asan_correct(d));
+    }
 
   return 0;
 }