[libcxx] [test] Fix non-Standard assumptions about how many elements are allocated

[STL_MSFT]

Summary

The recently-added limited_allocator is much more conformant than the evil old stack_allocator. However, limited_allocator encodes non-Standard assumptions about how many allocations containers perform, which don't hold for MSVC. Specifically, MSVC's STL dynamically allocates sentinel nodes and "container proxies" (for debug mode checking), and its vector famously grows by 1.5x instead of 2x. I would like to retain the limited_allocator coverage, but tweak things so that they pass for both libc++ and MSVC.

test/std/containers/sequences/deque/deque.cons/size.pass.cpp
test/std/containers/sequences/deque/deque.cons/size_value.pass.cpp
deque is too weird. (MSVC's deque reallocates its blockmap several times while doing this.) Just mark the tests as LIBCPP_ONLY, the coward's way out.

test/std/containers/sequences/list/list.cons/input_iterator.pass.cpp
test/std/containers/sequences/list/list.cons/size_type.pass.cpp
test/std/containers/sequences/list/list.cons/size_value_alloc.pass.cpp
"Add 2 for implementations that dynamically allocate a sentinel node and container proxy."

test/std/containers/sequences/vector/vector.capacity/reserve.pass.cpp
test/std/containers/sequences/vector/vector.capacity/resize_size.pass.cpp
test/std/containers/sequences/vector/vector.capacity/resize_size_value.pass.cpp
test/std/containers/sequences/vector/vector.cons/construct_size_value.pass.cpp
"Add 1 for implementations that dynamically allocate a container proxy."

test/std/containers/sequences/vector/vector.cons/construct_iter_iter.pass.cpp
Ditto. The (InIt, InIt) ctor is unchanged at 63 elements allocated (MSVC's 1.5x results in fewer element allocations, enough to make room for the container proxy).

test/std/containers/sequences/vector/vector.modifiers/push_back.pass.cpp
test/std/containers/sequences/vector/vector.modifiers/push_back_rvalue.pass.cpp
Adjust numbers for container proxy and 1.5x growth, with the calculations in the comments.

[EricWF]

LGTM. I appreciate the doc for each of the magic numbers.

[STL_MSFT]

Committed r285346. Thanks!!

test/std/containers/sequences/deque/deque.cons/size.pass.cpp

int main()
     test<DefaultOnly, std::allocator<DefaultOnly> >(1025);
     test<DefaultOnly, std::allocator<DefaultOnly> >(2047);
     test<DefaultOnly, std::allocator<DefaultOnly> >(2048);
     test<DefaultOnly, std::allocator<DefaultOnly> >(2049);
     test<DefaultOnly, std::allocator<DefaultOnly> >(4095);
     test<DefaultOnly, std::allocator<DefaultOnly> >(4096);
     test<DefaultOnly, std::allocator<DefaultOnly> >(4097);
 
-    test1<DefaultOnly, limited_allocator<DefaultOnly, 4096> >(4095);
+    LIBCPP_ONLY(test1<DefaultOnly, limited_allocator<DefaultOnly, 4096> >(4095));
 
 #if TEST_STD_VER >= 11
     test<DefaultOnly, min_allocator<DefaultOnly> >(4095);
 #endif
 
 #if _LIBCPP_STD_VER > 11
     test3<DefaultOnly, std::allocator<DefaultOnly>> (1023);
     test3<int, std::allocator<int>>(1);
     test3<int, min_allocator<int>> (3);
 #endif
 
 }

test/std/containers/sequences/deque/deque.cons/size_value.pass.cpp

int main()
     test<int, std::allocator<int> >(1024, 25);
     test<int, std::allocator<int> >(1025, 0);
     test<int, std::allocator<int> >(2047, 110);
     test<int, std::allocator<int> >(2048, -500);
     test<int, std::allocator<int> >(2049, 654);
     test<int, std::allocator<int> >(4095, 78);
     test<int, std::allocator<int> >(4096, 1165);
     test<int, std::allocator<int> >(4097, 157);
-    test<int, limited_allocator<int, 4096> >(4095, 90);
+    LIBCPP_ONLY(test<int, limited_allocator<int, 4096> >(4095, 90));
 #if TEST_STD_VER >= 11
     test<int, min_allocator<int> >(4095, 90);
 #endif
 }

test/std/containers/sequences/list/list.cons/input_iterator.pass.cpp

