[libc++] [P0919] Some belated review on D87171

[• Quuxplusone]

Summary

A comment today on D87171 made me look at it, and then I made a bunch of review comments before finally noticing that it was shipped ages ago. 😛 Well, rather than let my comments go to waste, here's the gist of them.

• Simplify the structure of the new tests.
• Test const containers as well as non-const containers, since it's easy to do so.
• Remove redundant enable-iffing of helper structs' member functions. (They're not instantiated unless they're called, and who would call them?)
• Drive-by: _LIBCPP_INLINE_VISIBILITY on some swap functions where I don't see why it was missing in the first place.

[ldionne]

libcxx/include/map

548

I think those enable_ifs are important. Otherwise, if a non-transparent comparator is used with arguments that would trigger a conversion if one of the overloads above were used, it would be possible to observe the fact that a conversion is not being performed. Am I misunderstanding?

libcxx/test/std/containers/unord/unord.map/equal_range.transparent.pass.cpp

19

Why is this test named libcxx/test/std/containers/unord/unord.map/equal_range.transparent.pass.cpp since we seem to be testing both transparent and non-transparent comparators in it?

libcxx/test/std/containers/unord/unord.map/equal_range_const.transparent.pass.cpp

1

I'm a bit confused - where did these tests go?

[rarutyun]

libcxx/include/map

548

I have the same understanding. We might end up with breaking change (if I am not mistaken) when Comparator is not transparent and the key_type and K are not comparable

[• Quuxplusone]

libcxx/include/map

548

__map_value_compare is used only in member functions like map::find, where map::find is already SFINAEd appropriately. The user never gets their hands on an object of type __map_value_compare to call __map_value_compare::operator() directly; all the call-sites are under our control.

You did briefly scare me that maybe __map_value_compare was being aliased as map::value_compare (which is user-accessible); but no, map::value_compare is its own separate type, and __map_value_compare remains inaccessible AFAICT.

libcxx/test/std/containers/unord/unord.map/equal_range.transparent.pass.cpp

19

Well, it's not testing pre-C++20 comparators; it's just neg-testing the new C++20 behavior: i.e. that the transparent equal_range is correctly SFINAEd away when the comparator type is non-transparent. I think this (existing) organization is pretty reasonable.

libcxx/test/std/containers/unord/unord.map/equal_range_const.transparent.pass.cpp

1

The old files foo_const.transparent.pass.cpp and foo_non_const.transparent.pass.cpp have been combined into foo.transparent.pass.cpp. The only difference between the const and non-const files is now handled by e.g.

test_transparent_equal_range<M>({{1, 2}, {2, 3}});
test_transparent_equal_range<const M>({{1, 2}, {2, 3}});

libcxx/test/support/test_transparent_unordered.h

112

@ldionne: In case it helps, notice here that we know conversions must be 1, not any other number, because when find is non-transparent, it takes a parameter of type const StoredType<int>&, not const K&. So the conversion that happens, happens immediately to the argument on line 111. The innards of non-transparent find don't even know that SearchedType exists at all. (And therefore they never try to pass a SearchedType to __map_value_compare or __unordered_map_equal or anything.)

[rarutyun]

libcxx/test/std/containers/unord/unord.map/equal_range.transparent.pass.cpp

31

I don't mind to combine const and non-const overloads of API into one file. I don't recall why I decided to make them separate. I believe there was some precedence in tests already and I made it for the sake of consistency but I cannot tell for sure.

[• Quuxplusone]

@ldionne ping! (I believe my replies adequately address your comments without any new code updates needed.)

[• Quuxplusone]

Fix some more indentation, and use a different method of SFINAE (to make it easier to match the surrounding indentation to the pre-existing practice) in <unordered_map>. @ldionne ping!

[ldionne]

Indeed, I think all my concerns have been resolved now. Thanks.

libcxx/include/map

public:
     {
       using _VSTD::swap;
       swap(static_cast<_Compare&>(*this), static_cast<_Compare&>(__y));
     }
 
 #if _LIBCPP_STD_VER > 11
     template <typename _K2>
     _LIBCPP_INLINE_VISIBILITY
-    typename enable_if<__is_transparent<_Compare, _K2>::value, bool>::type
-    operator () ( const _K2& __x, const _CP& __y ) const
-        {return static_cast<const _Compare&>(*this) (__x, __y.__get_value().first);}
+    bool operator()(const _K2& __x, const _CP& __y) const
+        {return static_cast<const _Compare&>(*this)(__x, __y.__get_value().first);}
 
     template <typename _K2>
     _LIBCPP_INLINE_VISIBILITY
-    typename enable_if<__is_transparent<_Compare, _K2>::value, bool>::type
-    operator () (const _CP& __x, const _K2& __y) const
-        {return static_cast<const _Compare&>(*this) (__x.__get_value().first, __y);}
+    bool operator()(const _CP& __x, const _K2& __y) const
+        {return static_cast<const _Compare&>(*this)(__x.__get_value().first, __y);}
 #endif
 };
 
 template <class _Key, class _CP, class _Compare>
 class __map_value_compare<_Key, _CP, _Compare, false>
 {
     _Compare comp;
 
public:
     {
         using _VSTD::swap;
         swap(comp, __y.comp);
     }
 
 #if _LIBCPP_STD_VER > 11
     template <typename _K2>
     _LIBCPP_INLINE_VISIBILITY
-    typename enable_if<__is_transparent<_Compare, _K2>::value, bool>::type
-    operator () ( const _K2& __x, const _CP& __y ) const
-        {return comp (__x, __y.__get_value().first);}
+    bool operator()(const _K2& __x, const _CP& __y) const
+        {return comp(__x, __y.__get_value().first);}
 
     template <typename _K2>
     _LIBCPP_INLINE_VISIBILITY
-    typename enable_if<__is_transparent<_Compare, _K2>::value, bool>::type
-    operator () (const _CP& __x, const _K2& __y) const
-        {return comp (__x.__get_value().first, __y);}
+    bool operator()(const _CP& __x, const _K2& __y) const
+        {return comp(__x.__get_value().first, __y);}
 #endif
 };
 
 template <class _Key, class _CP, class _Compare, bool __b>
 inline _LIBCPP_INLINE_VISIBILITY
 void
 swap(__map_value_compare<_Key, _CP, _Compare, __b>& __x,
      __map_value_compare<_Key, _CP, _Compare, __b>& __y)

libcxx/include/unordered_map

public:
     const _Hash& hash_function() const _NOEXCEPT {return *this;}
     _LIBCPP_INLINE_VISIBILITY
     size_t operator()(const _Cp& __x) const
         {return static_cast<const _Hash&>(*this)(__x.__get_value().first);}
     _LIBCPP_INLINE_VISIBILITY
     size_t operator()(const _Key& __x) const
         {return static_cast<const _Hash&>(*this)(__x);}
 #if _LIBCPP_STD_VER > 17
-    template <typename _K2, typename = _EnableIf<__is_transparent<_Hash, _K2>::value && __is_transparent<_Pred, _K2>::value>>
+    template <typename _K2>
     _LIBCPP_INLINE_VISIBILITY
     size_t operator()(const _K2& __x) const
         {return static_cast<const _Hash&>(*this)(__x);}
 #endif
+    _LIBCPP_INLINE_VISIBILITY
     void swap(__unordered_map_hasher& __y)
         _NOEXCEPT_(__is_nothrow_swappable<_Hash>::value)
     {
         using _VSTD::swap;
         swap(static_cast<_Hash&>(*this), static_cast<_Hash&>(__y));
     }
 };
 
public:
     const _Hash& hash_function() const _NOEXCEPT {return __hash_;}
     _LIBCPP_INLINE_VISIBILITY
     size_t operator()(const _Cp& __x) const
         {return __hash_(__x.__get_value().first);}
     _LIBCPP_INLINE_VISIBILITY
     size_t operator()(const _Key& __x) const
         {return __hash_(__x);}
 #if _LIBCPP_STD_VER > 17
-    template <typename _K2, typename = _EnableIf<__is_transparent<_Hash, _K2>::value && __is_transparent<_Pred, _K2>::value>>
+    template <typename _K2>
     _LIBCPP_INLINE_VISIBILITY
     size_t operator()(const _K2& __x) const
         {return __hash_(__x);}
 #endif
+    _LIBCPP_INLINE_VISIBILITY
     void swap(__unordered_map_hasher& __y)
         _NOEXCEPT_(__is_nothrow_swappable<_Hash>::value)
     {
         using _VSTD::swap;
         swap(__hash_, __y.__hash_);
     }
 };
 
bool operator()(const _Cp& __x, const _Cp& __y) const
         {return static_cast<const _Pred&>(*this)(__x.__get_value().first, __y.__get_value().first);}
     _LIBCPP_INLINE_VISIBILITY
     bool operator()(const _Cp& __x, const _Key& __y) const
         {return static_cast<const _Pred&>(*this)(__x.__get_value().first, __y);}
     _LIBCPP_INLINE_VISIBILITY
     bool operator()(const _Key& __x, const _Cp& __y) const
         {return static_cast<const _Pred&>(*this)(__x, __y.__get_value().first);}
 #if _LIBCPP_STD_VER > 17
-    template <typename _K2, typename = _EnableIf<__is_transparent<_Hash, _K2>::value && __is_transparent<_Pred, _K2>::value>>
+    template <typename _K2>
     _LIBCPP_INLINE_VISIBILITY
     bool operator()(const _Cp& __x, const _K2& __y) const
         {return static_cast<const _Pred&>(*this)(__x.__get_value().first, __y);}
-    template <typename _K2, typename = _EnableIf<__is_transparent<_Hash, _K2>::value && __is_transparent<_Pred, _K2>::value>>
+    template <typename _K2>
     _LIBCPP_INLINE_VISIBILITY
     bool operator()(const _K2& __x, const _Cp& __y) const
         {return static_cast<const _Pred&>(*this)(__x, __y.__get_value().first);}
-    template <typename _K2, typename = _EnableIf<__is_transparent<_Hash, _K2>::value && __is_transparent<_Pred, _K2>::value>>
+    template <typename _K2>
     _LIBCPP_INLINE_VISIBILITY
     bool operator()(const _Key& __x, const _K2& __y) const
         {return static_cast<const _Pred&>(*this)(__x, __y);}
-    template <typename _K2, typename = _EnableIf<__is_transparent<_Hash, _K2>::value && __is_transparent<_Pred, _K2>::value>>
+    template <typename _K2>
     _LIBCPP_INLINE_VISIBILITY
     bool operator()(const _K2& __x, const _Key& __y) const
         {return static_cast<const _Pred&>(*this)(__x, __y);}
 #endif
+    _LIBCPP_INLINE_VISIBILITY
     void swap(__unordered_map_equal& __y)
         _NOEXCEPT_(__is_nothrow_swappable<_Pred>::value)
     {
         using _VSTD::swap;
         swap(static_cast<_Pred&>(*this), static_cast<_Pred&>(__y));
     }
 };
 
bool operator()(const _Cp& __x, const _Cp& __y) const
         {return __pred_(__x.__get_value().first, __y.__get_value().first);}
     _LIBCPP_INLINE_VISIBILITY
     bool operator()(const _Cp& __x, const _Key& __y) const
         {return __pred_(__x.__get_value().first, __y);}
     _LIBCPP_INLINE_VISIBILITY
     bool operator()(const _Key& __x, const _Cp& __y) const
         {return __pred_(__x, __y.__get_value().first);}
 #if _LIBCPP_STD_VER > 17
