[libcxx] Add missing checks to tests for the move w/allocator constructors of associative containers.

[amakc11]

Summary

This patch is a continuation of rCXX352512. This revision appears to be incomplete. It makes possible for the source containers to remain not empty after move construction of another container. In this case, less deallocations will be registered by test_allocator with counter. So, checks on Counter_base::gConstructed also require modification provided by this patch.

[ldionne]

test/std/containers/associative/map/map.cons/move_alloc.pass.cpp

181

Technically, I think the container could also have just 2 elements remaining, no? IOW, what you mean is really that num+6 <= Counter_base::gConstructed <= num+6+3?

[amakc11]

test/std/containers/associative/map/map.cons/move_alloc.pass.cpp

181

This assumption looks very strange to me. The std::move() either deletes everything in the source container or preserves everything. Any intermediate solution when this function deletes any random(??) number of elements looks unreasonable. However, if you have any specific reasons for implementing (and testing) such intermediate solution, please, provide them. Please, also consult Marshall who is the author of these tests.

[ldionne]

test/std/containers/associative/map/map.cons/move_alloc.pass.cpp

181

Well.. the standard says this (http://eel.is/c++draft/lib.types.movedfrom):

Objects of types defined in the C++ standard library may be moved from ([class.copy.ctor]). Move operations may be explicitly specified or implicitly generated. Unless otherwise specified, such moved-from objects shall be placed in a valid but unspecified state.

I couldn't find something that said that std::map behaved differently, therefore as far as the Standard is concerned, a moved-from map must be left in a valid-but-unspecified state. @mclow.lists can double-check that I'm not mistaken here.

If I'm right, then leaving the moved-from map completely full, leaving it empty, or leaving any number of elements in it are all valid implementations. Therefore your patch is not really improving the test suite, it's just making the specific implementation you're testing pass. Instead, I think Counter_base::gConstructed <= num+6+m1.size() would be better.

[amakc11]

Agree. Patch modified as suggested.

[ldionne]

r353955

test/std/containers/associative/map/map.cons/move_alloc.pass.cpp

int main(int, char**)
 
             M m2(m1);
             assert(m2 == m1);
             assert(Counter_base::gConstructed == num+6);
 
             M m3(std::move(m1), A());
             assert(m3 == m2);
             LIBCPP_ASSERT(m1.empty());
-            assert(Counter_base::gConstructed == num+6);
+            assert(Counter_base::gConstructed == num+6+(m1.empty()?0:3));
 
             {
             M m4(std::move(m2), A(5));
-            assert(Counter_base::gConstructed == num+6);
+            assert(Counter_base::gConstructed == num+6+(m1.empty()?0:3)+(m2.empty()?0:3));
             assert(m4 == m3);
             LIBCPP_ASSERT(m2.empty());
             }
-            assert(Counter_base::gConstructed == num+3);
+            assert(Counter_base::gConstructed == num+3+(m1.empty()?0:3)+(m2.empty()?0:3));
         }
         assert(Counter_base::gConstructed == 0);
     }
     {
         typedef std::pair<MoveOnly, MoveOnly> V;
         typedef std::pair<const MoveOnly, MoveOnly> VC;
         typedef test_compare<std::less<MoveOnly> > C;
         typedef min_allocator<VC> A;

test/std/containers/associative/multimap/multimap.cons/move_alloc.pass.cpp

int main(int, char**)
 
             M m2(m1);
             assert(m2 == m1);
             assert(Counter_base::gConstructed == 3*num);
 
             M m3(std::move(m1), A());
             assert(m3 == m2);
             LIBCPP_ASSERT(m1.empty());
-            assert(Counter_base::gConstructed == 3*num);
+            assert(Counter_base::gConstructed == (3+(m1.empty()?0:1))*num);
 
             {
             M m4(std::move(m2), A(5));
-            assert(Counter_base::gConstructed == 3*num);
+            assert(Counter_base::gConstructed == (3+(m1.empty()?0:1)+(m2.empty()?0:1))*num);
             assert(m4 == m3);
             LIBCPP_ASSERT(m2.empty());
             }
-            assert(Counter_base::gConstructed == 2*num);
+            assert(Counter_base::gConstructed == (2+(m1.empty()?0:1)+(m2.empty()?0:1))*num);
         }
         assert(Counter_base::gConstructed == 0);
     }
     {
         typedef std::pair<MoveOnly, MoveOnly> V;
         typedef std::pair<const MoveOnly, MoveOnly> VC;
         typedef test_compare<std::less<MoveOnly> > C;
         typedef min_allocator<VC> A;

test/std/containers/associative/multiset/multiset.cons/move_alloc.pass.cpp

int main(int, char**)
 
             M m2(m1);
             assert(m2 == m1);
             assert(Counter_base::gConstructed == 3*num);
 
             M m3(std::move(m1), A());
             assert(m3 == m2);
             LIBCPP_ASSERT(m1.empty());
-            assert(Counter_base::gConstructed == 3*num);
+            assert(Counter_base::gConstructed == (3+(m1.empty()?0:1))*num);
 
             {
             M m4(std::move(m2), A(5));
-            assert(Counter_base::gConstructed == 3*num);
+            assert(Counter_base::gConstructed == (3+(m1.empty()?0:1)+(m2.empty()?0:1))*num);
             assert(m4 == m3);
             LIBCPP_ASSERT(m2.empty());
             }
-            assert(Counter_base::gConstructed == 2*num);
+            assert(Counter_base::gConstructed == (2+(m1.empty()?0:1))*num);
         }
         assert(Counter_base::gConstructed == 0);
     }
 
   return 0;
 }

test/std/containers/associative/set/set.cons/move_alloc.pass.cpp

int main(int, char**)
 
             M m2(m1);
             assert(m2 == m1);
             assert(Counter_base::gConstructed == 6+num);
 
             M m3(std::move(m1), A());
             assert(m3 == m2);
             LIBCPP_ASSERT(m1.empty());
-            assert(Counter_base::gConstructed == 6+num);
+            assert(Counter_base::gConstructed == (m1.empty()?0:3)+6+num);
 
             {
             M m4(std::move(m2), A(5));
-            assert(Counter_base::gConstructed == 6+num);
+            assert(Counter_base::gConstructed == (m1.empty()?0:3)+(m2.empty()?0:3)+6+num);
             assert(m4 == m3);
             LIBCPP_ASSERT(m2.empty());
             }
-            assert(Counter_base::gConstructed == 3+num);
+            assert(Counter_base::gConstructed == (m1.empty()?0:3)+(m2.empty()?0:3)+3+num);
         }
         assert(Counter_base::gConstructed == 0);
     }
 
 
   return 0;
 }