[libcxx][test][NFC] Rewrite map count test and add test case for "final" compare

[ldionne]

Summary

Was part of D118114.
Unify test cases for std::map::count method and add test case for the comparator that marked final

[kboyarinov]

libcxx/test/std/containers/associative/map/map.ops/count.pass.cpp

73

Comment from D118114:

This test case is intended to improve code coverage of the libc++ implementation of map. The implementation uses helper class __map_value_compare for EBO:

template <class _Key, class _CP, class _Compare,

bool = is_empty_v<_Compare> && !is_final_v<_Compare>>

class __map_value_compare : private _Compare { /*...*/};

template <class _Key, class _CP, class _Compare>
class __map_value_compare<_Key, _CP, _Compare, false>
{

_Compare comp;
/*...*/

};
To test both generic template and the specialization, we need additional test-case for final comparator.
Do you think such testing should be organized in this manner or something should be added or changed?

[rarutyun]

LGTM. @ldionne, any thoughts on that review?

[ldionne]

[Github PR transition cleanup]

Commandeering to rebase and land.

[ldionne]

Rebase and fix a bug where we wouldn't make use of ArgType in the test.

[ldionne]

Will land once CI is green.

[ldionne]

Rebase and poke CI

[ldionne]

Shipping since the CI failures are unrelated.

libcxx/test/std/containers/associative/map/map.ops/count.pass.cpp

 #include <map>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 #include "private_constructor.h"
 #include "is_transparent.h"
 
-int main(int, char**)
-{
-    {
-    typedef std::pair<const int, double> V;
-    typedef std::map<int, double> M;
-    {
-        typedef M::size_type R;
-        V ar[] =
-        {
-            V(5, 5),
-            V(6, 6),
-            V(7, 7),
-            V(8, 8),
-            V(9, 9),
-            V(10, 10),
-            V(11, 11),
-            V(12, 12)
-        };
-        const M m(ar, ar+sizeof(ar)/sizeof(ar[0]));
-        R r = m.count(5);
-        assert(r == 1);
-        r = m.count(6);
-        assert(r == 1);
-        r = m.count(7);
-        assert(r == 1);
-        r = m.count(8);
-        assert(r == 1);
-        r = m.count(9);
-        assert(r == 1);
-        r = m.count(10);
-        assert(r == 1);
-        r = m.count(11);
-        assert(r == 1);
-        r = m.count(12);
-        assert(r == 1);
-        r = m.count(4);
-        assert(r == 0);
-    }
-    }
 #if TEST_STD_VER >= 11
+    template <class T>
+    struct FinalCompare final
     {
-    typedef std::pair<const int, double> V;
-    typedef std::map<int, double, std::less<int>, min_allocator<V>> M;
-    {
-        typedef M::size_type R;
-        V ar[] =
+        bool operator()(const T& x, const T& y) const
         {
-            V(5, 5),
-            V(6, 6),
-            V(7, 7),
-            V(8, 8),
-            V(9, 9),
-            V(10, 10),
-            V(11, 11),
-            V(12, 12)
-        };
-        const M m(ar, ar+sizeof(ar)/sizeof(ar[0]));
-        R r = m.count(5);
-        assert(r == 1);
-        r = m.count(6);
-        assert(r == 1);
-        r = m.count(7);
-        assert(r == 1);
-        r = m.count(8);
-        assert(r == 1);
-        r = m.count(9);
-        assert(r == 1);
-        r = m.count(10);
-        assert(r == 1);
-        r = m.count(11);
-        assert(r == 1);
-        r = m.count(12);
-        assert(r == 1);
-        r = m.count(4);
-        assert(r == 0);
-    }
+            return x < y;
         }
+    };
 #endif
-#if TEST_STD_VER > 11
-    {
-    typedef std::pair<const int, double> V;
-    typedef std::map<int, double, std::less <>> M;
-    typedef M::size_type R;
+
+template <class Map, class ArgType = typename Map::key_type>
+void test()
+    typedef typename Map::value_type V;
+    typedef typename Map::size_type R;
 
     V ar[] =
     {
         V(5, 5),
         V(6, 6),
         V(7, 7),
         V(8, 8),
         V(9, 9),
         V(10, 10),
         V(11, 11),
         V(12, 12)
     };
-    const M m(ar, ar+sizeof(ar)/sizeof(ar[0]));
-    R r = m.count(5);
-    assert(r == 1);
-    r = m.count(6);
-    assert(r == 1);
-    r = m.count(7);
-    assert(r == 1);
-    r = m.count(8);
-    assert(r == 1);
-    r = m.count(9);
-    assert(r == 1);
-    r = m.count(10);
-    assert(r == 1);
-    r = m.count(11);
-    assert(r == 1);
-    r = m.count(12);
-    assert(r == 1);
-    r = m.count(4);
+
+    const Map m(ar, ar + sizeof(ar) / sizeof(ar[0]));
+
+    for (int i = 0; i < 5; ++i)
+    {
+        R r = m.count(i);
         assert(r == 0);
+    }
 
-    r = m.count(C2Int(5));
-    assert(r == 1);
-    r = m.count(C2Int(6));
-    assert(r == 1);
-    r = m.count(C2Int(7));
-    assert(r == 1);
-    r = m.count(C2Int(8));
-    assert(r == 1);
-    r = m.count(C2Int(9));
-    assert(r == 1);
-    r = m.count(C2Int(10));
-    assert(r == 1);
-    r = m.count(C2Int(11));
-    assert(r == 1);
-    r = m.count(C2Int(12));
+    for (int i = 5; i < 13; ++i)
+    {
+        R r = m.count(i);
         assert(r == 1);
-    r = m.count(C2Int(4));
-    assert(r == 0);
-    }
+    }
 
+int main(int, char**)
+{
+    test<std::map<int, double> >();
+#if TEST_STD_VER >= 11
+    typedef std::pair<const int, double> V;
+    test<std::map<int, double, std::less<int>, min_allocator<V> > >();
+    test<std::map<int, double, FinalCompare<int> > >();
+#endif
+#if TEST_STD_VER > 11
+    typedef std::map<int, double, std::less<> > TM;
+    test<TM>();
+    test<TM, C2Int>();
+
     {
         typedef PrivateConstructor PC;
-    typedef std::map<PC, double, std::less<>> M;
+        typedef std::map<PC, double, std::less<> > M;
         typedef M::size_type R;
 
         M m;
         m [ PC::make(5)  ] = 5;
         m [ PC::make(6)  ] = 6;
         m [ PC::make(7)  ] = 7;
         m [ PC::make(8)  ] = 8;
         m [ PC::make(9)  ] = 9;
         m [ PC::make(10) ] = 10;
         m [ PC::make(11) ] = 11;
         m [ PC::make(12) ] = 12;
 
-    R r = m.count(5);
-    assert(r == 1);
-    r = m.count(6);
-    assert(r == 1);
-    r = m.count(7);
-    assert(r == 1);
-    r = m.count(8);
-    assert(r == 1);
-    r = m.count(9);
-    assert(r == 1);
-    r = m.count(10);
-    assert(r == 1);
-    r = m.count(11);
-    assert(r == 1);
-    r = m.count(12);
-    assert(r == 1);
-    r = m.count(4);
+        for (int i = 0; i < 5; ++i)
+        {
+            R r = m.count(i);
             assert(r == 0);
         }
-#endif
 
+        for (int i = 5; i < 13; ++i)
+        {
+            R r = m.count(i);
+            assert(r == 1);
+        }
+    }
+#endif
   return 0;
 }