-    template <typename _K2, typename = _EnableIf<__is_transparent<_Hash, _K2>::value && __is_transparent<_Pred, _K2>::value>>
+    template <typename _K2>
     _LIBCPP_INLINE_VISIBILITY
     bool operator()(const _Cp& __x, const _K2& __y) const
         {return __pred_(__x.__get_value().first, __y);}
-    template <typename _K2, typename = _EnableIf<__is_transparent<_Hash, _K2>::value && __is_transparent<_Pred, _K2>::value>>
+    template <typename _K2>
     _LIBCPP_INLINE_VISIBILITY
     bool operator()(const _K2& __x, const _Cp& __y) const
         {return __pred_(__x, __y.__get_value().first);}
-    template <typename _K2, typename = _EnableIf<__is_transparent<_Hash, _K2>::value && __is_transparent<_Pred, _K2>::value>>
+    template <typename _K2>
     _LIBCPP_INLINE_VISIBILITY
     bool operator()(const _Key& __x, const _K2& __y) const
         {return __pred_(__x, __y);}
-    template <typename _K2, typename = _EnableIf<__is_transparent<_Hash, _K2>::value && __is_transparent<_Pred, _K2>::value>>
+    template <typename _K2>
     _LIBCPP_INLINE_VISIBILITY
     bool operator()(const _K2& __x, const _Key& __y) const
         {return __pred_(__x, __y);}
 #endif
+    _LIBCPP_INLINE_VISIBILITY
     void swap(__unordered_map_equal& __y)
         _NOEXCEPT_(__is_nothrow_swappable<_Pred>::value)
     {
         using _VSTD::swap;
         swap(__pred_, __y.__pred_);
     }
 };
 

libcxx/test/std/containers/unord/unord.map/contains.transparent.pass.cpp

 // UNSUPPORTED: c++03, c++11, c++14, c++17
 
 #include <unordered_map>
 #include "test_transparent_unordered.h"
 
 int main(int, char**)
 {
     using key_type = StoredType<int>;
-    using ilist_type = std::initializer_list<std::pair<const key_type, int> >;
 
     {
       // Make sure conversions don't happen for transparent non-final hasher and key_equal
-      using map_type = const unord_map_type<std::unordered_map, transparent_hash, std::equal_to<> >;
-      test_transparent_contains<map_type>(ilist_type{{1, 2}, {2, 3}});
+      using M = unord_map_type<std::unordered_map, transparent_hash, std::equal_to<>>;
+      test_transparent_contains<M>({{1, 2}, {2, 3}});
+      test_transparent_contains<const M>({{1, 2}, {2, 3}});
     }
 
     {
       // Make sure conversions don't happen for transparent final hasher and key_equal
-      using map_type = const unord_map_type<std::unordered_map, transparent_hash_final, transparent_equal_final>;
-      test_transparent_contains<map_type>(ilist_type{{1, 2}, {2, 3}});
+      using M = unord_map_type<std::unordered_map, transparent_hash_final, transparent_equal_final>;
+      test_transparent_contains<M>({{1, 2}, {2, 3}});
+      test_transparent_contains<const M>({{1, 2}, {2, 3}});
     }
 
     {
       // Make sure conversions do happen for non-transparent hasher
-      using map_type = const unord_map_type<std::unordered_map, non_transparent_hash,
-                                       std::equal_to<> >;
-      test_non_transparent_contains<map_type>(ilist_type{{1, 2}, {2, 3}});
+      using M = unord_map_type<std::unordered_map, non_transparent_hash, std::equal_to<>>;
+      test_non_transparent_contains<M>({{1, 2}, {2, 3}});
+      test_non_transparent_contains<const M>({{1, 2}, {2, 3}});
     }
 
     {
       // Make sure conversions do happen for non-transparent key_equal
-      using map_type = const unord_map_type<std::unordered_map, transparent_hash,
-                                       std::equal_to<key_type> >;
-      test_non_transparent_contains<map_type>(ilist_type{{1, 2}, {2, 3}});
+      using M = unord_map_type<std::unordered_map, transparent_hash, std::equal_to<key_type>>;
+      test_non_transparent_contains<M>({{1, 2}, {2, 3}});
+      test_non_transparent_contains<const M>({{1, 2}, {2, 3}});
     }
 
     {
       // Make sure conversions do happen for both non-transparent hasher and key_equal
-      using map_type = const unord_map_type<std::unordered_map, non_transparent_hash,
-                                       std::equal_to<key_type> >;
-      test_non_transparent_contains<map_type>(ilist_type{{1, 2}, {2, 3}});
+      using M = unord_map_type<std::unordered_map, non_transparent_hash, std::equal_to<key_type>>;
+      test_non_transparent_contains<M>({{1, 2}, {2, 3}});
+      test_non_transparent_contains<const M>({{1, 2}, {2, 3}});
     }
 
     return 0;
 }

libcxx/test/std/containers/unord/unord.map/count.transparent.pass.cpp

 
 #include <unordered_map>
 
 #include "test_transparent_unordered.h"
 
 int main(int, char**)
 {
     using key_type = StoredType<int>;
-    using ilist_type = std::initializer_list<std::pair<const key_type, int> >;
 
     {
       // Make sure conversions don't happen for transparent non-final hasher and key_equal
-      using map_type = const unord_map_type<std::unordered_map, transparent_hash, std::equal_to<> >;
-      test_transparent_count<map_type>(ilist_type{{1, 2}, {2, 3}});
+      using M = unord_map_type<std::unordered_map, transparent_hash, std::equal_to<>>;
+      test_transparent_count<M>({{1, 2}, {2, 3}});
+      test_transparent_count<const M>({{1, 2}, {2, 3}});
     }
 
     {
       // Make sure conversions don't happen for transparent final hasher and key_equal
-      using map_type =
-          const unord_map_type<std::unordered_map, transparent_hash_final, transparent_equal_final>;
-      test_transparent_count<map_type>(ilist_type{{1, 2}, {2, 3}});
+      using M = unord_map_type<std::unordered_map, transparent_hash_final, transparent_equal_final>;
+      test_transparent_count<M>({{1, 2}, {2, 3}});
+      test_transparent_count<const M>({{1, 2}, {2, 3}});
     }
 
     {
       // Make sure conversions do happen for non-transparent hasher
-      using map_type = const unord_map_type<std::unordered_map, non_transparent_hash, std::equal_to<> >;
-      test_non_transparent_count<map_type>(ilist_type{{1, 2}, {2, 3}});
+      using M = unord_map_type<std::unordered_map, non_transparent_hash, std::equal_to<>>;
+      test_non_transparent_count<M>({{1, 2}, {2, 3}});
+      test_non_transparent_count<const M>({{1, 2}, {2, 3}});
     }
 
     {
       // Make sure conversions do happen for non-transparent key_equal
-      using map_type =
-          const unord_map_type<std::unordered_map, transparent_hash, std::equal_to<key_type> >;
-      test_non_transparent_count<map_type>(ilist_type{{1, 2}, {2, 3}});
+      using M = unord_map_type<std::unordered_map, transparent_hash, std::equal_to<key_type>>;
+      test_non_transparent_count<M>({{1, 2}, {2, 3}});
+      test_non_transparent_count<const M>({{1, 2}, {2, 3}});
     }
 
     {
       // Make sure conversions do happen for both non-transparent hasher and key_equal
-      using map_type =
-          const unord_map_type<std::unordered_map, non_transparent_hash, std::equal_to<key_type> >;
-      test_non_transparent_count<map_type>(ilist_type{{1, 2}, {2, 3}});
+      using M = unord_map_type<std::unordered_map, non_transparent_hash, std::equal_to<key_type>>;
+      test_non_transparent_count<M>({{1, 2}, {2, 3}});
+      test_non_transparent_count<const M>({{1, 2}, {2, 3}});
     }
 
     return 0;
 }

libcxx/test/std/containers/unord/unord.map/equal_range.transparent.pass.cpp

 // template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>,
 //           class Alloc = allocator<pair<const Key, T>>>
 // class unordered_map
 
 // template <typename K>
 // pair<iterator, iterator> equal_range(const K& k);
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 
 #include <unordered_map>
 
 #include "test_transparent_unordered.h"
 
 int main(int, char**)
 {
     using key_type = StoredType<int>;
-    using ilist_type = std::initializer_list<std::pair<const key_type, int> >;
 
     {
       // Make sure conversions don't happen for transparent non-final hasher and key_equal
-      using map_type = unord_map_type<std::unordered_map, transparent_hash,
-                                 std::equal_to<> >;
-      test_transparent_equal_range<map_type>(ilist_type{{1, 2}, {2, 3}});
+      using M = unord_map_type<std::unordered_map, transparent_hash, std::equal_to<>>;
+      test_transparent_equal_range<M>({{1, 2}, {2, 3}});
+      test_transparent_equal_range<const M>({{1, 2}, {2, 3}});
     }
 
     {
       // Make sure conversions don't happen for transparent final hasher and key_equal
-      using map_type = unord_map_type<std::unordered_map, transparent_hash_final,
-                                 transparent_equal_final>;
-      test_transparent_equal_range<map_type>(ilist_type{{1, 2}, {2, 3}});
+      using M = unord_map_type<std::unordered_map, transparent_hash_final, transparent_equal_final>;
+      test_transparent_equal_range<M>({{1, 2}, {2, 3}});
+      test_transparent_equal_range<const M>({{1, 2}, {2, 3}});
     }
 
     {
       // Make sure conversions do happen for non-transparent hasher
-      using map_type = unord_map_type<std::unordered_map, non_transparent_hash,
-                                 std::equal_to<> >;
-      test_non_transparent_equal_range<map_type>(ilist_type{{1, 2}, {2, 3}});
+      using M = unord_map_type<std::unordered_map, non_transparent_hash, std::equal_to<>>;
+      test_non_transparent_equal_range<M>({{1, 2}, {2, 3}});
+      test_non_transparent_equal_range<const M>({{1, 2}, {2, 3}});
     }
 
     {
       // Make sure conversions do happen for non-transparent key_equal
-      using map_type = unord_map_type<std::unordered_map, transparent_hash,
-                                 std::equal_to<key_type> >;
-      test_non_transparent_equal_range<map_type>(ilist_type{{1, 2}, {2, 3}});
+      using M = unord_map_type<std::unordered_map, transparent_hash, std::equal_to<key_type>>;
+      test_non_transparent_equal_range<M>({{1, 2}, {2, 3}});
+      test_non_transparent_equal_range<const M>({{1, 2}, {2, 3}});
     }
 
     {
       // Make sure conversions do happen for both non-transparent hasher and key_equal
-      using map_type = unord_map_type<std::unordered_map, non_transparent_hash,
-                                 std::equal_to<key_type> >;
-      test_non_transparent_equal_range<map_type>(ilist_type{{1, 2}, {2, 3}});
+      using M = unord_map_type<std::unordered_map, non_transparent_hash, std::equal_to<key_type>>;
+      test_non_transparent_equal_range<M>({{1, 2}, {2, 3}});
+      test_non_transparent_equal_range<const M>({{1, 2}, {2, 3}});
     }
 
     return 0;
 }