int main()
         assert(l.size() == sizeof(a)/sizeof(a[0]));
         assert(std::distance(l.begin(), l.end()) == sizeof(a)/sizeof(a[0]));
         int j = 0;
         for (std::list<int>::const_iterator i = l.begin(), e = l.end(); i != e; ++i, ++j)
             assert(*i == j);
     }
     {
         int a[] = {0, 1, 2, 3};
-        std::list<int, limited_allocator<int, sizeof(a)/sizeof(a[0])> > l(input_iterator<const int*>(a),
+        // Add 2 for implementations that dynamically allocate a sentinel node and container proxy.
+        std::list<int, limited_allocator<int, sizeof(a)/sizeof(a[0]) + 2> > l(input_iterator<const int*>(a),
                          input_iterator<const int*>(a + sizeof(a)/sizeof(a[0])));
         assert(l.size() == sizeof(a)/sizeof(a[0]));
         assert(std::distance(l.begin(), l.end()) == sizeof(a)/sizeof(a[0]));
         int j = 0;
         for (std::list<int>::const_iterator i = l.begin(), e = l.end(); i != e; ++i, ++j)
             assert(*i == j);
     }
 #if TEST_STD_VER >= 11

test/std/containers/sequences/list/list.cons/size_type.pass.cpp

int main()
         std::list<int>::const_iterator i = l.begin();
         assert(*i == 0);
         ++i;
         assert(*i == 0);
         ++i;
         assert(*i == 0);
     }
     {
-        std::list<int, limited_allocator<int, 3> > l(3);
+        // Add 2 for implementations that dynamically allocate a sentinel node and container proxy.
+        std::list<int, limited_allocator<int, 3 + 2> > l(3);
         assert(l.size() == 3);
         assert(std::distance(l.begin(), l.end()) == 3);
         std::list<int>::const_iterator i = l.begin();
         assert(*i == 0);
         ++i;
         assert(*i == 0);
         ++i;
         assert(*i == 0);

test/std/containers/sequences/list/list.cons/size_value_alloc.pass.cpp

int main()
         std::list<int>::const_iterator i = l.begin();
         assert(*i == 2);
         ++i;
         assert(*i == 2);
         ++i;
         assert(*i == 2);
     }
     {
-        std::list<int, limited_allocator<int, 3> > l(3, 2);
+        // Add 2 for implementations that dynamically allocate a sentinel node and container proxy.
+        std::list<int, limited_allocator<int, 3 + 2> > l(3, 2);
         assert(l.size() == 3);
         assert(std::distance(l.begin(), l.end()) == 3);
         std::list<int>::const_iterator i = l.begin();
         assert(*i == 2);
         ++i;
         assert(*i == 2);
         ++i;
         assert(*i == 2);

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

int main()
         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));
     }
     {
-        std::vector<int, limited_allocator<int, 250> > v(100);
+        // Add 1 for implementations that dynamically allocate a container proxy.
+        std::vector<int, limited_allocator<int, 250 + 1> > v(100);
         assert(v.capacity() == 100);
         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));

test/std/containers/sequences/vector/vector.capacity/resize_size.pass.cpp

#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
         assert(v.capacity() == 100);
         assert(is_contiguous_container_asan_correct(v));
         v.resize(200);
         assert(v.size() == 200);
         assert(v.capacity() >= 200);
         assert(is_contiguous_container_asan_correct(v));
     }
     {
-        std::vector<MoveOnly, limited_allocator<MoveOnly, 300> > v(100);
+        // Add 1 for implementations that dynamically allocate a container proxy.
+        std::vector<MoveOnly, limited_allocator<MoveOnly, 300 + 1> > v(100);
         v.resize(50);
         assert(v.size() == 50);
         assert(v.capacity() == 100);
         assert(is_contiguous_container_asan_correct(v));
         v.resize(200);
         assert(v.size() == 200);
         assert(v.capacity() >= 200);
         assert(is_contiguous_container_asan_correct(v));
     }
 #else  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
     {
         std::vector<int> v(100);
         v.resize(50);
         assert(v.size() == 50);
         assert(v.capacity() == 100);
         assert(is_contiguous_container_asan_correct(v));
         v.resize(200);
         assert(v.size() == 200);
         assert(v.capacity() >= 200);
         assert(is_contiguous_container_asan_correct(v));
     }
     {
-        std::vector<int, limited_allocator<int, 300> > v(100);
+        // Add 1 for implementations that dynamically allocate a container proxy.
+        std::vector<int, limited_allocator<int, 300 + 1> > v(100);
         v.resize(50);
         assert(v.size() == 50);
         assert(v.capacity() == 100);
         assert(is_contiguous_container_asan_correct(v));
         v.resize(200);
         assert(v.size() == 200);
         assert(v.capacity() >= 200);
         assert(is_contiguous_container_asan_correct(v));

test/std/containers/sequences/vector/vector.capacity/resize_size_value.pass.cpp

int main()
         assert(v.capacity() >= 200);
         assert(is_contiguous_container_asan_correct(v));
         for (unsigned i = 0; i < 50; ++i)
             assert(v[i] == 0);
         for (unsigned i = 50; i < 200; ++i)
             assert(v[i] == 1);
     }
     {
-        std::vector<int, limited_allocator<int, 300> > v(100);
+        // Add 1 for implementations that dynamically allocate a container proxy.
+        std::vector<int, limited_allocator<int, 300 + 1> > v(100);
         v.resize(50, 1);
         assert(v.size() == 50);
         assert(v.capacity() == 100);
         v.resize(200, 1);
         assert(v.size() == 200);
         assert(v.capacity() >= 200);
         assert(is_contiguous_container_asan_correct(v));
     }

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

