[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

89

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
-    {
-    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[] =
-        {
-            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);
-    }
-    }
+template <class T>
+struct FinalCompare final {
+  bool operator()(const T& x, const T& y) const { 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;
 
-    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);
+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 Map m(ar, ar + sizeof(ar) / sizeof(ar[0]));
+
+  for (int i = 0; i < 5; ++i) {
+    R r = m.count(ArgType(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));
+  for (int i = 5; i < 13; ++i) {
+    R r = m.count(ArgType(i));
     assert(r == 1);
-    r = m.count(C2Int(12));
-    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 >= 14
+  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;
+    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 // TEST_STD_VER >= 14
   return 0;
 }