libcxx/test/std/containers/unord/unord.map/equal_range_const.transparent.pass.cpp

-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-// <unordered_map>
-
-// template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>,
-//           class Alloc = allocator<pair<const Key, T>>>
-// class unordered_map
-
-// template <typename K>
-// pair<const_iterator, const_iterator> equal_range(const K& k) const;
-
-// UNSUPPORTED: c++03, c++11, c++14, c++17
-
-#include <unordered_map>
-
-#include "test_transparent_unordered.h"
-
-int main(int, char**)
-{
-    using key_type = StoredType<int>;
-    using ilist_type = std::initializer_list<std::pair<const key_type, int> >;
-
-    {
-      // Make sure conversions don't happen for transparent non-final hasher and key_equal
-      using map_type = const unord_map_type<std::unordered_map, transparent_hash,
-                                       std::equal_to<> >;
-      test_transparent_equal_range<map_type>(ilist_type{{1, 2}, {2, 3}});
-    }
-
-    {
-      // Make sure conversions don't happen for transparent final hasher and key_equal
-      using map_type = const unord_map_type<std::unordered_map, transparent_hash_final,
-                                       transparent_equal_final>;
-      test_transparent_equal_range<map_type>(ilist_type{{1, 2}, {2, 3}});
-    }
-
-    {
-      // Make sure conversions do happen for non-transparent hasher
-      using map_type = const unord_map_type<std::unordered_map, non_transparent_hash,
-                                       std::equal_to<> >;
-      test_non_transparent_equal_range<map_type>(ilist_type{{1, 2}, {2, 3}});
-    }
-
-    {
-      // Make sure conversions do happen for non-transparent key_equal
-      using map_type = const unord_map_type<std::unordered_map, transparent_hash,
-                                       std::equal_to<key_type> >;
-      test_non_transparent_equal_range<map_type>(ilist_type{{1, 2}, {2, 3}});
-    }
-
-    {
-      // Make sure conversions do happen for both non-transparent hasher and key_equal
-      using map_type = const unord_map_type<std::unordered_map, non_transparent_hash,
-                                       std::equal_to<key_type> >;
-      test_non_transparent_equal_range<map_type>(ilist_type{{1, 2}, {2, 3}});
-    }
-
-    return 0;
-}

libcxx/test/std/containers/unord/unord.map/find.transparent.pass.cpp

 
 #include <unordered_map>
 
 #include "test_transparent_unordered.h"
 
 int main(int, char**)
 {
     using key_type = StoredType<int>;
-    using ilist_type = std::initializer_list<std::pair<const key_type, int> >;
 
     {
       // Make sure conversions don't happen for transparent non-final hasher and key_equal
-      using map_type = unord_map_type<std::unordered_map, transparent_hash,
-                                 std::equal_to<> >;
-      test_transparent_find<map_type>(ilist_type{{1, 2}, {2, 3}});
+      using M = unord_map_type<std::unordered_map, transparent_hash, std::equal_to<>>;
+      test_transparent_find<M>({{1, 2}, {2, 3}});
+      test_transparent_find<const M>({{1, 2}, {2, 3}});
     }
 
     {
       // Make sure conversions don't happen for transparent final hasher and key_equal
-      using map_type = unord_map_type<std::unordered_map, transparent_hash_final,
-                                 transparent_equal_final>;
-      test_transparent_find<map_type>(ilist_type{{1, 2}, {2, 3}});
+      using M = unord_map_type<std::unordered_map, transparent_hash_final, transparent_equal_final>;
+      test_transparent_find<M>({{1, 2}, {2, 3}});
+      test_transparent_find<const M>({{1, 2}, {2, 3}});
     }
 
     {
       // Make sure conversions do happen for non-transparent hasher
-      using map_type = unord_map_type<std::unordered_map, non_transparent_hash,
-                                 std::equal_to<> >;
-      test_non_transparent_find<map_type>(ilist_type{{1, 2}, {2, 3}});
+      using M = unord_map_type<std::unordered_map, non_transparent_hash, std::equal_to<>>;
+      test_non_transparent_find<M>({{1, 2}, {2, 3}});
+      test_non_transparent_find<const M>({{1, 2}, {2, 3}});
     }
 
     {
       // Make sure conversions do happen for non-transparent key_equal
-      using map_type = unord_map_type<std::unordered_map, transparent_hash,
-                                 std::equal_to<key_type> >;
-      test_non_transparent_find<map_type>(ilist_type{{1, 2}, {2, 3}});
+      using M = unord_map_type<std::unordered_map, transparent_hash, std::equal_to<key_type>>;
+      test_non_transparent_find<M>({{1, 2}, {2, 3}});
+      test_non_transparent_find<const M>({{1, 2}, {2, 3}});
     }
 
     {
       // Make sure conversions do happen for both non-transparent hasher and key_equal
-      using map_type = unord_map_type<std::unordered_map, non_transparent_hash,
-                                 std::equal_to<key_type> >;
-      test_non_transparent_find<map_type>(ilist_type{{1, 2}, {2, 3}});
+      using M = unord_map_type<std::unordered_map, non_transparent_hash, std::equal_to<key_type>>;
+      test_non_transparent_find<M>({{1, 2}, {2, 3}});
+      test_non_transparent_find<const M>({{1, 2}, {2, 3}});
     }
 
     return 0;
 }

libcxx/test/std/containers/unord/unord.map/find_const.transparent.pass.cpp

-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-// <unordered_map>
-
-// template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>,
-//           class Alloc = allocator<pair<const Key, T>>>
-// class unordered_map
-
-// template <typename K>
-// const_iterator find(const K& k) const;
-
-// UNSUPPORTED: c++03, c++11, c++14, c++17
-
-#include <unordered_map>
-
-#include "test_transparent_unordered.h"
-
-int main(int, char**)
-{
-    using key_type = StoredType<int>;
-    using ilist_type = std::initializer_list<std::pair<const key_type, int> >;
-
-    {
-      // Make sure conversions don't happen for transparent non-final hasher and key_equal
-      using map_type = const unord_map_type<std::unordered_map, transparent_hash,
-                                       std::equal_to<> >;
-      test_transparent_find<map_type>(ilist_type{{1, 2}, {2, 3}});
-    }
-
-    {
-      // Make sure conversions don't happen for transparent final hasher and key_equal
-      using map_type = const unord_map_type<std::unordered_map, transparent_hash_final,
-                                       transparent_equal_final>;
-      test_transparent_find<map_type>(ilist_type{{1, 2}, {2, 3}});
-    }
-
-    {
-      // Make sure conversions do happen for non-transparent hasher
-      using map_type = const unord_map_type<std::unordered_map, non_transparent_hash,
-                                       std::equal_to<> >;
-      test_non_transparent_find<map_type>(ilist_type{{1, 2}, {2, 3}});
-    }
-
-    {
-      // Make sure conversions do happen for non-transparent key_equal
-      using map_type = const unord_map_type<std::unordered_map, transparent_hash,
-                                       std::equal_to<key_type> >;
-      test_non_transparent_find<map_type>(ilist_type{{1, 2}, {2, 3}});
-    }
-
-    {
-      // Make sure conversions do happen for both non-transparent hasher and key_equal
-      using map_type = const unord_map_type<std::unordered_map, non_transparent_hash,
-                                       std::equal_to<key_type> >;
-      test_non_transparent_find<map_type>(ilist_type{{1, 2}, {2, 3}});
-    }
-
-    return 0;
-}

libcxx/test/std/containers/unord/unord.multimap/contains.transparent.pass.cpp

 // UNSUPPORTED: c++03, c++11, c++14, c++17
 
 #include <unordered_map>
 #include "test_transparent_unordered.h"
 
 int main(int, char**)
 {
     using key_type = StoredType<int>;
-    using ilist_type = std::initializer_list<std::pair<const key_type, int> >;
 
     {
       // Make sure conversions don't happen for transparent non-final hasher and key_equal
-      using map_type = unord_map_type<std::unordered_multimap, transparent_hash,
-                                            std::equal_to<> >;
-      test_transparent_contains<map_type>(ilist_type{{1, 2}, {1, 3}, {2, 3}});
+      using M = unord_map_type<std::unordered_multimap, transparent_hash, std::equal_to<>>;
+      test_transparent_contains<M>({{1, 2}, {1, 3}, {2, 3}});
+      test_transparent_contains<const M>({{1, 2}, {1, 3}, {2, 3}});
     }
 
     {
       // Make sure conversions don't happen for transparent final hasher and key_equal
-      using map_type = unord_map_type<std::unordered_multimap, transparent_hash_final, transparent_equal_final>;
-      test_transparent_contains<map_type>(ilist_type{{1, 2}, {1, 3}, {2, 3}});
+      using M = unord_map_type<std::unordered_multimap, transparent_hash_final, transparent_equal_final>;
+      test_transparent_contains<M>({{1, 2}, {1, 3}, {2, 3}});
+      test_transparent_contains<const M>({{1, 2}, {1, 3}, {2, 3}});
     }
 
     {
       // Make sure conversions do happen for non-transparent hasher
-      using map_type = unord_map_type<std::unordered_multimap, non_transparent_hash,
-                                            std::equal_to<> >;
-      test_non_transparent_contains<map_type>(ilist_type{{1, 2}, {1, 3}, {2, 3}});
+      using M = unord_map_type<std::unordered_multimap, non_transparent_hash, std::equal_to<>>;
+      test_non_transparent_contains<M>({{1, 2}, {1, 3}, {2, 3}});
+      test_non_transparent_contains<const M>({{1, 2}, {1, 3}, {2, 3}});
     }
 
     {
       // Make sure conversions do happen for non-transparent key_equal
-      using map_type = unord_map_type<std::unordered_multimap, transparent_hash,
-                                            std::equal_to<key_type> >;
-      test_non_transparent_contains<map_type>(
-          ilist_type{{1, 2}, {1, 3}, {2, 3}});
+      using M = unord_map_type<std::unordered_multimap, transparent_hash, std::equal_to<key_type>>;
+      test_non_transparent_contains<M>({{1, 2}, {1, 3}, {2, 3}});
+      test_non_transparent_contains<const M>({{1, 2}, {1, 3}, {2, 3}});
     }
 
     {
       // Make sure conversions do happen for both non-transparent hasher and key_equal
-      using map_type = unord_map_type<std::unordered_multimap, non_transparent_hash,
-                                            std::equal_to<key_type> >;
-      test_non_transparent_contains<map_type>(
-          ilist_type{{1, 2}, {1, 3}, {2, 3}});
+      using M = unord_map_type<std::unordered_multimap, non_transparent_hash, std::equal_to<key_type>>;
+      test_non_transparent_contains<M>({{1, 2}, {1, 3}, {2, 3}});
+      test_non_transparent_contains<const M>({{1, 2}, {1, 3}, {2, 3}});
     }
 
     return 0;
 }