int main()
     int* an = a + sizeof(a)/sizeof(a[0]);
     test<std::vector<int> >(input_iterator<const int*>(a), input_iterator<const int*>(an));
     test<std::vector<int> >(forward_iterator<const int*>(a), forward_iterator<const int*>(an));
     test<std::vector<int> >(bidirectional_iterator<const int*>(a), bidirectional_iterator<const int*>(an));
     test<std::vector<int> >(random_access_iterator<const int*>(a), random_access_iterator<const int*>(an));
     test<std::vector<int> >(a, an);
 
     test<std::vector<int, limited_allocator<int, 63> > >(input_iterator<const int*>(a), input_iterator<const int*>(an));
-    test<std::vector<int, limited_allocator<int, 18> > >(forward_iterator<const int*>(a), forward_iterator<const int*>(an));
-    test<std::vector<int, limited_allocator<int, 18> > >(bidirectional_iterator<const int*>(a), bidirectional_iterator<const int*>(an));
-    test<std::vector<int, limited_allocator<int, 18> > >(random_access_iterator<const int*>(a), random_access_iterator<const int*>(an));
-    test<std::vector<int, limited_allocator<int, 18> > >(a, an);
+    // Add 1 for implementations that dynamically allocate a container proxy.
+    test<std::vector<int, limited_allocator<int, 18 + 1> > >(forward_iterator<const int*>(a), forward_iterator<const int*>(an));
+    test<std::vector<int, limited_allocator<int, 18 + 1> > >(bidirectional_iterator<const int*>(a), bidirectional_iterator<const int*>(an));
+    test<std::vector<int, limited_allocator<int, 18 + 1> > >(random_access_iterator<const int*>(a), random_access_iterator<const int*>(an));
+    test<std::vector<int, limited_allocator<int, 18 + 1> > >(a, an);
 #if TEST_STD_VER >= 11
     test<std::vector<int, min_allocator<int>> >(input_iterator<const int*>(a), input_iterator<const int*>(an));
     test<std::vector<int, min_allocator<int>> >(forward_iterator<const int*>(a), forward_iterator<const int*>(an));
     test<std::vector<int, min_allocator<int>> >(bidirectional_iterator<const int*>(a), bidirectional_iterator<const int*>(an));
     test<std::vector<int, min_allocator<int>> >(random_access_iterator<const int*>(a), random_access_iterator<const int*>(an));
     test<std::vector<int> >(a, an);
 #endif
 }

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

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

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

int main()
             assert(c[j] == j);
         c.push_back(4);
         assert(c.size() == 5);
         assert(is_contiguous_container_asan_correct(c));
         for (int j = 0; j < c.size(); ++j)
             assert(c[j] == j);
     }
     {
-        std::vector<int, limited_allocator<int, 15> > c;
+        // libc++ needs 15 because it grows by 2x (1 + 2 + 4 + 8).
+        // Use 17 for implementations that dynamically allocate a container proxy
+        // and grow by 1.5x (1 for proxy + 1 + 2 + 3 + 4 + 6).
+        std::vector<int, limited_allocator<int, 17> > c;
         c.push_back(0);
         assert(c.size() == 1);
         assert(is_contiguous_container_asan_correct(c));
         for (int j = 0; j < c.size(); ++j)
             assert(c[j] == j);
         c.push_back(1);
         assert(c.size() == 2);
         assert(is_contiguous_container_asan_correct(c));

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

#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
             assert(c[j] == MoveOnly(j));
         c.push_back(MoveOnly(4));
         assert(c.size() == 5);
         assert(is_contiguous_container_asan_correct(c));
         for (int j = 0; j < c.size(); ++j)
             assert(c[j] == MoveOnly(j));
     }
     {
-        std::vector<MoveOnly, limited_allocator<MoveOnly, 15> > c;
+        // libc++ needs 15 because it grows by 2x (1 + 2 + 4 + 8).
+        // Use 17 for implementations that dynamically allocate a container proxy
+        // and grow by 1.5x (1 for proxy + 1 + 2 + 3 + 4 + 6).
+        std::vector<MoveOnly, limited_allocator<MoveOnly, 17> > c;
         c.push_back(MoveOnly(0));
         assert(c.size() == 1);
         assert(is_contiguous_container_asan_correct(c));
         for (int j = 0; j < c.size(); ++j)
             assert(c[j] == MoveOnly(j));
         c.push_back(MoveOnly(1));
         assert(c.size() == 2);
         assert(is_contiguous_container_asan_correct(c));