libcxx/test/std/containers/unord/unord.multimap/count.transparent.pass.cpp

 
 #include <unordered_map>
 
 #include "test_transparent_unordered.h"
 
 int main(int, char**)
 {
     using key_type = StoredType<int>;
-    using ilist_type = std::initializer_list<std::pair<const key_type, int> >;
 
     {
       // Make sure conversions don't happen for transparent non-final hasher and key_equal
-      using map_type = const unord_map_type<std::unordered_multimap, transparent_hash, std::equal_to<> >;
-      test_transparent_count<map_type>(ilist_type{{1, 2}, {1, 3}, {2, 3}});
+      using M = unord_map_type<std::unordered_multimap, transparent_hash, std::equal_to<>>;
+      test_transparent_count<M>({{1, 2}, {1, 3}, {2, 3}});
+      test_transparent_count<const M>({{1, 2}, {1, 3}, {2, 3}});
     }
 
     {
       // Make sure conversions don't happen for transparent final hasher and key_equal
-      using map_type =
-          const unord_map_type<std::unordered_multimap, transparent_hash_final, transparent_equal_final>;
-      test_transparent_count<map_type>(ilist_type{{1, 2}, {1, 3}, {2, 3}});
+      using M = unord_map_type<std::unordered_multimap, transparent_hash_final, transparent_equal_final>;
+      test_transparent_count<M>({{1, 2}, {1, 3}, {2, 3}});
+      test_transparent_count<const M>({{1, 2}, {1, 3}, {2, 3}});
     }
 
     {
       // Make sure conversions do happen for non-transparent hasher
-      using map_type = const unord_map_type<std::unordered_multimap, non_transparent_hash, std::equal_to<> >;
-      test_non_transparent_count<map_type>(ilist_type{{1, 2}, {1, 3}, {2, 3}});
+      using M = unord_map_type<std::unordered_multimap, non_transparent_hash, std::equal_to<>>;
+      test_non_transparent_count<M>({{1, 2}, {1, 3}, {2, 3}});
+      test_non_transparent_count<const M>({{1, 2}, {1, 3}, {2, 3}});
     }
 
     {
       // Make sure conversions do happen for non-transparent key_equal
-      using map_type =
-          const unord_map_type<std::unordered_multimap, transparent_hash, std::equal_to<key_type> >;
-      test_non_transparent_count<map_type>(ilist_type{{1, 2}, {1, 3}, {2, 3}});
+      using M = unord_map_type<std::unordered_multimap, transparent_hash, std::equal_to<key_type>>;
+      test_non_transparent_count<M>({{1, 2}, {1, 3}, {2, 3}});
+      test_non_transparent_count<const M>({{1, 2}, {1, 3}, {2, 3}});
     }
 
     {
       // Make sure conversions do happen for both non-transparent hasher and key_equal
-      using map_type =
-          const unord_map_type<std::unordered_multimap, non_transparent_hash, std::equal_to<key_type> >;
-      test_non_transparent_count<map_type>(ilist_type{{1, 2}, {1, 3}, {2, 3}});
+      using M = unord_map_type<std::unordered_multimap, non_transparent_hash, std::equal_to<key_type>>;
+      test_non_transparent_count<M>({{1, 2}, {1, 3}, {2, 3}});
+      test_non_transparent_count<const M>({{1, 2}, {1, 3}, {2, 3}});
     }
 
     return 0;
 }

libcxx/test/std/containers/unord/unord.multimap/equal_range.transparent.pass.cpp

 
 #include <unordered_map>
 
 #include "test_transparent_unordered.h"
 
 int main(int, char**)
 {
     using key_type = StoredType<int>;
-    using ilist_type = std::initializer_list<std::pair<const key_type, int> >;
 
     {
       // Make sure conversions don't happen for transparent non-final hasher and key_equal
-      using map_type = unord_map_type<std::unordered_multimap, transparent_hash,
-                                 std::equal_to<> >;
-      test_transparent_equal_range<map_type>(ilist_type{{1, 2}, {1, 3}, {2, 3}});
+      using M = unord_map_type<std::unordered_multimap, transparent_hash, std::equal_to<>>;
+      test_transparent_equal_range<M>({{1, 2}, {1, 3}, {2, 3}});
+      test_transparent_equal_range<const M>({{1, 2}, {1, 3}, {2, 3}});
     }
 
     {
       // Make sure conversions don't happen for transparent final hasher and key_equal
-      using map_type = unord_map_type<std::unordered_multimap, transparent_hash_final,
-                                 transparent_equal_final>;
-      test_transparent_equal_range<map_type>(ilist_type{{1, 2}, {1, 3}, {2, 3}});
+      using M = unord_map_type<std::unordered_multimap, transparent_hash_final, transparent_equal_final>;
+      test_transparent_equal_range<M>({{1, 2}, {1, 3}, {2, 3}});
+      test_transparent_equal_range<const M>({{1, 2}, {1, 3}, {2, 3}});
     }
 
     {
       // Make sure conversions do happen for non-transparent hasher
-      using map_type = unord_map_type<std::unordered_multimap, non_transparent_hash,
-                                 std::equal_to<> >;
-      test_non_transparent_equal_range<map_type>(ilist_type{{1, 2}, {1, 3}, {2, 3}});
+      using M = unord_map_type<std::unordered_multimap, non_transparent_hash, std::equal_to<>>;
+      test_non_transparent_equal_range<M>({{1, 2}, {1, 3}, {2, 3}});
+      test_non_transparent_equal_range<const M>({{1, 2}, {1, 3}, {2, 3}});
     }
 
     {
       // Make sure conversions do happen for non-transparent key_equal
-      using map_type = unord_map_type<std::unordered_multimap, transparent_hash,
-                                 std::equal_to<key_type> >;
-      test_non_transparent_equal_range<map_type>(ilist_type{{1, 2}, {1, 3}, {2, 3}});
+      using M = unord_map_type<std::unordered_multimap, transparent_hash, std::equal_to<key_type>>;
+      test_non_transparent_equal_range<M>({{1, 2}, {1, 3}, {2, 3}});
+      test_non_transparent_equal_range<const M>({{1, 2}, {1, 3}, {2, 3}});
     }
 
     {
       // Make sure conversions do happen for both non-transparent hasher and key_equal
-      using map_type = unord_map_type<std::unordered_multimap, non_transparent_hash,
-                                 std::equal_to<key_type> >;
-      test_non_transparent_equal_range<map_type>(ilist_type{{1, 2}, {1, 3}, {2, 3}});
+      using M = unord_map_type<std::unordered_multimap, non_transparent_hash, std::equal_to<key_type>>;
+      test_non_transparent_equal_range<M>({{1, 2}, {1, 3}, {2, 3}});
+      test_non_transparent_equal_range<const M>({{1, 2}, {1, 3}, {2, 3}});
     }
 
     return 0;
 }

libcxx/test/std/containers/unord/unord.multimap/equal_range_const.transparent.pass.cpp

-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-// <unordered_map>
-
-// template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>,
-//           class Alloc = allocator<pair<const Key, T>>>
-// class unordered_multimap
-
-// template <typename K>
-// pair<const_iterator, const_iterator> equal_range(const K& k) const;
-
-// UNSUPPORTED: c++03, c++11, c++14, c++17
-
-#include <unordered_map>
-
-#include "test_transparent_unordered.h"
-
-int main(int, char**)
-{
-    using key_type = StoredType<int>;
-    using ilist_type = std::initializer_list<std::pair<const key_type, int> >;
-
-    {
-      // Make sure conversions don't happen for transparent non-final hasher and key_equal
-      using map_type = const unord_map_type<std::unordered_multimap, transparent_hash,
-                                       std::equal_to<> >;
-      test_transparent_equal_range<map_type>(ilist_type{{1, 2}, {1, 3}, {2, 3}});
-    }
-
-    {
-      // Make sure conversions don't happen for transparent final hasher and key_equal
-      using map_type = const unord_map_type<std::unordered_multimap, transparent_hash_final,
-                                       transparent_equal_final>;
-      test_transparent_equal_range<map_type>(ilist_type{{1, 2}, {1, 3}, {2, 3}});
-    }
-
-    {
-      // Make sure conversions do happen for non-transparent hasher
-      using map_type = const unord_map_type<std::unordered_multimap, non_transparent_hash,
-                                       std::equal_to<> >;
-      test_non_transparent_equal_range<map_type>(ilist_type{{1, 2}, {1, 3}, {2, 3}});
-    }
-
-    {
-      // Make sure conversions do happen for non-transparent key_equal
-      using map_type = const unord_map_type<std::unordered_multimap, transparent_hash,
-                                       std::equal_to<key_type> >;
-      test_non_transparent_equal_range<map_type>(ilist_type{{1, 2}, {1, 3}, {2, 3}});
-    }
-
-    {
-      // Make sure conversions do happen for both non-transparent hasher and key_equal
-      using map_type = const unord_map_type<std::unordered_multimap, non_transparent_hash,
-                                       std::equal_to<key_type> >;
-      test_non_transparent_equal_range<map_type>(ilist_type{{1, 2}, {1, 3}, {2, 3}});
-    }
-
-    return 0;
-}

libcxx/test/std/containers/unord/unord.multimap/find.transparent.pass.cpp

 
 #include <unordered_map>
 
 #include "test_transparent_unordered.h"
 
 int main(int, char**)
 {
     using key_type = StoredType<int>;
-    using ilist_type = std::initializer_list<std::pair<const key_type, int> >;
 
     {
       // Make sure conversions don't happen for transparent non-final hasher and key_equal
-      using map_type = unord_map_type<std::unordered_multimap, transparent_hash,
-                                 std::equal_to<> >;
-      test_transparent_find<map_type>(ilist_type{{1, 2}, {1, 3}, {2, 3}});
+      using M = unord_map_type<std::unordered_multimap, transparent_hash, std::equal_to<>>;
+      test_transparent_find<M>({{1, 2}, {1, 3}, {2, 3}});
+      test_transparent_find<const M>({{1, 2}, {1, 3}, {2, 3}});
     }
 
     {
       // Make sure conversions don't happen for transparent final hasher and key_equal
-      using map_type = unord_map_type<std::unordered_multimap, transparent_hash_final,
-                                 transparent_equal_final>;
-      test_transparent_find<map_type>(ilist_type{{1, 2}, {1, 3}, {2, 3}});
+      using M = unord_map_type<std::unordered_multimap, transparent_hash_final, transparent_equal_final>;
+      test_transparent_find<M>({{1, 2}, {1, 3}, {2, 3}});
+      test_transparent_find<const M>({{1, 2}, {1, 3}, {2, 3}});
     }
 
     {
       // Make sure conversions do happen for non-transparent hasher
-      using map_type = unord_map_type<std::unordered_multimap, non_transparent_hash,
-                                 std::equal_to<> >;
-      test_non_transparent_find<map_type>(ilist_type{{1, 2}, {1, 3}, {2, 3}});
+      using M = unord_map_type<std::unordered_multimap, non_transparent_hash, std::equal_to<>>;
+      test_non_transparent_find<M>({{1, 2}, {1, 3}, {2, 3}});
+      test_non_transparent_find<const M>({{1, 2}, {1, 3}, {2, 3}});
     }
 
     {
       // Make sure conversions do happen for non-transparent key_equal
-      using map_type = unord_map_type<std::unordered_multimap, transparent_hash,
-                                 std::equal_to<key_type> >;
-      test_non_transparent_find<map_type>(ilist_type{{1, 2}, {1, 3}, {2, 3}});
+      using M = unord_map_type<std::unordered_multimap, transparent_hash, std::equal_to<key_type>>;
+      test_non_transparent_find<M>({{1, 2}, {1, 3}, {2, 3}});
+      test_non_transparent_find<const M>({{1, 2}, {1, 3}, {2, 3}});
     }
 
     {
       // Make sure conversions do happen for both non-transparent hasher and key_equal
-      using map_type = unord_map_type<std::unordered_multimap, non_transparent_hash,
-                                 std::equal_to<key_type> >;
-      test_non_transparent_find<map_type>(ilist_type{{1, 2}, {1, 3}, {2, 3}});
+      using M = unord_map_type<std::unordered_multimap, non_transparent_hash, std::equal_to<key_type>>;
+      test_non_transparent_find<M>({{1, 2}, {1, 3}, {2, 3}});
+      test_non_transparent_find<const M>({{1, 2}, {1, 3}, {2, 3}});
     }
 
     return 0;
 }

libcxx/test/std/containers/unord/unord.multimap/find_const.transparent.pass.cpp

-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-// <unordered_map>
-
-// template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>,
-//           class Alloc = allocator<pair<const Key, T>>>
-// class unordered_multimap
-
-// template <typename K>
-// const_iterator find(const K& k) const;
-
-// UNSUPPORTED: c++03, c++11, c++14, c++17
-
-#include <unordered_map>
-
-#include "test_transparent_unordered.h"
-
-int main(int, char**)
-{
-    using key_type = StoredType<int>;
-    using ilist_type = std::initializer_list<std::pair<const key_type, int> >;
-
-    {
-      // Make sure conversions don't happen for transparent non-final hasher and key_equal
-      using map_type = const unord_map_type<std::unordered_multimap, transparent_hash,
-                                       std::equal_to<> >;
-      test_transparent_find<map_type>(ilist_type{{1, 2}, {1, 3}, {2, 3}});
-    }
-
-    {
-      // Make sure conversions don't happen for transparent final hasher and key_equal
-      using map_type = const unord_map_type<std::unordered_multimap, transparent_hash_final,
-                                       transparent_equal_final>;
-      test_transparent_find<map_type>(ilist_type{{1, 2}, {1, 3}, {2, 3}});
-    }
-
-    {
-      // Make sure conversions do happen for non-transparent hasher
-      using map_type = const unord_map_type<std::unordered_multimap, non_transparent_hash,
-                                       std::equal_to<> >;
-      test_non_transparent_find<map_type>(ilist_type{{1, 2}, {1, 3}, {2, 3}});
-    }
-
-    {
-      // Make sure conversions do happen for non-transparent key_equal
-      using map_type = const unord_map_type<std::unordered_multimap, transparent_hash,
-                                       std::equal_to<key_type> >;
-      test_non_transparent_find<map_type>(ilist_type{{1, 2}, {1, 3}, {2, 3}});
-    }
-
-    {
-      // Make sure conversions do happen for both non-transparent hasher and key_equal
-      using map_type = const unord_map_type<std::unordered_multimap, non_transparent_hash,
-                                       std::equal_to<key_type> >;
-      test_non_transparent_find<map_type>(ilist_type{{1, 2}, {1, 3}, {2, 3}});
-    }
-
-    return 0;
-}

libcxx/test/std/containers/unord/unord.multiset/contains.transparent.pass.cpp

 #include "test_transparent_unordered.h"
 
 int main(int, char**)
 {
     using key_type = StoredType<int>;
 
     {
       // Make sure conversions don't happen for transparent non-final hasher and key_equal
-      using set_type = unord_set_type<std::unordered_multiset, transparent_hash,
-                                            std::equal_to<> >;
-      test_transparent_contains<set_type>(key_type{1}, key_type{1}, key_type{2});
+      using S = unord_set_type<std::unordered_multiset, transparent_hash, std::equal_to<>>;
+      test_transparent_contains<S>({1, 1, 2});
+      test_transparent_contains<const S>({1, 1, 2});
     }
 
     {
       // Make sure conversions don't happen for transparent final hasher and key_equal
-      using set_type = unord_set_type<std::unordered_multiset, transparent_hash_final, transparent_equal_final>;
-      test_transparent_contains<set_type>(key_type{1}, key_type{1}, key_type{2});
+      using S = unord_set_type<std::unordered_multiset, transparent_hash_final, transparent_equal_final>;
+      test_transparent_contains<S>({1, 1, 2});
+      test_transparent_contains<const S>({1, 1, 2});
     }
 
     {
       // Make sure conversions do happen for non-transparent hasher
-      using set_type = unord_set_type<std::unordered_multiset, non_transparent_hash,
-                                            std::equal_to<> >;
-      test_non_transparent_contains<set_type>(key_type{1}, key_type{1}, key_type{2});
+      using S = unord_set_type<std::unordered_multiset, non_transparent_hash, std::equal_to<>>;
+      test_non_transparent_contains<S>({1, 1, 2});
+      test_non_transparent_contains<const S>({1, 1, 2});
     }
 
     {
       // Make sure conversions do happen for non-transparent key_equal
-      using set_type = unord_set_type<std::unordered_multiset, transparent_hash,
-                                            std::equal_to<key_type> >;
-      test_non_transparent_contains<set_type>(
-          key_type{1}, key_type{1}, key_type{2});
+      using S = unord_set_type<std::unordered_multiset, transparent_hash, std::equal_to<key_type>>;
+      test_non_transparent_contains<S>({1, 1, 2});
+      test_non_transparent_contains<const S>({1, 1, 2});
     }
 
     {
       // Make sure conversions do happen for both non-transparent hasher and key_equal
-      using set_type = unord_set_type<std::unordered_multiset, non_transparent_hash,
-                                            std::equal_to<key_type> >;
-      test_non_transparent_contains<set_type>(
-          key_type{1}, key_type{1}, key_type{2});
+      using S = unord_set_type<std::unordered_multiset, non_transparent_hash, std::equal_to<key_type>>;
+      test_non_transparent_contains<S>({1, 1, 2});
+      test_non_transparent_contains<const S>({1, 1, 2});
     }
 
     return 0;
 }

libcxx/test/std/containers/unord/unord.multiset/count.transparent.pass.cpp

 #include "test_transparent_unordered.h"
 
 int main(int, char**)
 {
     using key_type = StoredType<int>;
 
     {
       // Make sure conversions don't happen for transparent non-final hasher and key_equal
-      using set_type = const unord_set_type<std::unordered_multiset, transparent_hash, std::equal_to<> >;
-      test_transparent_count<set_type>(key_type{1}, key_type{1}, key_type{2});
+      using S = unord_set_type<std::unordered_multiset, transparent_hash, std::equal_to<>>;
+      test_transparent_count<S>({1, 1, 2});
+      test_transparent_count<const S>({1, 1, 2});
     }
 
     {
       // Make sure conversions don't happen for transparent final hasher and key_equal
-      using set_type =
-          const unord_set_type<std::unordered_multiset, transparent_hash_final, transparent_equal_final>;
-      test_transparent_count<set_type>(key_type{1}, key_type{1}, key_type{2});
+      using S = unord_set_type<std::unordered_multiset, transparent_hash_final, transparent_equal_final>;
+      test_transparent_count<S>({1, 1, 2});
+      test_transparent_count<const S>({1, 1, 2});
     }
 
     {
       // Make sure conversions do happen for non-transparent hasher
-      using set_type = const unord_set_type<std::unordered_multiset, non_transparent_hash, std::equal_to<> >;
-      test_non_transparent_count<set_type>(key_type{1}, key_type{1}, key_type{2});
+      using S = unord_set_type<std::unordered_multiset, non_transparent_hash, std::equal_to<>>;
+      test_non_transparent_count<S>({1, 1, 2});
+      test_non_transparent_count<const S>({1, 1, 2});
     }
 
     {
       // Make sure conversions do happen for non-transparent key_equal
-      using set_type =
-          const unord_set_type<std::unordered_multiset, transparent_hash, std::equal_to<key_type> >;
-      test_non_transparent_count<set_type>(key_type{1}, key_type{1}, key_type{2});
+      using S = unord_set_type<std::unordered_multiset, transparent_hash, std::equal_to<key_type>>;
+      test_non_transparent_count<S>({1, 1, 2});
+      test_non_transparent_count<const S>({1, 1, 2});
     }
 
     {
       // Make sure conversions do happen for both non-transparent hasher and key_equal
-      using set_type =
-          const unord_set_type<std::unordered_multiset, non_transparent_hash, std::equal_to<key_type> >;
-      test_non_transparent_count<set_type>(key_type{1}, key_type{1}, key_type{2});
+      using S = unord_set_type<std::unordered_multiset, non_transparent_hash, std::equal_to<key_type>>;
+      test_non_transparent_count<S>({1, 1, 2});
+      test_non_transparent_count<const S>({1, 1, 2});
     }
 
     return 0;
 }

libcxx/test/std/containers/unord/unord.multiset/equal_range.transparent.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <unordered_set>
 
 // template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>,
 //           class Alloc = allocator<pair<const Key, T>>>
-// class unordered_set
+// class unordered_multiset
 
 // template <typename K>
 // pair<const_iterator, const_iterator> equal_range(const K& k) const;
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 
 #include <unordered_set>
 
 #include "test_transparent_unordered.h"
 
 int main(int, char**)
 {
     using key_type = StoredType<int>;
 
     {
       // Make sure conversions don't happen for transparent non-final hasher and key_equal
-      using set_type = const unord_set_type<std::unordered_set, transparent_hash,
-                                       std::equal_to<> >;
-      test_transparent_equal_range<set_type>(key_type{1}, key_type{2});
+      using S = unord_set_type<std::unordered_multiset, transparent_hash, std::equal_to<>>;
+      test_transparent_equal_range<S>({1, 1, 2});
+      test_transparent_equal_range<const S>({1, 1, 2});
     }
 
     {
       // Make sure conversions don't happen for transparent final hasher and key_equal
-      using set_type = const unord_set_type<std::unordered_set, transparent_hash_final,
-                                       transparent_equal_final>;
-      test_transparent_equal_range<set_type>(key_type{1}, key_type{2});
+      using S = unord_set_type<std::unordered_multiset, transparent_hash_final, transparent_equal_final>;
+      test_transparent_equal_range<S>({1, 1, 2});
+      test_transparent_equal_range<const S>({1, 1, 2});
     }
 
     {
       // Make sure conversions do happen for non-transparent hasher
-      using set_type = const unord_set_type<std::unordered_set, non_transparent_hash,
-                                       std::equal_to<> >;
-      test_non_transparent_equal_range<set_type>(key_type{1}, key_type{2});
+      using S = unord_set_type<std::unordered_multiset, non_transparent_hash, std::equal_to<>>;
+      test_non_transparent_equal_range<S>({1, 1, 2});
+      test_non_transparent_equal_range<const S>({1, 1, 2});
     }
 
     {
       // Make sure conversions do happen for non-transparent key_equal
-      using set_type = const unord_set_type<std::unordered_set, transparent_hash,
-                                       std::equal_to<key_type> >;
-      test_non_transparent_equal_range<set_type>(key_type{1}, key_type{2});
+      using S = unord_set_type<std::unordered_multiset, transparent_hash, std::equal_to<key_type>>;
+      test_non_transparent_equal_range<S>({1, 1, 2});
+      test_non_transparent_equal_range<const S>({1, 1, 2});
     }
 
     {
       // Make sure conversions do happen for both non-transparent hasher and key_equal
-      using set_type = const unord_set_type<std::unordered_set, non_transparent_hash,
-                                       std::equal_to<key_type> >;
-      test_non_transparent_equal_range<set_type>(key_type{1}, key_type{2});
+      using S = unord_set_type<std::unordered_multiset, non_transparent_hash, std::equal_to<key_type>>;
+      test_non_transparent_equal_range<S>({1, 1, 2});
+      test_non_transparent_equal_range<const S>({1, 1, 2});
     }
 
     return 0;
 }

libcxx/test/std/containers/unord/unord.multiset/equal_range_const.transparent.pass.cpp

-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-// <unordered_set>
-
-// template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>,
-//           class Alloc = allocator<pair<const Key, T>>>
-// class unordered_multiset
-
-// template <typename K>
-// pair<const_iterator, const_iterator> equal_range(const K& k) const;
-
-// UNSUPPORTED: c++03, c++11, c++14, c++17
-
-#include <unordered_set>
-
-#include "test_transparent_unordered.h"
-
-int main(int, char**)
-{
-    using key_type = StoredType<int>;
-
-    {
-      // Make sure conversions don't happen for transparent non-final hasher and key_equal
-      using set_type = const unord_set_type<std::unordered_multiset, transparent_hash,
-                                       std::equal_to<> >;
-      test_transparent_equal_range<set_type>(key_type{1}, key_type{1}, key_type{2});
-    }
-
-    {
-      // Make sure conversions don't happen for transparent final hasher and key_equal
-      using set_type = const unord_set_type<std::unordered_multiset, transparent_hash_final,
-                                       transparent_equal_final>;
-      test_transparent_equal_range<set_type>(key_type{1}, key_type{1}, key_type{2});
-    }
-
-    {
-      // Make sure conversions do happen for non-transparent hasher
-      using set_type = const unord_set_type<std::unordered_multiset, non_transparent_hash,
-                                       std::equal_to<> >;
-      test_non_transparent_equal_range<set_type>(key_type{1}, key_type{1}, key_type{2});
-    }
-
-    {
-      // Make sure conversions do happen for non-transparent key_equal
-      using set_type = const unord_set_type<std::unordered_multiset, transparent_hash,
-                                       std::equal_to<key_type> >;
-      test_non_transparent_equal_range<set_type>(key_type{1}, key_type{1}, key_type{2});
-    }
-
-    {
-      // Make sure conversions do happen for both non-transparent hasher and key_equal
-      using set_type = const unord_set_type<std::unordered_multiset, non_transparent_hash,
-                                       std::equal_to<key_type> >;
-      test_non_transparent_equal_range<set_type>(key_type{1}, key_type{1}, key_type{2});
-    }
-
-    return 0;
-}

libcxx/test/std/containers/unord/unord.multiset/equal_range_non_const.transparent.pass.cpp

-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-// <unordered_set>
-
-// template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>,
-//           class Alloc = allocator<pair<const Key, T>>>
-// class unordered_multiset
-
-// template <typename K>
-// pair<iterator, iterator> equal_range(const K& k);
-
-// UNSUPPORTED: c++03, c++11, c++14, c++17
-
-#include <unordered_set>
-
-#include "test_transparent_unordered.h"
-
-int main(int, char**)
-{
-    using key_type = StoredType<int>;
-
-    {
-      // Make sure conversions don't happen for transparent non-final hasher and key_equal
-      using set_type = unord_set_type<std::unordered_multiset, transparent_hash,
-                                 std::equal_to<> >;
-      test_transparent_equal_range<set_type>(key_type{1}, key_type{1}, key_type{2});
-    }
-
-    {
-      // Make sure conversions don't happen for transparent final hasher and key_equal
-      using set_type = unord_set_type<std::unordered_multiset, transparent_hash_final,
-                                 transparent_equal_final>;
-      test_transparent_equal_range<set_type>(key_type{1}, key_type{1}, key_type{2});
-    }
-
-    {
-      // Make sure conversions do happen for non-transparent hasher
-      using set_type = unord_set_type<std::unordered_multiset, non_transparent_hash,
-                                 std::equal_to<> >;
-      test_non_transparent_equal_range<set_type>(key_type{1}, key_type{1}, key_type{2});
-    }
-
-    {
-      // Make sure conversions do happen for non-transparent key_equal
-      using set_type = unord_set_type<std::unordered_multiset, transparent_hash,
-                                 std::equal_to<key_type> >;
-      test_non_transparent_equal_range<set_type>(key_type{1}, key_type{1}, key_type{2});
-    }
-
-    {
-      // Make sure conversions do happen for both non-transparent hasher and key_equal
-      using set_type = unord_set_type<std::unordered_multiset, non_transparent_hash,
-                                 std::equal_to<key_type> >;
-      test_non_transparent_equal_range<set_type>(key_type{1}, key_type{1}, key_type{2});
-    }
-
-    return 0;
-}

libcxx/test/std/containers/unord/unord.multiset/find.transparent.pass.cpp

 #include "test_transparent_unordered.h"
 
 int main(int, char**)
 {
     using key_type = StoredType<int>;
 
     {
       // Make sure conversions don't happen for transparent non-final hasher and key_equal
-      using set_type = unord_set_type<std::unordered_multiset, transparent_hash,
-                                 std::equal_to<> >;
-      test_transparent_find<set_type>(key_type{1}, key_type{1}, key_type{2});
+      using S = unord_set_type<std::unordered_multiset, transparent_hash, std::equal_to<>>;
+      test_transparent_find<S>({1, 1, 2});
+      test_transparent_find<const S>({1, 1, 2});
     }
 
     {
       // Make sure conversions don't happen for transparent final hasher and key_equal
-      using set_type = unord_set_type<std::unordered_multiset, transparent_hash_final,
-                                 transparent_equal_final>;
-      test_transparent_find<set_type>(key_type{1}, key_type{1}, key_type{2});
+      using S = unord_set_type<std::unordered_multiset, transparent_hash_final, transparent_equal_final>;
+      test_transparent_find<S>({1, 1, 2});
+      test_transparent_find<const S>({1, 1, 2});
     }
 
     {
       // Make sure conversions do happen for non-transparent hasher
-      using set_type = unord_set_type<std::unordered_multiset, non_transparent_hash,
-                                 std::equal_to<> >;
-      test_non_transparent_find<set_type>(key_type{1}, key_type{1}, key_type{2});
+      using S = unord_set_type<std::unordered_multiset, non_transparent_hash, std::equal_to<>>;
+      test_non_transparent_find<S>({1, 1, 2});
+      test_non_transparent_find<const S>({1, 1, 2});
     }
 
     {
       // Make sure conversions do happen for non-transparent key_equal
-      using set_type = unord_set_type<std::unordered_multiset, transparent_hash,
-                                 std::equal_to<key_type> >;
-      test_non_transparent_find<set_type>(key_type{1}, key_type{1}, key_type{2});
+      using S = unord_set_type<std::unordered_multiset, transparent_hash, std::equal_to<key_type>>;
+      test_non_transparent_find<S>({1, 1, 2});
+      test_non_transparent_find<const S>({1, 1, 2});
     }
 
     {
       // Make sure conversions do happen for both non-transparent hasher and key_equal
-      using set_type = unord_set_type<std::unordered_multiset, non_transparent_hash,
-                                 std::equal_to<key_type> >;
-      test_non_transparent_find<set_type>(key_type{1}, key_type{1}, key_type{2});
+      using S = unord_set_type<std::unordered_multiset, non_transparent_hash, std::equal_to<key_type>>;
+      test_non_transparent_find<S>({1, 1, 2});
+      test_non_transparent_find<const S>({1, 1, 2});
     }
 
     return 0;
 }

libcxx/test/std/containers/unord/unord.multiset/find_const.transparent.pass.cpp

-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-// <unordered_set>
-
-// template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>,
-//           class Alloc = allocator<pair<const Key, T>>>
-// class unordered_multiset
-
-// template <typename K>
-// const_iterator find(const K& k) const;
-
-// UNSUPPORTED: c++03, c++11, c++14, c++17
-
-#include <unordered_set>
-
-#include "test_transparent_unordered.h"
-
-int main(int, char**)
-{
-    using key_type = StoredType<int>;
-
-    {
-      // Make sure conversions don't happen for transparent non-final hasher and key_equal
-      using set_type = const unord_set_type<std::unordered_multiset, transparent_hash,
-                                       std::equal_to<> >;
-      test_transparent_find<set_type>(key_type{1}, key_type{1}, key_type{2});
-    }
-
-    {
-      // Make sure conversions don't happen for transparent final hasher and key_equal
-      using set_type = const unord_set_type<std::unordered_multiset, transparent_hash_final,
-                                       transparent_equal_final>;
-      test_transparent_find<set_type>(key_type{1}, key_type{1}, key_type{2});
-    }
-
-    {
-      // Make sure conversions do happen for non-transparent hasher
-      using set_type = const unord_set_type<std::unordered_multiset, non_transparent_hash,
-                                       std::equal_to<> >;
-      test_non_transparent_find<set_type>(key_type{1}, key_type{1}, key_type{2});
-    }
-
-    {
-      // Make sure conversions do happen for non-transparent key_equal
-      using set_type = const unord_set_type<std::unordered_multiset, transparent_hash,
-                                       std::equal_to<key_type> >;
-      test_non_transparent_find<set_type>(key_type{1}, key_type{1}, key_type{2});
-    }
-
-    {
-      // Make sure conversions do happen for both non-transparent hasher and key_equal
-      using set_type = const unord_set_type<std::unordered_multiset, non_transparent_hash,
-                                       std::equal_to<key_type> >;
-      test_non_transparent_find<set_type>(key_type{1}, key_type{1}, key_type{2});
-    }
-
-    return 0;
-}

libcxx/test/std/containers/unord/unord.set/contains.transparent.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <unordered_set>
 
 // template <class Value, class Hash = hash<Value>, class Pred = equal_to<Value>,
 //           class Alloc = allocator<Value>>
-// class unordered_multiset
+// class unordered_set
 
 // template <typename K>
 // bool contains(const K& x) const;
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 
 #include <unordered_set>
 #include "test_transparent_unordered.h"
 
 int main(int, char**)
 {
     using key_type = StoredType<int>;
 
     {
       // Make sure conversions don't happen for transparent non-final hasher and key_equal
-      using set_type = const unord_set_type<std::unordered_set, transparent_hash, std::equal_to<> >;
-      test_transparent_contains<set_type>(key_type(1), key_type(2));
+      using S = unord_set_type<std::unordered_set, transparent_hash, std::equal_to<>>;
+      test_transparent_contains<S>({1, 2});
+      test_transparent_contains<const S>({1, 2});
     }
 
     {
       // Make sure conversions don't happen for transparent final hasher and key_equal
-      using set_type = const unord_set_type<std::unordered_set, transparent_hash_final, transparent_equal_final>;
-      test_transparent_contains<set_type>(key_type(1), key_type(2));
+      using S = unord_set_type<std::unordered_set, transparent_hash_final, transparent_equal_final>;
+      test_transparent_contains<S>({1, 2});
+      test_transparent_contains<const S>({1, 2});
     }
 
     {
       // Make sure conversions do happen for non-transparent hasher
-      using set_type = const unord_set_type<std::unordered_set, non_transparent_hash,
-                                       std::equal_to<> >;
-      test_non_transparent_contains<set_type>(key_type(1), key_type(2));
+      using S = unord_set_type<std::unordered_set, non_transparent_hash, std::equal_to<>>;
+      test_non_transparent_contains<S>({1, 2});
+      test_non_transparent_contains<const S>({1, 2});
     }
 
     {
       // Make sure conversions do happen for non-transparent key_equal
-      using set_type = const unord_set_type<std::unordered_set, transparent_hash,
-                                       std::equal_to<key_type> >;
-      test_non_transparent_contains<set_type>(key_type(1), key_type(2));
+      using S = unord_set_type<std::unordered_set, transparent_hash, std::equal_to<key_type>>;
+      test_non_transparent_contains<S>({1, 2});
+      test_non_transparent_contains<const S>({1, 2});
     }
 
     {
       // Make sure conversions do happen for both non-transparent hasher and key_equal
-      using set_type = const unord_set_type<std::unordered_set, non_transparent_hash,
-                                       std::equal_to<key_type> >;
-      test_non_transparent_contains<set_type>(key_type(1), key_type(2));
+      using S = unord_set_type<std::unordered_set, non_transparent_hash, std::equal_to<key_type>>;
+      test_non_transparent_contains<S>({1, 2});
+      test_non_transparent_contains<const S>({1, 2});
     }
 
     return 0;
 }

libcxx/test/std/containers/unord/unord.set/count.transparent.pass.cpp

 #include "test_transparent_unordered.h"
 
 int main(int, char**)
 {
     using key_type = StoredType<int>;
 
     {
       // Make sure conversions don't happen for transparent non-final hasher and key_equal
-      using set_type = const unord_set_type<std::unordered_set, transparent_hash, std::equal_to<> >;
-      test_transparent_count<set_type>(key_type{1},  key_type{2});
+      using S = unord_set_type<std::unordered_set, transparent_hash, std::equal_to<>>;
+      test_transparent_count<S>({1, 2});
+      test_transparent_count<const S>({1, 2});
     }
 
     {
       // Make sure conversions don't happen for transparent final hasher and key_equal
-      using set_type =
-          const unord_set_type<std::unordered_set, transparent_hash_final, transparent_equal_final>;
-      test_transparent_count<set_type>(key_type{1},  key_type{2});
+      using S = unord_set_type<std::unordered_set, transparent_hash_final, transparent_equal_final>;
+      test_transparent_count<S>({1, 2});
+      test_transparent_count<const S>({1, 2});
     }
 
     {
       // Make sure conversions do happen for non-transparent hasher
-      using set_type = const unord_set_type<std::unordered_set, non_transparent_hash, std::equal_to<> >;
-      test_non_transparent_count<set_type>(key_type{1},  key_type{2});
+      using S = unord_set_type<std::unordered_set, non_transparent_hash, std::equal_to<>>;
+      test_non_transparent_count<S>({1, 2});
+      test_non_transparent_count<const S>({1, 2});
     }
 
     {
       // Make sure conversions do happen for non-transparent key_equal
-      using set_type =
-          const unord_set_type<std::unordered_set, transparent_hash, std::equal_to<key_type> >;
-      test_non_transparent_count<set_type>(key_type{1},  key_type{2});
+      using S = unord_set_type<std::unordered_set, transparent_hash, std::equal_to<key_type>>;
+      test_non_transparent_count<S>({1, 2});
+      test_non_transparent_count<const S>({1, 2});
     }
 
     {
       // Make sure conversions do happen for both non-transparent hasher and key_equal
-      using set_type =
-          const unord_set_type<std::unordered_set, non_transparent_hash, std::equal_to<key_type> >;
-      test_non_transparent_count<set_type>(key_type{1},  key_type{2});
+      using S = unord_set_type<std::unordered_set, non_transparent_hash, std::equal_to<key_type>>;
+      test_non_transparent_count<S>({1, 2});
+      test_non_transparent_count<const S>({1, 2});
     }
 
     return 0;
 }

libcxx/test/std/containers/unord/unord.set/equal_range.transparent.pass.cpp

 #include "test_transparent_unordered.h"
 
 int main(int, char**)
 {
     using key_type = StoredType<int>;
 
     {
       // Make sure conversions don't happen for transparent non-final hasher and key_equal
-      using set_type = unord_set_type<std::unordered_set, transparent_hash,
-                                 std::equal_to<> >;
-      test_transparent_equal_range<set_type>(key_type{1}, key_type{2});
+      using S = unord_set_type<std::unordered_set, transparent_hash, std::equal_to<>>;
+      test_transparent_equal_range<S>({1, 2});
+      test_transparent_equal_range<const S>({1, 2});
     }
 
     {
       // Make sure conversions don't happen for transparent final hasher and key_equal
-      using set_type = unord_set_type<std::unordered_set, transparent_hash_final,
-                                 transparent_equal_final>;
-      test_transparent_equal_range<set_type>(key_type{1}, key_type{2});
+      using S = unord_set_type<std::unordered_set, transparent_hash_final, transparent_equal_final>;
+      test_transparent_equal_range<S>({1, 2});
+      test_transparent_equal_range<const S>({1, 2});
     }
 
     {
       // Make sure conversions do happen for non-transparent hasher
-      using set_type = unord_set_type<std::unordered_set, non_transparent_hash,
-                                 std::equal_to<> >;
-      test_non_transparent_equal_range<set_type>(key_type{1}, key_type{2});
+      using S = unord_set_type<std::unordered_set, non_transparent_hash, std::equal_to<>>;
+      test_non_transparent_equal_range<S>({1, 2});
+      test_non_transparent_equal_range<const S>({1, 2});
     }
 
     {
       // Make sure conversions do happen for non-transparent key_equal
-      using set_type = unord_set_type<std::unordered_set, transparent_hash,
-                                 std::equal_to<key_type> >;
-      test_non_transparent_equal_range<set_type>(key_type{1}, key_type{2});
+      using S = unord_set_type<std::unordered_set, transparent_hash, std::equal_to<key_type>>;
+      test_non_transparent_equal_range<S>({1, 2});
+      test_non_transparent_equal_range<const S>({1, 2});
     }
 
     {
       // Make sure conversions do happen for both non-transparent hasher and key_equal
-      using set_type = unord_set_type<std::unordered_set, non_transparent_hash,
-                                 std::equal_to<key_type> >;
-      test_non_transparent_equal_range<set_type>(key_type{1}, key_type{2});
+      using S = unord_set_type<std::unordered_set, non_transparent_hash, std::equal_to<key_type>>;
+      test_non_transparent_equal_range<S>({1, 2});
+      test_non_transparent_equal_range<const S>({1, 2});
     }
 
     return 0;
 }

libcxx/test/std/containers/unord/unord.set/find.transparent.pass.cpp

 #include "test_transparent_unordered.h"
 
 int main(int, char**)
 {
     using key_type = StoredType<int>;
 
     {
       // Make sure conversions don't happen for transparent non-final hasher and key_equal
-      using set_type = unord_set_type<std::unordered_set, transparent_hash,
-                                 std::equal_to<> >;
-      test_transparent_find<set_type>(key_type{1}, key_type{2});
+      using S = unord_set_type<std::unordered_set, transparent_hash, std::equal_to<>>;
+      test_transparent_find<S>({1, 2});
+      test_transparent_find<const S>({1, 2});
     }
 
     {
       // Make sure conversions don't happen for transparent final hasher and key_equal
-      using set_type = unord_set_type<std::unordered_set, transparent_hash_final,
-                                 transparent_equal_final>;
-      test_transparent_find<set_type>(key_type{1}, key_type{2});
+      using S = unord_set_type<std::unordered_set, transparent_hash_final, transparent_equal_final>;
+      test_transparent_find<S>({1, 2});
+      test_transparent_find<const S>({1, 2});
     }
 
     {
       // Make sure conversions do happen for non-transparent hasher
-      using set_type = unord_set_type<std::unordered_set, non_transparent_hash,
-                                 std::equal_to<> >;
-      test_non_transparent_find<set_type>(key_type{1}, key_type{2});
+      using S = unord_set_type<std::unordered_set, non_transparent_hash, std::equal_to<>>;
+      test_non_transparent_find<S>({1, 2});
+      test_non_transparent_find<const S>({1, 2});
     }
 
     {
       // Make sure conversions do happen for non-transparent key_equal
-      using set_type = unord_set_type<std::unordered_set, transparent_hash,
-                                 std::equal_to<key_type> >;
-      test_non_transparent_find<set_type>(key_type{1}, key_type{2});
+      using S = unord_set_type<std::unordered_set, transparent_hash, std::equal_to<key_type>>;
+      test_non_transparent_find<S>({1, 2});
+      test_non_transparent_find<const S>({1, 2});
     }
 
     {
       // Make sure conversions do happen for both non-transparent hasher and key_equal
-      using set_type = unord_set_type<std::unordered_set, non_transparent_hash,
-                                 std::equal_to<key_type> >;
-      test_non_transparent_find<set_type>(key_type{1}, key_type{2});
+      using S = unord_set_type<std::unordered_set, non_transparent_hash, std::equal_to<key_type>>;
+      test_non_transparent_find<S>({1, 2});
+      test_non_transparent_find<const S>({1, 2});
     }
 
     return 0;
 }

libcxx/test/std/containers/unord/unord.set/find_const.transparent.pass.cpp

-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-// <unordered_set>
-
-// template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>,
-//           class Alloc = allocator<pair<const Key, T>>>
-// class unordered_set
-
-// template <typename K>
-// const_iterator find(const K& k) const;
-
-// UNSUPPORTED: c++03, c++11, c++14, c++17
-
-#include <unordered_set>
-
-#include "test_transparent_unordered.h"
-
-int main(int, char**)
-{
-    using key_type = StoredType<int>;
-
-    {
-      // Make sure conversions don't happen for transparent non-final hasher and key_equal
-      using set_type = const unord_set_type<std::unordered_set, transparent_hash,
-                                       std::equal_to<> >;
-      test_transparent_find<set_type>(key_type{1}, key_type{2});
-    }
-
-    {
-      // Make sure conversions don't happen for transparent final hasher and key_equal
-      using set_type = const unord_set_type<std::unordered_set, transparent_hash_final,
-                                       transparent_equal_final>;
-      test_transparent_find<set_type>(key_type{1}, key_type{2});
-    }
-
-    {
-      // Make sure conversions do happen for non-transparent hasher
-      using set_type = const unord_set_type<std::unordered_set, non_transparent_hash,
-                                       std::equal_to<> >;
-      test_non_transparent_find<set_type>(key_type{1}, key_type{2});
-    }
-
-    {
-      // Make sure conversions do happen for non-transparent key_equal
-      using set_type = const unord_set_type<std::unordered_set, transparent_hash,
-                                       std::equal_to<key_type> >;
-      test_non_transparent_find<set_type>(key_type{1}, key_type{2});
-    }
-
-    {
-      // Make sure conversions do happen for both non-transparent hasher and key_equal
-      using set_type = const unord_set_type<std::unordered_set, non_transparent_hash,
-                                       std::equal_to<key_type> >;
-      test_non_transparent_find<set_type>(key_type{1}, key_type{2});
-    }
-
-    return 0;
-}

libcxx/test/support/is_transparent.h

private:
     };
 
 bool operator <(int          rhs,   const C2Int& lhs) { return rhs       < lhs.get(); }
 bool operator <(const C2Int& rhs,   const C2Int& lhs) { return rhs.get() < lhs.get(); }
 bool operator <(const C2Int& rhs,            int lhs) { return rhs.get() < lhs; }
 
 #endif // TEST_STD_VER > 11
 
-#if TEST_STD_VER > 17
-
-template <typename T>
-struct StoredType;
-
-template <typename T>
-struct SearchedType;
-
-struct hash_impl {
-  template <typename T>
-  constexpr std::size_t operator()(SearchedType<T> const& t) const {
-    return static_cast<std::size_t>(t.get_value());
-  }
-
-  template <typename T>
-  constexpr std::size_t operator()(StoredType<T> const& t) const {
-    return static_cast<std::size_t>(t.get_value());
-  }
-};
-
-struct non_transparent_hash : hash_impl {};
-
-struct transparent_hash : hash_impl {
-  using is_transparent = void;
-};
-
-struct transparent_hash_final final : transparent_hash {};
-
-struct transparent_equal_final final : std::equal_to<> {};
-
-template <typename T>
-struct SearchedType {
-  SearchedType(T value, int* counter) : value_(value), conversions_(counter) { }
-
-  // Whenever a conversion is performed, increment the counter to keep track
-  // of conversions.
-  operator StoredType<T>() const {
-    ++*conversions_;
-    return StoredType<T>{value_};
-  }
-
-  int get_value() const {
-    return value_;
-  }
-
-private:
-  T value_;
-  int* conversions_;
-};
-
-template <typename T>
-struct StoredType {
-  StoredType() = default;
-  StoredType(T value) : value_(value) { }
-
-  friend bool operator==(StoredType const& lhs, StoredType const& rhs) {
-    return lhs.value_ == rhs.value_;
-  }
-
-  // If we're being passed a SearchedType<T> object, avoid the conversion
-  // to T. This allows testing that the transparent operations are correctly
-  // forwarding the SearchedType all the way to this comparison by checking
-  // that we didn't have a conversion when we search for a SearchedType<T>
-  // in a container full of StoredType<T>.
-  friend bool operator==(StoredType const& lhs, SearchedType<T> const& rhs) {
-    return lhs.value_ == rhs.get_value();
-  }
-  friend bool operator==(SearchedType<T> const& lhs, StoredType<T> const& rhs) {
-    return lhs.get_value() == rhs.value_;
-  }
-
-  int get_value() const {
-    return value_;
-  }
-
-private:
-  T value_;
-};
-
-#endif // TEST_STD_VER > 17
-
 #endif // TRANSPARENT_H

libcxx/test/support/test_transparent_unordered.h

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef TEST_TRANSPARENT_UNORDERED_H
 #define TEST_TRANSPARENT_UNORDERED_H
 
 #include "test_macros.h"
 #include "is_transparent.h"
 
 #include <cassert>
 
-// testing transparent unordered containers
 #if TEST_STD_VER > 17
 
-template <template <typename...> class UnorderedSet, typename Hash,
-          typename Equal>
+template <typename T>
+struct StoredType;
+
+template <typename T>
+struct SearchedType;
+
+struct hash_impl {
+  template <typename T>
+  constexpr std::size_t operator()(SearchedType<T> const& t) const {
+    return static_cast<std::size_t>(t.get_value());
+  }
+
+  template <typename T>
+  constexpr std::size_t operator()(StoredType<T> const& t) const {
+    return static_cast<std::size_t>(t.get_value());
+  }
+};
+
+struct non_transparent_hash : hash_impl {};
+
+struct transparent_hash : hash_impl {
+  using is_transparent = void;
+};
+
+struct transparent_hash_final final : transparent_hash {};
+
+struct transparent_equal_final final : std::equal_to<> {};
+
+template <typename T>
+struct SearchedType {
+  explicit SearchedType(T value, int *counter) : value_(value), conversions_(counter) { }
+
+  // Whenever a conversion is performed, increment the counter to keep track
+  // of conversions.
+  operator StoredType<T>() const {
+    ++*conversions_;
+    return StoredType<T>{value_};
+  }
+
+  int get_value() const {
+    return value_;
+  }
+
+private:
+  T value_;
+  int *conversions_;
+};
+
+template <typename T>
+struct StoredType {
+  StoredType() = default;
+  StoredType(T value) : value_(value) { }
+
+  friend bool operator==(StoredType const& lhs, StoredType const& rhs) {
+    return lhs.value_ == rhs.value_;
+  }
+
+  // If we're being passed a SearchedType<T> object, avoid the conversion
+  // to T. This allows testing that the transparent operations are correctly
+  // forwarding the SearchedType all the way to this comparison by checking
+  // that we didn't have a conversion when we search for a SearchedType<T>
+  // in a container full of StoredType<T>.
+  friend bool operator==(StoredType const& lhs, SearchedType<T> const& rhs) {
+    return lhs.value_ == rhs.get_value();
+  }
+
+  int get_value() const {
+    return value_;
+  }
+
+private:
+  T value_;
+};
+
+template<template<class...> class UnorderedSet, class Hash, class Equal>
 using unord_set_type = UnorderedSet<StoredType<int>, Hash, Equal>;
 
-template <template <typename...> class UnorderedMap, typename Hash,
-          typename Equal>
+template<template<class...> class UnorderedMap, class Hash, class Equal>
 using unord_map_type = UnorderedMap<StoredType<int>, int, Hash, Equal>;
 
-template <typename Container, typename... Args>
-void test_transparent_find(Args&&... args) {
-  Container c{std::forward<Args>(args)...};
+template<class Container>
+void test_transparent_find(Container c) {
   int conversions = 0;
   assert(c.find(SearchedType<int>(1, &conversions)) != c.end());
   assert(c.find(SearchedType<int>(2, &conversions)) != c.end());
-  assert(conversions == 0);
   assert(c.find(SearchedType<int>(3, &conversions)) == c.end());
   assert(conversions == 0);
 }
 
-template <typename Container, typename... Args>
-void test_non_transparent_find(Args&&... args) {
-  Container c{std::forward<Args>(args)...};
+template<class Container>
+void test_non_transparent_find(Container c) {
   int conversions = 0;
   assert(c.find(SearchedType<int>(1, &conversions)) != c.end());
-  assert(conversions > 0);
-  conversions = 0;
+  assert(conversions == 1);
   assert(c.find(SearchedType<int>(2, &conversions)) != c.end());
-  assert(conversions > 0);
-  conversions = 0;
+  assert(conversions == 2);
   assert(c.find(SearchedType<int>(3, &conversions)) == c.end());
-  assert(conversions > 0);
+  assert(conversions == 3);
 }
 
-template <typename Container, typename... Args>
-void test_transparent_count(Args&&... args) {
-  Container c{std::forward<Args>(args)...};
+template<class Container>
+void test_transparent_count(Container c) {
   int conversions = 0;
   assert(c.count(SearchedType<int>(1, &conversions)) > 0);
   assert(c.count(SearchedType<int>(2, &conversions)) > 0);
-  assert(conversions == 0);
   assert(c.count(SearchedType<int>(3, &conversions)) == 0);
   assert(conversions == 0);
 }
 
-template <typename Container, typename... Args>
-void test_non_transparent_count(Args&&... args) {
-  Container c{std::forward<Args>(args)...};
+template<class Container>
+void test_non_transparent_count(Container c) {
   int conversions = 0;
   assert(c.count(SearchedType<int>(1, &conversions)) > 0);
-  assert(conversions > 0);
-  conversions = 0;
+  assert(conversions == 1);
   assert(c.count(SearchedType<int>(2, &conversions)) > 0);
-  assert(conversions > 0);
-  conversions = 0;
+  assert(conversions == 2);
   assert(c.count(SearchedType<int>(3, &conversions)) == 0);
-  assert(conversions > 0);
+  assert(conversions == 3);
 }
 
-template <typename Container, typename... Args>
-void test_transparent_contains(Args&&... args) {
-  Container c{std::forward<Args>(args)...};
+template<class Container>
+void test_transparent_contains(Container c) {
   int conversions = 0;
   assert(c.contains(SearchedType<int>(1, &conversions)));
   assert(c.contains(SearchedType<int>(2, &conversions)));
-  assert(conversions == 0);
   assert(!c.contains(SearchedType<int>(3, &conversions)));
   assert(conversions == 0);
 }
 
-template <typename Container, typename... Args>
-void test_non_transparent_contains(Args&&... args) {
-  Container c{std::forward<Args>(args)...};
+template<class Container>
+void test_non_transparent_contains(Container c) {
   int conversions = 0;
   assert(c.contains(SearchedType<int>(1, &conversions)));
-  assert(conversions > 0);
-  conversions = 0;
+  assert(conversions == 1);
   assert(c.contains(SearchedType<int>(2, &conversions)));
-  assert(conversions > 0);
-  conversions = 0;
+  assert(conversions == 2);
   assert(!c.contains(SearchedType<int>(3, &conversions)));
-  assert(conversions > 0);
+  assert(conversions == 3);
 }
 
-template <typename Container, typename... Args>
-void test_transparent_equal_range(Args&&... args) {
-  Container c{std::forward<Args>(args)...};
+template<class Container>
+void test_transparent_equal_range(Container c) {
   int conversions = 0;
   auto iters = c.equal_range(SearchedType<int>(1, &conversions));
   assert(std::distance(iters.first, iters.second) > 0);
   iters = c.equal_range(SearchedType<int>(2, &conversions));
   assert(std::distance(iters.first, iters.second) > 0);
-  assert(conversions == 0);
   iters = c.equal_range(SearchedType<int>(3, &conversions));
   assert(std::distance(iters.first, iters.second) == 0);
   assert(conversions == 0);
 }
 
-template <typename Container, typename... Args>
-void test_non_transparent_equal_range(Args&&... args) {
-  Container c{std::forward<Args>(args)...};
+template<class Container>
+void test_non_transparent_equal_range(Container c) {
   int conversions = 0;
   auto iters = c.equal_range(SearchedType<int>(1, &conversions));
   assert(std::distance(iters.first, iters.second) > 0);
-  assert(conversions > 0);
-  conversions = 0;
+  assert(conversions == 1);
   iters = c.equal_range(SearchedType<int>(2, &conversions));
   assert(std::distance(iters.first, iters.second) > 0);
-  assert(conversions > 0);
-  conversions = 0;
+  assert(conversions == 2);
   iters = c.equal_range(SearchedType<int>(3, &conversions));
   assert(std::distance(iters.first, iters.second) == 0);
-  assert(conversions > 0);
+  assert(conversions == 3);
 }
 
 #endif // TEST_STD_VER > 17
 
 #endif // TEST_TRANSPARENT_UNORDERED_H